diff --git a/.buildkite/amd/scripts/bootstrap-amd-omni.sh b/.buildkite/amd/scripts/bootstrap-amd-omni.sh
index 9eff6b6c7..60732d801 100755
--- a/.buildkite/amd/scripts/bootstrap-amd-omni.sh
+++ b/.buildkite/amd/scripts/bootstrap-amd-omni.sh
@@ -60,7 +60,8 @@ resolve_test_specs() {
     if ! selected_specs=$(python3 "$AMD_SUITE_SELECTOR" \
         --branch "$BUILDKITE_BRANCH" \
         --labels "$PR_LABELS" \
-        --debug-test-yaml "${DEBUG_TEST_YAML:-}"); then
+        --debug-test-yaml "${DEBUG_TEST_YAML:-}" \
+        --nightly "$NIGHTLY"); then
         exit 1
     fi
 
@@ -80,6 +81,12 @@ filter_test_specs_by_skip_ci() {
         case "$suite_spec" in
             READY_TESTS:*) level="l2" ;;
             MERGE_TESTS:*) level="l3" ;;
+            NIGHTLY_TESTS:*)
+                # Explicit PR and scheduled nightly selections must survive
+                # L2/L3 diff gating, including docs-only main commits.
+                runnable_specs+=("$suite_spec")
+                continue
+                ;;
             *)
                 echo "ERROR: unknown AMD test suite spec '$suite_spec'" >&2
                 exit 1
@@ -101,7 +108,7 @@ filter_test_specs_by_skip_ci() {
                 ":memo: CI skipped — docs or pytest skip-mark changes only" \
                 --style "info" 2>/dev/null || true
         fi
-        echo "No AMD L2/L3 suites remain after skip-ci filtering."
+        echo "No AMD suites remain after skip-ci filtering."
         exit 0
     fi
 }
@@ -219,8 +226,8 @@ if [[ $BUILDKITE_BRANCH == "main" ]]; then
     file_diff=$(get_diff_main)
 fi
 
-# Resolve PR tier labels before skip-ci so ready and merge suites can be
-# filtered independently for CI-YAML-only changes.
+# Resolve PR tier labels before skip-ci so ready/merge suites can be filtered
+# independently while an explicitly selected nightly suite passes through.
 resolve_test_specs
 filter_test_specs_by_skip_ci
 
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/scripts/select_test_suites.py b/.buildkite/amd/scripts/select_test_suites.py
index b7c72f6e4..daed05bd3 100644
--- a/.buildkite/amd/scripts/select_test_suites.py
+++ b/.buildkite/amd/scripts/select_test_suites.py
@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-"""Select AMD L2/L3 suites after Buildkite has created an AMD build.
+"""Select AMD ready/merge/nightly suites after Buildkite creates a build.
 
 This repository-side selector does not decide which GitHub label events start
 the external ``vllm-omni-amd-ci`` pipeline. Its Buildkite PR build condition
@@ -17,6 +17,7 @@ from collections.abc import Iterable
 SUITE_SPECS = {
     "ready": "READY_TESTS:test-amd-ready.yml",
     "merge": "MERGE_TESTS:test-amd-merge.yml",
+    "nightly": "NIGHTLY_TESTS:test-amd-nightly.yml",
 }
 
 
@@ -28,7 +29,7 @@ def _parse_debug_suites(value: str) -> tuple[str, ...]:
     seen: set[str] = set()
     for suite in suites:
         if suite not in SUITE_SPECS:
-            raise ValueError(f"DEBUG_TEST_YAML entries must be 'merge' or 'ready', got {suite!r}")
+            raise ValueError(f"DEBUG_TEST_YAML entries must be 'merge', 'nightly', or 'ready', got {suite!r}")
         if suite in seen:
             raise ValueError(f"duplicate DEBUG_TEST_YAML suite {suite!r}")
         seen.add(suite)
@@ -40,18 +41,27 @@ def select_amd_test_suites(
     branch: str,
     labels: Iterable[str],
     debug_test_yaml: str = "",
+    nightly: bool = False,
 ) -> tuple[str, ...]:
     """Return ordered suite names while preserving legacy unlabeled PRs."""
 
     if debug_test_yaml:
         return _parse_debug_suites(debug_test_yaml)
     if branch == "main":
-        return ("merge",)
+        return ("nightly",) if nightly else ("merge",)
 
     label_set = {label.strip() for label in labels if label.strip()}
-    selected = tuple(suite for label, suite in (("ready", "ready"), ("merge-test", "merge")) if label in label_set)
-    # AMD historically uploaded L2 for every PR build. Keep that behavior for
-    # triggers such as amd-test while adding tier selection for ready/merge-test.
+    selected = tuple(
+        suite
+        for label, suite in (
+            ("ready", "ready"),
+            ("merge-test", "merge"),
+            ("nightly-test", "nightly"),
+        )
+        if label in label_set
+    )
+    # AMD historically uploaded the ready suite for every admitted PR build.
+    # Preserve that fallback when no explicit tier label is present.
     return selected or ("ready",)
 
 
@@ -60,6 +70,7 @@ def main() -> int:
     parser.add_argument("--branch", required=True)
     parser.add_argument("--labels", default="")
     parser.add_argument("--debug-test-yaml", default="")
+    parser.add_argument("--nightly", type=int, choices=(0, 1), default=0)
     args = parser.parse_args()
 
     labels = tuple(args.labels.splitlines())
@@ -68,19 +79,15 @@ def main() -> int:
             branch=args.branch,
             labels=labels,
             debug_test_yaml=args.debug_test_yaml,
+            nightly=bool(args.nightly),
         )
     except ValueError as exc:
         parser.error(str(exc))
 
     label_set = {label.strip() for label in labels if label.strip()}
-    if not args.debug_test_yaml and args.branch != "main" and not ({"ready", "merge-test"} & label_set):
+    if args.branch != "main" and not args.debug_test_yaml and not ({"ready", "merge-test", "nightly-test"} & label_set):
         print(
-            "No AMD L2/L3 tier label found; preserving the legacy ready-suite fallback.",
-            file=sys.stderr,
-        )
-    if "nightly-test" in label_set:
-        print(
-            "AMD nightly-test has no suite yet and does not affect L2/L3 selection.",
+            "No AMD ready/merge/nightly label found; preserving the legacy ready-suite fallback.",
             file=sys.stderr,
         )
 
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-nightly.yml b/.buildkite/amd/test-amd-nightly.yml
new file mode 100644
index 000000000..0da365d0c
--- /dev/null
+++ b/.buildkite/amd/test-amd-nightly.yml
@@ -0,0 +1,66 @@
+# AMD MI300 `full_model` nightly coverage during burn-in.
+# All jobs are non-blocking until the lane has stable runtime evidence.
+# Historical build #11646 was red in Function Expansion and Accuracy (one
+# async_chunk similarity mismatch; Seed-TTS WER 0.376480 > 0.35).
+
+env:
+  VLLM_WORKER_MULTIPROC_METHOD: spawn
+  HF_HUB_DOWNLOAD_TIMEOUT: 300
+  HF_HUB_ETAG_TIMEOUT: 60
+
+steps:
+  # MI325 is the repository's legacy ROCm pytest marker. The AMD template maps
+  # agent_pool to the current MI300 Buildkite queues independently of that mark.
+  - group: ":full_moon: Qwen3-Omni MI300 Nightly"
+    steps:
+      - label: "Qwen3-Omni Function Expansion"
+        agent_pool: mi300_2
+        depends_on: amd-build
+        mirror_hardwares: [amdproduction]
+        grade: NonBlocking
+        timeout_in_minutes: 180
+        commands:
+          - export VLLM_ALLOW_LONG_MAX_MODEL_LEN="1"
+          - pytest -s -v tests/e2e/online_serving/test_qwen3_omni_expansion.py -m "full_model and rocm and MI325 and cards_2" --run-level "full_model"
+
+      - label: "Qwen3-Omni Accuracy"
+        agent_pool: mi300_2
+        depends_on: amd-build
+        mirror_hardwares: [amdproduction]
+        grade: NonBlocking
+        timeout_in_minutes: 180
+        artifact_paths:
+          - tests/e2e/accuracy/qwen3_omni/results/qwen_omni_acc/*.json
+        commands:
+          - export SEED_TTS_WER_EVAL=1
+          # PyTorch ROCm uses the torch.cuda device namespace.
+          - export SEED_TTS_EVAL_DEVICE=cuda:1
+          - pytest -s -v tests/e2e/accuracy/qwen3_omni/test_qwen3_omni.py -m "full_model and rocm and MI325 and cards_2" --run-level "full_model"
+          # Native tests run from the image copy under /app/vllm-omni, while
+          # Buildkite's artifact hook searches the checkout workspace.
+          - |
+            if [[ "$$PWD" != "$${BUILDKITE_BUILD_CHECKOUT_PATH:?}" ]]; then
+              artifact_dir="$${BUILDKITE_BUILD_CHECKOUT_PATH}/tests/e2e/accuracy/qwen3_omni/results/qwen_omni_acc"
+              mkdir -p "$$artifact_dir"
+              cp -v tests/e2e/accuracy/qwen3_omni/results/qwen_omni_acc/*.json "$$artifact_dir/"
+            fi
+
+      - label: "Qwen3-Omni Documentation Examples"
+        agent_pool: mi300_2
+        depends_on: amd-build
+        mirror_hardwares: [amdproduction]
+        grade: NonBlocking
+        timeout_in_minutes: 120
+        commands:
+          - export VLLM_ALLOW_LONG_MAX_MODEL_LEN="1"
+          - pytest -s -v tests/examples/online_serving/test_qwen3_omni.py -m "full_model and rocm and MI325 and cards_2" --run-level "full_model"
+
+      - label: "Qwen3-Omni AITER-on Smoke"
+        agent_pool: mi300_2
+        depends_on: amd-build
+        mirror_hardwares: [amdproduction]
+        grade: NonBlocking
+        timeout_in_minutes: 90
+        commands:
+          - export VLLM_ROCM_USE_AITER=1
+          - pytest -s -v tests/e2e/online_serving/test_qwen3_omni_expansion.py::test_text_to_text_audio_001 -m "full_model and rocm and MI325 and cards_2" --run-level "full_model"
diff --git a/.buildkite/amd/test-amd-ready.yml b/.buildkite/amd/test-amd-ready.yml
index 585f089a2..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
@@ -160,6 +194,39 @@ steps:
 #     - export VLLM_WORKER_MULTIPROC_METHOD=spawn
 #     - timeout 20m pytest -s -v tests/e2e/offline_inference/test_stable_audio_expansion.py -m "advanced_model and diffusion and L4" --run-level advanced_model
 
+- label: "ROCm · Engine & Model Executor GPU Coverage (R2-01)"
+  agent_pool: mi300_1
+  depends_on: amd-build
+  mirror_hardwares: [amdproduction]
+  grade: NonBlocking
+  timeout_in_minutes: 20
+  artifact_paths:
+    - "artifacts/rocm-r2-01/**/*"
+  commands:
+    # Native AMD tests run from /app/vllm-omni, while Buildkite uploads
+    # artifacts relative to its checkout directory.
+    - export R2_01_ARTIFACT_DIR="$$BUILDKITE_BUILD_CHECKOUT_PATH/artifacts/rocm-r2-01"
+    - mkdir -p "$$R2_01_ARTIFACT_DIR"
+    # The CUDA ready job also covers tests/worker/test_batched_omni_output.py.
+    # Keep the initial ROCm burn-in scoped to the requested directories.
+    # Verbose pytest output and JUnit retain node IDs without a second
+    # collection-only pass over the same GPU-backed test tree.
+    # The CUDA/L4-only CosyVoice3 ragged-flow parity test cold-JITs multiple
+    # AITER kernels on ROCm and is covered by the CUDA ready lane.
+    - >-
+      pytest -s -v -ra
+      tests/engine/ tests/model_executor/
+      -m 'core_model and cuda and not
+      (cards_2 or cards_3 or cards_4 or cards_5 or cards_6 or cards_7 or cards_8)'
+      -k 'not test_code2wav_streaming_batch_matches_ragged_flow_numerics'
+      --run-level "core_model"
+      --durations=0
+      --junitxml="$$R2_01_ARTIFACT_DIR/pytest.xml"
+      2>&1 | tee "$$R2_01_ARTIFACT_DIR/pytest.log"
+    - >-
+      tail -n 100 "$$R2_01_ARTIFACT_DIR/pytest.log" >
+      "$$R2_01_ARTIFACT_DIR/pytest-summary.txt"
+
 - label: "Engine Test"
   agent_pool: mi300_1
   depends_on: amd-build
@@ -172,6 +239,71 @@ steps:
               pytest -s -v tests/engine/test_async_omni_engine_abort.py
       '
 
+- label: "ROCm · Entrypoints GPU Coverage (R2-02)"
+  agent_pool: mi300_1
+  depends_on: amd-build
+  mirror_hardwares: [amdproduction]
+  grade: NonBlocking
+  timeout_in_minutes: 30
+  env:
+    VLLM_WORKER_MULTIPROC_METHOD: spawn
+  artifact_paths:
+    - "artifacts/rocm-r2-02/**/*"
+  commands:
+    # Native AMD tests run from /app/vllm-omni, while Buildkite uploads
+    # artifacts relative to its checkout directory.
+    - export R2_02_ARTIFACT_DIR="$$BUILDKITE_BUILD_CHECKOUT_PATH/artifacts/rocm-r2-02"
+    - mkdir -p "$$R2_02_ARTIFACT_DIR"
+    - >-
+      ps -eo pid=,ppid=,lstart=,stat=,comm= >
+      "$$R2_02_ARTIFACT_DIR/processes-before.txt"
+    # Verbose pytest output and JUnit retain selected node IDs without a
+    # second collection-only pass over the same GPU-backed test tree.
+    # The inner timeout leaves five minutes for teardown verification and
+    # artifact generation before the Buildkite step timeout.
+    - >-
+      timeout --signal=TERM --kill-after=1m 25m
+      pytest -s -v -ra
+      tests/entrypoints/
+      -m 'core_model and cuda and not
+      (cards_2 or cards_3 or cards_4 or cards_5 or cards_6 or cards_7 or cards_8)'
+      --run-level "core_model"
+      --durations=0
+      --junitxml="$$R2_02_ARTIFACT_DIR/pytest.xml"
+      2>&1 | tee "$$R2_02_ARTIFACT_DIR/pytest.log"
+    - >-
+      tail -n 100 "$$R2_02_ARTIFACT_DIR/pytest.log" >
+      "$$R2_02_ARTIFACT_DIR/pytest-summary.txt"
+    - |
+      sleep 5
+      ps -eo pid=,ppid=,lstart=,stat=,comm= > "$$R2_02_ARTIFACT_DIR/processes-after.txt"
+      # Compare PID plus process start time so PID reuse cannot hide a leak.
+      # Double dollars preserve awk field references through Buildkite interpolation.
+      awk '
+        NR == FNR {
+          if ($$9 != "ps") {
+            baseline[$$1 "|" $$3 "|" $$4 "|" $$5 "|" $$6 "|" $$7] = 1
+          }
+          next
+        }
+        $$9 != "ps" {
+          identity = $$1 "|" $$3 "|" $$4 "|" $$5 "|" $$6 "|" $$7
+          if (!(identity in baseline)) {
+            print
+            leaked = 1
+          }
+        }
+        END {
+          if (leaked) {
+            print "status=FAIL leaked_processes_detected=1"
+            exit 1
+          }
+          print "status=PASS leaked_processes=0"
+        }
+      ' "$$R2_02_ARTIFACT_DIR/processes-before.txt" \
+        "$$R2_02_ARTIFACT_DIR/processes-after.txt" \
+        2>&1 | tee "$$R2_02_ARTIFACT_DIR/process-cleanup.txt"
+
 # - label: "Omni Model Test Qwen3-Omni"
 #   agent_pool: mi300_2
 #   depends_on: amd-build
@@ -201,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
new file mode 100644
index 000000000..5dfbf8da4
--- /dev/null
+++ b/.buildkite/common/ci_source_file_dependencies.yml
@@ -0,0 +1,471 @@
+# Uploader-only path-prefix presets for CUDA L2–L5 and NPU L4 test YAML.
+# Referenced as ``source_file_dependencies: omni_qwen3_omni_function`` (or a list of
+# keys) on a step; ``upload_pipeline.py`` expands the key(s) only.
+#
+# YAML anchors above the registry hold model business-code paths. Job keys
+# ({model}_function / _perf / _accuracy / _reliability / _doc / _cov) alias
+# those anchors and add the scripts the job actually runs. Feature keys below
+# are unchanged. ``source_filter_fallback`` is not a job key: when no job-key
+# prefix matches, a matching diff keeps every job for that upload.
+#
+# YAML anchors are nested lists; the loader flattens them.
+
+x-qwen3-tts: &qwen3_tts
+  - vllm_omni/engine/async_omni_engine.py
+  - vllm_omni/entrypoints/omni_base.py
+  - vllm_omni/worker/gpu_model_runner.py
+  - vllm_omni/model_executor/models/qwen3_tts/
+  - vllm_omni/model_executor/models/common/qwen3_code_predictor.py
+  - vllm_omni/model_executor/models/common/snake_activation.py
+  - vllm_omni/model_executor/models/common/alias_free_activation.py
+  - vllm_omni/model_executor/stage_input_processors/qwen3_tts.py
+  - vllm_omni/deploy/qwen3_tts.yaml
+  - 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
+  - vllm_omni/entrypoints/omni_base.py
+  - vllm_omni/model_executor/models/minicpmo_4_5/
+  - vllm_omni/model_executor/models/step_audio2/
+  - vllm_omni/model_executor/models/cosyvoice3/code2wav_core/
+  - vllm_omni/model_executor/models/cosyvoice3/utils.py
+  - vllm_omni/model_executor/stage_input_processors/minicpmo_4_5_omni.py
+  - vllm_omni/deploy/minicpmo_4_5.yaml
+  - vllm_omni/transformers_utils/chat_templates/minicpmo45_native.jinja
+
+x-minicpmo-4-5-duplex: &minicpmo_4_5_duplex
+  - vllm_omni/deploy/minicpmo_4_5_duplex.yaml
+  - vllm_omni/engine/duplex/
+  - vllm_omni/engine/duplex_omni_engine.py
+  - vllm_omni/engine/duplex_orchestrator.py
+  - vllm_omni/engine/omni_engine_base.py
+  - 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
+  - vllm_omni/experimental/fullduplex/
+  - vllm_omni/core/sched/
+  - vllm_omni/outputs/multimodal_accumulation.py
+  - vllm_omni/engine/stage_init_utils.py
+  - vllm_omni/engine/orchestrator.py
+  - vllm_omni/entrypoints/cli/serve.py
+  - vllm_omni/entrypoints/openai/api_server.py
+  - vllm_omni/entrypoints/openai/duplex_capability.py
+  - vllm_omni/config/stage_config.py
+
+x-qwen2-5-omni: &qwen2_5_omni
+  - vllm_omni/engine/async_omni_engine.py
+  - vllm_omni/entrypoints/omni_base.py
+  - vllm_omni/model_executor/models/qwen2_5_omni/
+  - vllm_omni/model_executor/stage_input_processors/qwen2_5_omni.py
+  - vllm_omni/deploy/qwen2_5_omni.yaml
+
+x-qwen3-omni: &qwen3_omni
+  - vllm_omni/engine/async_omni_engine.py
+  - vllm_omni/entrypoints/omni_base.py
+  - vllm_omni/entrypoints/openai/serving_chat.py
+  - vllm_omni/model_executor/models/qwen3_omni/
+  - vllm_omni/model_executor/models/common/qwen3_code_predictor.py
+  - vllm_omni/model_executor/models/common/snake_activation.py
+  - vllm_omni/model_executor/models/qwen2_5_omni/qwen2_5_omni_thinker.py
+  - vllm_omni/model_executor/models/qwen3_tts/cuda_graph_decoder_wrapper.py
+  - vllm_omni/model_executor/stage_input_processors/qwen3_omni.py
+  - vllm_omni/deploy/qwen3_omni_moe.yaml
+  - vllm_omni/deploy/qwen3_omni_moe_thinking.yaml
+
+x-wan22: &wan22
+  - vllm_omni/diffusion/models/wan2_2/
+  - vllm_omni/diffusion/models/dmd2/
+
+x-cosmos3: &cosmos3
+  - vllm_omni/diffusion/models/cosmos3/
+  - vllm_omni/diffusion/distributed/autoencoders/autoencoder_kl_wan.py
+  - vllm_omni/experimental/world_models/
+  - vllm_omni/model_extras/cosmos3.py
+
+x-qwen-image: &qwen_image
+  - vllm_omni/diffusion/models/qwen_image/
+  - vllm_omni/diffusion/models/dmd2/
+  - vllm_omni/diffusion/distributed/autoencoders/autoencoder_kl_qwenimage.py
+
+x-hunyuan-image3: &hunyuan_image3
+  - vllm_omni/diffusion/models/hunyuan_image3/
+  - vllm_omni/model_executor/models/hunyuan_image3/
+  - vllm_omni/deploy/hunyuan_image3_dit.yaml
+
+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/
+  - vllm_omni/model_executor/models/hunyuan_video/
+
+x-ltx2: &ltx2
+  - vllm_omni/diffusion/models/ltx2/
+  - vllm_omni/model_extras/ltx2.py
+
+x-sana-video: &sana_video
+  - vllm_omni/diffusion/models/sana_video/
+  - vllm_omni/model_extras/sana_video.py
+
+x-z-image: &z_image
+  - vllm_omni/diffusion/models/z_image/
+
+x-stable-audio: &stable_audio
+  - vllm_omni/diffusion/models/stable_audio/
+
+x-lingbot-video: &lingbot_video
+  - vllm_omni/diffusion/models/lingbot_video/
+  - vllm_omni/model_extras/lingbot_video.py
+
+x-lingbot-world: &lingbot_world
+  - vllm_omni/diffusion/models/lingbot_world/
+
+
+source_file_dependencies:
+  # Hardware presets and shared test helpers. Not a job key — do not attach this
+  # to a step. Used only when no job-key prefix matches: then a hit keeps every job.
+  source_filter_fallback:
+    - .buildkite/common/ci_mirror_hardwares.yml
+    - tests/helpers/
+
+  # --- features ---
+  diffusion_distributed_attention:
+    - tests/diffusion/distributed/
+    - tests/diffusion/attention/test_attention_sp.py
+    - vllm_omni/diffusion/distributed/
+    - vllm_omni/diffusion/attention/
+    - vllm_omni/diffusion/data.py
+    - vllm_omni/diffusion/models/
+
+  custom_pipeline:
+    - tests/e2e/features/custom_pipeline/
+    - tests/e2e/features/helpers/custom_pipeline.py
+    - vllm_omni/diffusion/
+    - vllm_omni/engine/
+    - vllm_omni/entrypoints/
+    - vllm_omni/inputs/
+    - vllm_omni/outputs/
+
+  rlhf_verl_omni:
+    - tests/e2e/features/rlhf_test/test_verl_omni_e2e.py
+    - tests/e2e/features/helpers/verl_omni_server.py
+    - tests/e2e/features/helpers/custom_pipeline.py
+    - vllm_omni/diffusion/
+    - vllm_omni/engine/
+    - vllm_omni/entrypoints/
+    - vllm_omni/inputs/
+    - vllm_omni/outputs/
+
+  # Tiny-model diffusion jobs (shared across many model trees under models/).
+  diffusion_tiny_model:
+    - tests/model_tests/diffusion/
+    - vllm_omni/diffusion/models/
+
+  diffusion_offloader:
+    - tests/diffusion/offloader/
+    - vllm_omni/diffusion/offloader/
+
+  diffusion_quantization:
+    - tests/diffusion/quantization/
+    - vllm_omni/diffusion/quantization/
+
+  # --- models ---
+  # --- omni / tts jobs ---
+  omni_qwen3_omni_function:
+    - *qwen3_omni
+    - tests/e2e/offline_inference/test_qwen3_omni.py
+    - tests/e2e/offline_inference/test_qwen3_omni_colocate_async.py
+    - tests/e2e/offline_inference/test_qwen3_omni_autoround_w4a16_expansion.py
+    - tests/e2e/offline_inference/test_qwen3_omni_modelopt_nvfp4_w4a4.py
+    - tests/e2e/online_serving/test_qwen3_omni.py
+    - tests/e2e/online_serving/test_qwen3_omni_expansion.py
+    - tests/e2e/online_serving/test_qwen3_omni_multi_replicas.py
+
+  omni_qwen3_omni_accuracy:
+    - *qwen3_omni
+    - tests/e2e/accuracy/qwen3_omni/
+
+  omni_qwen3_omni_perf:
+    - *qwen3_omni
+    - tests/dfx/perf/scripts/run_benchmark.py
+    - tests/dfx/perf/tests/test_qwen3_omni_vllm_text.json
+    - tests/dfx/perf/tests/test_qwen3_omni_async_chunk.json
+    - tests/dfx/perf/tests/test_qwen3_omni_no_async_chunk.json
+    - tests/dfx/perf/tests/test_qwen3_omni_multi_replicas.json
+
+  omni_qwen3_omni_reliability:
+    - *qwen3_omni
+    - tests/dfx/reliability/test_reliability_qwen3_omni.py
+
+  omni_qwen3_omni_doc:
+    - *qwen3_omni
+    - examples/online_serving/qwen3_omni/
+    - examples/online_serving/openai_chat_completion_client_for_multimodal_generation.py
+    - tests/examples/online_serving/test_qwen3_omni.py
+
+  omni_qwen2_5_omni_doc:
+    - *qwen2_5_omni
+    - examples/online_serving/qwen2_5_omni/
+    - examples/online_serving/openai_chat_completion_client_for_multimodal_generation.py
+    - tests/examples/online_serving/test_qwen2_5_omni.py
+
+  omni_minicpmo_4_5_function:
+    - *minicpmo_4_5
+    - tests/e2e/offline_inference/test_minicpmo_4_5.py
+    - tests/e2e/online_serving/test_minicpmo_4_5.py
+    - tests/e2e/online_serving/test_minicpmo_4_5_expansion.py
+
+  omni_minicpmo_4_5_accuracy:
+    - *minicpmo_4_5
+    - tests/e2e/accuracy/minicpmo_4_5/
+
+  omni_minicpmo_4_5_perf:
+    - *minicpmo_4_5
+    - tests/dfx/perf/scripts/run_benchmark.py
+    - tests/dfx/perf/tests/test_minicpmo_4_5_ready.json
+    - tests/dfx/perf/tests/test_minicpmo_4_5.json
+
+  omni_minicpmo_4_5_doc:
+    - *minicpmo_4_5
+    - examples/online_serving/minicpmo/realtime_web/
+    - examples/online_serving/minicpmo/realtime_duplex_demo.py
+    - tests/examples/test_minicpmo_realtime_web_server.py
+    - tests/examples/test_minicpmo_realtime_web_static.py
+    - tests/examples/test_minicpmo_realtime_duplex_simple_demo.py
+
+  omni_minicpmo_4_5_duplex_function:
+    - *minicpmo_4_5
+    - *minicpmo_4_5_duplex
+    - tests/e2e/online_serving/test_minicpmo_4_5_duplex.py
+    - tests/e2e/online_serving/test_minicpmo_4_5_duplex_expansion.py
+    - tests/e2e/online_serving/test_duplex_client_live.py
+    - tests/e2e/online_serving/test_minicpmo_realtime_duplex_drivers.py
+    - tests/e2e/online_serving/helpers/minicpmo_realtime_duplex_scenarios.py
+    - tests/e2e/online_serving/run_minicpmo_realtime_duplex_multi_session.py
+    - tests/e2e/online_serving/run_minicpmo_realtime_duplex_server_vad.py
+    - tests/e2e/online_serving/run_minicpmo_realtime_duplex_soft_interrupt.py
+    - tests/e2e/online_serving/helpers/minicpmo_4_5_duplex.py
+    - tests/assets/minicpmo_4_5/
+    - tests/clients/
+    - tests/engine/duplex/
+    - tests/engine/test_duplex_omni_engine.py
+    - tests/engine/test_duplex_orchestrator.py
+    - tests/entrypoints/duplex/
+    - 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
+    - *minicpmo_4_5_duplex
+    - tests/dfx/perf/scripts/run_benchmark.py
+    - tests/dfx/perf/tests/test_minicpmo_4_5_duplex_seed_tts.json
+
+  tts_qwen3_tts_function:
+    - *qwen3_tts
+    - tests/e2e/features/prefill_phase/
+    - tests/e2e/offline_inference/test_qwen3_tts_base.py
+    - tests/e2e/offline_inference/test_qwen3_tts_customvoice.py
+    - tests/e2e/online_serving/test_qwen3_tts_base.py
+    - tests/e2e/online_serving/test_qwen3_tts_base_expansion.py
+    - tests/e2e/online_serving/test_qwen3_tts_customvoice.py
+    - tests/e2e/online_serving/test_qwen3_tts_customvoice_expansion.py
+
+  tts_qwen3_tts_perf:
+    - *qwen3_tts
+    - tests/dfx/perf/scripts/run_benchmark.py
+    - tests/dfx/perf/tests/test_tts.json
+
+  tts_qwen3_tts_cov:
+    - *qwen3_tts
+    - .buildkite/common/scripts/run_cov_split.sh
+    - pyproject.toml
+    - tests/e2e/offline_inference/test_qwen3_tts_base.py
+    - tests/e2e/online_serving/test_qwen3_tts_base.py
+
+  # --- diffusion jobs ---
+  diffusion_wan22_function:
+    - *wan22
+    - tests/e2e/offline_inference/test_wan22_t2v.py
+    - tests/e2e/offline_inference/test_wan22_autoround_w4a16_expansion.py
+    - tests/e2e/offline_inference/test_device_postprocess_equivalence.py
+    - tests/e2e/online_serving/test_wan22_t2v.py
+    - tests/e2e/online_serving/test_wan22_expansion.py
+
+  diffusion_wan22_accuracy:
+    - *wan22
+    - tests/e2e/accuracy/wan22_i2v/
+    - tests/e2e/accuracy/test_diffusers_backend_similarity.py
+
+  diffusion_wan22_perf:
+    - *wan22
+    - tests/dfx/perf/scripts/run_diffusion_benchmark.py
+    - tests/dfx/perf/tests/test_wan22_i2v_vllm_omni.json
+
+  diffusion_wan22_reliability:
+    - *wan22
+    - tests/dfx/reliability/test_reliability_wan22.py
+
+  diffusion_image_to_video_doc:
+    - *wan22
+    - *hunyuan_video
+    - *ltx2
+    - *sana_video
+    - *lingbot_video
+    - examples/offline_inference/image_to_video/
+    - tests/examples/offline_inference/test_image_to_video.py
+
+  diffusion_cosmos3_function:
+    - *cosmos3
+    - tests/e2e/online_serving/test_cosmos3.py
+
+  diffusion_cosmos3_accuracy:
+    - *cosmos3
+    - tests/e2e/accuracy/test_cosmos3_similarity.py
+
+  diffusion_cosmos3_perf:
+    - *cosmos3
+    - tests/dfx/perf/scripts/run_diffusion_benchmark.py
+    - tests/dfx/perf/tests/test_cosmos3_vllm_omni.json
+
+  diffusion_qwen_image_function:
+    - *qwen_image
+    - tests/e2e/online_serving/test_qwen_image.py
+    - tests/e2e/online_serving/test_qwen_image_expansion.py
+    - tests/e2e/offline_inference/test_qwen_image_autoround_w4a16_expansion.py
+
+  diffusion_qwen_image_accuracy:
+    - *qwen_image
+    - tests/e2e/accuracy/test_qwen_image.py
+    - tests/e2e/accuracy/test_diffusers_backend_similarity.py
+
+  diffusion_qwen_image_perf:
+    - *qwen_image
+    - tests/dfx/perf/scripts/run_diffusion_benchmark.py
+    - tests/dfx/perf/tests/test_qwen_image_vllm_omni.json
+
+  diffusion_text_to_image_doc:
+    - *qwen_image
+    - *z_image
+    - examples/offline_inference/text_to_image/
+    - examples/online_serving/text_to_image/
+    - tests/examples/offline_inference/test_text_to_image.py
+    - tests/examples/online_serving/test_text_to_image.py
+    - vllm_omni/diffusion/models/nextstep_1_1/
+    - vllm_omni/diffusion/models/longcat_image/
+    - vllm_omni/diffusion/models/ovis_image/
+    - vllm_omni/diffusion/models/omnigen2/
+    - vllm_omni/diffusion/models/sd3/
+    - vllm_omni/diffusion/models/flux/
+    - vllm_omni/diffusion/models/flux2/
+    - vllm_omni/diffusion/models/flux2_klein/
+    - vllm_omni/diffusion/models/hidream_image/
+    - vllm_omni/diffusion/models/krea2/
+    - vllm_omni/diffusion/models/lingbot_video/
+
+  diffusion_hunyuan_image3_function:
+    - *hunyuan_image3
+    - tests/e2e/offline_inference/test_hunyuanimage3_i2t_expansion.py
+
+  diffusion_hunyuan_image3_accuracy:
+    - *hunyuan_image3
+    - tests/e2e/accuracy/test_hunyuan_image3_pixel_accuracy.py
+
+  diffusion_hunyuan_image3_perf:
+    - *hunyuan_image3
+    - tests/dfx/perf/scripts/run_diffusion_benchmark.py
+    - tests/dfx/perf/tests/test_hunyuan_image_tp2_cfgp2.json
+    - tests/dfx/perf/tests/test_hunyuan_image_tp2_sp2.json
+    - tests/dfx/perf/tests/test_hunyuan_image_tp4.json
+
+  diffusion_hunyuan_image3_reliability:
+    - *hunyuan_image3
+    - tests/dfx/reliability/test_reliability_hunyuan_image.py
+
+  diffusion_minimax_h3_function:
+    - *minimax_h3
+    - tests/e2e/online_serving/test_minimax_h3_dlo_dp2_t2va.py
+    - tests/e2e/online_serving/minimax_h3/
+    - tests/diffusion/models/minimax_h3/
+    - vllm_omni/diffusion/lora/
+    - vllm_omni/diffusion/offloader/
+    - vllm_omni/diffusion/distributed/
+    - vllm_omni/entrypoints/openai/
+
+  diffusion_minimax_h3_accuracy:
+    - *minimax_h3
+    - tests/e2e/accuracy/minimax_h3/
+
+  diffusion_minimax_h3_perf:
+    - *minimax_h3
+    - tests/dfx/perf/scripts/run_diffusion_benchmark.py
+    - tests/dfx/perf/tests/test_minimax_h3_vllm_omni.json
+
+  diffusion_hunyuan_video_function:
+    - *hunyuan_video
+    - tests/e2e/online_serving/test_hunyuan_video_15_expansion.py
+
+  diffusion_hunyuan_video_accuracy:
+    - *hunyuan_video
+    - tests/e2e/accuracy/hunyuanvideo15_t2v/
+    - tests/e2e/accuracy/hunyuanvideo15_i2v/
+
+  diffusion_hunyuan_video_perf:
+    - *hunyuan_video
+    - tests/dfx/perf/scripts/run_diffusion_benchmark.py
+    - tests/dfx/perf/tests/test_hunyuanvideo15_t2v_vllm_omni.json
+    - tests/dfx/perf/tests/test_hunyuanvideo15_i2v_vllm_omni.json
+
+  diffusion_z_image_function:
+    - *z_image
+    - tests/e2e/online_serving/test_z_image.py
+    - tests/e2e/online_serving/test_zimage_expansion.py
+
+  diffusion_sana_video_function:
+    - *sana_video
+    - tests/e2e/online_serving/test_sana_video_expansion.py
+    - tests/e2e/accuracy/sana_video/
+
+  diffusion_stable_audio_function:
+    - *stable_audio
+    - tests/e2e/offline_inference/test_stable_audio_expansion.py
+    - tests/e2e/online_serving/test_stable_audio_online_expansion.py
+
+  diffusion_lingbot_function:
+    - *lingbot_video
+    - *lingbot_world
+    - tests/e2e/online_serving/test_lingbot_video.py
+    - tests/e2e/online_serving/test_lingbot_video_moe.py
+    - tests/e2e/offline_inference/test_lingbot_world_v2.py
+
+
+  # Invalid-param jobs: model business code only, plus the reliability scripts.
+  reliability_invalid_param_h100:
+    - *qwen3_omni
+    - *minicpmo_4_5
+    - *qwen_image
+    - *wan22
+    - tests/dfx/reliability/invalid_param_test/
+
+  reliability_invalid_param_l4:
+    - *qwen3_tts
+    - *stable_audio
+    - tests/dfx/reliability/invalid_param_test/
diff --git a/.buildkite/common/scripts/skip_ci.py b/.buildkite/common/scripts/skip_ci.py
index 8d5fdd5e0..3b4168c01 100644
--- a/.buildkite/common/scripts/skip_ci.py
+++ b/.buildkite/common/scripts/skip_ci.py
@@ -44,6 +44,7 @@ L3_YAML_FILES: dict[str, str] = {
 L45_YAML_FILES: dict[str, str] = {
     ".buildkite/cuda/test-nightly.yml": "cuda",
     ".buildkite/cuda/test-weekly.yml": "cuda",
+    ".buildkite/amd/test-amd-nightly.yml": "amd",
     ".buildkite/npu/test-npu-nightly.yml": "npu",
 }
 
diff --git a/.buildkite/common/scripts/upload_pipeline.py b/.buildkite/common/scripts/upload_pipeline.py
index 749f35f5a..71ed75119 100644
--- a/.buildkite/common/scripts/upload_pipeline.py
+++ b/.buildkite/common/scripts/upload_pipeline.py
@@ -10,8 +10,17 @@ Bootstrap mode (``bootstrap-upload-steps.yml``):
   - Detect docs-only, pytest skip-mark-only, or combined skip-ci from git diff.
   - When only CI level YAML changes, enable **L2/L3** upload steps for affected levels only.
 
-Test pipeline mode (e.g. test-merge.yml):
-  - Drop steps whose ``source_file_dependencies`` do not match changed files.
+Test pipeline mode (e.g. test-merge.yml, test-nightly.yml, test-weekly.yml):
+  - Drop steps whose ``source_file_dependencies`` do not match changed files
+    (string/list keys from ci_source_file_dependencies.yml, or inline path
+    prefixes). Filtering applies on **PR label** uploads and on post-merge
+    ``main`` L3 uploads. Scheduled ``main`` uploads that pass ``--all``
+    (NIGHTLY/WEEKLY) or ``--e2e`` keep every selected job and still strip
+    the field. If no job-key prefix matches, a change to the pipeline YAML
+    being uploaded or to a path under the ``source_filter_fallback`` registry
+    key keeps every job so command, env, and hardware edits can be validated
+    before merge. When any job-key prefix already matches, normal filtering
+    wins.
   - Expand uploader-only ``mirror_hardwares`` into ``agents`` (+ optional ``image``
     for NPU) + ``plugins`` (see ci_mirror_hardwares.yml).
   - Omit ``mirror_hardwares`` to compose ``{chip}_{n}`` from pytest ``-m`` SKU
@@ -87,6 +96,10 @@ BOOTSTRAP_UPLOAD_IF_KEYS = {
 }
 E2E_GROUP_MARKER = "E2E Test"
 CI_MIRROR_HARDWARES_PATH = ROOT / ".buildkite/common/ci_mirror_hardwares.yml"
+CI_SOURCE_FILE_DEPENDENCIES_PATH = ROOT / ".buildkite/common/ci_source_file_dependencies.yml"
+# Registry key whose prefixes bypass source filtering. Paths live in
+# ci_source_file_dependencies.yml; do not attach this key to a job.
+SOURCE_FILTER_FALLBACK_KEY = "source_filter_fallback"
 CUDA_HF_TOKEN_ENV = "VLLM_CI_HF_TOKEN"
 CUDA_HF_TOKEN_EXPORT = f'if [ -n "$${{{CUDA_HF_TOKEN_ENV}:-}}" ]; then export HF_TOKEN="$${{{CUDA_HF_TOKEN_ENV}}}"; fi'
 
@@ -95,14 +108,7 @@ CUDA_HF_TOKEN_EXPORT = f'if [ -n "$${{{CUDA_HF_TOKEN_ENV}:-}}" ]; then export HF
 # ``*_UPLOAD_IF``: full gate for uploading that child pipeline.
 NIGHTLY_MAIN_IF = 'build.branch == "main" && build.env("NIGHTLY") == "1"'
 NIGHTLY_LABEL_IF = (
-    f"({NIGHTLY_MAIN_IF}) || "
-    '(build.branch != "main" && ('
-    'build.pull_request.labels includes "nightly-test" || '
-    'build.pull_request.labels includes "omni-test" || '
-    'build.pull_request.labels includes "tts-test" || '
-    'build.pull_request.labels includes "diffusion-x2iat-test" || '
-    'build.pull_request.labels includes "diffusion-x2v-test"'
-    "))"
+    f'({NIGHTLY_MAIN_IF}) || (build.branch != "main" && build.pull_request.labels includes "nightly-test")'
 )
 WEEKLY_E2E_IF = 'build.branch == "main" && build.env("WEEKLY") == "1"'
 WEEKLY_MAIN_IF = 'build.branch == "main" && (build.env("WEEKLY") == "1" || build.env("NON_CRITICAL") == "1")'
@@ -248,7 +254,7 @@ def _render_bootstrap_pipeline(
     return yaml.safe_dump(doc, sort_keys=False)
 
 
-# --- Test pipeline (test-ready.yml, test-merge.yml) ---
+# --- Test pipeline (test-ready.yml, test-merge.yml, test-nightly.yml) ---
 
 
 @lru_cache(maxsize=1)
@@ -264,6 +270,117 @@ def _load_mirror_hardwares() -> dict[str, dict[str, Any]]:
     return presets
 
 
+@lru_cache(maxsize=1)
+def _load_source_file_dependencies() -> dict[str, list[str]]:
+    def flatten(value: Any, *, key: str) -> list[str]:
+        """Flatten YAML-anchor nested lists into a de-duplicated prefix list."""
+        if isinstance(value, str):
+            if not value.strip():
+                raise ValueError(f"empty path in source_file_dependencies[{key!r}]")
+            return [value]
+        if isinstance(value, list):
+            flattened: list[str] = []
+            seen: set[str] = set()
+            for item in value:
+                for path in flatten(item, key=key):
+                    if path not in seen:
+                        seen.add(path)
+                        flattened.append(path)
+            return flattened
+        raise ValueError(
+            f"source_file_dependencies[{key!r}] must be a list of path prefixes, got {type(value).__name__}",
+        )
+
+    if not CI_SOURCE_FILE_DEPENDENCIES_PATH.is_file():
+        raise FileNotFoundError(
+            f"missing CI source_file_dependencies registry: {CI_SOURCE_FILE_DEPENDENCIES_PATH}",
+        )
+    doc = yaml.safe_load(CI_SOURCE_FILE_DEPENDENCIES_PATH.read_text(encoding="utf-8"))
+    if not isinstance(doc, dict):
+        raise ValueError(f"invalid CI source_file_dependencies registry: {CI_SOURCE_FILE_DEPENDENCIES_PATH}")
+    presets = doc.get("source_file_dependencies")
+    if not isinstance(presets, dict):
+        raise ValueError(f"source_file_dependencies must be a mapping in {CI_SOURCE_FILE_DEPENDENCIES_PATH}")
+    loaded: dict[str, list[str]] = {}
+    for key, value in presets.items():
+        if not isinstance(key, str) or not key.strip():
+            raise ValueError(
+                f"source_file_dependencies keys must be non-empty strings in {CI_SOURCE_FILE_DEPENDENCIES_PATH}",
+            )
+        loaded[key] = flatten(value, key=key)
+    return loaded
+
+
+_REGISTRY_KEY_RE = re.compile(r"^[a-z][a-z0-9_]*$")
+
+
+def _parse_command_text(step: dict[str, Any]) -> str:
+    """Parse step ``commands`` / ``command`` into a single string."""
+    raw = step.get("commands", step.get("command"))
+    if raw is None:
+        return ""
+    if isinstance(raw, str):
+        return raw
+    if isinstance(raw, list):
+        return "\n".join(str(item) for item in raw if item is not None)
+    return str(raw)
+
+
+def _resolve_source_file_dependencies(step: dict[str, Any]) -> list[str] | None:
+    """Expand a registry key (or list of keys / inline path prefixes)."""
+    deps = step.get("source_file_dependencies")
+    if deps is None:
+        return None
+
+    def dedupe(*groups: list[str]) -> list[str]:
+        merged: list[str] = []
+        seen: set[str] = set()
+        for group in groups:
+            for path in group:
+                if path not in seen:
+                    seen.add(path)
+                    merged.append(path)
+        return merged
+
+    def lookup(key: str) -> list[str]:
+        if key == SOURCE_FILTER_FALLBACK_KEY:
+            raise ValueError(
+                f"source_file_dependencies {key!r} bypasses filtering and cannot be attached to a step "
+                f"({_get_step_label(step)!r})",
+            )
+        registry = _load_source_file_dependencies()
+        paths = registry.get(key)
+        if paths is None:
+            known = ", ".join(sorted(registry))
+            raise ValueError(
+                f"unknown source_file_dependencies {key!r} in step {_get_step_label(step)!r}; known: {known}",
+            )
+        return list(paths)
+
+    prefixes: list[str]
+    if isinstance(deps, str):
+        prefixes = lookup(deps) if _REGISTRY_KEY_RE.fullmatch(deps) else [deps]
+    elif isinstance(deps, list):
+        if not all(isinstance(item, str) for item in deps):
+            raise ValueError(
+                f"source_file_dependencies must be a string key or list of strings in step {_get_step_label(step)!r}",
+            )
+        keyish = [bool(_REGISTRY_KEY_RE.fullmatch(item)) for item in deps]
+        if deps and all(keyish):
+            prefixes = dedupe(*(lookup(key) for key in deps))
+        elif any(keyish):
+            raise ValueError(
+                f"source_file_dependencies in step {_get_step_label(step)!r} mixes registry keys and path prefixes",
+            )
+        else:
+            prefixes = list(deps)
+    else:
+        raise ValueError(
+            f"source_file_dependencies must be a string key or list in step {_get_step_label(step)!r}",
+        )
+    return prefixes
+
+
 @lru_cache(maxsize=1)
 def _cuda_mirror_chips() -> tuple[str, ...]:
     """Lowercase CUDA SKUs that have at least one ``{chip}_{n}`` preset.
@@ -278,7 +395,7 @@ def _cuda_mirror_chips() -> tuple[str, ...]:
     return tuple(sorted(chips, key=lambda chip: (-len(chip), chip)))
 
 
-def _read_cards_marks(expr: str) -> tuple[set[int], bool]:
+def _parse_cards_marks(expr: str) -> tuple[set[int], bool]:
     """Parse registered ``cards_n`` / ``not cards_n`` from a pytest ``-m`` expr.
 
     Returns positive card counts and whether any ``not cards_*`` is present.
@@ -295,8 +412,8 @@ def _read_cards_marks(expr: str) -> tuple[set[int], bool]:
     return positives, has_not_cards
 
 
-def _read_hardware_marks(expr: str) -> set[str]:
-    """Return lowercase positive CUDA SKUs that have a mirror preset.
+def _parse_hardware_marks(expr: str) -> set[str]:
+    """Parse lowercase positive CUDA SKUs that have a mirror preset.
 
     ``not H100`` is ignored. SKUs with no ``{chip}_*`` preset (e.g. H200) are dropped.
     """
@@ -338,36 +455,22 @@ def _get_mirror_hw_selector() -> str:
     return selector
 
 
-def _read_pytest_marks(commands: Any) -> tuple[set[str], int | Literal["max"] | None]:
-    """Read pytest ``-m`` from step commands: CUDA SKU chips and cards count.
+def _parse_pytest_marks(step: dict[str, Any]) -> tuple[set[str], int | Literal["max"] | None]:
+    """Parse pytest ``-m`` from step commands: CUDA SKU chips and cards count.
 
     *chips* are lowercase SKUs from positive markers (``not H100`` is ignored).
     *cards* is the max positive ``cards_n``, ``"max"`` when only ``not cards_*``
     is present, or ``None``.
     """
-    chunks: list[str] = []
-
-    def _collect(value: Any) -> None:
-        if value is None:
-            return
-        if isinstance(value, str):
-            chunks.append(value)
-        elif isinstance(value, list):
-            for part in value:
-                _collect(part)
-        else:
-            chunks.append(str(value))
-
-    _collect(commands)
-    text = "\n".join(chunks)
+    text = _parse_command_text(step)
 
     chips: set[str] = set()
     positives: set[int] = set()
     has_not_cards = False
     for match in _PYTEST_MARKER_ARG.finditer(text):
         expr = match.group(1) or match.group(2) or match.group(3) or ""
-        chips |= _read_hardware_marks(expr)
-        card_counts, not_cards = _read_cards_marks(expr)
+        chips |= _parse_hardware_marks(expr)
+        card_counts, not_cards = _parse_cards_marks(expr)
         positives.update(card_counts)
         has_not_cards = has_not_cards or not_cards
 
@@ -484,7 +587,7 @@ def _expand_mirror_hardwares(step: dict[str, Any]) -> dict[str, Any] | None:
     if "mirror_hardwares" not in step:
         if has_pool:
             return step
-        chips, cards = _read_pytest_marks(step.get("commands"))
+        chips, cards = _parse_pytest_marks(step)
         if not chips and cards is None:
             return step
         preset_name = _compose_mirror_hardware_name(chips, cards, step_label=step_label)
@@ -552,11 +655,7 @@ def _process_test_steps(
             processed.append(step)
             continue
 
-        deps = step.get("source_file_dependencies")
-        if deps is not None and not isinstance(deps, list):
-            raise ValueError(
-                f"source_file_dependencies must be a list in step {_get_step_label(step)!r}",
-            )
+        deps = _resolve_source_file_dependencies(step)
         if changed_files is not None and deps is not None and not _match_source_file(changed_files, deps):
             _log(f"skip {_get_step_label(step)!r} (no changes under {deps})")
             continue
@@ -595,10 +694,25 @@ def _select_e2e_group_steps(steps: list[Any]) -> list[Any]:
     return selected
 
 
+def _any_source_dependency_match(steps: list[Any], changed_files: list[str]) -> bool:
+    """True when any step with ``source_file_dependencies`` matches *changed_files*."""
+    for step in steps:
+        if not isinstance(step, dict):
+            continue
+        deps = _resolve_source_file_dependencies(step)
+        if deps is not None and _match_source_file(changed_files, deps):
+            return True
+        nested = step.get("steps")
+        if isinstance(nested, list) and _any_source_dependency_match(nested, changed_files):
+            return True
+    return False
+
+
 def _render_test_pipeline(
     doc: dict[str, Any],
     changed_files: list[str] | None,
     *,
+    pipeline_path: Path | None = None,
     e2e_only: bool = False,
 ) -> dict[str, Any]:
     """Filter steps by PR diff and strip uploader-only ``source_file_dependencies`` metadata."""
@@ -611,6 +725,13 @@ def _render_test_pipeline(
         return doc
     if e2e_only:
         steps = _select_e2e_group_steps(steps)
+    # Bypass is a fallback: only when no job-key prefix matched.
+    if changed_files is not None and pipeline_path is not None:
+        if not _any_source_dependency_match(steps, changed_files):
+            bypass = _source_filter_fallback_reason(changed_files, pipeline_path)
+            if bypass is not None:
+                _log(f"keep all jobs (no source_file_dependencies match; bypassed by {bypass})")
+                changed_files = None
     steps = _process_test_steps(steps, changed_files)
     return {**doc, "steps": steps}
 
@@ -618,6 +739,60 @@ def _render_test_pipeline(
 # --- Entry (read file → bootstrap or test render → YAML string) ---
 
 
+def _repo_relative_posix(path: Path) -> str:
+    resolved = path.resolve()
+    try:
+        return resolved.relative_to(ROOT).as_posix()
+    except ValueError:
+        return path.as_posix().replace("\\", "/")
+
+
+def _source_filter_fallback_prefixes() -> list[str]:
+    """Shared uploader/registry prefixes from ``source_filter_fallback``. Not a job key."""
+    registry = _load_source_file_dependencies()
+    prefixes = registry.get(SOURCE_FILTER_FALLBACK_KEY)
+    if not prefixes:
+        raise ValueError(
+            f"source_file_dependencies[{SOURCE_FILTER_FALLBACK_KEY!r}] must list shared uploader paths "
+            f"in {CI_SOURCE_FILE_DEPENDENCIES_PATH}",
+        )
+    return prefixes
+
+
+def _source_filter_fallback_reason(changed_files: list[str] | None, pipeline_path: Path) -> str | None:
+    """Return the changed path that should disable source filtering, if any."""
+    if not changed_files:
+        return None
+    changed = set(changed_files)
+    pipeline_rel = _repo_relative_posix(pipeline_path)
+    if pipeline_rel in changed:
+        return pipeline_rel
+    prefixes = _source_filter_fallback_prefixes()
+    for path in changed_files:
+        if _match_source_file([path], prefixes):
+            return path
+    return None
+
+
+def _changed_files_for_source_filter(
+    ctx,
+    *,
+    force_all: bool,
+    e2e_only: bool,
+) -> list[str] | None:
+    """Return the diff to filter against, or None to keep every step.
+
+    ``--all`` / ``--e2e`` disable filtering (scheduled NIGHTLY/WEEKLY full
+    uploads and weekly E2E sweeps). Post-merge ``main`` L3 and PR-label
+    uploads filter against the commit/PR diff. Pipeline YAML /
+    ``source_filter_fallback`` matches are applied later in
+    ``_render_test_pipeline`` only when no job-key prefix already matched.
+    """
+    if force_all or e2e_only:
+        return None
+    return ctx.changed_files
+
+
 def _render_pipeline(
     path: Path,
     *,
@@ -635,13 +810,18 @@ def _render_pipeline(
 
     text = path.read_text(encoding="utf-8")
     ctx = resolve_ci_context_from_git()
-    changed_files = None if force_all or e2e_only else ctx.changed_files
+    changed_files = _changed_files_for_source_filter(ctx, force_all=force_all, e2e_only=e2e_only)
 
     doc = yaml.safe_load(text)
     if not isinstance(doc, dict):
         raise ValueError(f"invalid pipeline YAML: {path}")
 
-    doc = _render_test_pipeline(doc, changed_files, e2e_only=e2e_only)
+    doc = _render_test_pipeline(
+        doc,
+        changed_files,
+        pipeline_path=path,
+        e2e_only=e2e_only,
+    )
     return yaml.safe_dump(doc, sort_keys=False)
 
 
diff --git a/.buildkite/cuda/bootstrap-upload-steps.yml b/.buildkite/cuda/bootstrap-upload-steps.yml
index ab4254feb..3f5aa1cb1 100644
--- a/.buildkite/cuda/bootstrap-upload-steps.yml
+++ b/.buildkite/cuda/bootstrap-upload-steps.yml
@@ -22,7 +22,8 @@ steps:
     agents:
       queue: "cpu_queue_premerge"
 
-  # L3 Test — PR merge-test label (diff-aware) or main+WEEKLY=1 (--e2e, full E2E group)
+  # L3 Test — PR merge-test label or post-merge on main (both diff-aware);
+  # main+WEEKLY=1 uploads the E2E group only (--e2e).
   - label: "Upload Merge Pipeline"
     depends_on: image-build
     key: upload-merge-pipeline
@@ -36,20 +37,30 @@ steps:
     agents:
       queue: "cpu_queue_premerge"
 
-  # L4 Test — main+NIGHTLY=1 (scheduled), or PR with specific label (e.g. add label then Rebuild)
+  # L4 Test — main+NIGHTLY=1 (full pipeline), or PR nightly-test label (diff-aware)
   - label: "Upload Nightly Pipeline"
     depends_on: image-build
     key: upload-nightly-pipeline
     commands:
-      - python3 .buildkite/common/scripts/upload_pipeline.py --upload .buildkite/cuda/test-nightly.yml
+      - |
+        EXTRA=""
+        if [ "${NIGHTLY:-}" = "1" ] && [ "${BUILDKITE_BRANCH}" = "main" ]; then
+          EXTRA="--all"
+        fi
+        python3 .buildkite/common/scripts/upload_pipeline.py --upload $$EXTRA .buildkite/cuda/test-nightly.yml
     agents:
       queue: "cpu_queue_premerge"
 
-  # L5 Test — main+WEEKLY=1 / NON_CRITICAL=1 (scheduled), or PR with weekly-test label
+  # L5 Test — main+WEEKLY=1 / NON_CRITICAL=1 (full pipeline), or PR weekly-test label (diff-aware)
   - label: "Upload Weekly Pipeline"
     depends_on: image-build
     key: upload-weekly-pipeline
     commands:
-      - python3 .buildkite/common/scripts/upload_pipeline.py --upload .buildkite/cuda/test-weekly.yml
+      - |
+        EXTRA=""
+        if [ "${BUILDKITE_BRANCH}" = "main" ]; then
+          EXTRA="--all"
+        fi
+        python3 .buildkite/common/scripts/upload_pipeline.py --upload $$EXTRA .buildkite/cuda/test-weekly.yml
     agents:
       queue: "cpu_queue_premerge"
diff --git a/.buildkite/cuda/test-merge.yml b/.buildkite/cuda/test-merge.yml
index 71eabf527..cf0af0d31 100644
--- a/.buildkite/cuda/test-merge.yml
+++ b/.buildkite/cuda/test-merge.yml
@@ -1,5 +1,6 @@
 # CUDA CI L3 (`advanced_model` e2e) plus L1 CPU Simple Test (`core_model and cpu`).
-# Uploaded by Upload Merge Pipeline: PR label `merge-test`, or post-merge on main.
+# Uploaded by Upload Merge Pipeline: PR label `merge-test`, or post-merge on main
+# (both diff-aware via source_file_dependencies).
 
 env:
   VLLM_WORKER_MULTIPROC_METHOD: spawn
@@ -65,7 +66,9 @@ steps:
         # 0.26 startup regression is understood and fixed.
         timeout_in_minutes: 90
         commands:
-          - pytest -s -v tests/entrypoints/ -m "advanced_model and cuda and H100" --run-level "advanced_model"
+          # Turn-based server VAD over /v1/realtime is deferred to RFC #7181 PR 5
+          # (see the P0 thread on #7413); the test stays in the tree and runs again there.
+          - pytest -s -v tests/entrypoints/ -m "advanced_model and cuda and H100" --run-level "advanced_model" --deselect tests/entrypoints/openai_api/test_qwen3_omni_realtime_websocket.py::TestQwen3OmniRealtimeWebSocket::test_server_vad_multi_turn_without_client_commit
         mirror_hardwares: h100_2
 
       - label: "Entrypoint Test with L4"
@@ -78,21 +81,7 @@ steps:
     depends_on: upload-merge-pipeline
     steps:
       - label: "TTS · Qwen3-TTS CustomVoice Test"
-        source_file_dependencies:
-          - tests/e2e/features/prefill_phase/
-          - vllm_omni/worker/gpu_model_runner.py
-          - tests/helpers/media.py
-          - tests/e2e/online_serving/test_qwen3_tts_customvoice.py
-          - tests/e2e/offline_inference/test_qwen3_tts_customvoice.py
-          - vllm_omni/model_executor/models/qwen3_tts/
-          - vllm_omni/model_executor/models/common/qwen3_code_predictor.py
-          - vllm_omni/model_executor/models/common/snake_activation.py
-          - vllm_omni/model_executor/models/common/alias_free_activation.py
-          - vllm_omni/model_executor/stage_input_processors/qwen3_tts.py
-          - vllm_omni/deploy/qwen3_tts.yaml
-          - vllm_omni/entrypoints/openai/serving_speech.py
-          - vllm_omni/entrypoints/openai/tts_adapters/
-          - vllm_omni/engine/stage_pool.py
+        source_file_dependencies: tts_qwen3_tts_function
         commands:
           - |
             timeout 40m bash -c "
@@ -103,21 +92,7 @@ steps:
         mirror_hardwares: l4_1
 
       - label: "TTS · Qwen3-TTS Base Test"
-        source_file_dependencies:
-          - tests/helpers/media.py
-          - tests/e2e/online_serving/test_qwen3_tts_base.py
-          - tests/e2e/offline_inference/test_qwen3_tts_base.py
-          - vllm_omni/model_executor/models/qwen3_tts/
-          - vllm_omni/model_executor/models/common/qwen3_code_predictor.py
-          - vllm_omni/model_executor/models/common/snake_activation.py
-          - vllm_omni/model_executor/models/common/alias_free_activation.py
-          - vllm_omni/model_executor/stage_input_processors/qwen3_tts.py
-          - vllm_omni/deploy/qwen3_tts.yaml
-          - vllm_omni/entrypoints/openai/serving_speech.py
-          - vllm_omni/entrypoints/openai/tts_adapters/
-          - vllm_omni/engine/stage_pool.py
-          - .buildkite/common/scripts/run_cov_split.sh
-          - pyproject.toml
+        source_file_dependencies: tts_qwen3_tts_cov
         # 40 -> 60: the coverage split runs the model twice.
         timeout_in_minutes: 60
         commands:
@@ -132,36 +107,14 @@ steps:
         mirror_hardwares: l4_1
 
       - label: "Omni · Qwen3-Omni Test"
-        source_file_dependencies:
-          - tests/e2e/offline_inference/test_qwen3_omni.py
-          - tests/e2e/offline_inference/test_qwen3_omni_colocate_async.py
-          - tests/e2e/online_serving/test_qwen3_omni.py
-          - tests/helpers/runtime.py
-          - vllm_omni/entrypoints/openai/serving_chat.py
-          - vllm_omni/model_executor/models/qwen3_omni/
-          - vllm_omni/model_executor/models/common/qwen3_code_predictor.py
-          - vllm_omni/model_executor/models/common/snake_activation.py
-          - vllm_omni/model_executor/models/qwen2_5_omni/qwen2_5_omni_thinker.py
-          - vllm_omni/model_executor/models/qwen3_tts/cuda_graph_decoder_wrapper.py
-          - vllm_omni/model_executor/stage_input_processors/qwen3_omni.py
-          - vllm_omni/deploy/qwen3_omni_moe.yaml
-          - vllm_omni/deploy/qwen3_omni_moe_thinking.yaml
+        source_file_dependencies: omni_qwen3_omni_function
         timeout_in_minutes: 50
         commands:
           - pytest -s -v tests/e2e/offline_inference/test_qwen3_omni.py tests/e2e/online_serving/test_qwen3_omni.py tests/e2e/offline_inference/test_qwen3_omni_colocate_async.py -m 'advanced_model and cuda' --run-level 'advanced_model'
         mirror_hardwares: h100_2
 
       - label: "Omni · MiniCPM-o 4.5 Test"
-        source_file_dependencies:
-          - tests/e2e/offline_inference/test_minicpmo_4_5.py
-          - tests/e2e/online_serving/test_minicpmo_4_5.py
-          - vllm_omni/transformers_utils/chat_templates/minicpmo45_native.jinja
-          - vllm_omni/model_executor/models/minicpmo_4_5/
-          - vllm_omni/model_executor/models/step_audio2/
-          - vllm_omni/model_executor/models/cosyvoice3/code2wav_core/
-          - vllm_omni/model_executor/models/cosyvoice3/utils.py
-          - vllm_omni/model_executor/stage_input_processors/minicpmo_4_5_omni.py
-          - vllm_omni/deploy/minicpmo_4_5.yaml
+        source_file_dependencies: omni_minicpmo_4_5_function
         timeout_in_minutes: 50
         commands:
           - pytest -s -v tests/e2e/offline_inference/test_minicpmo_4_5.py tests/e2e/online_serving/test_minicpmo_4_5.py -m 'advanced_model and cuda' --run-level 'advanced_model'
@@ -174,48 +127,7 @@ steps:
         mirror_hardwares: h100_2
 
       - label: "Omni · MiniCPM-o 4.5 Duplex Test"
-        source_file_dependencies:
-          - tests/assets/minicpmo_4_5/response_required_16k.wav
-          - tests/assets/minicpmo_4_5/soft_interrupt_16k.wav
-          - tests/e2e/online_serving/test_minicpmo_4_5_duplex.py
-          - tests/e2e/online_serving/test_minicpmo_4_5_duplex_expansion.py
-          - tests/e2e/online_serving/test_minicpmo_realtime_duplex_drivers.py
-          - tests/e2e/online_serving/helpers/minicpmo_realtime_duplex_scenarios.py
-          - tests/e2e/online_serving/run_minicpmo_realtime_duplex_multi_session.py
-          - tests/e2e/online_serving/run_minicpmo_realtime_duplex_server_vad.py
-          - tests/e2e/online_serving/run_minicpmo_realtime_duplex_soft_interrupt.py
-          - vllm_omni/deploy/minicpmo_4_5.yaml
-          - tests/e2e/online_serving/helpers/minicpmo_4_5_duplex.py
-          - vllm_omni/engine/duplex/
-          - vllm_omni/entrypoints/duplex/
-          # Public duplex client library + its unit suites: client-side
-          # changes must re-run the duplex e2e group. The live client probe
-          # (test_duplex_client_live.py, single GPU, core tier) runs in the
-          # ready pipeline's duplex group.
-          - vllm_omni/clients/
-          - tests/clients/
-          - vllm_omni/entrypoints/duplex_request_client.py
-          - vllm_omni/outputs/duplex.py
-          - vllm_omni/model_executor/duplex_sampling.py
-          - tests/engine/duplex/
-          - tests/entrypoints/duplex/
-          - tests/model_executor/models/minicpmo_4_5/duplex/
-          # Legacy Realtime probe client + video stacking used by the e2e drivers.
-          - vllm_omni/experimental/fullduplex/
-          - vllm_omni/model_executor/models/minicpmo_4_5/
-          - vllm_omni/model_executor/models/step_audio2/
-          - vllm_omni/model_executor/models/cosyvoice3/code2wav_core/
-          - vllm_omni/model_executor/models/cosyvoice3/utils.py
-          - vllm_omni/model_executor/stage_input_processors/minicpmo_4_5_omni.py
-          - vllm_omni/core/sched/
-          - vllm_omni/outputs/multimodal_accumulation.py
-          - vllm_omni/engine/stage_init_utils.py
-          - vllm_omni/engine/async_omni_engine.py
-          - vllm_omni/engine/orchestrator.py
-          - vllm_omni/entrypoints/cli/serve.py
-          - vllm_omni/entrypoints/openai/api_server.py
-          - vllm_omni/entrypoints/openai/duplex_capability.py
-          - vllm_omni/config/stage_config.py
+        source_file_dependencies: omni_minicpmo_4_5_duplex_function
         timeout_in_minutes: 50
         commands:
           - pytest -s -v tests/e2e/online_serving/test_minicpmo_4_5_duplex.py -m 'advanced_model and cuda' --run-level 'advanced_model'
@@ -234,11 +146,7 @@ steps:
         mirror_hardwares: h100_1
 
       - label: "Diffusion · Qwen Image Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_qwen_image.py
-          - vllm_omni/diffusion/models/qwen_image/
-          - vllm_omni/diffusion/models/dmd2/
-          - vllm_omni/diffusion/distributed/autoencoders/autoencoder_kl_qwenimage.py
+        source_file_dependencies: diffusion_qwen_image_function
         commands:
           - |
             timeout 40m bash -c '
@@ -248,11 +156,7 @@ steps:
         mirror_hardwares: h100_1
 
       - label: "Diffusion · Wan22 Test"
-        source_file_dependencies:
-          - tests/e2e/offline_inference/test_wan22_t2v.py
-          - tests/e2e/online_serving/test_wan22_t2v.py
-          - vllm_omni/diffusion/models/wan2_2/
-          - vllm_omni/diffusion/models/dmd2/
+        source_file_dependencies: diffusion_wan22_function
         commands:
           - |
             timeout 40m bash -c "
@@ -262,9 +166,7 @@ steps:
         mirror_hardwares: h100_1
 
       - label: "Diffusion · HunyuanVideo-1.5 Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_hunyuan_video_15_expansion.py
-          - vllm_omni/diffusion/models/hunyuan_video/
+        source_file_dependencies: diffusion_hunyuan_video_function
         commands:
           - |
             timeout 40m bash -c "
@@ -274,17 +176,7 @@ steps:
         mirror_hardwares: h100_1
 
       - label: "Diffusion · MiniMax-H3 L3 DLO DP2 and FastH3"
-        source_file_dependencies:
-          - tests/e2e/online_serving/minimax_h3/
-          - tests/helpers/assertions.py
-          - tests/helpers/mark.py
-          - tests/helpers/media.py
-          - tests/helpers/runtime.py
-          - vllm_omni/diffusion/models/minimax_h3/
-          - vllm_omni/diffusion/lora/
-          - vllm_omni/diffusion/offloader/
-          - vllm_omni/diffusion/distributed/
-          - vllm_omni/entrypoints/openai/
+        source_file_dependencies: diffusion_minimax_h3_function
         # Keep four server lifecycles in one Buildkite job, but never in one
         # pytest process. DLO uses multiprocessing shared-memory queues; the
         # parent's resource_tracker can retain a stale /psm_* entry during
diff --git a/.buildkite/cuda/test-nightly.yml b/.buildkite/cuda/test-nightly.yml
index c85e9abc1..adc94f9e9 100644
--- a/.buildkite/cuda/test-nightly.yml
+++ b/.buildkite/cuda/test-nightly.yml
@@ -12,138 +12,145 @@ steps:
   - group: ":card_index_dividers: Omni Model Test"
     key: nightly-omni-test-group
     depends_on: upload-nightly-pipeline
-    if: build.env("NIGHTLY") == "1" || build.pull_request.labels includes "nightly-test" || build.pull_request.labels includes "omni-test"
+    if: build.env("NIGHTLY") == "1" || build.pull_request.labels includes "nightly-test"
     steps:
 
       - label: ":full_moon: Omni · Function Test with H100 · Single-GPU"
+        source_file_dependencies:
+          - omni_qwen3_omni_function
+          - omni_minicpmo_4_5_function
         timeout_in_minutes: 120
         commands:
           - pytest -sv tests/e2e --run-level "full_model" -m "full_model and H100 and B200 and omni and cards_1" --ignore=tests/e2e/accuracy --ignore=tests/e2e/online_serving/test_minicpmo_4_5_duplex_expansion.py
 
       - label: ":full_moon: Omni · Function Test with H100 · 2-GPU"
+        source_file_dependencies:
+          - omni_qwen3_omni_function
+          - omni_minicpmo_4_5_function
         timeout_in_minutes: 90
         commands:
           - pytest -sv tests/e2e --run-level "full_model" -m "full_model and H100 and B200 and omni and cards_2" --ignore=tests/e2e/accuracy --ignore=tests/e2e/online_serving/test_qwen3_omni_multi_replicas.py
 
       - label: ":full_moon: Omni · MiniCPM-o 4.5 Duplex Test"
+        source_file_dependencies: omni_minicpmo_4_5_duplex_function
         timeout_in_minutes: 50
         commands:
-          - pytest -s -v tests/e2e/online_serving/test_minicpmo_4_5_duplex_expansion.py -m "full_model and cuda and H100 and omni and cards_1" --run-level "full_model"
-        mirror_hardwares: h100_1
+          - pytest -s -v tests/e2e/online_serving/test_minicpmo_4_5_duplex_expansion.py -m "full_model and cuda and H100 and B200 and omni and cards_1" --run-level "full_model"
 
       - label: ":full_moon: Omni · Doc Test with L4 · 4-GPU"
+        source_file_dependencies: omni_qwen2_5_omni_doc
         timeout_in_minutes: 90
         commands:
           - export VLLM_ALLOW_LONG_MAX_MODEL_LEN="1"
-          - pytest -s -v tests/examples/ -m "full_model and omni and L4 and cards_4" --run-level "full_model"
-        mirror_hardwares: l4_4
+          - pytest -s -v tests/examples/ -m "full_model and omni and L4 and B200 and cards_4" --run-level "full_model"
 
       - label: ":full_moon: Omni · Doc Test with H100 · 2-GPU"
+        source_file_dependencies: omni_qwen3_omni_doc
         timeout_in_minutes: 90
         commands:
-          - pytest -s -v tests/examples/ -m "full_model and omni and H100 and cards_2" --run-level "full_model"
-        mirror_hardwares: h100_2
+          - pytest -s -v tests/examples/ -m "full_model and omni and H100 and B200 and cards_2" --run-level "full_model"
 
       - label: ":full_moon: Omni · Accuracy Test"
+        source_file_dependencies: omni_qwen3_omni_accuracy
         timeout_in_minutes: 180
         commands:
           - export SEED_TTS_WER_EVAL=1
           - export SEED_TTS_EVAL_DEVICE=cuda:1
           - |
             set +e
-            pytest -s -v tests/e2e/accuracy/qwen3_omni/test_qwen3_omni.py -m "full_model" --run-level full_model
+            pytest -s -v tests/e2e/accuracy/qwen3_omni/test_qwen3_omni.py -m "full_model and H100 and B200 and cards_2" --run-level full_model
             EXIT=$$?
             buildkite-agent artifact upload "tests/e2e/accuracy/qwen3_omni/results/qwen_omni_acc/*.json"
             exit $$EXIT
-        mirror_hardwares: h100_2
 
       - label: ":full_moon: Omni · MiniCPM-o 4.5 · Accuracy Test"
+        source_file_dependencies: omni_minicpmo_4_5_accuracy
         timeout_in_minutes: 180
         commands:
           - export SEED_TTS_WER_EVAL=1
           - export SEED_TTS_EVAL_DEVICE=cuda:1
           - |
             set +e
-            pytest -s -v tests/e2e/accuracy/minicpmo_4_5/test_minicpmo_4_5.py -m "full_model and cuda" --run-level full_model
+            pytest -s -v tests/e2e/accuracy/minicpmo_4_5/test_minicpmo_4_5.py -m "full_model and H100 and B200 and cuda and (cards_1 or cards_2)" --run-level full_model
             EXIT=$$?
             buildkite-agent artifact upload "tests/e2e/accuracy/minicpmo_4_5/results/*.json"
             exit $$EXIT
-        mirror_hardwares: h100_2
 
       - label: ":full_moon: Omni · Perf Test · No Async Chunk"
+        source_file_dependencies: omni_qwen3_omni_perf
         key: nightly-omni-performance-no-async-chunk
         timeout_in_minutes: 300
         commands:
           - export BENCHMARK_DIR=tests/dfx/perf/results
           - |
             set +e
-            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_qwen3_omni_no_async_chunk.json
+            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_qwen3_omni_no_async_chunk.json -m "H100 and B200 and cards_2"
             EXIT=$$?
             buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
             exit $$EXIT
-        mirror_hardwares: h100_2
 
       - label: ":full_moon: Omni · Perf Test · Async Chunk"
+        source_file_dependencies: omni_qwen3_omni_perf
         key: nightly-omni-performance-async-chunk
         timeout_in_minutes: 180
         commands:
           - export BENCHMARK_DIR=tests/dfx/perf/results
           - |
             set +e
-            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_qwen3_omni_async_chunk.json -m "H100 and full_model"
+            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_qwen3_omni_async_chunk.json -m "H100 and B200 and full_model and cards_2"
             EXIT=$$?
             buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
             exit $$EXIT
-        mirror_hardwares: h100_2
 
       - label: ":full_moon: Omni · MiniCPM-o 4.5 · Perf Test"
+        source_file_dependencies: omni_minicpmo_4_5_perf
         key: nightly-omni-performance-minicpmo-4-5
         timeout_in_minutes: 180
         commands:
           - export BENCHMARK_DIR=tests/dfx/perf/results
           - |
             set +e
-            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_minicpmo_4_5.json
+            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_minicpmo_4_5.json -m "H100 and B200 and cards_1"
             EXIT=$$?
             buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
             exit $$EXIT
-        mirror_hardwares: h100_1
 
       - label: ":full_moon: Omni · MiniCPM-o 4.5 · Duplex Seed-TTS Perf Test"
+        source_file_dependencies: omni_minicpmo_4_5_duplex_perf
         key: nightly-omni-performance-minicpmo-4-5-duplex-seed-tts
         timeout_in_minutes: 180
         commands:
           - export BENCHMARK_DIR=tests/dfx/perf/results
           - |
             set +e
-            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_minicpmo_4_5_duplex_seed_tts.json
+            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_minicpmo_4_5_duplex_seed_tts.json -m "H100 and B200 and cards_1"
             EXIT=$$?
             buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
             exit $$EXIT
-        mirror_hardwares: h100_1
 
       - label: ":full_moon: Omni · Multi-Replica Startup Test with 4x H100"
+        source_file_dependencies: omni_qwen3_omni_function
         timeout_in_minutes: 45
         commands:
-          - pytest -s -v tests/e2e/online_serving/test_qwen3_omni_multi_replicas.py -m "full_model" --run-level "core_model"
-        mirror_hardwares: h100_4
+          - pytest -s -v tests/e2e/online_serving/test_qwen3_omni_multi_replicas.py -m "full_model and H100 and B200 and cards_4" --run-level "core_model"
 
   - group: ":card_index_dividers: TTS Model Test"
     key: nightly-tts-test-group
     depends_on: upload-nightly-pipeline
-    if: build.env("NIGHTLY") == "1" || build.pull_request.labels includes "nightly-test" || build.pull_request.labels includes "tts-test"
+    if: build.env("NIGHTLY") == "1" || build.pull_request.labels includes "nightly-test"
     steps:
 
       - label: ":full_moon: TTS · Function Test with L4"
+        source_file_dependencies: tts_qwen3_tts_function
         timeout_in_minutes: 120
         commands:
           - export VLLM_ALLOW_LONG_MAX_MODEL_LEN="1"
           - export VLLM_USE_DEEP_GEMM="0"
           - export VLLM_MOE_USE_DEEP_GEMM="0"
-          - pytest -s -v tests/e2e/ -m "full_model and L4 and tts" --run-level "full_model" --ignore=tests/e2e/accuracy
-        mirror_hardwares: l4_1
+          - pytest -s -v tests/e2e/ -m "full_model and L4 and B200 and tts and cards_1" --run-level "full_model" --ignore=tests/e2e/accuracy
 
       - label: ":full_moon: TTS · Perf Test · Single-GPU"
+        source_file_dependencies: tts_qwen3_tts_perf
         key: nightly-tts-performance-single
         timeout_in_minutes: 180
         commands:
@@ -151,13 +158,13 @@ steps:
           - export VLLM_ALLOW_LONG_MAX_MODEL_LEN="1"
           - |
             set +e
-            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_tts.json -m "H100 and cards_1"
+            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_tts.json -m "H100 and B200 and cards_1"
             EXIT=$$?
             buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
             exit $$EXIT
-        mirror_hardwares: h100_1
 
       - label: ":full_moon: TTS · Perf Test · 2-GPU"
+        source_file_dependencies: tts_qwen3_tts_perf
         key: nightly-tts-performance-2gpu
         timeout_in_minutes: 180
         commands:
@@ -165,11 +172,10 @@ steps:
           - export VLLM_ALLOW_LONG_MAX_MODEL_LEN="1"
           - |
             set +e
-            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_tts.json -m "H100 and cards_2"
+            pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_tts.json -m "H100 and B200 and cards_2"
             EXIT=$$?
             buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
             exit $$EXIT
-        mirror_hardwares: h100_2
 
   - group: ":card_index_dividers: Tiny Model Tests [Multi-GPU]"
     key: nightly-tiny-model-test-group
@@ -180,6 +186,7 @@ steps:
     steps:
 
       - label: ":full_moon: Tiny Model Tests · Diffusion (Multi-GPU accelerations) · 2-GPU"
+        source_file_dependencies: diffusion_tiny_model
         timeout_in_minutes: 30
         # NOTE: Single-GPU (core_model) tiny model tests run on the ready label,
         # so nightly only adds the multi-GPU parallelism configurations.
@@ -189,91 +196,85 @@ steps:
         # for the CI, since these tests should pass irrespective of whether or not we use
         # the full weights or not.
         commands:
-          - pytest -sv tests/model_tests/diffusion -m 'full_model and cuda and cards_2' --run-level "core_model"
-        mirror_hardwares: l4_2
+          - pytest -sv tests/model_tests/diffusion -m 'full_model and L4 and B200 and cuda and cards_2' --run-level "core_model"
 
       - label: ":full_moon: Tiny Model Tests · Diffusion (Multi-GPU accelerations) · 4-GPU"
+        source_file_dependencies: diffusion_tiny_model
         timeout_in_minutes: 30
         # CFG+TP extra_test_groups request 2×2=4 devices (see get_required_device_count).
         commands:
-          - pytest -sv tests/model_tests/diffusion -m 'full_model and cuda and cards_4' --run-level "core_model"
-        mirror_hardwares: l4_4
+          - pytest -sv tests/model_tests/diffusion -m 'full_model and L4 and B200 and cuda and cards_4' --run-level "core_model"
 
   - group: ":card_index_dividers: Diffusion X2I(&A&T) Model Test"
     key: nightly-diffusion-x2iat-group
     depends_on: upload-nightly-pipeline
     if: >-
       build.env("NIGHTLY") == "1" ||
-      build.pull_request.labels includes "nightly-test" ||
-      build.pull_request.labels includes "diffusion-x2iat-test"
+      build.pull_request.labels includes "nightly-test"
     steps:
 
       - label: ":full_moon: Diffusion X2I(&A&T) · Function Test with H100 · Single-GPU"
+        source_file_dependencies: diffusion_qwen_image_function
         timeout_in_minutes: 120
         commands:
           - >-
             pytest -sv
             tests/e2e/online_serving/test_qwen_image_expansion.py
+            -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
         commands:
           - >-
             pytest -sv
             tests/e2e/online_serving/test_qwen_image_expansion.py
-            -m "full_model and diffusion and H100 and cards_2"
+            -m "full_model and diffusion and H100 and B200 and cards_2"
             --run-level "full_model"
-        mirror_hardwares: h100_2
 
-      - label: ":full_moon: Diffusion X2I(&A&T) · Boogu Edit CFG · 3-GPU"
+      - label: ":full_moon: Diffusion X2I(&A&T) · Function Test with L4 · Single-GPU"
+        source_file_dependencies: diffusion_qwen_image_function
         timeout_in_minutes: 120
         commands:
-          - >-
-            pytest -sv
-            tests/e2e/online_serving/test_boogu_image_edit_expansion.py
-            -k "test_double_guidance_cfg_parallel and cfg_parallel_3_full"
-            -m "slow and diffusion and cuda and H100 and cards_3"
-            --run-level "full_model"
-        mirror_hardwares: h100_3
+          - pytest -sv tests/e2e/offline_inference/test_qwen_image_autoround_w4a16_expansion.py -m "full_model and diffusion and L4 and B200 and cards_1" --run-level "full_model"
 
-      - label: ":full_moon: Diffusion X2I(&A&T) · Function Test with L4 · 4-GPU"
-        timeout_in_minutes: 120
-        commands:
-          - pytest -sv tests/e2e/ -k "not test_wan and not hunyuan" -m "full_model and diffusion and L4 and cards_4" --run-level "full_model" --ignore=tests/e2e/accuracy
-        mirror_hardwares: l4_4
 
       - label: ":full_moon: Diffusion X2I(&A&T) · Doc Test"
+        source_file_dependencies: diffusion_text_to_image_doc
         timeout_in_minutes: 60
         commands:
-          - pytest -s -v tests/examples/*/test_text_to_image.py -m "full_model and example and H100" --run-level "full_model"
-        mirror_hardwares: h100_2
+          - pytest -s -v tests/examples/*/test_text_to_image.py -m "full_model and example and H100 and B200 and (cards_1 or cards_2)" --run-level "full_model"
 
       - label: ":full_moon: Diffusion X2I(&A&T) · Accuracy Test"
+        source_file_dependencies: diffusion_qwen_image_accuracy
         timeout_in_minutes: 180
         commands:
           - export VLLM_HTTP_TIMEOUT_KEEP_ALIVE=120
-          - pytest -s -v tests/e2e/accuracy/test_qwen_image.py --run-level full_model
-          - pytest -s -v tests/e2e/accuracy/test_diffusers_backend_similarity.py -k '2i_matches_diffusers' -m full_model --run-level full_model
-        mirror_hardwares: h100_1
+          - pytest -s -v tests/e2e/accuracy/test_qwen_image.py -m "H100 and B200 and cards_1" --run-level full_model
+          - pytest -s -v tests/e2e/accuracy/test_diffusers_backend_similarity.py -k '2i_matches_diffusers' -m "full_model and H100 and B200 and cards_1" --run-level full_model
 
       - label: ":full_moon: HunyuanImage3-DIT · Accuracy Test"
+        source_file_dependencies: diffusion_hunyuan_image3_accuracy
         timeout_in_minutes: 180
         commands:
           - export HUNYUAN_IMAGE3_MODEL="tencent/HunyuanImage-3.0-Instruct"
           - export HUNYUAN_IMAGE3_DEVICES="0,1,2,3"
-          - pytest -s -v tests/e2e/accuracy/test_hunyuan_image3_pixel_accuracy.py -m full_model --run-level full_model
-        mirror_hardwares: h100_4
-
-      - label: ":full_moon: HiDream-O1-Image · Accuracy Test"
-        timeout_in_minutes: 180
-        commands:
-          - pytest -s -v tests/e2e/accuracy/test_hidream_o1_image.py -m full_model --run-level full_model
-        mirror_hardwares: h100_2
+          - pytest -s -v tests/e2e/accuracy/test_hunyuan_image3_pixel_accuracy.py -m "full_model and H100 and B200 and cards_4" --run-level full_model
 
       - label: ":full_moon: Diffusion X2I(&A&T) · Perf Test · Qwen-Image · Single-GPU"
+        source_file_dependencies: diffusion_qwen_image_perf
         key: nightly-diffusion-x2iat-performance-qwen-image-single
         timeout_in_minutes: 180
         commands:
@@ -281,168 +282,182 @@ steps:
           - export CACHE_DIT_VERSION=1.5.0
           - |
             set +e
-            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_qwen_image_vllm_omni.json -m "H100 and cards_1"
+            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_qwen_image_vllm_omni.json -m "H100 and B200 and cards_1"
             EXIT=$$?
             buildkite-agent artifact upload "tests/dfx/perf/results/diffusion_result_*.json"
             buildkite-agent artifact upload "tests/dfx/perf/results/logs/*.log"
             exit $$EXIT
-        mirror_hardwares: h100_1
 
       - label: ":full_moon: Diffusion X2I(&A&T) · Perf Test · Qwen-Image · 4-GPU"
+        source_file_dependencies: diffusion_qwen_image_perf
         key: nightly-diffusion-x2iat-performance-qwen-image-4gpu
         timeout_in_minutes: 180
         commands:
           - export DIFFUSION_BENCHMARK_DIR=tests/dfx/perf/results
-          - export DIFFUSION_ATTENTION_BACKEND=FLASH_ATTN
           - export CACHE_DIT_VERSION=1.5.0
+          # Do not pin DIFFUSION_ATTENTION_BACKEND: H100 auto-selects FLASH_ATTN;
+          # B200 rejects explicit FLASH_ATTN without FA4 and uses CUDNN/TRTLLM.
           - |
             set +e
-            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_qwen_image_vllm_omni.json -m "H100 and cards_4"
+            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_qwen_image_vllm_omni.json -m "H100 and B200 and cards_4"
             EXIT=$$?
             buildkite-agent artifact upload "tests/dfx/perf/results/diffusion_result_*.json"
             buildkite-agent artifact upload "tests/dfx/perf/results/logs/*.log"
             exit $$EXIT
-        mirror_hardwares: h100_4
 
   - group: ":card_index_dividers: Diffusion X2V Model Test"
     key: nightly-diffusion-x2v-group
     depends_on: upload-nightly-pipeline
     if: >-
       build.env("NIGHTLY") == "1" ||
-      build.pull_request.labels includes "nightly-test" ||
-      build.pull_request.labels includes "diffusion-x2v-test"
+      build.pull_request.labels includes "nightly-test"
     steps:
 
       - label: ":full_moon: Diffusion X2V · Wan2.2 T2V Function Test · Single-GPU"
+        source_file_dependencies: diffusion_wan22_function
         timeout_in_minutes: 90
         commands:
-          - pytest -s -v tests/e2e/online_serving/test_wan22_expansion.py -k "t2v" -m "full_model and cuda and H100 and cards_1" --run-level "full_model"
-        mirror_hardwares: h100_1
+          - pytest -s -v tests/e2e/online_serving/test_wan22_expansion.py -k "t2v" -m "full_model and cuda and H100 and B200 and cards_1" --run-level "full_model"
 
       - label: ":full_moon: Diffusion X2V · Wan2.2 T2V Function Test · 2-GPU"
+        source_file_dependencies: diffusion_wan22_function
         timeout_in_minutes: 90
         commands:
-          - pytest -s -v tests/e2e/online_serving/test_wan22_expansion.py -k "t2v" -m "full_model and cuda and H100 and cards_2" --run-level "full_model"
-        mirror_hardwares: h100_2
+          - pytest -s -v tests/e2e/online_serving/test_wan22_expansion.py -k "t2v" -m "full_model and cuda and H100 and B200 and cards_2" --run-level "full_model"
 
       - label: ":full_moon: Diffusion X2V · Wan2.2 I2V/TI2V Function Test · Single-GPU"
+        source_file_dependencies: diffusion_wan22_function
         timeout_in_minutes: 90
         commands:
-          - pytest -s -v tests/e2e/online_serving/test_wan22_expansion.py -k "i2v" -m "full_model and cuda and H100 and cards_1" --run-level "full_model"
-        mirror_hardwares: h100_1
+          - pytest -s -v tests/e2e/online_serving/test_wan22_expansion.py -k "i2v" -m "full_model and cuda and H100 and B200 and cards_1" --run-level "full_model"
 
       - label: ":full_moon: Diffusion X2V · Wan2.2 I2V/TI2V Function Test · 2-GPU"
+        source_file_dependencies: diffusion_wan22_function
         timeout_in_minutes: 90
         commands:
-          - pytest -s -v tests/e2e/online_serving/test_wan22_expansion.py -k "i2v" -m "full_model and cuda and H100 and cards_2" --run-level "full_model"
-        mirror_hardwares: h100_2
+          - pytest -s -v tests/e2e/online_serving/test_wan22_expansion.py -k "i2v" -m "full_model and cuda and H100 and B200 and cards_2" --run-level "full_model"
 
       - label: ":full_moon: Diffusion X2V · HunyuanVideo-1.5 Function Test"
+        source_file_dependencies: diffusion_hunyuan_video_function
         timeout_in_minutes: 90
         commands:
-          - pytest -s -v tests/e2e/online_serving/test_hunyuan_video_15_expansion.py -m "full_model and cuda" --run-level "full_model"
-        mirror_hardwares: h100_2
+          - pytest -s -v tests/e2e/online_serving/test_hunyuan_video_15_expansion.py -m "full_model and H100 and B200 and cuda and (cards_1 or cards_2)" --run-level "full_model"
 
-      - label: ":full_moon: Diffusion X2V · MAGI-2 Preview Serving Smoke"
-        timeout_in_minutes: 180
+      - label: ":full_moon: Diffusion X2V · LingBot Function Test"
+        source_file_dependencies: diffusion_lingbot_function
+        timeout_in_minutes: 120
         commands:
-          - pytest -s -v tests/e2e/online_serving/test_magi2.py -m "advanced_model and diffusion and cuda and H100 and cards_4" --run-level "advanced_model"
-        mirror_hardwares: h100_4
+          - >-
+            pytest -s -v
+            tests/e2e/online_serving/test_lingbot_video.py
+            tests/e2e/online_serving/test_lingbot_video_moe.py
+            tests/e2e/offline_inference/test_lingbot_world_v2.py
+            -m "full_model and diffusion and H100 and B200 and cards_1"
+            --run-level "full_model"
 
       - label: ":full_moon: Diffusion X2V · Doc Test"
+        source_file_dependencies: diffusion_image_to_video_doc
         timeout_in_minutes: 60
         commands:
-          - pytest -s -v tests/examples/offline_inference/test_image_to_video.py -m "full_model and example and H100" --run-level "full_model"
-        mirror_hardwares: h100_1
+          - pytest -s -v tests/examples/offline_inference/test_image_to_video.py -m "full_model and example and H100 and B200 and cards_1" --run-level "full_model"
 
-      - label: ":full_moon: Diffusion X2V · Other Function Test"
+      - label: ":full_moon: Diffusion X2V · Wan2.2 Autoround Function Test"
+        source_file_dependencies: diffusion_wan22_function
         timeout_in_minutes: 90
         commands:
-          - pytest -s -v tests/e2e/offline_inference/test_wan22_autoround_w4a16_expansion.py -m "full_model and cuda" --run-level "full_model"
-        mirror_hardwares: h100_2
+          - pytest -s -v tests/e2e/offline_inference/test_wan22_autoround_w4a16_expansion.py -m "full_model and H100 and B200 and cuda and (cards_1 or cards_2)" --run-level "full_model"
+
+      - label: ":full_moon: Diffusion X2V · Wan2.2 Device-Postprocess Equivalence Test"
+        source_file_dependencies: diffusion_wan22_function
+        timeout_in_minutes: 90
+        commands:
+          - |
+            VLLM_OMNI_DEVICE_POSTPROCESS_MODEL=Wan-AI/Wan2.2-TI2V-5B-Diffusers \
+              pytest -s -v tests/e2e/offline_inference/test_device_postprocess_equivalence.py -m "full_model and H100 and B200 and cuda and cards_1" --run-level "full_model"
 
       - label: ":full_moon: Diffusion X2V · Wan2.2 Accuracy Test"
+        source_file_dependencies: diffusion_wan22_accuracy
         timeout_in_minutes: 180
         commands:
-          - pytest -s -v tests/e2e/accuracy/wan22_i2v/test_wan22_i2v_video_similarity.py -m full_model --run-level full_model
-          - pytest -s -v tests/e2e/accuracy/test_diffusers_backend_similarity.py -k '2v_matches_diffusers' -m full_model --run-level full_model
-        mirror_hardwares: h100_2
+          - pytest -s -v tests/e2e/accuracy/wan22_i2v/test_wan22_i2v_video_similarity.py -m "full_model and H100 and B200 and (cards_1 or cards_2)" --run-level full_model
+          - pytest -s -v tests/e2e/accuracy/test_diffusers_backend_similarity.py -k '2v_matches_diffusers' -m "full_model and H100 and B200 and cards_1" --run-level full_model
 
       - label: ":full_moon: Diffusion X2V · MiniMax H3 I2VA/Ref2VA Accuracy Test"
+        source_file_dependencies: diffusion_minimax_h3_accuracy
         timeout_in_minutes: 180
         commands:
-          - pytest -s -v tests/e2e/accuracy/minimax_h3/test_minimax_h3_i2va_ref2va_similarity.py -m full_model --run-level full_model
-        mirror_hardwares: h100_4
+          - pytest -s -v tests/e2e/accuracy/minimax_h3/test_minimax_h3_i2va_ref2va_similarity.py -m "full_model and H100 and B200 and cards_4" --run-level full_model
 
-      - label: ":full_moon: Diffusion X2V · Other Accuracy Test"
+      - label: ":full_moon: Diffusion X2V · HunyuanVideo-1.5 Accuracy Test"
+        source_file_dependencies: diffusion_hunyuan_video_accuracy
         timeout_in_minutes: 180
         commands:
-          - pytest -s -v tests/e2e/accuracy/hunyuanvideo15_t2v/test_hunyuanvideo15_t2v_video_similarity.py -m full_model --run-level full_model
-          - pytest -s -v tests/e2e/accuracy/hunyuanvideo15_i2v/test_hunyuanvideo15_i2v_video_similarity.py -m full_model --run-level full_model
-        mirror_hardwares: h100_2
+          - pytest -s -v tests/e2e/accuracy/hunyuanvideo15_t2v/test_hunyuanvideo15_t2v_video_similarity.py -m "full_model and H100 and B200 and (cards_1 or cards_2)" --run-level full_model
+          - pytest -s -v tests/e2e/accuracy/hunyuanvideo15_i2v/test_hunyuanvideo15_i2v_video_similarity.py -m "full_model and H100 and B200 and (cards_1 or cards_2)" --run-level full_model
 
       - label: ":full_moon: Diffusion X2V · Perf Test · Single-GPU"
+        source_file_dependencies: diffusion_wan22_perf
         key: nightly-diffusion-x2v-performance-single
         timeout_in_minutes: 180
         commands:
           - export DIFFUSION_BENCHMARK_DIR=tests/dfx/perf/results
           - |
             set +e
-            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_wan22_i2v_vllm_omni.json -m "H100 and cards_1"
+            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_wan22_i2v_vllm_omni.json -m "H100 and B200 and cards_1"
             EXIT=$$?
             buildkite-agent artifact upload "tests/dfx/perf/results/diffusion_result_*.json"
             buildkite-agent artifact upload "tests/dfx/perf/results/logs/*.log"
             exit $$EXIT
-        mirror_hardwares: h100_1
 
       - label: ":full_moon: Diffusion X2V · Perf Test · 2-GPU"
+        source_file_dependencies:
+          - diffusion_wan22_perf
+          - diffusion_cosmos3_perf
         key: nightly-diffusion-x2v-performance-2gpu
         timeout_in_minutes: 180
         commands:
           - export DIFFUSION_BENCHMARK_DIR=tests/dfx/perf/results
-          - export DIFFUSION_ATTENTION_BACKEND=FLASH_ATTN
           - |
             set +e
-            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_wan22_i2v_vllm_omni.json -m "H100 and cards_2"
+            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_wan22_i2v_vllm_omni.json -m "H100 and B200 and cards_2"
             EXIT1=$$?
-            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_cosmos3_vllm_omni.json -m "H100 and cards_2"
+            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_cosmos3_vllm_omni.json -m "H100 and B200 and cards_2"
             EXIT2=$$?
             buildkite-agent artifact upload "tests/dfx/perf/results/diffusion_result_*.json"
             buildkite-agent artifact upload "tests/dfx/perf/results/logs/*.log"
             if [ $$EXIT1 -ne 0 ]; then exit $$EXIT1; fi
             exit $$EXIT2
-        mirror_hardwares: h100_2
 
       - label: ":full_moon: Diffusion X2V · Perf Test · HunyuanVideo-1.5"
+        source_file_dependencies: diffusion_hunyuan_video_perf
         key: nightly-diffusion-x2v-performance-hunyuanvideo15
         timeout_in_minutes: 180
         commands:
           - export DIFFUSION_BENCHMARK_DIR=tests/dfx/perf/results
           - |
             set +e
-            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_hunyuanvideo15_t2v_vllm_omni.json
+            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_hunyuanvideo15_t2v_vllm_omni.json -m "H100 and B200 and (cards_1 or cards_2)"
             EXIT1=$$?
-            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_hunyuanvideo15_i2v_vllm_omni.json
+            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_hunyuanvideo15_i2v_vllm_omni.json -m "H100 and B200 and (cards_1 or cards_2)"
             EXIT2=$$?
             buildkite-agent artifact upload "tests/dfx/perf/results/diffusion_result_*.json"
             buildkite-agent artifact upload "tests/dfx/perf/results/logs/*.log"
             if [ $$EXIT1 -ne 0 ]; then exit $$EXIT1; fi
             exit $$EXIT2
-        mirror_hardwares: h100_2
 
       - label: ":full_moon: Diffusion X2V · Perf Test · MiniMax-H3"
+        source_file_dependencies: diffusion_minimax_h3_perf
         key: nightly-diffusion-x2v-performance-minimax-h3
         timeout_in_minutes: 180
         commands:
           - export DIFFUSION_BENCHMARK_DIR=tests/dfx/perf/results
           - |
             set +e
-            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_minimax_h3_vllm_omni.json
+            pytest -s -v tests/dfx/perf/scripts/run_diffusion_benchmark.py --test-config-file tests/dfx/perf/tests/test_minimax_h3_vllm_omni.json -m "H100 and B200 and cards_4"
             EXIT=$$?
             buildkite-agent artifact upload "tests/dfx/perf/results/diffusion_result_*.json"
             buildkite-agent artifact upload "tests/dfx/perf/results/logs/*.log"
             exit $$EXIT
-        mirror_hardwares: h100_4
 
   - group: ":card_index_dividers: Diffusion Test"
     key: nightly-diffusion-test-group
@@ -450,59 +465,59 @@ steps:
     if: build.env("NIGHTLY") == "1" || build.pull_request.labels includes "nightly-test"
     steps:
       - label: ":full_moon: Diffusion · Distributed Test with L4 · 2-GPU"
+        source_file_dependencies: diffusion_distributed_attention
         timeout_in_minutes: 60
         commands:
-          - pytest -sv tests/diffusion/distributed/ -m 'full_model and cuda and L4 and cards_2' --run-level "full_model"
-        mirror_hardwares: l4_2
+          - pytest -sv tests/diffusion/distributed/ -m 'full_model and cuda and L4 and B200 and cards_2' --run-level "full_model"
 
       - label: ":full_moon: Diffusion · Distributed Test with L4 · 3-GPU"
+        source_file_dependencies: diffusion_distributed_attention
         timeout_in_minutes: 60
         commands:
-          - pytest -sv tests/diffusion/distributed/ -m 'full_model and cuda and L4 and cards_3' --run-level "full_model"
-        mirror_hardwares: l4_3
+          - pytest -sv tests/diffusion/distributed/ -m 'full_model and cuda and L4 and B200 and cards_3' --run-level "full_model"
 
       - label: ":full_moon: Diffusion · Distributed Test with L4 · 4-GPU"
+        source_file_dependencies: diffusion_distributed_attention
         timeout_in_minutes: 60
         commands:
-          - pytest -sv tests/diffusion/distributed/ -m 'full_model and cuda and L4 and cards_4' --run-level "full_model"
-        mirror_hardwares: l4_4
+          - pytest -sv tests/diffusion/distributed/ -m 'full_model and cuda and L4 and B200 and cards_4' --run-level "full_model"
 
       - label: ":full_moon: Diffusion · Distributed Test with H100 · 2-GPU"
+        source_file_dependencies: diffusion_distributed_attention
         timeout_in_minutes: 60
         commands:
-          - pytest -sv tests/diffusion/distributed/ -m 'full_model and cuda and H100 and cards_2' --run-level "full_model"
-        mirror_hardwares: h100_2
+          - pytest -sv tests/diffusion/distributed/ -m 'full_model and cuda and H100 and B200 and cards_2' --run-level "full_model"
 
       - label: ":full_moon: Diffusion · Distributed Test with H100 · 4-GPU"
+        source_file_dependencies: diffusion_distributed_attention
         timeout_in_minutes: 60
         commands:
-          - pytest -sv tests/diffusion/distributed/ -m 'full_model and cuda and H100 and cards_4' --run-level "full_model"
-        mirror_hardwares: h100_4
+          - pytest -sv tests/diffusion/distributed/ -m 'full_model and cuda and H100 and B200 and cards_4' --run-level "full_model"
 
       - label: ":full_moon: Diffusion · Offloader Test"
+        source_file_dependencies: diffusion_offloader
         timeout_in_minutes: 60
         commands:
-          - pytest -sv tests/diffusion/offloader -m "full_model and cuda"
-        mirror_hardwares: l4_1
+          - pytest -sv tests/diffusion/offloader -m "full_model and L4 and B200 and cuda and cards_1"
 
       - label: ":full_moon: Diffusion · Quantization Test with H100 · Single-GPU"
+        source_file_dependencies: diffusion_quantization
         timeout_in_minutes: 60
         commands:
-          - pytest -sv tests/diffusion/quantization -m 'full_model and cuda and H100' --run-level "full_model"
-        mirror_hardwares: h100_1
+          - pytest -sv tests/diffusion/quantization -m 'full_model and cuda and H100 and B200 and cards_1' --run-level "full_model"
 
       - label: ":full_moon: Diffusion · MiniMax H3 FP8 Quality Test with H100 · 2-GPU"
+        source_file_dependencies: diffusion_minimax_h3_function
         timeout_in_minutes: 60
         commands:
-          - pytest -sv tests/diffusion/models/minimax_h3/test_minimax_h3_quantization_quality.py -m 'full_model and cuda and H100' --run-level "full_model"
-        mirror_hardwares: h100_2
+          - pytest -sv tests/diffusion/models/minimax_h3/test_minimax_h3_quantization_quality.py -m 'full_model and cuda and H100 and B200 and cards_2' --run-level "full_model"
 
       - label: ":full_moon: Diffusion · Quantization Test with L4"
+        source_file_dependencies: diffusion_quantization
         timeout_in_minutes: 60
         commands:
           - pip install "vllm-gguf-plugin==0.0.4"
-          - pytest -sv tests/diffusion/quantization -m 'full_model and cuda and L4' --run-level "full_model"
-        mirror_hardwares: l4_1
+          - pytest -sv tests/diffusion/quantization -m 'full_model and cuda and L4 and B200 and cards_1' --run-level "full_model"
 
   # NOTE: ":email: Nightly Collection & Email" is deprecated and will be removed soon.
   # Do not add new depends_on entries or extend this step.
diff --git a/.buildkite/cuda/test-ready.yml b/.buildkite/cuda/test-ready.yml
index b5fc335e7..1f07b0721 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"
@@ -54,16 +60,19 @@ steps:
         mirror_hardwares: l4_1
 
       - label: "Diffusion · Distributed Test · Single-GPU"
+        source_file_dependencies: diffusion_distributed_attention
         commands:
           - timeout 20m pytest -sv tests/diffusion/distributed -m 'core_model and cuda and L4 and cards_1' --run-level "core_model"
         mirror_hardwares: l4_1
 
       - label: "Diffusion · Distributed Test · 2-GPU"
+        source_file_dependencies: diffusion_distributed_attention
         commands:
           - timeout 20m pytest -sv tests/diffusion/distributed -m 'core_model and cuda and L4 and cards_2' --run-level "core_model"
         mirror_hardwares: l4_2
 
       - label: "Diffusion · Distributed & Attention Test · 4-GPU"
+        source_file_dependencies: diffusion_distributed_attention
         commands:
           - timeout 20m pytest -sv tests/diffusion/distributed -m 'core_model and cuda and L4 and cards_4' --run-level "core_model"
           - timeout 20m pytest -sv tests/diffusion/attention/test_attention_sp.py -m 'core_model and cuda and L4 and cards_4' --run-level "core_model"
@@ -93,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
 
@@ -120,29 +129,14 @@ steps:
     depends_on: upload-ready-pipeline
     steps:
       - label: "Custom Pipeline Test"
-        source_file_dependencies:
-          - tests/e2e/features/custom_pipeline/
-          - tests/e2e/features/helpers/custom_pipeline.py
-          - vllm_omni/diffusion/
-          - vllm_omni/engine/
-          - vllm_omni/entrypoints/
-          - vllm_omni/inputs/
-          - vllm_omni/outputs/
+        source_file_dependencies: custom_pipeline
         commands:
           - timeout 20m pytest -s -v tests/e2e/features/custom_pipeline/ -m "core_model"
         mirror_hardwares: l4_1
 
 
       - label: "RLHF · VeRL-Omni E2E Test"
-        source_file_dependencies:
-          - tests/e2e/features/rlhf_test/test_verl_omni_e2e.py
-          - tests/e2e/features/helpers/verl_omni_server.py
-          - tests/e2e/features/helpers/custom_pipeline.py
-          - vllm_omni/diffusion/
-          - vllm_omni/engine/
-          - vllm_omni/entrypoints/
-          - vllm_omni/inputs/
-          - vllm_omni/outputs/
+        source_file_dependencies: rlhf_verl_omni
         commands:
           - |
             timeout 20m bash -c "
@@ -151,17 +145,7 @@ steps:
         mirror_hardwares: l4_1
 
       - label: "Omni · Qwen3-Omni Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_qwen3_omni.py
-          - tests/helpers/runtime.py
-          - vllm_omni/entrypoints/openai/serving_chat.py
-          - vllm_omni/model_executor/models/qwen3_omni/
-          - vllm_omni/model_executor/models/common/qwen3_code_predictor.py
-          - vllm_omni/model_executor/models/common/snake_activation.py
-          - vllm_omni/model_executor/models/qwen2_5_omni/qwen2_5_omni_thinker.py
-          - vllm_omni/model_executor/models/qwen3_tts/cuda_graph_decoder_wrapper.py
-          - vllm_omni/model_executor/stage_input_processors/qwen3_omni.py
-          - vllm_omni/deploy/qwen3_omni_moe.yaml
+        source_file_dependencies: omni_qwen3_omni_function
         commands:
           - |
             timeout 20m bash -c "
@@ -170,14 +154,7 @@ steps:
         mirror_hardwares: h100_2
 
       - label: "Omni · MiniCPM-o 4.5 Offline Test"
-        source_file_dependencies:
-          - tests/e2e/offline_inference/test_minicpmo_4_5.py
-          - vllm_omni/model_executor/models/minicpmo_4_5/
-          - vllm_omni/model_executor/models/step_audio2/
-          - vllm_omni/model_executor/models/cosyvoice3/code2wav_core/
-          - vllm_omni/model_executor/models/cosyvoice3/utils.py
-          - vllm_omni/model_executor/stage_input_processors/minicpmo_4_5_omni.py
-          - vllm_omni/deploy/minicpmo_4_5.yaml
+        source_file_dependencies: omni_minicpmo_4_5_function
         commands:
           - |
             timeout 20m bash -c "
@@ -186,15 +163,7 @@ steps:
         mirror_hardwares: h100_1
 
       - label: "Omni · MiniCPM-o 4.5 Online Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_minicpmo_4_5.py
-          - vllm_omni/transformers_utils/chat_templates/minicpmo45_native.jinja
-          - vllm_omni/model_executor/models/minicpmo_4_5/
-          - vllm_omni/model_executor/models/step_audio2/
-          - vllm_omni/model_executor/models/cosyvoice3/code2wav_core/
-          - vllm_omni/model_executor/models/cosyvoice3/utils.py
-          - vllm_omni/model_executor/stage_input_processors/minicpmo_4_5_omni.py
-          - vllm_omni/deploy/minicpmo_4_5.yaml
+        source_file_dependencies: omni_minicpmo_4_5_function
         commands:
           - |
             timeout 20m bash -c "
@@ -203,48 +172,7 @@ steps:
         mirror_hardwares: h100_1
 
       - label: "Omni · MiniCPM-o 4.5 Duplex Test"
-        source_file_dependencies:
-          - tests/assets/minicpmo_4_5/response_required_16k.wav
-          - tests/assets/minicpmo_4_5/soft_interrupt_16k.wav
-          - tests/e2e/online_serving/test_minicpmo_4_5_duplex.py
-          - tests/e2e/online_serving/test_minicpmo_4_5_duplex_expansion.py
-          - tests/e2e/online_serving/test_minicpmo_realtime_duplex_drivers.py
-          - tests/e2e/online_serving/helpers/minicpmo_realtime_duplex_scenarios.py
-          - tests/e2e/online_serving/run_minicpmo_realtime_duplex_multi_session.py
-          - tests/e2e/online_serving/run_minicpmo_realtime_duplex_server_vad.py
-          - tests/e2e/online_serving/run_minicpmo_realtime_duplex_soft_interrupt.py
-          - vllm_omni/deploy/minicpmo_4_5.yaml
-          - tests/e2e/online_serving/helpers/minicpmo_4_5_duplex.py
-          - vllm_omni/engine/duplex/
-          - vllm_omni/entrypoints/duplex/
-          # Public duplex client library + its unit suites: client-side
-          # changes must re-run the duplex e2e group, which includes the
-          # live client probe (test_duplex_client_live.py, single GPU).
-          - vllm_omni/clients/
-          - tests/clients/
-          - tests/e2e/online_serving/test_duplex_client_live.py
-          - vllm_omni/entrypoints/duplex_request_client.py
-          - vllm_omni/outputs/duplex.py
-          - vllm_omni/model_executor/duplex_sampling.py
-          - tests/engine/duplex/
-          - tests/entrypoints/duplex/
-          - tests/model_executor/models/minicpmo_4_5/duplex/
-          # Legacy Realtime probe client + video stacking used by the e2e drivers.
-          - vllm_omni/experimental/fullduplex/
-          - vllm_omni/model_executor/models/minicpmo_4_5/
-          - vllm_omni/model_executor/models/step_audio2/
-          - vllm_omni/model_executor/models/cosyvoice3/code2wav_core/
-          - vllm_omni/model_executor/models/cosyvoice3/utils.py
-          - vllm_omni/model_executor/stage_input_processors/minicpmo_4_5_omni.py
-          - vllm_omni/core/sched/
-          - vllm_omni/outputs/multimodal_accumulation.py
-          - vllm_omni/engine/stage_init_utils.py
-          - vllm_omni/engine/async_omni_engine.py
-          - vllm_omni/engine/orchestrator.py
-          - vllm_omni/entrypoints/cli/serve.py
-          - vllm_omni/entrypoints/openai/api_server.py
-          - vllm_omni/entrypoints/openai/duplex_capability.py
-          - vllm_omni/config/stage_config.py
+        source_file_dependencies: omni_minicpmo_4_5_duplex_function
         commands:
           - |
             timeout 35m bash -c "
@@ -254,29 +182,14 @@ steps:
 
       - label: "Omni · MiniCPM-o 4.5 Perf Test"
         timeout_in_minutes: 60
-        source_file_dependencies:
-          - tests/dfx/perf/tests/test_minicpmo_4_5_ready.json
-          - vllm_omni/deploy/minicpmo_4_5.yaml
-          - vllm_omni/model_executor/models/minicpmo_4_5/
-          - vllm_omni/model_executor/stage_input_processors/minicpmo_4_5_omni.py
+        source_file_dependencies: omni_minicpmo_4_5_perf
         commands:
           - export BENCHMARK_DIR=tests/dfx/perf/results
           - pytest -s -v tests/dfx/perf/scripts/run_benchmark.py --test-config-file tests/dfx/perf/tests/test_minicpmo_4_5_ready.json -m 'core_model and cuda'
         mirror_hardwares: h100_1
 
       - label: "TTS · Qwen3-TTS CustomVoice Test"
-        source_file_dependencies:
-          - tests/helpers/media.py
-          - tests/e2e/online_serving/test_qwen3_tts_customvoice.py
-          - vllm_omni/model_executor/models/qwen3_tts/
-          - vllm_omni/model_executor/models/common/qwen3_code_predictor.py
-          - vllm_omni/model_executor/models/common/snake_activation.py
-          - vllm_omni/model_executor/models/common/alias_free_activation.py
-          - vllm_omni/model_executor/stage_input_processors/qwen3_tts.py
-          - vllm_omni/deploy/qwen3_tts.yaml
-          - vllm_omni/entrypoints/openai/serving_speech.py
-          - vllm_omni/entrypoints/openai/tts_adapters/
-          - vllm_omni/engine/stage_pool.py
+        source_file_dependencies: tts_qwen3_tts_function
         commands:
           - |
             timeout 20m bash -c "
@@ -286,10 +199,7 @@ steps:
         mirror_hardwares: l4_1
 
       - label: "Diffusion · Wan22 Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_wan22_t2v.py
-          - vllm_omni/diffusion/models/wan2_2/
-          - vllm_omni/diffusion/models/dmd2/
+        source_file_dependencies: diffusion_wan22_function
         commands:
           - |
             timeout 40m bash -c "
@@ -299,12 +209,7 @@ steps:
         mirror_hardwares: h100_1
 
       - label: "Diffusion · Cosmos3 Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_cosmos3.py
-          - vllm_omni/diffusion/models/cosmos3/
-          - vllm_omni/diffusion/distributed/autoencoders/autoencoder_kl_wan.py
-          - vllm_omni/experimental/world_models/
-          - vllm_omni/model_extras/cosmos3.py
+        source_file_dependencies: diffusion_cosmos3_function
         commands:
           - |
             timeout 40m bash -c "
@@ -315,14 +220,7 @@ steps:
 
       - label: "Diffusion · MiniMax-H3 DLO DP2 T2VA Test"
         timeout_in_minutes: 90
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_minimax_h3_dlo_dp2_t2va.py
-          - tests/helpers/assertions.py
-          - tests/helpers/runtime.py
-          - vllm_omni/diffusion/models/minimax_h3/
-          - vllm_omni/diffusion/offloader/
-          - vllm_omni/diffusion/distributed/
-          - vllm_omni/entrypoints/openai/
+        source_file_dependencies: diffusion_minimax_h3_function
         commands:
           - |
             timeout 80m bash -c "
@@ -344,11 +242,7 @@ steps:
         mirror_hardwares: h100_1
 
       - label: "Diffusion · Qwen Image Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_qwen_image.py
-          - vllm_omni/diffusion/models/qwen_image/
-          - vllm_omni/diffusion/models/dmd2/
-          - vllm_omni/diffusion/distributed/autoencoders/autoencoder_kl_qwenimage.py
+        source_file_dependencies: diffusion_qwen_image_function
         commands:
           - |
             timeout 40m bash -c "
@@ -358,9 +252,7 @@ steps:
         mirror_hardwares: h100_1
 
       - label: "Diffusion · HunyuanVideo-1.5 Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_hunyuan_video_15_expansion.py
-          - vllm_omni/diffusion/models/hunyuan_video/
+        source_file_dependencies: diffusion_hunyuan_video_function
         commands:
           - |
             timeout 40m bash -c "
diff --git a/.buildkite/cuda/test-weekly.yml b/.buildkite/cuda/test-weekly.yml
index 614af9572..70ab59356 100644
--- a/.buildkite/cuda/test-weekly.yml
+++ b/.buildkite/cuda/test-weekly.yml
@@ -29,36 +29,42 @@ steps:
     steps:
 
       - label: "Reliability Test · qwen3-omni"
+        source_file_dependencies: omni_qwen3_omni_reliability
         timeout_in_minutes: 180
         commands:
           - pytest -s -v tests/dfx/reliability/test_reliability_qwen3_omni.py -m "slow"
         mirror_hardwares: h100_2
 
       - label: "Reliability Test · wan22"
+        source_file_dependencies: diffusion_wan22_reliability
         timeout_in_minutes: 180
         commands:
           - pytest -s -v tests/dfx/reliability/test_reliability_wan22.py -m "slow"
         mirror_hardwares: h100_2
 
       - label: "Reliability Test · hunyuan-image"
+        source_file_dependencies: diffusion_hunyuan_image3_reliability
         timeout_in_minutes: 180
         commands:
           - pytest -s -v tests/dfx/reliability/test_reliability_hunyuan_image.py -m "slow"
         mirror_hardwares: h100_4
 
       - label: "Reliability Test · Invalid parameters · H100 · Single-GPU"
+        source_file_dependencies: reliability_invalid_param_h100
         timeout_in_minutes: 90
         commands:
           - pytest -s -v tests/dfx/reliability/invalid_param_test/ -m "slow and H100 and cards_1"
         mirror_hardwares: h100_1
 
       - label: "Reliability Test · Invalid parameters · H100 · 2-GPU"
+        source_file_dependencies: reliability_invalid_param_h100
         timeout_in_minutes: 90
         commands:
           - pytest -s -v tests/dfx/reliability/invalid_param_test/ -m "slow and H100 and cards_2"
         mirror_hardwares: h100_2
 
       - label: "Reliability Test · Invalid parameters · L4"
+        source_file_dependencies: reliability_invalid_param_l4
         timeout_in_minutes: 120
         commands:
           - pytest -s -v tests/dfx/reliability/invalid_param_test/ -m "slow and L4"
@@ -70,6 +76,7 @@ steps:
     steps:
 
       - label: ":full_moon: Omni · Perf Test · vLLM Text"
+        source_file_dependencies: omni_qwen3_omni_perf
         key: weekly-omni-performance-vllm-text
         timeout_in_minutes: 180
         commands:
@@ -96,6 +103,7 @@ steps:
         mirror_hardwares: h100_2
 
       - label: ":full_moon: Omni · Perf Test · Multi-Replica"
+        source_file_dependencies: omni_qwen3_omni_perf
         key: weekly-omni-performance-multi-replicas
         timeout_in_minutes: 180
         commands:
@@ -183,13 +191,14 @@ steps:
       # from downgrading transformers; see
       # examples/offline_inference/text_to_speech/README.md.
       - label: "TTS · Gepard-1.0 · L4"
-        timeout_in_minutes: 60
+        timeout_in_minutes: 90
         commands:
           - export VLLM_ALLOW_LONG_MAX_MODEL_LEN="1"
           - printf '%s\n' "transformers>=5.5.3" "huggingface-hub>=1.0" > /tmp/gepard-overrides.txt
           - uv pip install --python "$(python3 -c 'import sys; print(sys.executable)')" "nemo_toolkit[tts]==2.7.3" --overrides /tmp/gepard-overrides.txt
           - >-
             pytest -s -v tests/e2e/offline_inference/test_gepard_tts.py
+            tests/e2e/online_serving/test_gepard_tts.py
             -m "tts and cuda"
             --run-level "full_model"
         mirror_hardwares: l4_1
@@ -221,24 +230,277 @@ steps:
             --run-level "full_model"
         mirror_hardwares: l4_4
 
-      - label: "Diffusion · H100 · Single-GPU"
-        timeout_in_minutes: 150
+      # Split the old shared H100 Single-GPU sweep: one pytest process collected
+      # every slow+cards_1 diffusion file and exceeded 150 minutes.
+      - label: "Diffusion · Qwen-Image · H100 · Single-GPU"
+        timeout_in_minutes: 120
         commands:
           - >-
             pytest -sv
-            tests/e2e/ -m "slow and diffusion and H100 and cards_1"
+            tests/e2e/online_serving/test_qwen_image_edit.py
+            tests/e2e/online_serving/test_qwen_image_edit_expansion.py
+            tests/e2e/online_serving/test_qwen_image_layered.py
+            tests/e2e/online_serving/test_qwen_image_layered_expansion.py
+            tests/e2e/accuracy/test_qwen_image_edit.py
+            tests/e2e/accuracy/test_qwen_image_layered.py
+            -m "slow and diffusion and H100 and cards_1"
             --run-level "full_model"
         mirror_hardwares: h100_1
 
-      - label: "Diffusion · H100 · 2-GPU"
+      - label: "Diffusion · Wan2.1 VACE · H100 · Single-GPU"
         timeout_in_minutes: 90
         commands:
           - >-
             pytest -sv
-            tests/e2e/ -m "slow and diffusion and H100 and cards_2"
+            tests/e2e/online_serving/test_wan_2_1_vace_expansion.py
+            -m "slow and diffusion and H100 and cards_1"
+            --run-level "full_model"
+        mirror_hardwares: h100_1
+
+      - label: "Diffusion · LongCat · H100 · Single-GPU"
+        timeout_in_minutes: 90
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/online_serving/test_longcat_image_expansion.py
+            tests/e2e/online_serving/test_longcat_image_edit_expansion.py
+            -m "slow and diffusion and H100 and cards_1"
+            --run-level "full_model"
+        mirror_hardwares: h100_1
+
+      - label: "Diffusion · Bagel · H100 · Single-GPU"
+        timeout_in_minutes: 90
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/online_serving/test_bagel.py
+            tests/e2e/online_serving/test_bagel_expansion.py
+            tests/e2e/offline_inference/test_bagel.py
+            tests/e2e/offline_inference/test_bagel_expansion.py
+            -m "slow and diffusion and H100 and cards_1"
+            --run-level "full_model"
+        mirror_hardwares: h100_1
+
+      - label: "Diffusion · Boogu · H100 · Single-GPU"
+        timeout_in_minutes: 90
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/online_serving/test_boogu_image.py
+            tests/e2e/online_serving/test_boogu_image_edit.py
+            tests/e2e/online_serving/test_boogu_image_expansion.py
+            tests/e2e/online_serving/test_boogu_image_edit_expansion.py
+            -m "slow and diffusion and H100 and cards_1"
+            --run-level "full_model"
+        mirror_hardwares: h100_1
+
+      - label: "Diffusion · Flux · H100 · Single-GPU"
+        timeout_in_minutes: 90
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/online_serving/test_flux_2_dev_expansion.py
+            tests/e2e/offline_inference/test_flux1_schnell_expansion.py
+            -m "slow and diffusion and H100 and cards_1"
+            --run-level "full_model"
+        mirror_hardwares: h100_1
+
+      - label: "Diffusion · LTX · H100 · Single-GPU"
+        timeout_in_minutes: 120
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/online_serving/test_ltx.py
+            tests/e2e/online_serving/test_ltx25.py
+            tests/e2e/accuracy/ltx/test_ltx_official_similarity.py
+            tests/e2e/accuracy/ltx/test_ltx25_official_similarity.py
+            -m "slow and diffusion and H100 and cards_1"
+            --run-level "full_model"
+        mirror_hardwares: h100_1
+
+      - label: "Diffusion · Krea2 · H100 · Single-GPU"
+        timeout_in_minutes: 90
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/online_serving/test_krea2_expansion.py
+            tests/e2e/offline_inference/test_krea2_expansion.py
+            -m "slow and diffusion and H100 and cards_1"
+            --run-level "full_model"
+        mirror_hardwares: h100_1
+
+      - label: "Diffusion · HiDream-I1 · H100 · Single-GPU"
+        timeout_in_minutes: 90
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/online_serving/test_hidream_i1_full_expansion.py
+            -m "slow and diffusion and H100 and cards_1"
+            --run-level "full_model"
+        mirror_hardwares: h100_1
+
+      - label: "Diffusion · SANA-Video · H100 · Single-GPU"
+        source_file_dependencies: diffusion_sana_video_function
+        timeout_in_minutes: 180
+        commands:
+          - export SANA_VIDEO_GOLDEN_BASE_URL=https://vllm-public-assets.s3.us-west-2.amazonaws.com/omni-assets/sana-video/v2
+          - >-
+            pytest -sv
+            tests/e2e/online_serving/test_sana_video_expansion.py
+            tests/e2e/accuracy/sana_video/
+            -m "slow and diffusion and H100 and cards_1"
+            --run-level "full_model"
+        mirror_hardwares: h100_1
+
+      - label: "Diffusion · SenseNova-U1 · H100 · Single-GPU"
+        timeout_in_minutes: 90
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/offline_inference/test_sensenova_u1_expansion.py
+            tests/e2e/offline_inference/test_sensenova_u1_text2img_expansion.py
+            tests/e2e/offline_inference/test_sensenova_u1_img2img_expansion.py
+            -m "slow and diffusion and H100 and cards_1"
+            --run-level "full_model"
+        mirror_hardwares: h100_1
+
+      - label: "Diffusion · MammothModa2 · H100 · Single-GPU"
+        timeout_in_minutes: 90
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/offline_inference/test_mammoth_moda2_expansion.py
+            -m "slow and diffusion and H100 and cards_1"
+            --run-level "full_model"
+        mirror_hardwares: h100_1
+
+      - label: "Diffusion · Helios · H100 · Single-GPU"
+        timeout_in_minutes: 90
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/accuracy/test_video_streaming_output_similarity.py
+            -m "slow and diffusion and H100 and cards_1"
+            --run-level "full_model"
+        mirror_hardwares: h100_1
+
+      # Split the old shared H100 2-GPU sweep: one pytest process collected every
+      # slow+cards_2 diffusion file and exceeded 90 minutes.
+      - label: "Diffusion · Qwen-Image · H100 · 2-GPU"
+        timeout_in_minutes: 90
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/online_serving/test_qwen_image_edit_expansion.py
+            tests/e2e/online_serving/test_qwen_image_layered_expansion.py
+            -m "slow and diffusion and H100 and cards_2"
             --run-level "full_model"
         mirror_hardwares: h100_2
 
+      - label: "Diffusion · Wan2.1 VACE · H100 · 2-GPU"
+        timeout_in_minutes: 90
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/online_serving/test_wan_2_1_vace_expansion.py
+            -m "slow and diffusion and H100 and cards_2"
+            --run-level "full_model"
+        mirror_hardwares: h100_2
+
+      - label: "Diffusion · LongCat · H100 · 2-GPU"
+        timeout_in_minutes: 90
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/online_serving/test_longcat_image_expansion.py
+            tests/e2e/online_serving/test_longcat_image_edit_expansion.py
+            -m "slow and diffusion and H100 and cards_2"
+            --run-level "full_model"
+        mirror_hardwares: h100_2
+
+      - label: "Diffusion · Bagel · H100 · 2-GPU"
+        timeout_in_minutes: 90
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/online_serving/test_bagel_expansion.py
+            -m "slow and diffusion and H100 and cards_2"
+            --run-level "full_model"
+        mirror_hardwares: h100_2
+
+      - label: "Diffusion · Boogu · H100 · 2-GPU"
+        timeout_in_minutes: 90
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/online_serving/test_boogu_image_expansion.py
+            tests/e2e/online_serving/test_boogu_image_edit_expansion.py
+            -m "slow and diffusion and H100 and cards_2"
+            --run-level "full_model"
+        mirror_hardwares: h100_2
+
+      - label: "Diffusion · Flux · H100 · 2-GPU"
+        timeout_in_minutes: 90
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/online_serving/test_flux_2_dev_expansion.py
+            tests/e2e/offline_inference/test_flux1_kontext_expansion.py
+            -m "slow and diffusion and H100 and cards_2"
+            --run-level "full_model"
+        mirror_hardwares: h100_2
+
+      - label: "Diffusion · GLM-Image · H100 · 2-GPU"
+        timeout_in_minutes: 90
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/online_serving/test_glm_image_expansion.py
+            tests/e2e/offline_inference/test_glm_image_autoround_w4a16_expansion.py
+            -m "slow and diffusion and H100 and cards_2"
+            --run-level "full_model"
+        mirror_hardwares: h100_2
+
+      - label: "Diffusion · LTX · H100 · 2-GPU"
+        timeout_in_minutes: 90
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/online_serving/test_ltx.py
+            -m "slow and diffusion and H100 and cards_2"
+            --run-level "full_model"
+        mirror_hardwares: h100_2
+
+      - label: "Diffusion · Krea2 · H100 · 2-GPU"
+        timeout_in_minutes: 90
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/offline_inference/test_krea2_expansion.py
+            -m "slow and diffusion and H100 and cards_2"
+            --run-level "full_model"
+        mirror_hardwares: h100_2
+
+      - label: "Diffusion · DreamZero · H100 · 2-GPU"
+        timeout_in_minutes: 90
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/online_serving/test_dreamzero_expansion.py
+            tests/e2e/accuracy/test_dreamzero.py
+            -m "slow and diffusion and H100 and cards_2"
+            --run-level "full_model"
+        mirror_hardwares: h100_2
+
+      - label: "Diffusion · H100 · 3-GPU"
+        timeout_in_minutes: 120
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/ -m "slow and diffusion and H100 and cards_3"
+            --run-level "full_model"
+        mirror_hardwares: h100_3
+
       - label: "Diffusion · H100 · 4-GPU"
         timeout_in_minutes: 90
         commands:
@@ -246,4 +508,33 @@ steps:
             pytest -sv
             tests/e2e/ -m "slow and diffusion and H100 and cards_4"
             --run-level "full_model"
+            --ignore=tests/e2e/online_serving/test_magi2.py
+        mirror_hardwares: h100_4
+
+      # Dedicated: HiDream-O1 accuracy needs a long TP2 run; the shared H100
+      # 2-GPU sweep is only 90 minutes.
+      - label: "Diffusion · HiDream-O1-Image Accuracy · H100 · 2-GPU"
+        timeout_in_minutes: 180
+        commands:
+          - pytest -s -v tests/e2e/accuracy/test_hidream_o1_image.py -m "slow and diffusion and cuda and H100 and cards_2" --run-level "full_model"
+        mirror_hardwares: h100_2
+
+      # Dedicated: Boogu CFG-parallel size 3 needs 3 GPUs; weekly has no H100 3-GPU sweep.
+      - label: "Diffusion · Boogu Edit CFG · H100 · 3-GPU"
+        timeout_in_minutes: 120
+        commands:
+          - >-
+            pytest -sv
+            tests/e2e/online_serving/test_boogu_image_edit_expansion.py
+            -k "test_double_guidance_cfg_parallel and cfg_parallel_3_full"
+            -m "slow and diffusion and cuda and H100 and cards_3"
+            --run-level "full_model"
+        mirror_hardwares: h100_3
+
+      # Dedicated: MAGI-2 Preview serving smoke needs ~30 min server init; the
+      # shared H100 4-GPU sweep is only 90 minutes.
+      - label: "Diffusion · MAGI-2 Preview Serving Smoke · H100 · 4-GPU"
+        timeout_in_minutes: 180
+        commands:
+          - pytest -s -v tests/e2e/online_serving/test_magi2.py -m "slow and diffusion and cuda and H100 and cards_4" --run-level "full_model"
         mirror_hardwares: h100_4
diff --git a/.buildkite/intel/pipeline-intel.yml b/.buildkite/intel/pipeline-intel.yml
index d6134b028..1e2f86af2 100644
--- a/.buildkite/intel/pipeline-intel.yml
+++ b/.buildkite/intel/pipeline-intel.yml
@@ -10,7 +10,7 @@ steps:
           DOCKER_BUILDKIT: "1"
           # Buildkite will automatically replace this with the actual commit hash
           VLLM_IMAGE_TAG: "${BUILDKITE_COMMIT}"
-          VLLM_VERSION: "v0.28.0"
+          VLLM_VERSION: "v0.29.0"
         priority: 100
         timeout_in_minutes: 60
         soft_fail: false
diff --git a/.buildkite/npu/bootstrap-upload-steps.yml b/.buildkite/npu/bootstrap-upload-steps.yml
index 398fbc6dc..d88fcc70b 100644
--- a/.buildkite/npu/bootstrap-upload-steps.yml
+++ b/.buildkite/npu/bootstrap-upload-steps.yml
@@ -93,7 +93,7 @@ steps:
     command: |
       python3 .buildkite/common/scripts/upload_pipeline.py --upload .buildkite/npu/test-npu-ready.yml
 
-  # L4 Test — main+NIGHTLY=1 (scheduled), or PR with specific label (e.g. add label then Rebuild)
+  # L4 Test — main+NIGHTLY=1 (scheduled), or PR nightly-test label
   - label: "Upload Nightly Pipeline"
     depends_on:
       - image-build-a2
@@ -102,6 +102,11 @@ steps:
       - image-build-310p
     key: upload-nightly-pipeline
     commands:
-      - python3 .buildkite/common/scripts/upload_pipeline.py --upload .buildkite/npu/test-npu-nightly.yml
+      - |
+        EXTRA=""
+        if [ "${NIGHTLY:-}" = "1" ] && [ "${BUILDKITE_BRANCH}" = "main" ]; then
+          EXTRA="--all"
+        fi
+        python3 .buildkite/common/scripts/upload_pipeline.py --upload $$EXTRA .buildkite/npu/test-npu-nightly.yml
     agents:
       queue: "cpu_queue_premerge"
diff --git a/.buildkite/npu/pipeline-npu-a3.yml b/.buildkite/npu/pipeline-npu-a3.yml
index a57f5f8e5..3544b384d 100644
--- a/.buildkite/npu/pipeline-npu-a3.yml
+++ b/.buildkite/npu/pipeline-npu-a3.yml
@@ -96,13 +96,7 @@
   #   key: upload-nightly-pipeline
   #   if: >-
   #     (build.branch == "main" && build.env("NIGHTLY") == "1") ||
-  #     (build.branch != "main" && (
-  #       build.pull_request.labels includes "nightly-test" ||
-  #       build.pull_request.labels includes "omni-test" ||
-  #       build.pull_request.labels includes "tts-test" ||
-  #       build.pull_request.labels includes "diffusion-x2iat-test" ||
-  #       build.pull_request.labels includes "diffusion-x2v-test"
-  #     ))
+  #     (build.branch != "main" && build.pull_request.labels includes "nightly-test")
   #   commands:
   #     - buildkite-agent pipeline upload .buildkite/npu/test-npu-nightly.yml
   #   agents:
diff --git a/.buildkite/npu/test-npu-nightly.yml b/.buildkite/npu/test-npu-nightly.yml
index e049783ce..0c39a3f93 100644
--- a/.buildkite/npu/test-npu-nightly.yml
+++ b/.buildkite/npu/test-npu-nightly.yml
@@ -4,10 +4,10 @@ steps:
     depends_on: upload-nightly-pipeline
     if: >-
       build.env("NIGHTLY") == "1" ||
-      build.pull_request.labels includes "nightly-test" ||
-      build.pull_request.labels includes "omni-test"
+      build.pull_request.labels includes "nightly-test"
     steps:
       - label: ":full_moon: Omni · Perf Test · No Async Chunk"
+        source_file_dependencies: omni_qwen3_omni_perf
         key: nightly-omni-performance-no-async-chunk
         timeout_in_minutes: 180
         mirror_hardwares: a3_npu_4
@@ -24,6 +24,7 @@ steps:
             buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
             exit $$EXIT
       - label: ":full_moon: Omni · Perf Test · Async Chunk"
+        source_file_dependencies: omni_qwen3_omni_perf
         key: nightly-omni-performance-async-chunk
         timeout_in_minutes: 180
         mirror_hardwares: a3_npu_4
@@ -40,6 +41,7 @@ steps:
             buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
             exit $$EXIT
       - label: ":full_moon: Omni · MiniCPM-o 4.5 Test"
+        source_file_dependencies: omni_minicpmo_4_5_function
         mirror_hardwares: a3_npu_2
         env:
           VLLM_WORKER_MULTIPROC_METHOD: spawn
@@ -48,6 +50,7 @@ steps:
         commands:
           - pytest -s -v tests/e2e/offline_inference/test_minicpmo_4_5.py tests/e2e/online_serving/test_minicpmo_4_5.py tests/e2e/online_serving/test_minicpmo_4_5_expansion.py -m 'full_model' --run-level 'full_model'
       - label: ":full_moon: Omni · MiniCPM-o 4.5 · Duplex Test"
+        source_file_dependencies: omni_minicpmo_4_5_duplex_function
         timeout_in_minutes: 180
         mirror_hardwares: a3_npu_2
         env:
@@ -62,6 +65,7 @@ steps:
             -m "npu and A3 and omni"
             --run-level full_model
       - label: ":full_moon: Omni · MiniCPM-o 4.5 · Accuracy Test"
+        source_file_dependencies: omni_minicpmo_4_5_accuracy
         timeout_in_minutes: 180
         mirror_hardwares: a3_npu_2
         env:
@@ -82,6 +86,7 @@ steps:
             buildkite-agent artifact upload "tests/e2e/accuracy/minicpmo_4_5/results/*.json"
             exit $$EXIT
       - label: ":full_moon: Omni · MiniCPM-o 4.5 · Perf Test"
+        source_file_dependencies: omni_minicpmo_4_5_perf
         key: nightly-omni-performance-minicpmo-4-5-npu
         timeout_in_minutes: 180
         mirror_hardwares: a3_npu_2
@@ -98,6 +103,7 @@ steps:
             buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
             exit $$EXIT
       - label: ":full_moon: Omni · MiniCPM-o 4.5 · Perf Test (A2)"
+        source_file_dependencies: omni_minicpmo_4_5_perf
         key: nightly-omni-performance-minicpmo-4-5-npu-a2
         timeout_in_minutes: 180
         mirror_hardwares: a2b3_npu_1
@@ -115,6 +121,7 @@ steps:
             buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
             exit $$EXIT
       - label: ":full_moon: Omni · MiniCPM-o 4.5 · Duplex Seed-TTS Perf Test"
+        source_file_dependencies: omni_minicpmo_4_5_duplex_perf
         key: nightly-omni-performance-minicpmo-4-5-duplex-seed-tts-npu
         timeout_in_minutes: 180
         mirror_hardwares: a3_npu_2
@@ -133,9 +140,10 @@ steps:
   - group: ":card_index_dividers: TTS Model Test"
     key: nightly-tts-test-group
     depends_on: upload-nightly-pipeline
-    if: build.env("NIGHTLY") == "1" || build.pull_request.labels includes "nightly-test" || build.pull_request.labels includes "tts-test"
+    if: build.env("NIGHTLY") == "1" || build.pull_request.labels includes "nightly-test"
     steps:
       - label: ":full_moon: TTS · Perf Test"
+        source_file_dependencies: tts_qwen3_tts_perf
         timeout_in_minutes: 180
         mirror_hardwares: a3_npu_2
         env:
@@ -151,15 +159,15 @@ steps:
             EXIT=$$?
             buildkite-agent artifact upload "tests/dfx/perf/results/*.json"
             exit $$EXIT
-  - group: ":card_index_dividers: Diffusion I2I Model Test"
-    key: nightly-HunyuanImage3-x2i-test-group
+  - group: ":card_index_dividers: Diffusion X2I(&A&T) Model Test"
+    key: nightly-diffusion-x2iat-group
     depends_on: upload-nightly-pipeline
     if: >-
       build.env("NIGHTLY") == "1" ||
-      build.pull_request.labels includes "nightly-test" ||
-      build.pull_request.labels includes "diffusion-x2iat-test"
+      build.pull_request.labels includes "nightly-test"
     steps:
       - label: ":full_moon: HunyuanImage3-DIT · Accuracy Test"
+        source_file_dependencies: diffusion_hunyuan_image3_accuracy
         timeout_in_minutes: 180
         mirror_hardwares: a3_npu_4
         env:
@@ -169,15 +177,8 @@ steps:
           DIFFUSION_ATTENTION_BACKEND: TORCH_SDPA
         commands:
           - pytest -s -v tests/e2e/accuracy/test_hunyuan_image3_pixel_accuracy.py -m "full_model and A3" --run-level full_model
-  - group: ":card_index_dividers: Diffusion Benchmark Perf Test"
-    key: nightly-diffusion-benchmark-group
-    depends_on: upload-nightly-pipeline
-    if: >-
-      build.env("NIGHTLY") == "1" ||
-      build.pull_request.labels includes "nightly-test" ||
-      build.pull_request.labels includes "diffusion-x2iat-test"
-    steps:
       - label: ":full_moon: Diffusion Perf · HunyuanImage3 TP=2 CFGP=2"
+        source_file_dependencies: diffusion_hunyuan_image3_perf
         timeout_in_minutes: 180
         mirror_hardwares: a3_npu_4
         env:
@@ -194,6 +195,7 @@ steps:
             buildkite-agent artifact upload "tests/dfx/perf/results/logs/*.log"
             exit $$EXIT
       - label: ":full_moon: Diffusion Perf · HunyuanImage3 TP=2 SP=2"
+        source_file_dependencies: diffusion_hunyuan_image3_perf
         timeout_in_minutes: 180
         mirror_hardwares: a3_npu_4
         env:
@@ -210,6 +212,7 @@ steps:
             buildkite-agent artifact upload "tests/dfx/perf/results/logs/*.log"
             exit $$EXIT
       - label: ":full_moon: Diffusion Perf · HunyuanImage3 TP=4"
+        source_file_dependencies: diffusion_hunyuan_image3_perf
         timeout_in_minutes: 180
         mirror_hardwares: a3_npu_4
         env:
@@ -230,10 +233,41 @@ steps:
     depends_on: upload-nightly-pipeline
     if: >-
       build.env("NIGHTLY") == "1" ||
-      build.pull_request.labels includes "nightly-test" ||
-      build.pull_request.labels includes "diffusion-x2v-test"
+      build.pull_request.labels includes "nightly-test"
     steps:
-      - label: ":full_moon: Diffusion X2V · Function Test"
+      - 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
         env:
           VLLM_WORKER_MULTIPROC_METHOD: spawn
@@ -241,7 +275,8 @@ steps:
           HF_TOKEN: "${HF_TOKEN}"
         commands:
           - pytest -s -v tests/e2e/online_serving/test_wan22_expansion.py -k npu_i2v --run-level "full_model"
-      - label: ":full_moon: Diffusion X2V · Perf Test"
+      - label: ":full_moon: Diffusion X2V · Wan 2.2 Perf Test"
+        source_file_dependencies: diffusion_wan22_perf
         key: nightly-diffusion-x2v-performance
         timeout_in_minutes: 180
         mirror_hardwares: a3_npu_4
diff --git a/.claude/skills/vllm-omni-test/SKILL.md b/.claude/skills/vllm-omni-test/SKILL.md
index 2d4226788..f0fb009d5 100644
--- a/.claude/skills/vllm-omni-test/SKILL.md
+++ b/.claude/skills/vllm-omni-test/SKILL.md
@@ -468,10 +468,10 @@ When the user asks for **invalid parameter validation**, **invalid request bodie
 | **Invalid parameters Test · H100** | `pytest -s -v tests/dfx/reliability/invalid_param_test/ -m "slow and H100"` | Diffusion / omni / video invalid-param tests with `H100` hardware mark |
 | **Invalid parameters Test · L4** | `pytest -s -v tests/dfx/reliability/invalid_param_test/ -m "slow and L4"` | TTS / lighter models marked `L4` |
 
-- **Trigger:** `build.env("WEEKLY") == "1"` or PR label `weekly-test`.
+- **Trigger:** `build.env("WEEKLY") == "1"` (all weekly jobs) or PR label `weekly-test` (Reliability / Perf, then filtered by `source_file_dependencies`).
 - **Default:** extending an existing `invalid_param_test` script needs **no YAML edit** — the weekly steps already sweep the whole directory.
 - **Edit YAML only** when adding a **new hardware queue**, a **new top-level script** that must run in isolation, or a **model-specific weekly shard** (mirror neighboring reliability steps).
-- Weekly steps **do not** use `source_file_dependencies`.
+- Weekly Reliability / Perf jobs declare `source_file_dependencies`. Filtering applies only on the `weekly-test` label; `WEEKLY=1` on `main` keeps every job in those groups. CPU coverage (`WEEKLY=1` only) and the E2E Tests group (`NON_CRITICAL=1` only) do **not** use this field.
 
 **Example — append to `test_invalid_image_generation.py`:**
 
@@ -644,7 +644,7 @@ If the test is not already collected by an existing pipeline command (for exampl
 | **L2** | `test-ready.yml` with `core_model` + `source_file_dependencies` | merge / nightly pipelines |
 | **Invalid param** | `test-weekly.yml` — **Invalid parameters Test** group (`-m "slow and H100"` / `-m "slow and L4"`). Usually **no YAML edit** when appending cases to existing `invalid_param_test` scripts | `test-ready.yml`, `test-merge.yml`, `test-nightly.yml` |
 
-`test-nightly.yml` shards use **explicit pytest file paths** in `commands` (and PR labels like `diffusion-x2iat-test`); they generally **do not** use `source_file_dependencies`. Only suggest merge/ready YAML when the requested level is L3/L2 (or the user explicitly asks for multi-level CI).
+`test-nightly.yml` shards use **explicit pytest file paths** in `commands` plus `source_file_dependencies`; PR trigger is `nightly-test` (path filter), or `NIGHTLY=1` on `main` (all jobs). Only suggest merge/ready YAML when the requested level is L3/L2 (or the user explicitly asks for multi-level CI).
 
 **`test-nightly.yml` top-level groups** (each uses `full_model` + type marker in pytest `-m`):
 
@@ -653,7 +653,7 @@ If the test is not already collected by an existing pipeline command (for exampl
 | **Omni Model Test** | `omni` | Function / doc / accuracy / **perf** for Qwen-Omni family |
 | **TTS Model Test** | `tts` | `-m "full_model and L4 and tts"` (and H100 variants when enabled); **Perf Test** uses `run_benchmark.py` + `test_tts.json` |
 | **Diffusion X2I(&A&T) Model Test** | `diffusion` | Image/audio/text diffusion; explicit file shards for **Function**; **Perf Test · &lt;Model&gt;** uses `run_diffusion_benchmark.py` + JSON config |
-| **Diffusion X2V Model Test** | `diffusion` | Video-only (Wan, HunyuanVideo, …); PR label `diffusion-x2v-test`; separate **Perf** steps when in-tree |
+| **Diffusion X2V Model Test** | `diffusion` | Video-only (Wan, HunyuanVideo, …); separate **Perf** steps when in-tree |
 
 Guidelines when editing YAML:
 
diff --git a/.claude/skills/vllm-omni-test/references/test-routing.md b/.claude/skills/vllm-omni-test/references/test-routing.md
index 5b90957d6..a61324e6d 100644
--- a/.claude/skills/vllm-omni-test/references/test-routing.md
+++ b/.claude/skills/vllm-omni-test/references/test-routing.md
@@ -37,7 +37,7 @@ Every model-centric e2e test must declare **exactly one** type marker:
 | **Diffusion X2I(&A&T) Model Test** | x2**i** / x2**a** / x2**t** — image, audio, text (non-video) | Qwen-Image*, BAGEL, FLUX, SD3, Z-Image, LongCat, DreamZero |
 | **Diffusion X2V Model Test** | x2**v** — video only | Wan2.2, HunyuanVideo 1.5, Wan VACE |
 
-PR labels for selective nightly runs: `diffusion-x2iat-test`, `diffusion-x2v-test` (plus `nightly-test` / `NIGHTLY=1`).
+PR label for L4 on a branch: `nightly-test` (jobs then filtered by `source_file_dependencies`). Scheduled `main` uses `NIGHTLY=1` and runs every nightly job. L5 Reliability / Perf use `weekly-test` with the same path filter; CPU coverage and the weekly E2E group are env-only (`WEEKLY=1` / `NON_CRITICAL=1`) and are not source-filtered.
 
 ## Level and Marker Mapping
 
@@ -238,7 +238,7 @@ pytest -s -v dfx/reliability/invalid_param_test/ -m "slow and L4"
 pytest -s -v dfx/reliability/invalid_param_test/test_invalid_image_generation.py::test_images_generations_invalid_requests -m "slow and H100"
 ```
 
-**Trigger:** `WEEKLY=1` or PR label `weekly-test`. Appending cases to existing scripts usually needs **no YAML edit** (directory sweep). No `source_file_dependencies` on weekly steps.
+**Trigger:** `WEEKLY=1` (all jobs) or PR label `weekly-test` (Reliability / Perf, filtered by `source_file_dependencies`). Appending cases to existing scripts usually needs **no YAML edit** (directory sweep).
 
 ### Platform-targeted examples
 
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 cbd53a9a0..f33e26b40 100644
--- a/apps/ComfyUI-vLLM-Omni/README.md
+++ b/apps/ComfyUI-vLLM-Omni/README.md
@@ -13,7 +13,6 @@ It can send model inference requests to either a locally running vLLM-Omni servi
 > [!TIP]
 > If you run both ComfyUI and vLLM-Omni on the same device, you can create separate virtual environments and use different Python versions for them.
 
-
 ## Installation
 
 Copy this folder to the `custom_nodes` subfolder of your ComfyUI installation. Your directory should look like `ComfyUI/custom_nodes/ComfyUI-vLLM-Omni`.
@@ -21,9 +20,10 @@ Copy this folder to the `custom_nodes` subfolder of your ComfyUI installation. Y
 If you are running ComfyUI during copying, you should restart ComfyUI to load this extension.
 
 > [!TIP]
-> You can use utility websites such as https://download-directory.github.io/ to download a subdirectory of a repo. Also checkout community discussions (e.g., https://stackoverflow.com/questions/7106012/download-a-single-folder-or-directory-from-a-github-repository) for more info.
+> You can use utility websites such as <https://download-directory.github.io/> to download a subdirectory of a repo. Also checkout community discussions (e.g., <https://stackoverflow.com/questions/7106012/download-a-single-folder-or-directory-from-a-github-repository>) for more info.
 
 On the device and virtual environment you run ComfyUI, launch ComfyUI with
+
 ```bash
 cd ComfyUI
 
@@ -35,6 +35,7 @@ python main.py --cpu
 ```
 
 On the device and virtual environment you run vLLM-Omni, start a model service with
+
 ```bash
 vllm serve The_Model_ID_to_Serve --omni --port 8000
 ```
@@ -48,14 +49,30 @@ This extension offers the following nodes based on the output modalities (at **C
 
 - **Generate Image** for text-to-image and image-to-image tasks
 - **Generate Video** for text-to-video, first-frame/image-to-video, and reference-conditioned video
+- **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**)
 
 > [!NOTE]
 > The node UI and feature designs are intended to match vLLM-Omni online serving interfaces. It cannot offer more than what the interfaces support.
 
+Every node carries the vLLM-Omni mark in its title bar and is tinted by what it outputs, so a graph is readable at a glance:
+
+| Colour | Nodes | What they produce |
+| --- | --- | --- |
+| Blue | Generate Image, Generate Video, Multimodality Understanding, TTS, TTS Voice Clone | A generated image, video, audio, or text. These are the only nodes that reach a server. |
+| Amber | AR / Diffusion / Multi-Stage Sampling Params | Sampling parameters that apply to any model |
+| Purple | Qwen TTS Params, Wan Video Params, MiniMax-H3 Video Params | Parameters that only one model family accepts |
+| Red | LoRA, FastH3 Deployment | Which weights the server is expected to have loaded |
+| Teal | Video References | Reference media |
+
+Recolouring a node by hand (right click -> Colors) overrides its tint, and the choice is kept.
+
+**Generate Video** takes a clip length in seconds (`duration`), not a frame count. Frames stay the wire unit and are derived with the node's `fps`, so the length is always measured against the rate that is actually served; models that accept only certain frame counts still round to their own lattice server-side. Graphs saved before this widget existed stored `num_frames` in its place and are converted on load, using the fps recorded alongside it -- the browser console names every node it rewrites.
+
 To build a simple workflow yourself,
 
 - Drag a generation node onto the canvas.
@@ -117,11 +134,134 @@ 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
+12 connected inputs in total. Any mixture containing at least one image or video
+is supported; empty and audio-only references are rejected. For example, you can
+combine 6 images, 3 videos, and 3 audio clips in one request.
+
+Within each media type, references follow slot-number order, skipping unconnected
+slots. For example, connecting `image_2` and `image_9` sends `image_2` as the first
+image and `image_9` as the second. Each image slot uses the first image in its batch.
+Existing connections to `image_1`, `image_2`, `audio_1`, `audio_2`, `video_1`, and
+`video_2` remain valid in saved workflows.
+
+#### MiniMax-H3 Reference to Video
+
+Load [MiniMax-H3 Reference to Video](example_workflows/vLLM-Omni%20MiniMax-H3%20Reference%20to%20Video.json)
+from **Templates → ComfyUI-vLLM-Omni**, or drag the JSON onto the canvas.
+It adapts the [official ComfyUI R2V workflow](https://github.com/Comfy-Org/workflow_templates/blob/main/templates/video_minimax_h3_r2v.json)
+to remote vLLM-Omni execution. Model loading, sampling, and VAE decoding run on
+the server; ComfyUI loads references and saves the returned video.
+
+Use an extension version containing the audio-preserving output fix from
+[#7456](https://github.com/vllm-project/vllm-omni/pull/7456). Older versions can
+drop the server's audio while decoding the response.
+
+1. Start a Ref2VA-capable service using the [MiniMax-H3 recipe](../../recipes/MiniMaxAI/MiniMax-H3.md).
+   Set **Generate Video** to its `/v1` URL and served model name.
+2. Select your own image in **Load Image**. The template's filenames are placeholders
+   relative to ComfyUI's input directory; no sample assets or model weights are bundled.
+3. Connect **Load Video** and **Load Audio** when needed. Duplicate the loaders to
+   fill more reference slots, or disconnect the image when using video-only input.
+   Keep the references connected to **Generate Video** and leave `frame` disconnected.
+4. Match prompt tags such as `<Picture 1>`, `<Video 1>`, and `<Audio 1>` to the
+   connected references, counting each media type separately and skipping empty slots.
+5. Run the workflow. **Save Video** writes an MP4 under `output/video/` and preserves
+   the generated audio when the audio-output prerequisite is installed.
+
+The default is **1344×768, 24 FPS, 124 frames** (about 5.17 seconds), 50 sampling
+points, video flow shift 12, audio flow shift 3, and seed 42. The duration widget
+is set to 5.167 seconds, which converts to 124 frames at 24 FPS. Other H3 canvas presets
+are 1024×768, 768×768, 768×1024, and 768×1344. Keep frame counts at `17k+5` within
+the 4–15 second output range; examples are 107, 124, 209, and 345 frames.
+Reference video/audio clips must each be 2–15 seconds, with at most 15 seconds of
+reference video and at most 15 seconds of standalone reference audio per request.
+
+For **Ref2VA Turbo**, use the same template. Configure a Ref2VA-only server with
+`--lora-backend peft --lora-path "$TURBO_LORA" --task-type ref2va`, following the
+recipe's hardware setup. For `minimax_h3_ref2v_turbo_4step_v0.1_bf16.safetensors`,
+set **LoRA** `local_path` to that file's path on the server and connect it to
+**Generate Video**. Use `num_inference_steps=5`, `flow_shift=12`,
+`audio_flow_shift=3`, and LoRA `scale=1`. The API counts sigma points, so five
+points produce four denoiser evaluations. Use the Diffusers artifact, not its
+`_comfyui_` export. To return to base mode, disconnect LoRA and restore 50 steps.
+The 8-step v1.0 Ref2VA adapter instead requires nine sampling points and video
+flow shift 6. FastH3 is a separate startup-fused T2VA deployment.
+
+Validate the template's wiring and defaults locally with:
+
+```bash
+python -m pytest tests/e2e/features/comfyui/test_h3_reference_workflow.py -q
+```
+
+For a real-model check, run the workflow against H3 and inspect the saved file:
+
+```bash
+ffprobe -v error -show_entries stream=codec_type,width,height,r_frame_rate,sample_rate,channels \
+  -show_entries format=duration -of json "$OUTPUT_MP4"
+```
+
+Check for 24 FPS video, stereo audio, the requested canvas, and aligned duration;
+also play the result to assess reference conditioning and audio/video synchronization.
+Record the server commit, model/adapter, input assets, prompt, settings, and output
+alongside the result. Local schema or mocked-server checks do not establish H3
+generation quality or replace this real-model validation.
+
+### MiniMax H3 Text to Video
+
+Import [the H3 text-to-video template](example_workflows/MiniMax_H3_Text_to_Video.json)
+for remote video generation with audio. It includes connected base presets and
+optional Turbo sampling, H3 parameters, and Remote LoRA nodes. See the
+[workflow guide](docs/minimax-h3-t2v.md) for server setup, artifact-specific Turbo
+settings, and saved-video/audio validation. Set Remote LoRA’s `local_path` to
+the downloaded Turbo artifact on your server before enabling Turbo.
+
+#### H3 video upscale (WF-07)
+
+The **vLLM-Omni MiniMax H3 Video Upscale** template generates video remotely, upscales it with SeedVR2, and saves the original and upscaled videos with the generated audio and FPS. See [workflow setup](docs/wf07-h3-upscale.md).
+
+#### FastH3 text-to-video
+
+FastH3 is fused into MiniMax-H3 when the vLLM-Omni server starts; it is not a request-switchable LoRA. Download one adapter variant and start a non-offloaded FL2VA server. For the Dense / Data-Free profile:
+
+```bash
+export FASTH3_DIR=/path/to/fasth3
+hf download FastVideo/FastVideo-FastH3-4-step-Preview-v1-LoRA \
+  dense-datafree/adapter_model.safetensors --local-dir "${FASTH3_DIR}"
+
+vllm serve /path/to/MiniMax-H3 \
+  --omni \
+  --task-type fl2va \
+  --lora-path "${FASTH3_DIR}/dense-datafree/adapter_model.safetensors" \
+  --port 8000
+```
+
+For the VSA / Data-Free profile, download `vsa-datafree/adapter_model.safetensors`, use that file as `--lora-path`, and add:
+
+```bash
+--diffusion-attention-backend FASTVIDEO_VSA \
+--fastvideo-vsa-topk 64
+```
+
+The VSA profile also requires a compatible `fastvideo-kernel` installation. See the [MiniMax-H3 FastH3 recipe](../../recipes/MiniMaxAI/MiniMax-H3.md#fasth3-adapter) for the full serving contract, supported parallel layouts, and kernel requirements.
+
+Open the **vLLM-Omni FastH3 Text to Video** template, then:
+
+- Set the server URL and served model name on **FastH3 Deployment**.
+- Connect its output to **Generate Video → fast_h3**. When connected, the deployment node's URL and model take precedence over the corresponding Generate Video widgets.
+- Keep `frame`, `references`, **LoRA**, and **MiniMax-H3 Video Params** disconnected. FastH3 Preview v1 supports T2VA only, is already fused, and owns both flow shifts.
+- A connected **Diffusion Sampling Params** node may set seed and other ordinary sampling options. The integration always enforces four denoising steps and 24 FPS for FastH3.
+
+The node records which server the workflow targets; it does not start one, nor switch adapters or attention backends on a running server.
 
 ### TTS (e.g., Qwen TTS series)
 
@@ -137,6 +277,17 @@ You can configure per-stage sampling parameters for multi-stage models.
 > [!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**)
@@ -152,6 +303,8 @@ You can configure per-stage sampling parameters for multi-stage models.
 
 Follow the [development convention and rules of vLLM-Omni](https://docs.vllm.ai/projects/vllm-omni/en/latest/contributing/).
 
+Node tints and the title-bar mark are applied in `web/main.js`, keyed off each node's declared output types rather than a list of node names. A new node that returns an existing type is themed with no front-end change; a new output type needs one entry in `FAMILY_BY_OUTPUT` there.
+
 ## Limitation and Non-Goals
 
 - Single server mode only. No automatic load balancing or failover.
@@ -178,11 +331,11 @@ Whenever you find an issue or problem, please
 
 Features
 
-- https://github.com/dougbtv/comfyui-vllm-omni/ The official reference implementation for ComfyUI integration with vLLM-Omni's DALL-E compatible image generation API.
-- https://github.com/Comfy-Org/ComfyUI/tree/master/comfy_extras ComfyUI's built-in node implementations.
+- <https://github.com/dougbtv/comfyui-vllm-omni/> The official reference implementation for ComfyUI integration with vLLM-Omni's DALL-E compatible image generation API.
+- <https://github.com/Comfy-Org/ComfyUI/tree/master/comfy_extras> ComfyUI's built-in node implementations.
 
 UI/UX design references
 
-- https://github.com/sgl-project/sglang/pull/15271 SGLang Diffusion's official ComfyUI integration for image and video generation.
-- https://github.com/SXQBW/ComfyUI-Qwen-Omni A third party ComfyUI integration for Qwen Omni series.
-- https://github.com/flybirdxx/ComfyUI-Qwen-TTS https://github.com/DarioFT/ComfyUI-Qwen3-TTS Third  party ComfyUI integrations for Qwen TTS series.
+- <https://github.com/sgl-project/sglang/pull/15271> SGLang Diffusion's official ComfyUI integration for image and video generation.
+- <https://github.com/SXQBW/ComfyUI-Qwen-Omni> A third party ComfyUI integration for Qwen Omni series.
+- <https://github.com/flybirdxx/ComfyUI-Qwen-TTS> <https://github.com/DarioFT/ComfyUI-Qwen3-TTS> Third  party ComfyUI integrations for Qwen TTS series.
diff --git a/apps/ComfyUI-vLLM-Omni/__init__.py b/apps/ComfyUI-vLLM-Omni/__init__.py
index 268107899..8c1b03d87 100644
--- a/apps/ComfyUI-vLLM-Omni/__init__.py
+++ b/apps/ComfyUI-vLLM-Omni/__init__.py
@@ -1,4 +1,8 @@
-"""Top-level package for comfyui_vllm_omni."""  # noqa: N999  # This is not a python library intended to be imported
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+# ruff: noqa: N999
+
+"""Top-level package for comfyui_vllm_omni."""  # This is not a Python library intended to be imported.
 
 __all__ = [
     "NODE_CLASS_MAPPINGS",
@@ -13,7 +17,9 @@ __version__ = "0.0.1"
 from .comfyui_vllm_omni.nodes import (
     VLLMOmniARSampling,
     VLLMOmniDiffusionSampling,
+    VLLMOmniFastH3Deployment,
     VLLMOmniGenerateImage,
+    VLLMOmniGenerateMusic,
     VLLMOmniGenerateVideo,
     VLLMOmniMiniMaxH3Params,
     VLLMOmniQwenTTSParams,
@@ -33,6 +39,7 @@ NODE_CLASS_MAPPINGS = {
     "VLLMOmniGenerateVideo": VLLMOmniGenerateVideo,
     "VLLMOmniUnderstanding": VLLMOmniUnderstanding,
     "VLLMOmniTTS": VLLMOmniTTS,
+    "VLLMOmniGenerateMusic": VLLMOmniGenerateMusic,
     "VLLMOmniVoiceClone": VLLMOmniVoiceClone,
     "VLLMOmniVideoReferences": VLLMOmniVideoReferences,
     # === Params ===
@@ -40,6 +47,7 @@ NODE_CLASS_MAPPINGS = {
     "VLLMOmniDiffusionSampling": VLLMOmniDiffusionSampling,
     "VLLMOmniSamplingParamsList": VLLMOmniSamplingParamsList,
     "VLLMOmniRemoteLoRA": VLLMOmniRemoteLoRA,
+    "VLLMOmniFastH3Deployment": VLLMOmniFastH3Deployment,
     "VLLMOmniQwenTTSParams": VLLMOmniQwenTTSParams,
     "VLLMOmniWanParams": VLLMOmniWanParams,
     "VLLMOmniMiniMaxH3Params": VLLMOmniMiniMaxH3Params,
@@ -52,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 ===
@@ -59,6 +68,7 @@ NODE_DISPLAY_NAME_MAPPINGS = {
     "VLLMOmniDiffusionSampling": "Diffusion Sampling Params",
     "VLLMOmniSamplingParamsList": "Multi-Stage Sampling Params List",
     "VLLMOmniRemoteLoRA": "LoRA",
+    "VLLMOmniFastH3Deployment": "FastH3 Deployment",
     "VLLMOmniQwenTTSParams": "Qwen TTS Params",
     "VLLMOmniWanParams": "Wan Video Params",
     "VLLMOmniMiniMaxH3Params": "MiniMax-H3 Video Params",
diff --git a/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/nodes.py b/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/nodes.py
index 8fd00cd9c..6d5006a11 100644
--- a/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/nodes.py
+++ b/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/nodes.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 from typing import Literal
 
 import torch
@@ -7,9 +10,13 @@ from .utils.api_client import VLLMOmniClient
 from .utils.logger import get_logger
 from .utils.models import lookup_model_spec
 from .utils.types import (
+    MAX_REFERENCE_AUDIOS,
+    MAX_REFERENCE_IMAGES,
+    MAX_REFERENCE_VIDEOS,
     AudioFormat,
     AutoregressionSamplingParams,
     DiffusionSamplingParams,
+    FastH3Deployment,
     MiniMaxH3ModelSpecificParams,
     QwenTTSModelSpecificParams,
     VideoReferences,
@@ -22,6 +29,23 @@ from .utils.validators import (
 
 logger = get_logger(__name__)
 
+FASTH3_INFERENCE_STEPS = 4
+FASTH3_FPS = 24
+# A FastH3 deployment may expose H3 under any --served-model-name, so the payload
+# spec has to be named outright rather than recovered from that alias.
+FASTH3_SPEC_MODEL = "MiniMax-H3"
+
+
+def _resolve_fast_h3_deployment(deployment: dict) -> tuple[str, str]:
+    if not isinstance(deployment, dict):
+        raise ValueError("FastH3 deployment must be provided by a FastH3 Deployment node.")
+
+    url = str(deployment.get("url") or "").strip().rstrip("/")
+    model = str(deployment.get("model") or "").strip()
+    if not url or not model:
+        raise ValueError("FastH3 deployment requires both URL and model.")
+    return url, model
+
 
 class _VLLMOmniGenerateBase:
     """Base class for vLLM-Omni generation nodes with shared functionality."""
@@ -162,14 +186,30 @@ class VLLMOmniGenerateVideo(_VLLMOmniGenerateBase):
                 "width": ("INT", {"default": 832, "min": 1}),
                 "height": ("INT", {"default": 480, "min": 1}),
                 "fps": ("INT", {"default": 16, "min": 1}),
-                "num_frames": ("INT", {"default": 41, "min": 1}),
+                "duration": (
+                    "FLOAT",
+                    {
+                        "default": 4.0,
+                        "min": 0.1,
+                        "step": 0.1,
+                        "round": 0.001,
+                        "tooltip": (
+                            "Clip length in seconds, converted to frames with the fps above. "
+                            "Models that only accept certain frame counts (e.g. MiniMax-H3) round to "
+                            "their own lattice, so the served clip can be slightly longer than requested."
+                        ),
+                    },
+                ),
             },
             "optional": {
                 "frame": ("IMAGE",),
+                "first_frame": ("IMAGE",),
+                "last_frame": ("IMAGE",),
                 "references": ("VIDEO_REFERENCES",),
                 "sampling_params": ("SAMPLING_PARAMS",),
                 "lora": ("REMOTE_LORA",),
                 "model_params": ("VIDEO_PARAMS",),
+                "fast_h3": ("FASTH3_DEPLOYMENT",),
             },
         }
 
@@ -178,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(
@@ -194,20 +252,71 @@ class VLLMOmniGenerateVideo(_VLLMOmniGenerateBase):
         width: int,
         height: int,
         fps: int,
-        num_frames: int,
+        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,
         lora: dict | None = None,
+        fast_h3: dict | None = None,
         **kwargs,
     ):
         if kwargs:
             logger.info("Uncaught kwargs: %s", kwargs)
         logger.debug("Got sampling params: %s", sampling_params)
         logger.debug("Got model params: %s", model_params)
-        validate_model_and_sampling_params_types(model, sampling_params)
+
+        # Which spec builds the payload. Only a FastH3 deployment separates this
+        # from the served name; every other path keeps them equal.
+        spec_model = model
+
+        if fast_h3 is not None:
+            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."
+                )
+
+            url, model = _resolve_fast_h3_deployment(fast_h3)
+            logger.info("Using FastH3 deployment at %s", url)
+            fps = FASTH3_FPS
+            # The served name is whatever the operator passed to --served-model-name.
+            # Left alone, lookup_model_spec would miss H3 for an alias such as
+            # "fasth3", drop the params builder, and send a t2va request carrying no
+            # aspect_ratio -- which the server refuses.
+            spec_model = FASTH3_SPEC_MODEL
+
+            if sampling_params is None:
+                sampling_params = DiffusionSamplingParams()
+            elif isinstance(sampling_params, list):
+                if len(sampling_params) != 1:
+                    raise ValueError("FastH3 expects a single diffusion sampling params group.")
+                sampling_params = sampling_params[0].__class__(sampling_params[0])
+            else:
+                sampling_params = sampling_params.__class__(sampling_params)
+            sampling_params["num_inference_steps"] = FASTH3_INFERENCE_STEPS
+
+            # FastH3 owns both modality shifts. Sending the ordinary H3 values
+            # from a connected H3 Params node would turn a deployment choice
+            # into a request-level override, which the server intentionally
+            # rejects when it differs from the fused adapter contract.
+            if model_params is not None:
+                model_params = model_params.__class__(model_params)
+                model_params.pop("flow_shift", None)
+                model_params.pop("audio_flow_shift", None)
+
+        # Frames stay the wire unit. Convert after the FastH3 branch above, so the
+        # duration is measured against the fps the server will actually apply.
+        num_frames = max(1, round(duration * fps))
+
+        validate_model_and_sampling_params_types(spec_model, sampling_params)
 
         # Currently, all video generation models are single-stage diffusion models
         if isinstance(sampling_params, list):
@@ -227,8 +336,11 @@ class VLLMOmniGenerateVideo(_VLLMOmniGenerateBase):
         client = VLLMOmniClient(url)
         output = await client.generate_video(
             model=model,
+            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,
@@ -418,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):
@@ -695,6 +867,52 @@ class VLLMOmniRemoteLoRA:
         return (lora,)
 
 
+class VLLMOmniFastH3Deployment:
+    """Select a vLLM-Omni service that fused FastH3 at startup."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "url": (
+                    "STRING",
+                    {
+                        "default": "http://localhost:8000/v1",
+                        "tooltip": "URL of a vLLM-Omni server started with a FastH3 --lora-path.",
+                    },
+                ),
+                "model": (
+                    "STRING",
+                    {
+                        "default": "MiniMaxAI/MiniMax-H3",
+                        "tooltip": "Model name exposed by the FastH3 deployment.",
+                    },
+                ),
+            }
+        }
+
+    RETURN_TYPES = ("FASTH3_DEPLOYMENT",)
+    RETURN_NAMES = ("deployment",)
+    FUNCTION = "get_deployment"
+    CATEGORY = "vLLM-Omni"
+    DESCRIPTION = (
+        "Selects a server with FastH3 fused at startup. The connected Generate Video node uses T2VA, "
+        "four inference steps, and 24 FPS without sending a request-level LoRA."
+    )
+
+    @classmethod
+    def VALIDATE_INPUTS(cls, url, model) -> str | Literal[True]:
+        try:
+            _resolve_fast_h3_deployment({"url": url, "model": model})
+        except ValueError as exc:
+            return str(exc)
+        return True
+
+    def get_deployment(self, url: str, model: str):
+        url, model = _resolve_fast_h3_deployment({"url": url, "model": model})
+        return (FastH3Deployment({"url": url, "model": model}),)
+
+
 class VLLMOmniQwenTTSParams:
     @classmethod
     def INPUT_TYPES(cls):
@@ -790,6 +1008,10 @@ class VLLMOmniVideoReferences:
                 "audio_2": ("AUDIO",),
                 "video_1": ("VIDEO",),
                 "video_2": ("VIDEO",),
+                # Append ports to preserve connections in saved workflows.
+                **{f"image_{i}": ("IMAGE",) for i in range(3, MAX_REFERENCE_IMAGES + 1)},
+                **{f"audio_{i}": ("AUDIO",) for i in range(3, MAX_REFERENCE_AUDIOS + 1)},
+                **{f"video_{i}": ("VIDEO",) for i in range(3, MAX_REFERENCE_VIDEOS + 1)},
             },
         }
 
@@ -806,21 +1028,26 @@ class VLLMOmniVideoReferences:
         audio_2: AudioInput | None = None,
         video_1: VideoInput | None = None,
         video_2: VideoInput | None = None,
+        image_3: torch.Tensor | None = None,
+        image_4: torch.Tensor | None = None,
+        image_5: torch.Tensor | None = None,
+        image_6: torch.Tensor | None = None,
+        image_7: torch.Tensor | None = None,
+        image_8: torch.Tensor | None = None,
+        image_9: torch.Tensor | None = None,
+        audio_3: AudioInput | None = None,
+        video_3: VideoInput | None = None,
         **kwargs,
     ):
         if kwargs:
             logger.info("Uncaught kwargs: %s", kwargs)
         refs = VideoReferences()
-        if image_1 is not None:
-            refs["image_1"] = image_1
-        if image_2 is not None:
-            refs["image_2"] = image_2
-        if audio_1 is not None:
-            refs["audio_1"] = audio_1
-        if audio_2 is not None:
-            refs["audio_2"] = audio_2
-        if video_1 is not None:
-            refs["video_1"] = video_1
-        if video_2 is not None:
-            refs["video_2"] = video_2
+        for kind, values in (
+            ("image", (image_1, image_2, image_3, image_4, image_5, image_6, image_7, image_8, image_9)),
+            ("video", (video_1, video_2, video_3)),
+            ("audio", (audio_1, audio_2, audio_3)),
+        ):
+            for index, value in enumerate(values, start=1):
+                if value is not None:
+                    refs[f"{kind}_{index}"] = value
         return (refs,)
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 cd509244a..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
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 """
 An high-level API client adapter that forwards ComfyUI inputs to vLLM-Omni's REST API,
 and transforms the API responses back to ComfyUI formats.
@@ -17,6 +20,7 @@ from comfy_api.input import AudioInput, VideoInput
 
 from .format import (
     audio_to_base64,
+    audio_to_bytes,
     base64_to_audio,
     base64_to_image_tensor,
     bytes_to_audio,
@@ -28,7 +32,13 @@ from .format import (
 )
 from .logger import get_logger, pretty_printer
 from .models import lookup_model_spec
-from .types import AudioFormat
+from .types import (
+    MAX_REFERENCE_AUDIOS,
+    MAX_REFERENCE_IMAGES,
+    MAX_REFERENCE_VIDEOS,
+    MAX_TOTAL_REFERENCES,
+    AudioFormat,
+)
 
 logger = get_logger(__name__)
 
@@ -267,14 +277,33 @@ 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,
         lora: dict | None = None,
+        spec_model: str | None = None,
         **extra_params,
     ) -> VideoInput:
+        """Post a video job and return the decoded result.
+
+        ``spec_model`` names the model whose payload spec builds the request, for
+        deployments that serve a known model under a different ``model`` alias. It
+        never reaches the wire; defaults to ``model``.
+        """
         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()
@@ -294,43 +323,62 @@ class VLLMOmniClient:
 
         # === multimodal inputs (first-last-frames, references, etc.) ===
         input_reference_image: torch.Tensor | None = None
-        audio_reference: AudioInput | None = None
-        reference_videos: list[VideoInput] = []
+        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:
-            images = [references[k] for k in ("image_1", "image_2") if k in references and references[k] is not None]
-            audios = [references[k] for k in ("audio_1", "audio_2") if k in references and references[k] is not None]
-            videos = [references[k] for k in ("video_1", "video_2") if k in references and references[k] is not None]
-
-            if not images and not audios and not videos:
-                raise ValueError("references is empty; connect at least one image/audio/video.")
-
-            if videos:
-                if images or audios:
-                    raise ValueError(
-                        "Video references cannot be combined with image or audio references. "
-                        "Connect only video_1/video_2 for multi-video Ref2VA."
-                    )
-                reference_videos = videos
-                video_task = "ref2va"
-            elif len(images) == 1 and len(audios) == 1:
-                input_reference_image = images[0]
-                audio_reference = audios[0]
-                video_task = "ref2va"
-            else:
+            reference_formats = (
+                ("image", MAX_REFERENCE_IMAGES, "png", "image/png", image_tensor_to_png_bytes),
+                ("video", MAX_REFERENCE_VIDEOS, "mp4", "video/mp4", video_to_bytes),
+                ("audio", MAX_REFERENCE_AUDIOS, "mp3", "audio/mpeg", audio_to_bytes),
+            )
+            supported_inputs = {f"{kind}_{i}" for kind, limit, *_ in reference_formats for i in range(1, limit + 1)}
+            connected = {name: value for name, value in references.items() if value is not None}
+            unsupported = connected.keys() - supported_inputs
+            if unsupported:
+                raise ValueError(f"Unsupported reference input(s): {', '.join(sorted(unsupported))}.")
+            if not any(name.startswith(("image_", "video_")) for name in connected):
                 raise ValueError(
-                    "Invalid references combination. Supported modes: "
-                    "(1) one or more videos only, or (2) exactly one image and one audio."
+                    "references requires at least one image or video; audio-only inputs are not supported."
                 )
+            if len(connected) > MAX_TOTAL_REFERENCES:
+                raise ValueError(
+                    f"references supports at most {MAX_TOTAL_REFERENCES} inputs in total "
+                    f"(up to {MAX_REFERENCE_IMAGES} images, {MAX_REFERENCE_VIDEOS} videos, "
+                    f"and {MAX_REFERENCE_AUDIOS} audios)."
+                )
+            for kind, limit, extension, content_type, encode in reference_formats:
+                for index in range(1, limit + 1):
+                    name = f"{kind}_{index}"
+                    if name in connected:
+                        filename = f"{name}.{extension}"
+                        form.add_field(
+                            "input_references",
+                            encode(connected[name], filename),
+                            filename=filename,
+                            content_type=content_type,
+                        )
+            video_task = "ref2va"
         else:
             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),
@@ -338,32 +386,27 @@ class VLLMOmniClient:
                 content_type="image/png",
             )
 
-        if audio_reference is not None:
-            form.add_field(
-                "audio_reference",
-                json.dumps({"audio_url": audio_to_base64(audio_reference)}, ensure_ascii=False),
-            )
-
-        for idx, video in enumerate(reference_videos, start=1):
-            video_filename = f"reference_{idx}.mp4"
-            form.add_field(
-                "input_references",
-                video_to_bytes(video, video_filename),
-                filename=video_filename,
-                content_type="video/mp4",
-            )
+        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(model)
         params_builder = spec.get("params_builder") if spec else None
         if params_builder is not None:
             form_fields = params_builder(
                 model_params or {},
                 extra_params={**extra_params, "task": video_task},
+                width=width,
+                height=height,
             )
             for k, v in form_fields.items():
                 form.add_field(k, v if isinstance(v, str) else str(v))
diff --git a/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/utils/format.py b/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/utils/format.py
index 42d396f06..c2aba4cff 100644
--- a/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/utils/format.py
+++ b/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/utils/format.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 """Image/tensor format helpers.
 
 The image generation part is derived from dougbtv/comfyui-vllm-omni by Doug (@dougbtv).
@@ -170,6 +173,10 @@ def bytes_to_video(video_bytes: bytes) -> VideoInput:
                 audio_stream = container.streams.audio[-1]
                 audio_frames = []
                 resampler = AudioResampler(format="fltp")
+                # Decoding the video stream above left the container at EOF.
+                # Rewind before demuxing again, or this pass yields no frames
+                # and the audio of a T2VA result is silently dropped.
+                container.seek(0)
                 for frame in container.decode(audio_stream):
                     if not isinstance(frame, AudioFrame):
                         continue
diff --git a/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/utils/models.py b/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/utils/models.py
index 3a37db16d..82c7e4a51 100644
--- a/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/utils/models.py
+++ b/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/utils/models.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 import json
 import re
 from typing import Any
@@ -34,10 +37,28 @@ def _qwen25_payload_preprocessor(payload: dict) -> dict:
     return payload
 
 
+MINIMAX_H3_ASPECT_RATIOS = {
+    "21:9": 21.0 / 9.0,
+    "16:9": 16.0 / 9.0,
+    "4:3": 4.0 / 3.0,
+    "1:1": 1.0,
+    "3:4": 3.0 / 4.0,
+    "9:16": 9.0 / 16.0,
+}
+
+
+def _nearest_minimaxh3_aspect_ratio(width: int, height: int) -> str:
+    """Pick the supported named ratio closest to the requested frame size."""
+    target = float(width) / float(height)
+    return min(MINIMAX_H3_ASPECT_RATIOS, key=lambda name: abs(MINIMAX_H3_ASPECT_RATIOS[name] - target))
+
+
 def _minimaxh3_params_builder(
     model_params: dict[str, Any],
     *,
     extra_params: dict[str, Any],
+    width: int | None = None,
+    height: int | None = None,
 ) -> dict[str, Any]:
     """Build multipart form fields for MiniMax-H3 from model_params + routed task."""
     params = dict(model_params)
@@ -53,6 +74,12 @@ def _minimaxh3_params_builder(
     if params:
         logger.warning("Unused MiniMax-H3 model params ignored: %s", sorted(params))
 
+    # H3 refuses t2va without a named aspect ratio, and the Generate Video node
+    # carries width/height rather than a ratio. fl2va takes its ratio from the
+    # input image and ref2va defaults server-side, so only t2va needs this.
+    if merged_extra_params.get("task") == "t2va" and "aspect_ratio" not in merged_extra_params and width and height:
+        merged_extra_params["aspect_ratio"] = _nearest_minimaxh3_aspect_ratio(width, height)
+
     if merged_extra_params:
         form_fields["extra_params"] = json.dumps(merged_extra_params, ensure_ascii=False)
     return form_fields
diff --git a/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/utils/types.py b/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/utils/types.py
index e1ae43916..6d12a98c2 100644
--- a/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/utils/types.py
+++ b/apps/ComfyUI-vLLM-Omni/comfyui_vllm_omni/utils/types.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 from collections.abc import Callable
 from enum import Enum, auto
 from typing import Any, Literal, TypeAlias
@@ -27,10 +30,20 @@ class MiniMaxH3ModelSpecificParams(dict):
     pass
 
 
+MAX_REFERENCE_IMAGES = 9
+MAX_REFERENCE_VIDEOS = 3
+MAX_REFERENCE_AUDIOS = 3
+MAX_TOTAL_REFERENCES = 12
+
+
 class VideoReferences(dict):
     pass
 
 
+class FastH3Deployment(dict):
+    """Descriptor for a server that fused FastH3 at startup."""
+
+
 class ModelMode(Enum):
     IMAGE_GENERATION = auto()
     VIDEO_GENERATION = auto()
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/docs/minimax-h3-t2v.md b/apps/ComfyUI-vLLM-Omni/docs/minimax-h3-t2v.md
new file mode 100644
index 000000000..790aa0f53
--- /dev/null
+++ b/apps/ComfyUI-vLLM-Omni/docs/minimax-h3-t2v.md
@@ -0,0 +1,94 @@
+# MiniMax H3 Text to Video (WF-01)
+
+Import [MiniMax_H3_Text_to_Video.json](../example_workflows/MiniMax_H3_Text_to_Video.json)
+into ComfyUI, or select it under **Templates → ComfyUI-vLLM-Omni**.
+The template connects existing nodes to a remote H3 service and saves the
+returned video with audio. ComfyUI does not load H3 weights.
+
+## Setup
+
+Install the [ComfyUI extension](../README.md#installation) and follow the
+[H3 deployment recipe](../../../recipes/MiniMaxAI/MiniMax-H3.md) for your hardware.
+For a two-GPU FL2VA server with sufficient memory:
+
+```bash
+export MODEL=/path/to/MiniMax-H3/FL2VA
+CUDA_VISIBLE_DEVICES=0,1 VLLM_WORKER_MULTIPROC_METHOD=spawn \
+VLLM_OMNI_VIDEO_SYNC_TIMEOUT=14400 \
+vllm serve "$MODEL" --omni --host 127.0.0.1 --port 8000 \
+  --served-model-name MiniMaxAI/MiniMax-H3 --trust-remote-code \
+  --task-type fl2va --num-gpus 2 --tensor-parallel-size 2 \
+  --text-encoder-tp-size 2 --enforce-eager
+```
+
+Set Generate Video's **url** to the address reachable from ComfyUI, including
+`/v1`, and match its **model** to the served name. The defaults are
+`http://localhost:8000/v1` and `MiniMaxAI/MiniMax-H3`.
+
+## Base and Turbo
+
+Base presets are connected by default. Write the scene and its sound in the
+same **prompt**; leave **frame**, **references**, and **fast_h3** disconnected.
+The template uses 1344×768, 24 FPS, seed 1101 and **duration** 5.167 seconds
+(124 frames, satisfying H3's `17k+5` constraint). The existing client infers
+`16:9` from these dimensions. For portrait output, use 768×1344.
+
+| Setting | Base | Turbo v1.0 768p |
+| --- | --- | --- |
+| Inference steps | 50 | 5 (4 forwards) |
+| Video flow shift | 12 | 6 |
+| Audio flow shift | 3 | 3 |
+| Remote LoRA | Disconnected | Connected, scale 1 |
+
+For Turbo, use the **Diffusers-layout** artifact from
+[lightx2v/Minimax-h3-Turbo](https://huggingface.co/lightx2v/Minimax-h3-Turbo):
+
+```text
+minimax_h3_fl2v_turbo_4step_v1.0_768p_bf16.safetensors
+```
+
+Add `--lora-backend peft --lora-path "$TURBO_LORA"` to the server command,
+where `TURBO_LORA` is the full server-side path to that file. Enter the same
+path in Remote LoRA's **local_path**; retain name `h3-turbo-v1.0-768p`, scale
+`1.0`, and **int_id** `0` so the existing API derives the ID from the path.
+The template leaves the path blank for users to configure. The `_comfyui_`
+export is not supported by this backend.
+
+Connect **Turbo sampling**, **Turbo H3 params**, and **Remote LoRA** to Generate
+Video's `sampling_params`, `model_params`, and `lora` inputs, replacing the
+Base links. To return to Base, restore both Base links and disconnect LoRA.
+Other Turbo artifacts may need different settings; see the
+[artifact table](../../../recipes/MiniMaxAI/MiniMax-H3.md#turbo-lora).
+
+If importing an older template with a frame-count widget, reimport this JSON
+or set **duration** to **5.167**; do not interpret 124 frames as 124 seconds.
+
+## Validation
+
+Queue the configured workflow and inspect the MP4 saved under
+`ComfyUI/output/video/MiniMax_H3_WF01_*.mp4`:
+
+```bash
+ffprobe -v error -show_streams -show_format -of json "$OUTPUT"
+ffmpeg -v error -i "$OUTPUT" -f null -
+```
+
+Check the requested dimensions, frame count, 24 FPS and both video/audio
+streams, then watch and listen to the saved file. The current upstream
+extension includes the shared audio-preserving decoder fix.
+
+On September 16, the narrowed workflow was validated through ComfyUI using
+existing upstream Python code at `4a8ac297`, two H20-3e GPUs, vLLM 0.29.0,
+PyTorch 2.13.0+cu129 and ComfyUI `1d48d9cf`. The run used the template's
+forest-stream prompt, explicit server-side Turbo LoRA path, and settings
+above, with `TORCH_SDPA`, `--usp 1 --ring 1`, and tiled VAE parallelism on two
+GPUs. ComfyUI execution took 131.55 seconds. SaveVideo produced 124 H.264
+frames at 1344×768 and 24 FPS, plus 32 kHz stereo AAC audio. Video/audio
+durations were 5.166667/5.167000 seconds; full decoding passed and audio was
+nonzero. This is model-generated output, not a ground-truth reference or a
+subjective audio-quality assessment. Base graph validation passed with Turbo
+nodes disconnected; full 50-step Base quality was not evaluated.
+
+Based on the official
+[ComfyUI H3 T2V template](https://github.com/Comfy-Org/workflow_templates/blob/main/templates/video_minimax_h3_t2v.json),
+using remote inference instead of local model loaders.
diff --git a/apps/ComfyUI-vLLM-Omni/docs/wf07-h3-upscale.md b/apps/ComfyUI-vLLM-Omni/docs/wf07-h3-upscale.md
new file mode 100644
index 000000000..dfdbd166f
--- /dev/null
+++ b/apps/ComfyUI-vLLM-Omni/docs/wf07-h3-upscale.md
@@ -0,0 +1,21 @@
+# WF-07: H3 video upscale with SeedVR2
+
+Generate video and audio through vLLM-Omni H3, upscale the decoded frames with SeedVR2, and save both the original and upscaled videos. The generated audio and FPS connect directly to Create Video.
+
+## Requirements
+
+- ComfyUI with ComfyUI-vLLM-Omni and [ComfyUI-SeedVR2_VideoUpscaler](https://github.com/numz/ComfyUI-SeedVR2_VideoUpscaler#-installation) installed.
+- An H3 service using the FL2VA checkpoint partition. Follow the [H3 recipe](../../../recipes/MiniMaxAI/MiniMax-H3.md) for server setup.
+- `seedvr2_ema_3b_fp16.safetensors` and `ema_vae_fp16.safetensors` from [SeedVR2's ComfyUI weights](https://huggingface.co/numz/SeedVR2_comfyUI/tree/main), placed in `ComfyUI/models/SEEDVR2`. The SeedVR2 nodes can also download them on first use.
+
+## Use
+
+Open **vLLM-Omni MiniMax H3 Video Upscale.json** from the example workflows. An API-format version is provided alongside it. Set the Generate Video URL/model and the LoRA path as seen by the H3 server.
+
+The preset uses the LightX2V v1.0 768p Turbo adapter in Diffusers format: `minimax_h3_fl2v_turbo_4step_v1.0_768p_bf16.safetensors`, five sigma points, video/audio flow shifts 6/3, and LoRA scale 1. Preload the same adapter on the server using the [Turbo LoRA recipe](../../../recipes/MiniMaxAI/MiniMax-H3.md#turbo-lora). For base H3, disconnect LoRA, set inference steps to 50, and set video flow shift to 12.
+
+The H3 preset requests 1344 x 768 at 24 FPS for 5.167 seconds, which gives 124 frames. SeedVR2's `resolution=1536` sets the target short edge, producing 2688 x 1536 for this input. Update this value when changing the input size; it is an output resolution, not a fixed 2x multiplier.
+
+The SeedVR2 preset uses 3B FP16, five-frame batches, one overlapping frame, uniform batch padding, and LAB color correction. The DiT loader uses CPU offload with 32 swapped blocks; the VAE uses tiled encoding and decoding. Select the local GPU in both model loaders. See the [SeedVR2 settings](https://github.com/numz/ComfyUI-SeedVR2_VideoUpscaler#-usage) when adjusting memory use or batch size.
+
+Run the workflow. The two Save Video nodes write MP4s under `WF07/generated` and `WF07/upscaled` in ComfyUI's output directory.
diff --git a/apps/ComfyUI-vLLM-Omni/example_workflows/MiniMax_H3_Text_to_Video.json b/apps/ComfyUI-vLLM-Omni/example_workflows/MiniMax_H3_Text_to_Video.json
new file mode 100644
index 000000000..137ee8c2d
--- /dev/null
+++ b/apps/ComfyUI-vLLM-Omni/example_workflows/MiniMax_H3_Text_to_Video.json
@@ -0,0 +1,362 @@
+{
+  "last_node_id": 8,
+  "last_link_id": 3,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "VLLMOmniDiffusionSampling",
+      "pos": [
+        20,
+        20
+      ],
+      "size": [
+        310,
+        280
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "diffusion sampling params",
+          "type": "SAMPLING_PARAMS",
+          "links": [
+            1
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VLLMOmniDiffusionSampling"
+      },
+      "widgets_values": [
+        1,
+        50,
+        1.0,
+        1.0,
+        false,
+        false,
+        1101,
+        "fixed"
+      ],
+      "title": "Base sampling"
+    },
+    {
+      "id": 2,
+      "type": "VLLMOmniMiniMaxH3Params",
+      "pos": [
+        20,
+        340
+      ],
+      "size": [
+        310,
+        140
+      ],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "MiniMax-H3 video params",
+          "type": "VIDEO_PARAMS",
+          "links": [
+            2
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VLLMOmniMiniMaxH3Params"
+      },
+      "widgets_values": [
+        3.0,
+        12.0
+      ],
+      "title": "Base H3 params"
+    },
+    {
+      "id": 3,
+      "type": "VLLMOmniGenerateVideo",
+      "pos": [
+        430,
+        20
+      ],
+      "size": [
+        430,
+        440
+      ],
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "frame",
+          "type": "IMAGE",
+          "link": null
+        },
+        {
+          "name": "references",
+          "type": "VIDEO_REFERENCES",
+          "link": null
+        },
+        {
+          "name": "sampling_params",
+          "type": "SAMPLING_PARAMS",
+          "link": 1
+        },
+        {
+          "name": "lora",
+          "type": "REMOTE_LORA",
+          "link": null
+        },
+        {
+          "name": "model_params",
+          "type": "VIDEO_PARAMS",
+          "link": 2
+        },
+        {
+          "name": "fast_h3",
+          "type": "FASTH3_DEPLOYMENT",
+          "link": null
+        },
+        {
+          "name": "duration",
+          "type": "FLOAT",
+          "widget": {
+            "name": "duration"
+          },
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "video",
+          "type": "VIDEO",
+          "links": [
+            3
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VLLMOmniGenerateVideo"
+      },
+      "widgets_values": [
+        "http://localhost:8000/v1",
+        "MiniMaxAI/MiniMax-H3",
+        "A small stream flows through a sunlit forest. The camera slowly moves toward the water. Birds chirp in the trees and water gurgles over smooth stones. Natural continuous sound, no music.",
+        "",
+        1344,
+        768,
+        24,
+        5.167
+      ]
+    },
+    {
+      "id": 4,
+      "type": "SaveVideo",
+      "pos": [
+        940,
+        20
+      ],
+      "size": [
+        440,
+        440
+      ],
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "video",
+          "type": "VIDEO",
+          "link": 3
+        }
+      ],
+      "outputs": [
+        {
+          "name": "video",
+          "type": "VIDEO",
+          "links": null,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "SaveVideo"
+      },
+      "widgets_values": [
+        "video/MiniMax_H3_WF01",
+        "mp4",
+        "auto"
+      ]
+    },
+    {
+      "id": 5,
+      "type": "VLLMOmniRemoteLoRA",
+      "pos": [
+        430,
+        540
+      ],
+      "size": [
+        430,
+        160
+      ],
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "lora",
+          "type": "REMOTE_LORA",
+          "links": null,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VLLMOmniRemoteLoRA"
+      },
+      "widgets_values": [
+        "",
+        "h3-turbo-v1.0-768p",
+        1.0,
+        0
+      ],
+      "title": "Optional Turbo: server LoRA path"
+    },
+    {
+      "id": 6,
+      "type": "VLLMOmniDiffusionSampling",
+      "pos": [
+        20,
+        540
+      ],
+      "size": [
+        310,
+        280
+      ],
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "diffusion sampling params",
+          "type": "SAMPLING_PARAMS",
+          "links": null,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VLLMOmniDiffusionSampling"
+      },
+      "widgets_values": [
+        1,
+        5,
+        1.0,
+        1.0,
+        false,
+        false,
+        1101,
+        "fixed"
+      ],
+      "title": "Turbo sampling (4 forwards)"
+    },
+    {
+      "id": 7,
+      "type": "VLLMOmniMiniMaxH3Params",
+      "pos": [
+        430,
+        740
+      ],
+      "size": [
+        310,
+        140
+      ],
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "MiniMax-H3 video params",
+          "type": "VIDEO_PARAMS",
+          "links": null,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VLLMOmniMiniMaxH3Params"
+      },
+      "widgets_values": [
+        3.0,
+        6.0
+      ],
+      "title": "Turbo H3 params"
+    },
+    {
+      "id": 8,
+      "type": "Note",
+      "pos": [
+        940,
+        520
+      ],
+      "size": [
+        440,
+        440
+      ],
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "properties": {
+        "Node name for S&R": "Note"
+      },
+      "widgets_values": [
+        "MiniMax H3 Text to Video (WF-01)\n\nBASE: connected presets, 50 steps / video flow 12 / audio flow 3.\n\nTURBO: set Remote LoRA local_path to the SERVER path of minimax_h3_fl2v_turbo_4step_v1.0_768p_bf16.safetensors from lightx2v/Minimax-h3-Turbo. Keep name h3-turbo-v1.0-768p, scale 1.0 and int_id 0. Connect Turbo sampling, Turbo H3 params, and LoRA to Generate Video, replacing the two Base links. Use 5 steps (4 forwards), video flow 6 and audio flow 3. Do not use the ComfyUI-layout artifact.\n\nKeep frame, references and fast_h3 disconnected. 1344x768, 24 FPS, duration 5.167 seconds = 124 frames (17*7+5). The client selects the named 16:9 preset from the dimensions. Save Video preserves video and audio.\n\nSet URL and served model name for your server. See docs/minimax-h3-t2v.md for setup and validation. Source: Comfy-Org/workflow_templates/templates/video_minimax_h3_t2v.json."
+      ],
+      "title": "Setup / Base and Turbo"
+    }
+  ],
+  "links": [
+    [
+      1,
+      1,
+      0,
+      3,
+      2,
+      "SAMPLING_PARAMS"
+    ],
+    [
+      2,
+      2,
+      0,
+      3,
+      4,
+      "VIDEO_PARAMS"
+    ],
+    [
+      3,
+      3,
+      0,
+      4,
+      0,
+      "VIDEO"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {
+    "ds": {
+      "scale": 0.8,
+      "offset": [
+        50,
+        50
+      ]
+    }
+  },
+  "version": 0.4
+}
diff --git a/apps/ComfyUI-vLLM-Omni/example_workflows/vLLM-Omni FastH3 Text to Video.json b/apps/ComfyUI-vLLM-Omni/example_workflows/vLLM-Omni FastH3 Text to Video.json
new file mode 100644
index 000000000..5b3d54f39
--- /dev/null
+++ b/apps/ComfyUI-vLLM-Omni/example_workflows/vLLM-Omni FastH3 Text to Video.json	
@@ -0,0 +1,322 @@
+{
+  "id": "c6db00da-2ccb-4ff8-8334-d67e1a267781",
+  "revision": 0,
+  "last_node_id": 5,
+  "last_link_id": 3,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "MarkdownNote",
+      "pos": [40, 20],
+      "size": [420, 250],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "title": "FastH3 server prerequisite",
+      "properties": {},
+      "widgets_values": [
+        "FastH3 must be fused when the vLLM-Omni server starts. Use --task-type fl2va and --lora-path pointing to exactly one FastH3 adapter file. Do not use CPU or layerwise offload. For VSA / Data-Free, also install fastvideo-kernel and use --diffusion-attention-backend FASTVIDEO_VSA --fastvideo-vsa-topk 64."
+      ],
+      "color": "#432",
+      "bgcolor": "#000"
+    },
+    {
+      "id": 2,
+      "type": "VLLMOmniFastH3Deployment",
+      "pos": [40, 320],
+      "size": [420, 160],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [
+        {
+          "localized_name": "url",
+          "name": "url",
+          "type": "STRING",
+          "widget": {"name": "url"},
+          "link": null
+        },
+        {
+          "localized_name": "model",
+          "name": "model",
+          "type": "STRING",
+          "widget": {"name": "model"},
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "localized_name": "deployment",
+          "name": "deployment",
+          "type": "FASTH3_DEPLOYMENT",
+          "links": [1]
+        }
+      ],
+      "properties": {"Node name for S&R": "VLLMOmniFastH3Deployment"},
+      "widgets_values": [
+        "http://localhost:8000/v1",
+        "MiniMaxAI/MiniMax-H3"
+      ]
+    },
+    {
+      "id": 3,
+      "type": "VLLMOmniDiffusionSampling",
+      "pos": [40, 540],
+      "size": [420, 230],
+      "flags": {},
+      "order": 2,
+      "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]
+        }
+      ],
+      "properties": {"Node name for S&R": "VLLMOmniDiffusionSampling"},
+      "widgets_values": [1, 4, 1, 1, false, false, 1101, "fixed"]
+    },
+    {
+      "id": 4,
+      "type": "VLLMOmniGenerateVideo",
+      "pos": [560, 210],
+      "size": [540, 610],
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [
+        {
+          "localized_name": "frame",
+          "name": "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": null
+        },
+        {
+          "localized_name": "fast_h3",
+          "name": "fast_h3",
+          "shape": 7,
+          "type": "FASTH3_DEPLOYMENT",
+          "link": 1
+        },
+        {
+          "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": [3]
+        }
+      ],
+      "properties": {"Node name for S&R": "VLLMOmniGenerateVideo"},
+      "widgets_values": [
+        "http://localhost:8000/v1",
+        "MiniMaxAI/MiniMax-H3",
+        "A cinematic live-action singer performs naturally on a neon-lit stage, with synchronized vocals and environmental sound.",
+        "",
+        1344,
+        768,
+        24,
+        4.458
+      ]
+    },
+    {
+      "id": 5,
+      "type": "SaveVideo",
+      "pos": [1200, 280],
+      "size": [380, 310],
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "inputs": [
+        {
+          "localized_name": "video",
+          "name": "video",
+          "type": "VIDEO",
+          "link": 3
+        },
+        {
+          "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/ComfyUI-FastH3", "auto", "auto"]
+    }
+  ],
+  "links": [
+    [1, 2, 0, 4, 5, "FASTH3_DEPLOYMENT"],
+    [2, 3, 0, 4, 2, "SAMPLING_PARAMS"],
+    [3, 4, 0, 5, 0, "VIDEO"]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {
+    "workflowRendererVersion": "LG",
+    "ds": {"scale": 0.9, "offset": [100, 100]}
+  },
+  "version": 0.4
+}
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 MiniMax H3 Video Upscale.json b/apps/ComfyUI-vLLM-Omni/example_workflows/vLLM-Omni MiniMax H3 Video Upscale.json
new file mode 100644
index 000000000..e8a21d065
--- /dev/null
+++ b/apps/ComfyUI-vLLM-Omni/example_workflows/vLLM-Omni MiniMax H3 Video Upscale.json	
@@ -0,0 +1,724 @@
+{
+  "version": 0.4,
+  "last_node_id": 12,
+  "last_link_id": 13,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "VLLMOmniGenerateVideo",
+      "pos": [
+        360,
+        20
+      ],
+      "size": [
+        330,
+        480
+      ],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "frame",
+          "type": "IMAGE",
+          "shape": 7,
+          "link": null
+        },
+        {
+          "name": "references",
+          "type": "VIDEO_REFERENCES",
+          "shape": 7,
+          "link": null
+        },
+        {
+          "name": "sampling_params",
+          "type": "SAMPLING_PARAMS",
+          "shape": 7,
+          "link": 11
+        },
+        {
+          "name": "lora",
+          "type": "REMOTE_LORA",
+          "shape": 7,
+          "link": 12
+        },
+        {
+          "name": "model_params",
+          "type": "VIDEO_PARAMS",
+          "shape": 7,
+          "link": 10
+        },
+        {
+          "name": "fast_h3",
+          "type": "FASTH3_DEPLOYMENT",
+          "shape": 7,
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "video",
+          "type": "VIDEO",
+          "links": [
+            1,
+            9
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VLLMOmniGenerateVideo"
+      },
+      "widgets_values": [
+        "http://127.0.0.1:8091/v1",
+        "MiniMaxAI/MiniMax-H3",
+        "A small brass bell hanging from a wooden beam in a quiet garden. A gentle breeze swings the bell and it rings clearly. Static camera, natural daylight, continuous motion, synchronized ringing and soft birdsong.",
+        "",
+        1344,
+        768,
+        24,
+        5.167
+      ]
+    },
+    {
+      "id": 2,
+      "type": "GetVideoComponents",
+      "pos": [
+        730,
+        20
+      ],
+      "size": [
+        250,
+        125
+      ],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "video",
+          "type": "VIDEO",
+          "link": 1
+        }
+      ],
+      "outputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "links": [
+            2
+          ]
+        },
+        {
+          "name": "audio",
+          "type": "AUDIO",
+          "links": [
+            6
+          ]
+        },
+        {
+          "name": "fps",
+          "type": "FLOAT",
+          "links": [
+            5
+          ]
+        },
+        {
+          "name": "bit_depth",
+          "type": "INT",
+          "links": [
+            7
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "GetVideoComponents"
+      }
+    },
+    {
+      "id": 3,
+      "type": "SeedVR2LoadDiTModel",
+      "pos": [
+        730,
+        290
+      ],
+      "size": [
+        340,
+        245
+      ],
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "inputs": [
+        {
+          "localized_name": "torch_compile_args",
+          "name": "torch_compile_args",
+          "shape": 7,
+          "type": "TORCH_COMPILE_ARGS",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "localized_name": "SEEDVR2_DIT",
+          "name": "SEEDVR2_DIT",
+          "type": "SEEDVR2_DIT",
+          "links": [
+            3
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "SeedVR2LoadDiTModel"
+      },
+      "widgets_values": [
+        "seedvr2_ema_3b_fp16.safetensors",
+        "cuda:0",
+        32,
+        false,
+        "cpu",
+        false,
+        "sdpa"
+      ]
+    },
+    {
+      "id": 4,
+      "type": "SeedVR2VideoUpscaler",
+      "pos": [
+        1120,
+        290
+      ],
+      "size": [
+        340,
+        415
+      ],
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "inputs": [
+        {
+          "localized_name": "image",
+          "name": "image",
+          "type": "IMAGE",
+          "link": 2
+        },
+        {
+          "localized_name": "dit",
+          "name": "dit",
+          "type": "SEEDVR2_DIT",
+          "link": 3
+        },
+        {
+          "localized_name": "vae",
+          "name": "vae",
+          "type": "SEEDVR2_VAE",
+          "link": 13
+        }
+      ],
+      "outputs": [
+        {
+          "localized_name": "IMAGE",
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            4
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "SeedVR2VideoUpscaler"
+      },
+      "widgets_values": [
+        42,
+        "fixed",
+        1536,
+        0,
+        5,
+        true,
+        "lab",
+        1,
+        0,
+        0.0,
+        0.0,
+        "cpu",
+        false
+      ]
+    },
+    {
+      "id": 5,
+      "type": "CreateVideo",
+      "pos": [
+        1490,
+        290
+      ],
+      "size": [
+        250,
+        175
+      ],
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 4
+        },
+        {
+          "name": "fps",
+          "type": "FLOAT",
+          "widget": {
+            "name": "fps"
+          },
+          "link": 5
+        },
+        {
+          "name": "audio",
+          "type": "AUDIO",
+          "shape": 7,
+          "link": 6
+        },
+        {
+          "name": "bit_depth",
+          "type": "INT",
+          "widget": {
+            "name": "bit_depth"
+          },
+          "link": 7
+        }
+      ],
+      "outputs": [
+        {
+          "name": "VIDEO",
+          "type": "VIDEO",
+          "links": [
+            8
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CreateVideo"
+      },
+      "widgets_values": [
+        24,
+        8
+      ]
+    },
+    {
+      "id": 6,
+      "type": "SaveVideo",
+      "pos": [
+        1790,
+        290
+      ],
+      "size": [
+        330,
+        280
+      ],
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "video",
+          "type": "VIDEO",
+          "link": 8
+        },
+        {
+          "name": "filename_prefix",
+          "type": "STRING",
+          "widget": {
+            "name": "filename_prefix"
+          },
+          "link": null
+        },
+        {
+          "name": "format",
+          "type": "COMBO",
+          "widget": {
+            "name": "format"
+          },
+          "link": null
+        },
+        {
+          "name": "codec",
+          "type": "COMFY_DYNAMICCOMBO_V3",
+          "widget": {
+            "name": "codec"
+          },
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "video",
+          "type": "VIDEO",
+          "links": []
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "SaveVideo"
+      },
+      "widgets_values": [
+        "WF07/upscaled",
+        "mp4",
+        "auto"
+      ]
+    },
+    {
+      "id": 7,
+      "type": "VLLMOmniMiniMaxH3Params",
+      "pos": [
+        0,
+        20
+      ],
+      "size": [
+        320,
+        120
+      ],
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "MiniMax-H3 video params",
+          "type": "VIDEO_PARAMS",
+          "links": [
+            10
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VLLMOmniMiniMaxH3Params"
+      },
+      "widgets_values": [
+        3.0,
+        6.0
+      ]
+    },
+    {
+      "id": 8,
+      "type": "VLLMOmniDiffusionSampling",
+      "pos": [
+        0,
+        200
+      ],
+      "size": [
+        320,
+        280
+      ],
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "diffusion sampling params",
+          "type": "SAMPLING_PARAMS",
+          "links": [
+            11
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VLLMOmniDiffusionSampling"
+      },
+      "widgets_values": [
+        1,
+        5,
+        1.0,
+        1.0,
+        false,
+        true,
+        42,
+        "fixed"
+      ]
+    },
+    {
+      "id": 9,
+      "type": "VLLMOmniRemoteLoRA",
+      "pos": [
+        0,
+        530
+      ],
+      "size": [
+        320,
+        210
+      ],
+      "flags": {},
+      "order": 9,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "lora",
+          "type": "REMOTE_LORA",
+          "links": [
+            12
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VLLMOmniRemoteLoRA"
+      },
+      "widgets_values": [
+        "models/minimax-h3-turbo/minimax_h3_fl2v_turbo_4step_v1.0_768p_bf16.safetensors",
+        "h3-turbo-v1.0",
+        1.0,
+        0
+      ]
+    },
+    {
+      "id": 10,
+      "type": "SaveVideo",
+      "pos": [
+        1120,
+        20
+      ],
+      "size": [
+        330,
+        190
+      ],
+      "flags": {},
+      "order": 10,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "video",
+          "type": "VIDEO",
+          "link": 9
+        },
+        {
+          "name": "filename_prefix",
+          "type": "STRING",
+          "widget": {
+            "name": "filename_prefix"
+          },
+          "link": null
+        },
+        {
+          "name": "format",
+          "type": "COMBO",
+          "widget": {
+            "name": "format"
+          },
+          "link": null
+        },
+        {
+          "name": "codec",
+          "type": "COMFY_DYNAMICCOMBO_V3",
+          "widget": {
+            "name": "codec"
+          },
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "video",
+          "type": "VIDEO",
+          "links": []
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "SaveVideo"
+      },
+      "widgets_values": [
+        "WF07/generated",
+        "mp4",
+        "auto"
+      ],
+      "title": "Save generated video before upscale"
+    },
+    {
+      "id": 11,
+      "type": "Note",
+      "pos": [
+        360,
+        560
+      ],
+      "size": [
+        330,
+        260
+      ],
+      "flags": {},
+      "order": 11,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "properties": {
+        "Node name for S&R": "Note"
+      },
+      "widgets_values": [
+        "WF-07: H3 + SeedVR2\n\nInstall ComfyUI-SeedVR2_VideoUpscaler. The DiT and VAE loaders use SeedVR2 3B FP16 and ema_vae_fp16.\n\nSet the H3 service URL/model and the server-side Turbo LoRA path.\n\n1536 is the target short edge for this 1344 x 768 preset (2x). Original audio and FPS connect directly to Create Video.\n\nFor base H3: disconnect LoRA, use 50 steps and video flow shift 12."
+      ]
+    },
+    {
+      "id": 12,
+      "type": "SeedVR2LoadVAEModel",
+      "pos": [
+        730,
+        590
+      ],
+      "size": [
+        340,
+        315
+      ],
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "inputs": [
+        {
+          "localized_name": "torch_compile_args",
+          "name": "torch_compile_args",
+          "shape": 7,
+          "type": "TORCH_COMPILE_ARGS",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "localized_name": "SEEDVR2_VAE",
+          "name": "SEEDVR2_VAE",
+          "type": "SEEDVR2_VAE",
+          "links": [
+            13
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "SeedVR2LoadVAEModel"
+      },
+      "widgets_values": [
+        "ema_vae_fp16.safetensors",
+        "cuda:0",
+        true,
+        1024,
+        128,
+        true,
+        768,
+        128,
+        "false",
+        "cpu",
+        false
+      ]
+    }
+  ],
+  "links": [
+    [
+      1,
+      1,
+      0,
+      2,
+      0,
+      "VIDEO"
+    ],
+    [
+      2,
+      2,
+      0,
+      4,
+      0,
+      "IMAGE"
+    ],
+    [
+      3,
+      3,
+      0,
+      4,
+      1,
+      "SEEDVR2_DIT"
+    ],
+    [
+      4,
+      4,
+      0,
+      5,
+      0,
+      "IMAGE"
+    ],
+    [
+      5,
+      2,
+      2,
+      5,
+      1,
+      "FLOAT"
+    ],
+    [
+      6,
+      2,
+      1,
+      5,
+      2,
+      "AUDIO"
+    ],
+    [
+      7,
+      2,
+      3,
+      5,
+      3,
+      "INT"
+    ],
+    [
+      8,
+      5,
+      0,
+      6,
+      0,
+      "VIDEO"
+    ],
+    [
+      9,
+      1,
+      0,
+      10,
+      0,
+      "VIDEO"
+    ],
+    [
+      10,
+      7,
+      0,
+      1,
+      4,
+      "VIDEO_PARAMS"
+    ],
+    [
+      11,
+      8,
+      0,
+      1,
+      2,
+      "SAMPLING_PARAMS"
+    ],
+    [
+      12,
+      9,
+      0,
+      1,
+      3,
+      "REMOTE_LORA"
+    ],
+    [
+      13,
+      12,
+      0,
+      4,
+      2,
+      "SEEDVR2_VAE"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {
+    "ds": {
+      "scale": 0.52,
+      "offset": [
+        100,
+        100
+      ]
+    }
+  }
+}
diff --git a/apps/ComfyUI-vLLM-Omni/example_workflows/vLLM-Omni MiniMax-H3 Reference to Video.json b/apps/ComfyUI-vLLM-Omni/example_workflows/vLLM-Omni MiniMax-H3 Reference to Video.json
new file mode 100644
index 000000000..3a9693df9
--- /dev/null
+++ b/apps/ComfyUI-vLLM-Omni/example_workflows/vLLM-Omni MiniMax-H3 Reference to Video.json	
@@ -0,0 +1,786 @@
+{
+  "id": "e7a4e606-6510-4c4e-b127-9a8b6bf3ea71",
+  "revision": 0,
+  "last_node_id": 11,
+  "last_link_id": 5,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "LoadImage",
+      "pos": [
+        40,
+        100
+      ],
+      "size": [
+        320,
+        300
+      ],
+      "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
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoadImage"
+      },
+      "widgets_values": [
+        "h3_reference.png",
+        "image"
+      ],
+      "title": "Reference image \u2014 select a local file"
+    },
+    {
+      "type": "LoadVideo",
+      "size": [
+        320,
+        200
+      ],
+      "flags": {},
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "VIDEO",
+          "type": "VIDEO",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoadVideo"
+      },
+      "widgets_values": [
+        "h3_reference.mp4"
+      ],
+      "id": 2,
+      "pos": [
+        40,
+        470
+      ],
+      "order": 1,
+      "mode": 0,
+      "title": "Optional reference video"
+    },
+    {
+      "id": 3,
+      "type": "LoadAudio",
+      "pos": [
+        40,
+        1100
+      ],
+      "size": [
+        320,
+        160
+      ],
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [
+        {
+          "localized_name": "audio",
+          "name": "audio",
+          "type": "COMBO",
+          "widget": {
+            "name": "audio"
+          },
+          "link": null
+        },
+        {
+          "localized_name": "audioUI",
+          "name": "audioUI",
+          "type": "AUDIO_UI",
+          "widget": {
+            "name": "audioUI"
+          },
+          "link": null
+        },
+        {
+          "localized_name": "choose file to upload",
+          "name": "upload",
+          "type": "AUDIOUPLOAD",
+          "widget": {
+            "name": "upload"
+          },
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "localized_name": "AUDIO",
+          "name": "AUDIO",
+          "type": "AUDIO",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoadAudio"
+      },
+      "widgets_values": [
+        "h3_reference.wav",
+        null,
+        ""
+      ],
+      "title": "Optional reference audio"
+    },
+    {
+      "id": 4,
+      "type": "VLLMOmniVideoReferences",
+      "pos": [
+        420,
+        100
+      ],
+      "size": [
+        300,
+        365
+      ],
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image_1",
+          "type": "IMAGE",
+          "shape": 7,
+          "link": 1
+        },
+        {
+          "name": "image_2",
+          "type": "IMAGE",
+          "shape": 7,
+          "link": null
+        },
+        {
+          "name": "audio_1",
+          "type": "AUDIO",
+          "shape": 7,
+          "link": null
+        },
+        {
+          "name": "audio_2",
+          "type": "AUDIO",
+          "shape": 7,
+          "link": null
+        },
+        {
+          "name": "video_1",
+          "type": "VIDEO",
+          "shape": 7,
+          "link": null
+        },
+        {
+          "name": "video_2",
+          "type": "VIDEO",
+          "shape": 7,
+          "link": null
+        },
+        {
+          "name": "image_3",
+          "type": "IMAGE",
+          "shape": 7,
+          "link": null
+        },
+        {
+          "name": "image_4",
+          "type": "IMAGE",
+          "shape": 7,
+          "link": null
+        },
+        {
+          "name": "image_5",
+          "type": "IMAGE",
+          "shape": 7,
+          "link": null
+        },
+        {
+          "name": "image_6",
+          "type": "IMAGE",
+          "shape": 7,
+          "link": null
+        },
+        {
+          "name": "image_7",
+          "type": "IMAGE",
+          "shape": 7,
+          "link": null
+        },
+        {
+          "name": "image_8",
+          "type": "IMAGE",
+          "shape": 7,
+          "link": null
+        },
+        {
+          "name": "image_9",
+          "type": "IMAGE",
+          "shape": 7,
+          "link": null
+        },
+        {
+          "name": "audio_3",
+          "type": "AUDIO",
+          "shape": 7,
+          "link": null
+        },
+        {
+          "name": "video_3",
+          "type": "VIDEO",
+          "shape": 7,
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "localized_name": "references",
+          "name": "references",
+          "type": "VIDEO_REFERENCES",
+          "links": [
+            2
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VLLMOmniVideoReferences"
+      },
+      "widgets_values": [],
+      "title": "References \u2014 up to 12 total"
+    },
+    {
+      "id": 5,
+      "type": "VLLMOmniDiffusionSampling",
+      "pos": [
+        420,
+        530
+      ],
+      "size": [
+        310,
+        275
+      ],
+      "flags": {},
+      "order": 4,
+      "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": [
+            3
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VLLMOmniDiffusionSampling"
+      },
+      "widgets_values": [
+        1,
+        50,
+        1.0,
+        1.0,
+        false,
+        false,
+        42,
+        "fixed"
+      ],
+      "title": "Sampling \u2014 base 50 / Turbo 5"
+    },
+    {
+      "id": 6,
+      "type": "VLLMOmniMiniMaxH3Params",
+      "pos": [
+        790,
+        750
+      ],
+      "size": [
+        310,
+        105
+      ],
+      "flags": {},
+      "order": 5,
+      "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": [
+            4
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VLLMOmniMiniMaxH3Params"
+      },
+      "widgets_values": [
+        3.0,
+        12.0
+      ],
+      "title": "H3 video/audio flow shifts"
+    },
+    {
+      "type": "VLLMOmniRemoteLoRA",
+      "size": [
+        310,
+        180
+      ],
+      "flags": {},
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "lora",
+          "type": "REMOTE_LORA",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VLLMOmniRemoteLoRA"
+      },
+      "widgets_values": [
+        "",
+        "h3-ref2va-turbo",
+        1.0,
+        0
+      ],
+      "id": 7,
+      "pos": [
+        420,
+        940
+      ],
+      "order": 6,
+      "mode": 0,
+      "title": "Optional Turbo LoRA \u2014 connect to enable"
+    },
+    {
+      "id": 8,
+      "type": "VLLMOmniGenerateVideo",
+      "pos": [
+        800,
+        100
+      ],
+      "size": [
+        470,
+        560
+      ],
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "inputs": [
+        {
+          "localized_name": "frame",
+          "name": "frame",
+          "shape": 7,
+          "type": "IMAGE",
+          "link": null
+        },
+        {
+          "localized_name": "references",
+          "name": "references",
+          "shape": 7,
+          "type": "VIDEO_REFERENCES",
+          "link": 2
+        },
+        {
+          "localized_name": "sampling_params",
+          "name": "sampling_params",
+          "shape": 7,
+          "type": "SAMPLING_PARAMS",
+          "link": 3
+        },
+        {
+          "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": 4
+        },
+        {
+          "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": [
+            5
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VLLMOmniGenerateVideo"
+      },
+      "widgets_values": [
+        "http://localhost:8000/v1",
+        "MiniMaxAI/MiniMax-H3",
+        "Use the subject and visual style from <Picture 1>. Create a cinematic shot with a gentle camera move and natural ambient sound.",
+        "",
+        1344,
+        768,
+        24,
+        5.167
+      ],
+      "title": "MiniMax-H3 Reference to Video"
+    },
+    {
+      "id": 9,
+      "type": "SaveVideo",
+      "pos": [
+        1360,
+        100
+      ],
+      "size": [
+        410,
+        420
+      ],
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "inputs": [
+        {
+          "localized_name": "video",
+          "name": "video",
+          "type": "VIDEO",
+          "link": 5
+        },
+        {
+          "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-Ref2VA",
+        "mp4",
+        "h264"
+      ],
+      "title": "Save generated video with audio"
+    },
+    {
+      "id": 10,
+      "type": "MarkdownNote",
+      "pos": [
+        1360,
+        590
+      ],
+      "size": [
+        440,
+        595
+      ],
+      "flags": {},
+      "order": 9,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "title": "Reference inputs and output settings",
+      "properties": {},
+      "widgets_values": [
+        "## Reference to Video\nSelect an image, set the server URL and served model name, then run.\n\nConnect the optional video/audio loaders to Video References, or duplicate loaders for more inputs: up to 9 images, 3 videos, 3 audio clips, 12 total. At least one image or video is required.\n\nSlots are numbered separately per media type. Empty slots are skipped. Update prompt tags such as <Picture 1>, <Video 1>, <Audio 1> to match the connected references. Videos keep their own soundtrack in the reference upload.\n\n**Output:** 24 FPS; 124 frames (~5.17 s). Valid frame counts are 107, 124, 141, 158, 175, 192, 209, 226, 243, 260, 277, 294, 311, 328, 345.\n\n**Width x height:** 1344x768 (16:9), 1024x768 (4:3), 768x768 (1:1), 768x1024 (3:4), 768x1344 (9:16).\n\nEach reference video/audio clip must be 2\u201315 s. Total reference-video duration <=15 s; total standalone-audio duration <=15 s.\n\nRequires the expanded Video References node and the audio-preserving video output fix. See the extension README for setup and validation status."
+      ],
+      "color": "#432",
+      "bgcolor": "#000"
+    },
+    {
+      "id": 11,
+      "type": "MarkdownNote",
+      "pos": [
+        790,
+        940
+      ],
+      "size": [
+        480,
+        455
+      ],
+      "flags": {},
+      "order": 10,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "title": "Optional Turbo \u2014 same workflow",
+      "properties": {},
+      "widgets_values": [
+        "## Turbo Ref2VA\nBase mode: leave LoRA disconnected; use 50 steps, video flow shift 12, audio flow shift 3.\n\nFor the 4-step v0.1 Ref2VA Turbo adapter:\n1. Start a Ref2VA-only server with the Diffusers adapter loaded (see README).\n2. Set LoRA local_path to its path on the server, then connect LoRA to Generate Video.\n3. Set Sampling num_inference_steps to **5**; keep shifts at **12 / 3**, scale **1**.\n\nvLLM-Omni counts sigma points: 5 points give 4 denoiser evaluations. Use minimax_h3_ref2v_turbo_4step_v0.1_bf16.safetensors, not the _comfyui_ export.\n\nDisconnect LoRA and restore 50 steps to return to base mode. FastH3 is a separate T2VA deployment, not this option.\n\nAdapted from the official ComfyUI MiniMax-H3 R2V workflow: https://github.com/Comfy-Org/workflow_templates/blob/main/templates/video_minimax_h3_r2v.json"
+      ],
+      "color": "#432",
+      "bgcolor": "#000"
+    }
+  ],
+  "links": [
+    [
+      1,
+      1,
+      0,
+      4,
+      0,
+      "IMAGE"
+    ],
+    [
+      2,
+      4,
+      0,
+      8,
+      1,
+      "VIDEO_REFERENCES"
+    ],
+    [
+      3,
+      5,
+      0,
+      8,
+      2,
+      "SAMPLING_PARAMS"
+    ],
+    [
+      4,
+      6,
+      0,
+      8,
+      4,
+      "VIDEO_PARAMS"
+    ],
+    [
+      5,
+      8,
+      0,
+      9,
+      0,
+      "VIDEO"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {
+    "workflowRendererVersion": "LG",
+    "ds": {
+      "scale": 0.85,
+      "offset": [
+        100,
+        100
+      ]
+    }
+  },
+  "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/apps/ComfyUI-vLLM-Omni/example_workflows/vLLM-Omni Video Generation.json b/apps/ComfyUI-vLLM-Omni/example_workflows/vLLM-Omni Video Generation.json
index 9785845a5..b03b463d8 100644
--- a/apps/ComfyUI-vLLM-Omni/example_workflows/vLLM-Omni Video Generation.json	
+++ b/apps/ComfyUI-vLLM-Omni/example_workflows/vLLM-Omni Video Generation.json	
@@ -1 +1 @@
-{"id":"3aea1d08-7de5-4997-ba71-b2f66ad72a21","revision":0,"last_node_id":24,"last_link_id":35,"nodes":[{"id":13,"type":"SaveVideo","pos":[1315.729153459605,-137.92038948394355],"size":[374,313.7692307692308],"flags":{},"order":9,"mode":0,"inputs":[{"localized_name":"video","name":"video","type":"VIDEO","link":32},{"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/ComfyUI","auto","auto"]},{"id":10,"type":"MarkdownNote","pos":[183.74636797766794,-571.2529158046766],"size":[240.3326478922474,136.3505820791881],"flags":{},"order":0,"mode":0,"inputs":[],"outputs":[],"title":"Note: Task and Input","properties":{},"widgets_values":["vLLM-Omni nodes are categorized based on the output modality. The \"Generate Video\" node supports both *text-to-video*, *frame-to-video*, and *reference-to-video* generation. The node will create corresponding payload depending on whether an input image is present or not."],"color":"#432","bgcolor":"#000"},{"id":4,"type":"LoadImage","pos":[452.07189605801125,-569.7242536425791],"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":[29]},{"localized_name":"MASK","name":"MASK","type":"MASK","links":null}],"properties":{"Node name for S&R":"LoadImage"},"widgets_values":["rap.png","image"]},{"id":23,"type":"LoadImage","pos":[9.206110246057657,-7.6955291509170785],"size":[270,314],"flags":{},"order":2,"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":[34]},{"localized_name":"MASK","name":"MASK","type":"MASK","links":null}],"properties":{"Node name for S&R":"LoadImage"},"widgets_values":["white-cat.jpg","image"]},{"id":22,"type":"MarkdownNote","pos":[-9.783113411416666,-148.8790300038605],"size":[297.3012007349086,88],"flags":{},"order":3,"mode":0,"inputs":[],"outputs":[],"title":"Note: Reference to video (r2v)","properties":{},"widgets_values":["For r2v tasks, connect this Video Reference block to the main Generate Video block. Then disconnect the \"frame\" input above."],"color":"#432","bgcolor":"#000"},{"id":24,"type":"LoadAudio","pos":[317.9929742385805,-141.44821500065095],"size":[282.798828125,136],"flags":{},"order":4,"mode":0,"inputs":[{"localized_name":"audio","name":"audio","type":"COMBO","widget":{"name":"audio"},"link":null},{"localized_name":"audioUI","name":"audioUI","type":"AUDIO_UI","widget":{"name":"audioUI"},"link":null},{"localized_name":"choose file to upload","name":"upload","type":"AUDIOUPLOAD","widget":{"name":"upload"},"link":null}],"outputs":[{"localized_name":"AUDIO","name":"AUDIO","type":"AUDIO","links":[35]}],"properties":{"Node name for S&R":"LoadAudio"},"widgets_values":["nothing-beats-a-jet2-holiday.mp3",null,""]},{"id":21,"type":"VLLMOmniVideoReferences","pos":[376.6129172897595,105.41557277556292],"size":[156.9380859375,126],"flags":{},"order":7,"mode":0,"inputs":[{"localized_name":"image_1","name":"image_1","shape":7,"type":"IMAGE","link":34},{"localized_name":"image_2","name":"image_2","shape":7,"type":"IMAGE","link":null},{"localized_name":"audio_1","name":"audio_1","shape":7,"type":"AUDIO","link":35},{"localized_name":"audio_2","name":"audio_2","shape":7,"type":"AUDIO","link":null},{"localized_name":"video_1","name":"video_1","shape":7,"type":"VIDEO","link":null},{"localized_name":"video_2","name":"video_2","shape":7,"type":"VIDEO","link":null}],"outputs":[{"localized_name":"references","name":"references","type":"VIDEO_REFERENCES","links":null}],"properties":{"Node name for S&R":"VLLMOmniVideoReferences"},"widgets_values":[]},{"id":8,"type":"VLLMOmniDiffusionSampling","pos":[83.24620208113915,422.08543477542605],"size":[284.205078125,226],"flags":{},"order":5,"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":[30]}],"properties":{"Node name for S&R":"VLLMOmniDiffusionSampling"},"widgets_values":[1,50,1,1,false,false,213,"randomize"]},{"id":18,"type":"VLLMOmniMiniMaxH3Params","pos":[483.0944676363692,426.7197881452892],"size":[276.56796875,82],"flags":{},"order":6,"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":[33]}],"properties":{"Node name for S&R":"VLLMOmniMiniMaxH3Params"},"widgets_values":[3,12]},{"id":16,"type":"VLLMOmniGenerateVideo","pos":[826.1428043381621,-148.53719710697413],"size":[425.5948726785682,551.767376721426],"flags":{},"order":8,"mode":0,"inputs":[{"localized_name":"frame","name":"frame","shape":7,"type":"IMAGE","link":29},{"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":30},{"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":33},{"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":"num_frames","name":"num_frames","type":"INT","widget":{"name":"num_frames"},"link":null}],"outputs":[{"localized_name":"video","name":"video","type":"VIDEO","links":[32]}],"properties":{"Node name for S&R":"VLLMOmniGenerateVideo"},"widgets_values":["http://localhost:8000/v1","/workspace/models/hub/models--MiniMaxAI--MiniMax-H3/snapshots/428986c4aa5280855b9ac26eff8d1a46b5999cd0/FL2VA","A scene of urban fantasy art. A dynamic graffiti art character. A boy made of spray paint comes to life on a concrete wall. He sings an English rap song at high speed while striking a classic, energetic rapper pose. The scene is set under an urban railway bridge at night. The light comes from a single street lamp, creating a cinematic atmosphere full of high energy and amazing detail. The audio of the video consists entirely of the rap, with no other dialogue or noise.","",832,480,24,120]}],"links":[[29,4,0,16,0,"IMAGE"],[30,8,0,16,2,"SAMPLING_PARAMS"],[32,16,0,13,0,"VIDEO"],[33,18,0,16,4,"VIDEO_PARAMS"],[34,23,0,21,0,"IMAGE"],[35,24,0,21,2,"AUDIO"]],"groups":[{"id":1,"title":"Image-to-video input (first-frame-to-video)","bounding":[168.92390079062986,-653.2124402506535,560.8246471437027,407.4246532472182],"color":"#3f789e","flags":{}},{"id":2,"title":"Reference-to-video input","bounding":[-66.75175444110151,-225.24978633666066,805.4597228678848,554.7384400819777],"color":"#3f789e","flags":{}}],"config":{},"extra":{"workflowRendererVersion":"LG","ds":{"scale":0.8,"offset":[1240.4751945653188,770.6151743053379]}},"version":0.4}
+{"id":"3aea1d08-7de5-4997-ba71-b2f66ad72a21","revision":0,"last_node_id":24,"last_link_id":35,"nodes":[{"id":13,"type":"SaveVideo","pos":[1315.729153459605,-137.92038948394355],"size":[374,313.7692307692308],"flags":{},"order":9,"mode":0,"inputs":[{"localized_name":"video","name":"video","type":"VIDEO","link":32},{"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/ComfyUI","auto","auto"]},{"id":10,"type":"MarkdownNote","pos":[183.74636797766794,-571.2529158046766],"size":[240.3326478922474,136.3505820791881],"flags":{},"order":0,"mode":0,"inputs":[],"outputs":[],"title":"Note: Task and Input","properties":{},"widgets_values":["vLLM-Omni nodes are categorized based on the output modality. The \"Generate Video\" node supports both *text-to-video*, *frame-to-video*, and *reference-to-video* generation. The node will create corresponding payload depending on whether an input image is present or not."],"color":"#432","bgcolor":"#000"},{"id":4,"type":"LoadImage","pos":[452.07189605801125,-569.7242536425791],"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":[29]},{"localized_name":"MASK","name":"MASK","type":"MASK","links":null}],"properties":{"Node name for S&R":"LoadImage"},"widgets_values":["rap.png","image"]},{"id":23,"type":"LoadImage","pos":[9.206110246057657,-7.6955291509170785],"size":[270,314],"flags":{},"order":2,"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":[34]},{"localized_name":"MASK","name":"MASK","type":"MASK","links":null}],"properties":{"Node name for S&R":"LoadImage"},"widgets_values":["white-cat.jpg","image"]},{"id":22,"type":"MarkdownNote","pos":[-9.783113411416666,-148.8790300038605],"size":[297.3012007349086,88],"flags":{},"order":3,"mode":0,"inputs":[],"outputs":[],"title":"Note: Reference to video (r2v)","properties":{},"widgets_values":["For r2v tasks, connect this Video Reference block to the main Generate Video block. Then disconnect the \"frame\" input above."],"color":"#432","bgcolor":"#000"},{"id":24,"type":"LoadAudio","pos":[317.9929742385805,-141.44821500065095],"size":[282.798828125,136],"flags":{},"order":4,"mode":0,"inputs":[{"localized_name":"audio","name":"audio","type":"COMBO","widget":{"name":"audio"},"link":null},{"localized_name":"audioUI","name":"audioUI","type":"AUDIO_UI","widget":{"name":"audioUI"},"link":null},{"localized_name":"choose file to upload","name":"upload","type":"AUDIOUPLOAD","widget":{"name":"upload"},"link":null}],"outputs":[{"localized_name":"AUDIO","name":"AUDIO","type":"AUDIO","links":[35]}],"properties":{"Node name for S&R":"LoadAudio"},"widgets_values":["nothing-beats-a-jet2-holiday.mp3",null,""]},{"id":21,"type":"VLLMOmniVideoReferences","pos":[376.6129172897595,105.41557277556292],"size":[156.9380859375,126],"flags":{},"order":7,"mode":0,"inputs":[{"localized_name":"image_1","name":"image_1","shape":7,"type":"IMAGE","link":34},{"localized_name":"image_2","name":"image_2","shape":7,"type":"IMAGE","link":null},{"localized_name":"audio_1","name":"audio_1","shape":7,"type":"AUDIO","link":35},{"localized_name":"audio_2","name":"audio_2","shape":7,"type":"AUDIO","link":null},{"localized_name":"video_1","name":"video_1","shape":7,"type":"VIDEO","link":null},{"localized_name":"video_2","name":"video_2","shape":7,"type":"VIDEO","link":null}],"outputs":[{"localized_name":"references","name":"references","type":"VIDEO_REFERENCES","links":null}],"properties":{"Node name for S&R":"VLLMOmniVideoReferences"},"widgets_values":[]},{"id":8,"type":"VLLMOmniDiffusionSampling","pos":[83.24620208113915,422.08543477542605],"size":[284.205078125,226],"flags":{},"order":5,"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":[30]}],"properties":{"Node name for S&R":"VLLMOmniDiffusionSampling"},"widgets_values":[1,50,1,1,false,false,213,"randomize"]},{"id":18,"type":"VLLMOmniMiniMaxH3Params","pos":[483.0944676363692,426.7197881452892],"size":[276.56796875,82],"flags":{},"order":6,"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":[33]}],"properties":{"Node name for S&R":"VLLMOmniMiniMaxH3Params"},"widgets_values":[3,12]},{"id":16,"type":"VLLMOmniGenerateVideo","pos":[826.1428043381621,-148.53719710697413],"size":[425.5948726785682,551.767376721426],"flags":{},"order":8,"mode":0,"inputs":[{"localized_name":"frame","name":"frame","shape":7,"type":"IMAGE","link":29},{"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":30},{"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":33},{"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":[32]}],"properties":{"Node name for S&R":"VLLMOmniGenerateVideo"},"widgets_values":["http://localhost:8000/v1","/workspace/models/hub/models--MiniMaxAI--MiniMax-H3/snapshots/428986c4aa5280855b9ac26eff8d1a46b5999cd0/FL2VA","A scene of urban fantasy art. A dynamic graffiti art character. A boy made of spray paint comes to life on a concrete wall. He sings an English rap song at high speed while striking a classic, energetic rapper pose. The scene is set under an urban railway bridge at night. The light comes from a single street lamp, creating a cinematic atmosphere full of high energy and amazing detail. The audio of the video consists entirely of the rap, with no other dialogue or noise.","",832,480,24,5.0]}],"links":[[29,4,0,16,0,"IMAGE"],[30,8,0,16,2,"SAMPLING_PARAMS"],[32,16,0,13,0,"VIDEO"],[33,18,0,16,4,"VIDEO_PARAMS"],[34,23,0,21,0,"IMAGE"],[35,24,0,21,2,"AUDIO"]],"groups":[{"id":1,"title":"Image-to-video input (first-frame-to-video)","bounding":[168.92390079062986,-653.2124402506535,560.8246471437027,407.4246532472182],"color":"#3f789e","flags":{}},{"id":2,"title":"Reference-to-video input","bounding":[-66.75175444110151,-225.24978633666066,805.4597228678848,554.7384400819777],"color":"#3f789e","flags":{}}],"config":{},"extra":{"workflowRendererVersion":"LG","ds":{"scale":0.8,"offset":[1240.4751945653188,770.6151743053379]}},"version":0.4}
diff --git a/apps/ComfyUI-vLLM-Omni/web/main.js b/apps/ComfyUI-vLLM-Omni/web/main.js
index da99b2539..9aba6260e 100644
--- a/apps/ComfyUI-vLLM-Omni/web/main.js
+++ b/apps/ComfyUI-vLLM-Omni/web/main.js
@@ -1,19 +1,153 @@
 /**
- * @file This file is intended to add dynamic fields to vLLM-Omni nodes
- * based on widget (in-node form fields) and input (connection link) values and changes.
- * However, this functionality is currently disabled/commented out.
- * Because it introduces too much complexity,
- * and it may even conflict with the current backend (Python) validation for unknown reasons (pending ComfyUI upstream fixes).
+ * @file Front-end extension for the vLLM-Omni nodes.
+ *
+ * Branding. Every vLLM-Omni node draws the vLLM-Omni "v" mark where LiteGraph
+ * would otherwise draw its default title dot, and is tinted by the kind of value
+ * it produces: blue nodes reach a server, amber and purple ones only assemble
+ * parameters, red ones pin what the server has loaded, teal ones carry media.
+ * A graph is then readable at a glance, and a node that turns out to be the
+ * wrong colour for where it sits is usually wired wrong.
+ *
+ * The tint is keyed off each node's declared output types rather than a list of
+ * node names, so a node added later is themed as soon as it returns one of the
+ * existing types.
+ *
+ * It also migrates Generate Video graphs saved before `duration` replaced the
+ * `num_frames` widget. See migrateNumFramesToDuration below.
+ *
+ * This file also used to host dynamic fields on vLLM-Omni nodes, driven by
+ * widget (in-node form fields) and input (connection link) values and changes.
+ * That is deliberately absent: it introduced too much complexity, and it even
+ * conflicted with the current backend (Python) validation for unknown reasons
+ * (pending ComfyUI upstream fixes).
  */
 
 import { app } from "../../scripts/app.js";
+
+const MARK_URL = new URL("./vllm-omni-mark.svg", import.meta.url).href;
+const MARK_ASPECT = 157 / 165;
+
+/**
+ * Title bar and body tints, one per node family.
+ *
+ * The hues are the logo's: the amber and blue of the "v" mark, and three stops
+ * of the gradient ring in the "O" (#9128A3, #CC5260, and the teal neighbouring
+ * its blue). All of them are dark because LiteGraph paints the title bar darker
+ * than the body and expects both to sit under light text; the ComfyUI light
+ * theme lightens custom node colours on its own.
+ */
+const FAMILIES = {
+    generate: { color: "#152A43", bgcolor: "#1F4269" },
+    sampling: { color: "#3A2C12", bgcolor: "#5C461C" },
+    model: { color: "#2E1233", bgcolor: "#4A1C52" },
+    deployment: { color: "#3A1A1F", bgcolor: "#5C2931" },
+    media: { color: "#0F2E2A", bgcolor: "#194A44" },
+};
+
+/** Output type -> family. Types absent here fall through to "generate". */
+const FAMILY_BY_OUTPUT = {
+    SAMPLING_PARAMS: "sampling",
+    TTS_PARAMS: "model",
+    VIDEO_PARAMS: "model",
+    REMOTE_LORA: "deployment",
+    FASTH3_DEPLOYMENT: "deployment",
+    VIDEO_REFERENCES: "media",
+};
+
+function familyOf(nodeData) {
+    for (const type of nodeData.output ?? []) {
+        const family = FAMILY_BY_OUTPUT[type];
+        if (family) {
+            return family;
+        }
+    }
+    // What is left returns a generated artifact (IMAGE, VIDEO, AUDIO, STRING),
+    // which is only ever produced by a node that talks to a vLLM-Omni server.
+    return "generate";
+}
+
+/**
+ * Rewrite a pre-rename Generate Video graph in place.
+ *
+ * `duration` (seconds) took over the slot `num_frames` used to occupy, and
+ * ComfyUI restores widget values positionally, so a graph saved before the
+ * rename reads its frame count as a duration: the workflow this repository
+ * shipped stored 120 frames at 24 fps, which would come back as a 120-second
+ * request. Saved files still name the old widget under `inputs`, and that is
+ * what makes the rewrite both detectable and safe to apply exactly once -- once
+ * rewritten the node serializes `duration`, so a later load finds nothing to do.
+ */
+function migrateNumFramesToDuration(node, info) {
+    const savedBeforeRename = (info?.inputs ?? []).some((input) => input?.widget?.name === "num_frames");
+    if (!savedBeforeRename) {
+        return
+    }
+    const duration = node.widgets?.find((widget) => widget.name === "duration");
+    const fps = node.widgets?.find((widget) => widget.name === "fps");
+    if (!duration || !fps) {
+        return
+    }
+    // configure() has already placed the stale frame count in the duration widget.
+    const frames = Number(duration.value);
+    const rate = Number(fps.value);
+    if (!Number.isFinite(frames) || !Number.isFinite(rate) || rate <= 0) {
+        return
+    }
+    const seconds = Math.max(duration.options?.min ?? 0.1, Math.round((frames / rate) * 1000) / 1000);
+    console.info(
+        `vLLM-Omni: migrated Generate Video "${node.title}" from ${frames} frames to ${seconds}s at ${rate} fps.`,
+    );
+    duration.value = seconds;
+}
+
+const mark = new Image();
+let markReady = false;
+mark.addEventListener("load", () => {
+    markReady = true;
+    // The image resolves after the first frames are already on screen.
+    app.graph?.setDirtyCanvas?.(true, true);
+});
+mark.src = MARK_URL;
+
 app.registerExtension({
     name: "vllm.vllm_omni",
     async beforeRegisterNodeDef(nodeType, nodeData, app) {
         if (!nodeData.name.startsWith("VLLMOmni")) {
             return
         }
-        // Stub frontend plugin for now
+
+        const { color, bgcolor } = FAMILIES[familyOf(nodeData)];
+        // On the prototype, not the instance: a colour the user picks by hand is
+        // written to the instance and shadows this, so manual overrides survive.
+        nodeType.prototype.color = color;
+        nodeType.prototype.bgcolor = bgcolor;
+
+        if (nodeData.name === "VLLMOmniGenerateVideo") {
+            const onConfigure = nodeType.prototype.onConfigure;
+            nodeType.prototype.onConfigure = function (info) {
+                onConfigure?.apply(this, arguments);
+                migrateNumFramesToDuration(this, info);
+            };
+        }
+
+        // Defining this replaces the default dot outright — LiteGraph draws its
+        // own square or circle only for nodes that leave onDrawTitleBox unset.
+        nodeType.prototype.onDrawTitleBox = function (ctx, titleHeight, _size, scale) {
+            // Zoomed out far enough that LiteGraph itself drops to flat shapes,
+            // the mark is a few muddy pixels. Leave the title bar clean instead.
+            if (!markReady || (scale !== undefined && scale < 0.5)) {
+                return
+            }
+            const height = titleHeight * 0.62;
+            const width = height * MARK_ASPECT;
+            ctx.drawImage(
+                mark,
+                titleHeight * 0.5 - width * 0.5,
+                titleHeight * -0.5 - height * 0.5,
+                width,
+                height,
+            );
+        };
     },
     async setup() {
         console.info("vLLM-Omni Setup complete!")
diff --git a/apps/ComfyUI-vLLM-Omni/web/vllm-omni-mark.svg b/apps/ComfyUI-vLLM-Omni/web/vllm-omni-mark.svg
new file mode 100644
index 000000000..5ce519c1b
--- /dev/null
+++ b/apps/ComfyUI-vLLM-Omni/web/vllm-omni-mark.svg
@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 157 165" width="157" height="165">
+  <title>vLLM-Omni</title>
+  <polygon points="0,36 62,36 62,160" fill="#F1B844"/>
+  <polygon points="96,36 157,0 121,165 68,165" fill="#54A0F8"/>
+</svg>
diff --git a/artifacts/pr7759-review/issue_comments.txt b/artifacts/pr7759-review/issue_comments.txt
new file mode 100644
index 000000000..470278708
--- /dev/null
+++ b/artifacts/pr7759-review/issue_comments.txt
@@ -0,0 +1,54 @@
+=== chatgpt-codex-connector ===
+<!-- codex-pull-request-review-summary -->
+
+## Codex Review Summary
+
+This comment shows the latest Codex review activity on this pull request.
+
+| Review | Status | Commit | Review trigger |
+| --- | --- | --- | --- |
+| 📝 **Code Review** | ✅ **Completed** <relative-time datetime="2026-09-18T02:12:54.670114Z">2026-09-18T02:12:54.670114Z</relative-time> | `3affc77` | PR opened |
+
+
+
+<details> <summary>ℹ️ About Codex in GitHub</summary>
+<br/>
+
+[Your team has set up Codex to review pull requests in this repo](https://chatgpt.com/codex/cloud/settings/general). Reviews are triggered when you
+- Open a pull request for review
+- Mark a draft as ready
+- Comment "@codex review" or "@codex security review".
+
+Codex reacts with 👀 while any review is running, comments if it has suggestions, and reacts with 👍 once all reviews finish with no findings.
+
+</details>
+
+=== vllm-omni-review-bot ===
+This PR appears to belong to: **docs/design/module/diffusion/index.md**, **docs/design/module/diffusion/parallelism.md**.
+
+Module owners: @princepride @xuechendi @Bounty-hunter
+
+Routing: @princepride via module of the changed files, module named in the PR description; @xuechendi via module of the changed files, module named in the PR description; @Bounty-hunter via module named in the PR description, CODEOWNERS
+
+@Isotr0py, please review your own changes and leave a short self-review comment describing what you checked. PRs without author self-review may not be assigned a reviewer.
+
+Please take a look when you have a chance. If you would like an automated review, mention @vllm-omni-review-bot in a comment.
+
+<!-- omni-reviewbot:assignment:v1 repo=vllm-project/vllm-omni pr=7759 -->
+
+=== vllm-omni-review-bot ===
+## Omni ReviewBot triage note
+
+Resolved as of `a26013145cfa`: the high-priority or low-quality signal noted on an earlier commit no longer applies.
+
+<!-- omni-reviewbot:quality-note:v1 repo=vllm-project/vllm-omni pr=7759 -->
+<!-- omni-reviewbot:quality-note-head:a26013145cfa0e710cc401bf086a68e2a7f215e4 -->
+<!-- omni-reviewbot:quality-note-state:retracted -->
+
+
+=== Bounty-hunter ===
+is prefix cache depend on https://github.com/vllm-project/vllm-omni/pull/7719 ?
+
+=== SamitHuang ===
+Pls resolve the conflicts for further review, thx
+
diff --git a/artifacts/pr7759-review/review_comments.txt b/artifacts/pr7759-review/review_comments.txt
new file mode 100644
index 000000000..b68f3e163
--- /dev/null
+++ b/artifacts/pr7759-review/review_comments.txt
@@ -0,0 +1,93 @@
+=== id:4043203379 | chatgpt-codex-connector[bot] | vllm_omni/diffusion/models/qwen_image_21/pipeline_qwen_image_21.py:1247 | reply_to:null ===
+**<sub><sub>![P1 Badge](https://img.shields.io/badge/P1-orange?style=flat)</sub></sub>  Keep new requests out of populated KV-cache batches**
+
+With step execution and `max_num_seqs > 1`, the scheduler explicitly admits compatible waiting requests alongside already-running requests, so a request arriving after the first denoise step produces exactly this mixed `prefill`/`decode` phase set and aborts the whole batch here. Since the recipe advertises continuous step execution with `--max-num-seqs 8`, the pipeline must either handle mixed phases or prevent such requests from joining an in-flight batch rather than raising.
+
+Useful? React with 👍 / 👎.
+
+=== id:4043203389 | chatgpt-codex-connector[bot] | vllm_omni/diffusion/models/qwen_image_21/pipeline_qwen_image_21.py:193 | reply_to:null ===
+**<sub><sub>![P1 Badge](https://img.shields.io/badge/P1-orange?style=flat)</sub></sub>  Partition batches by image-conditioning layout**
+
+The preprocessor never sets `request.batch_compatibility_key`, so the generic request and step schedulers consider text-only requests, image-conditioned requests, and requests with different condition-image layouts compatible when their sampling parameters match. Such requests are then placed in one batch and rejected later by `_prepare_generation_context` or `denoise_step`, turning otherwise valid concurrent requests into batch-wide failures; record the conditioning mode, image count, and resized slot sizes in the compatibility key on both the empty-image and image paths.
+
+Useful? React with 👍 / 👎.
+
+=== id:4043203392 | chatgpt-codex-connector[bot] | vllm_omni/diffusion/models/qwen_image_21/pipeline_qwen_image_21.py:693 | reply_to:null ===
+**<sub><sub>![P1 Badge](https://img.shields.io/badge/P1-orange?style=flat)</sub></sub>  Preserve request order when duplicating condition latents**
+
+When a request batch contains more than one prompt and `num_outputs_per_prompt > 1`, prompt embeddings are ordered per request (`A, A, B, B`), but concatenating the encoded batch repeatedly orders condition latents as `A, B, A, B`. The second and third generations therefore receive another request's condition image; duplicate each encoded row consecutively so its order matches the repeated prompt embeddings and output splitting.
+
+Useful? React with 👍 / 👎.
+
+=== id:4043203401 | chatgpt-codex-connector[bot] | vllm_omni/diffusion/models/qwen_image_21/pipeline_qwen_image_21.py:147 | reply_to:null ===
+**<sub><sub>![P2 Badge](https://img.shields.io/badge/P2-yellow?style=flat)</sub></sub>  Avoid truth-testing tensor and ndarray image inputs**
+
+For a condition image supplied as a multi-element `torch.Tensor` or `numpy.ndarray`, this truth-value check raises an ambiguity error before `_to_pil` can process it, despite `_to_pil` explicitly supporting both input types. Check explicitly for `None` or an empty list instead so these supported image representations reach conversion.
+
+Useful? React with 👍 / 👎.
+
+=== id:4043275121 | SamitHuang | vllm_omni/diffusion/models/qwen_image_21/pipeline_qwen_image_21.py:283 | reply_to:null ===
+This pipeline is the entire new model surface (~1.3k lines here, plus transformer/VAE/CUDA graph) and the PR adds **zero tests**. Commits `4fc3cf8` / `3affc77` mention Qwen-Image-2.1 unit tests and then `clean tests` removes them from the branch. Add at least (1) unit tests for preprocess, `prepare_latents` duplication, mixed-phase `_assemble_kv_cache`, and VAE `spatial_compression_ratio=16`, and (2) a `tests/e2e/online_serving/test_qwen_image_21.py` smoke wired into `.buildkite/cuda/test-ready.yml` the same way `test_qwen_image.py` is. Without that, the TP / VAE-tiling / CUDA-graph claims in the commit messages are not merge-blocking evidence.
+
+=== id:4043275125 | SamitHuang | vllm_omni/diffusion/models/qwen_image_21/decode_graph.py:274 | reply_to:null ===
+`register_prefill` copies prefix K/V into a **shared** entry keyed only by `(branch, batch, prefix_len, target_tokens, dtype, device, backend)` and then **re-points every caller’s `kv_cache` dict at those tensors**. A second in-flight request with the same key `copy_`s over the first request’s prefix while the first request’s cache still aliases the same storage, so decode attends to another request’s text/image tokens. Sequential reuse of one buffer is fine; concurrent ownership is not. Keep per-request (or per-generation) static buffers, or refuse CUDA-graph decode whenever more than one live cache aliases the same key. This interacts directly with the recipe’s `--max-num-seqs 8` serving path.
+
+=== id:4043275130 | SamitHuang | vllm_omni/diffusion/models/qwen_image_21/pipeline_qwen_image_21.py:693 | reply_to:null ===
+`encode_prompt` expands with `prompt_embeds.repeat(1, num_images_per_prompt, 1).view(batch * n, ...)` which is request-major (`A, A, B, B`). `torch.cat([encoded] * (batch_size // encoded.shape[0]), dim=0)` is tile-major (`A, B, A, B`). For a 2-prompt batch with `num_outputs_per_prompt=2`, generations 2 and 3 therefore get the other request’s condition latents (and `split_diffusion_output_by_request` will pair them as if they were correct). Use `repeat_interleave(repeats=n, dim=0)` (or encode-then-repeat per row) so condition latents match the prompt-embed order. This needs a unit test with `batch_size=2, n=2`.
+
+=== id:4043275138 | SamitHuang | vllm_omni/diffusion/models/qwen_image_21/pipeline_qwen_image_21.py:147 | reply_to:null ===
+`if not raw_image` is an ambiguous truth-value check. `_to_pil` documents `torch.Tensor` and `numpy.ndarray` inputs; a multi-element tensor/array raises `RuntimeError: Boolean value of Tensor with more than one value is ambiguous` before conversion. Treat T2I as `raw_image is None or raw_image == []` (and maybe empty tuple), then always wrap a single image in a list. Same pattern should apply to whatever OpenAI image-edit path feeds tensors into `multi_modal_data["image"]`.
+
+=== id:4043275145 | SamitHuang | recipes/Qwen/Qwen-Image-2.1.md:107 | reply_to:null ===
+This example advertises `--step-execution --max-num-seqs 8`, but `QwenImage21Pipeline._assemble_kv_cache` raises if a new request’s first denoise step joins a batch that is already in decode (`Cannot batch requests at mixed KV-cache phases`). With the default step scheduler admitting waiting requests into a running batch, that is the normal continuous-batching case, not an edge case. Either keep mixed-phase requests out of the same `InputBatch` (and document the restriction here), or do not publish this command until that TODO is implemented. As written, following the recipe under load fails the whole batch.
+
+=== id:4043327545 | SamitHuang | vllm_omni/diffusion/data.py:909 | reply_to:null ===
+the CUDA graph for decode seems only used by QwenImage2.1? It's better to claim how it works together with eager mode or cudagraph_mode.
+
+=== id:4043342420 | SamitHuang | examples/offline_inference/text_to_image/text_to_image.py:1 | reply_to:null ===
+can provide a `examples/offline_inference/image_to_image/run_qwen_image_21.sh` script as well
+
+=== id:4043666922 | hsliuustc0106 | vllm_omni/diffusion/data.py:909 | reply_to:null ===
+This flag has no ingress, so the CUDA-graph decode path is unreachable for users: it's not in `OmniEngineArgs`/`StageDeployConfig`/`_DiffusionConfigProjection` (contrast `vae_use_tiling`, which flows through all three), and `Omni(enable_cuda_graph_decode=True)` is silently dropped by `from_kwargs`' field-name filter (`data.py:1604`). The only writer is the `False` default, so `decode_graph.py` + the transformer machinery only run under tests. Either wire it like `enforce_eager`/`vae_use_tiling` (deploy knob + projection) or document it as test-only in the recipe — the body's checked "[x] CUDA Graph for decode steps" reads as user-available today.
+
+=== id:4043667674 | hsliuustc0106 | vllm_omni/diffusion/models/qwen_image_21/pipeline_qwen_image_21.py:1246 | reply_to:null ===
+Reachable under the recipe's own `--step-execution --max-num-seqs 8`, and it fails the whole wave, not just the joiner: the default scheduler admits waiting requests while running ones are mid-generation (`base_scheduler.py` schedules running first, then admits waiting while capacity remains; `_can_schedule_waiting` compares only `StepBatchSamplingParamsKey` — no KV phase), and a `denoise_step` exception terminally fails every scheduled request via `diffusion_engine.py`'s `Execution failed for diffusion requests ...` handler. So one fresh arrival converts all in-flight requests into errors. Fix direction: phase-aware admission (defer joins while any running request is past step 0) or a per-model `batch_compatibility_key`; until then the features-table ✅ for Step Execution and the recipe's serving block overstate support vs. the unchecked TODO box.
+
+=== id:4043668653 | hsliuustc0106 | examples/offline_inference/image_to_image/qwen_image_21_edit.py:1 | reply_to:null ===
+Blocking per the examples policy: a newly added model-specific Python example (the file names one model family), while this directory's convention is the generic runner (`image_edit.py`, which dispatches via `get_model_class_name`/`build_image_to_image_prompt` — the same helpers this script calls). Smallest fix: register a `QwenImage21Pipeline` spec in `model_extras/_EXTRA_SPECS` (it's missing, so `build_image_to_image_prompt` currently falls through to the generic builder and silently ignores the `height`/`width` args this script passes) and fold this into `image_edit.py`; drop the model-specific file.
+
+=== id:4043668703 | hsliuustc0106 | vllm_omni/diffusion/models/qwen_image_21/__init__.py:1 | reply_to:null ===
+No tests anywhere in the PR. Sibling new models each ship a `tests/diffusion/models/<model>/` suite (sensenova_u1, glm_image, boogu_image incl. registry tests, ovis_image, z_image), and no CI lane touches `qwen_image_21` today. Given the new surface — registry entry, pre/post-process funcs, KV-cache prefill/decode protocol, step-mode merge/scatter, graph fallback gates — at least a CPU-runnable registry + loading + pre/post-process test would protect it.
+
+=== id:4043668767 | hsliuustc0106 | recipes/Qwen/Qwen-Image-2.1.md:3 | reply_to:null ===
+Missing the head-vs-reference comparison the model-addition checklist requires: the body's Test Plan is empty and there's no diffusers-#14804 quality/latency A/B (same checkpoint, inputs, seed, precision, hardware) — the recipe's only number is the tile-size PSNR probe. The checked TODO boxes (TP=2/4 vs single-card output, VAE tiling, CUDA graphs) also have no attached measurements. Please add the reference A/B with exact commands and both sides' outputs, or state why it can't run yet.
+
+=== id:4044943764 | RuixiangMa | tests/diffusion/models/qwen_image_21/test_batch_compatibility.py:1 | reply_to:null ===
+Test coverage is insufficient.
+
+=== id:4045080762 | RuixiangMa | vllm_omni/diffusion/distributed/autoencoders/autoencoder_kl_qwenimage21.py:2 | reply_to:null ===
+```suggestion
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+```
+
+=== id:4045084688 | RuixiangMa | vllm_omni/diffusion/models/qwen_image_21/__init__.py:2 | reply_to:null ===
+```suggestion
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+```
+
+=== id:4059060032 | FayeSpica | vllm_omni/diffusion/models/qwen_image_21/qwen_image_21_transformer.py:388 | reply_to:null ===
+```suggestion
+        height_index = torch.where(height_index < 0, height_index + self.freqs[1].shape[0], height_index)
+        width_index = torch.where(width_index < 0, width_index + self.freqs[2].shape[0], width_index)
+        return torch.cat(
+            [
+                self.freqs[0].index_select(0, frame_index),
+                self.freqs[1].index_select(0, height_index),
+                self.freqs[2].index_select(0, width_index),
+            ],
+            dim=-1,
+        )
+```
+
+Could we use `torch.index_select` here for NPU compatibility, similar to #6320? This was the only issue preventing the model from starting on NPU in my tests.
+
diff --git a/benchmarks/README.md b/benchmarks/README.md
index 0a8fb8058..182bba02d 100644
--- a/benchmarks/README.md
+++ b/benchmarks/README.md
@@ -4,6 +4,11 @@ This directory contains benchmark suites for evaluating different model families
 
 ## Benchmark families
 
+### [Qwen2.5-Omni](qwen2_5_omni/README.md) — Embedding Wrapper Latency
+
+CPU-observed A/B timings for redundant text embedding removal, with real checkpoint
+embeddings, warmup, paired blocks, and embedding call-count validation.
+
 ### [TTS](tts/README.md) — Text-to-Speech
 
 Model-agnostic serving benchmarks for TTS models, including Qwen3-TTS and VoxCPM2.
diff --git a/benchmarks/diffusion/benchmark_qwen_image_qk_norm_rope.py b/benchmarks/diffusion/benchmark_qwen_image_qk_norm_rope.py
new file mode 100644
index 000000000..2eaa097bd
--- /dev/null
+++ b/benchmarks/diffusion/benchmark_qwen_image_qk_norm_rope.py
@@ -0,0 +1,222 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Benchmark Qwen-Image Q/K RMSNorm + interleaved RoPE.
+
+Example:
+
+    CUDA_VISIBLE_DEVICES=0 python benchmarks/diffusion/benchmark_qwen_image_qk_norm_rope.py \
+      --seq-len 4096 --warmup 20 --iters 100 --include-compiled --profile
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from collections.abc import Callable
+
+import torch
+import torch.nn.functional as F
+
+from vllm_omni.diffusion.layers.fused_qk_norm_rope import (
+    _fused_cuda_supported,
+    fused_qk_norm_rope,
+)
+from vllm_omni.diffusion.layers.rope import RotaryEmbedding
+
+
+def _parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--batch", type=int, default=1)
+    parser.add_argument("--seq-len", type=int, default=4096)
+    parser.add_argument("--heads", type=int, default=24)
+    parser.add_argument("--kv-heads", type=int, default=24)
+    parser.add_argument("--head-dim", type=int, default=128)
+    parser.add_argument("--warmup", type=int, default=20)
+    parser.add_argument("--iters", type=int, default=100)
+    parser.add_argument("--dtype", choices=("bf16", "fp16", "fp32"), default="bf16")
+    parser.add_argument("--packed-qkv-view", action="store_true")
+    parser.add_argument("--include-compiled", action="store_true")
+    parser.add_argument("--profile", action="store_true")
+    return parser.parse_args()
+
+
+def _dtype(name: str) -> torch.dtype:
+    return {
+        "bf16": torch.bfloat16,
+        "fp16": torch.float16,
+        "fp32": torch.float32,
+    }[name]
+
+
+def _make_inputs(args: argparse.Namespace, dtype: torch.dtype, device: torch.device):
+    torch.manual_seed(2026)
+    if args.packed_qkv_view:
+        qkv_dim = (args.heads + args.kv_heads + args.kv_heads) * args.head_dim
+        qkv = torch.randn(args.batch, args.seq_len, qkv_dim, device=device, dtype=dtype)
+        q, k, _ = qkv.split(
+            [
+                args.heads * args.head_dim,
+                args.kv_heads * args.head_dim,
+                args.kv_heads * args.head_dim,
+            ],
+            dim=-1,
+        )
+        q = q.unflatten(-1, (args.heads, args.head_dim))
+        k = k.unflatten(-1, (args.kv_heads, args.head_dim))
+    else:
+        q = torch.randn(args.batch, args.seq_len, args.heads, args.head_dim, device=device, dtype=dtype)
+        k = torch.randn(args.batch, args.seq_len, args.kv_heads, args.head_dim, device=device, dtype=dtype)
+
+    q_weight = torch.randn(args.head_dim, device=device, dtype=dtype)
+    k_weight = torch.randn(args.head_dim, device=device, dtype=dtype)
+    angles = torch.randn(args.seq_len, args.head_dim // 2, device=device, dtype=torch.float32)
+    freqs = torch.polar(torch.ones_like(angles), angles)
+    return q, k, q_weight, k_weight, freqs
+
+
+def _native(
+    q: torch.Tensor,
+    k: torch.Tensor,
+    q_weight: torch.Tensor,
+    k_weight: torch.Tensor,
+    freqs: torch.Tensor,
+    eps: float,
+) -> 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)
+    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(
+    q: torch.Tensor,
+    k: torch.Tensor,
+    q_weight: torch.Tensor,
+    k_weight: torch.Tensor,
+    freqs: torch.Tensor,
+    eps: float,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    batch, seq_len, num_heads, head_dim = q.shape
+    num_kv_heads = k.shape[2]
+    rope_table = torch.cat((freqs.real, freqs.imag), dim=-1)
+    rope_table = rope_table.unsqueeze(0).expand(batch, -1, -1).reshape(batch * seq_len, head_dim)
+    out_q, out_k = fused_qk_norm_rope(
+        q.reshape(batch * seq_len, num_heads, head_dim),
+        k.reshape(batch * seq_len, num_kv_heads, head_dim),
+        q_weight,
+        k_weight,
+        rope_table,
+        eps,
+        interleaved=True,
+    )
+    return (
+        out_q.reshape(batch, seq_len, num_heads, head_dim),
+        out_k.reshape(batch, seq_len, num_kv_heads, head_dim),
+    )
+
+
+def _measure(fn: Callable[[], tuple[torch.Tensor, torch.Tensor]], warmup: int, iters: int) -> list[float]:
+    for _ in range(warmup):
+        fn()
+    torch.accelerator.synchronize()
+    start = torch.cuda.Event(enable_timing=True)
+    end = torch.cuda.Event(enable_timing=True)
+    samples = []
+    for _ in range(iters):
+        start.record()
+        fn()
+        end.record()
+        end.synchronize()
+        samples.append(start.elapsed_time(end))
+    return samples
+
+
+def _stats(samples: list[float]) -> dict[str, float]:
+    samples = sorted(samples)
+    return {
+        "median_ms": samples[len(samples) // 2],
+        "p90_ms": samples[int(len(samples) * 0.9)],
+        "mean_ms": sum(samples) / len(samples),
+    }
+
+
+def _profile(fn: Callable[[], tuple[torch.Tensor, torch.Tensor]]) -> str:
+    from torch.profiler import ProfilerActivity, profile
+
+    with profile(activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA]) as prof:
+        fn()
+        torch.accelerator.synchronize()
+    return prof.key_averages().table(sort_by="self_cuda_time_total", row_limit=15)
+
+
+def main() -> None:
+    args = _parse_args()
+    if not torch.cuda.is_available():
+        raise RuntimeError("This benchmark requires CUDA")
+    device = torch.device("cuda")
+    dtype = _dtype(args.dtype)
+    eps = 1e-6
+    q, k, q_weight, k_weight, freqs = _make_inputs(args, dtype, device)
+
+    def native():
+        return _native(q, k, q_weight, k_weight, freqs, eps)
+
+    def fused():
+        return _fused(q, k, q_weight, k_weight, freqs, eps)
+
+    results: dict[str, object] = {
+        "device": torch.cuda.get_device_name(),
+        "batch": args.batch,
+        "seq_len": args.seq_len,
+        "heads": args.heads,
+        "kv_heads": args.kv_heads,
+        "head_dim": args.head_dim,
+        "dtype": args.dtype,
+        "packed_qkv_view": args.packed_qkv_view,
+        "fused_fast_path_supported": _fused_cuda_supported(
+            q.reshape(args.batch * args.seq_len, args.heads, args.head_dim),
+            k.reshape(args.batch * args.seq_len, args.kv_heads, args.head_dim),
+            args.head_dim,
+            args.head_dim,
+            interleaved=True,
+        ),
+    }
+
+    native_samples = _measure(native, args.warmup, args.iters)
+    fused_samples = _measure(fused, args.warmup, args.iters)
+    expected_q, expected_k = native()
+    actual_q, actual_k = fused()
+    torch.accelerator.synchronize()
+
+    native_stats = _stats(native_samples)
+    fused_stats = _stats(fused_samples)
+    results["native"] = native_stats
+    results["fused"] = fused_stats
+    results["speedup_vs_native"] = native_stats["median_ms"] / fused_stats["median_ms"]
+    results["max_abs_q"] = (actual_q.float() - expected_q.float()).abs().max().item()
+    results["max_abs_k"] = (actual_k.float() - expected_k.float()).abs().max().item()
+    results["mean_abs_q"] = (actual_q.float() - expected_q.float()).abs().mean().item()
+    results["mean_abs_k"] = (actual_k.float() - expected_k.float()).abs().mean().item()
+
+    if args.include_compiled:
+        compiled_native = torch.compile(native, dynamic=True, fullgraph=True)
+        compiled_fused = torch.compile(fused, dynamic=True, fullgraph=True)
+        compiled_native_stats = _stats(_measure(compiled_native, args.warmup, args.iters))
+        compiled_fused_stats = _stats(_measure(compiled_fused, args.warmup, args.iters))
+        results["compiled_native"] = compiled_native_stats
+        results["compiled_fused"] = compiled_fused_stats
+        results["compiled_fused_speedup_vs_compiled_native"] = (
+            compiled_native_stats["median_ms"] / compiled_fused_stats["median_ms"]
+        )
+
+    print(json.dumps(results, indent=2))
+    if args.profile:
+        print("\n# fused profile")
+        print(_profile(fused))
+
+
+if __name__ == "__main__":
+    main()
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/host_weight_runtime/README.md b/benchmarks/host_weight_runtime/README.md
new file mode 100644
index 000000000..899811151
--- /dev/null
+++ b/benchmarks/host_weight_runtime/README.md
@@ -0,0 +1,57 @@
+# Host weight dependency memory diagnostic
+
+`safetensors_retention.py` isolates repeated CPU `get_tensor()` calls from
+access to one cached tensor view. It imports neither vLLM nor HWR and uses a
+synthetic float32 payload controlled by `--tensor-elements` (default: 64).
+Tensor size can affect retention: a negative result for 16 elements does not
+rule out growth for 64 elements. The selected size is recorded in the JSON
+arguments and used for both file creation and the correctness check.
+HWR itself calls `get_tensor()` when
+acquiring a lease, then exposes cached views; this probe does not measure HWR
+requests or repeated lease acquisition.
+
+Run one mode per fresh process in the same Python environment and CPU affinity:
+
+```bash
+git rev-parse HEAD > revision.txt
+git status --short > working-tree.txt
+git diff > working-tree.patch
+# Select an allowed CPU from your process affinity; 0 is only an example.
+CUDA_VISIBLE_DEVICES='' taskset -c 0 timeout 120s python \
+  benchmarks/host_weight_runtime/safetensors_retention.py \
+  --mode get_tensor --iterations 10000 --sample-every 5000 > feasibility.json
+```
+
+For a size comparison, run 16 and 64 elements twice each in fresh processes,
+with cached reuse as a control at both sizes:
+
+```bash
+for repetition in 1 2; do
+  for elements in 16 64; do
+    for mode in get_tensor reuse; do
+      CUDA_VISIBLE_DEVICES='' taskset -c 0 timeout 120s python \
+        benchmarks/host_weight_runtime/safetensors_retention.py \
+        --mode "$mode" --tensor-elements "$elements" \
+        > "$mode-$elements-$repetition.json"
+    done
+  done
+done
+```
+
+The diagnostic sets Torch to one CPU thread, warms up before the baseline,
+and reports preparation separately from timed loop work. Checkpoints run GC
+and report Linux private/anonymous memory, RSS, and open descriptors. It checks
+that transient tensor objects and the final cached view are released. Linux
+`/proc/self/smaps_rollup` must be readable; invalid arguments and missing proc
+support fail explicitly. Keep raw JSON and the repository snapshot with results.
+
+Compare the final loop sample with the warmed baseline, then inspect the closed
+sample. Private-memory growth after Python tensor objects disappear is evidence
+of retention in the dependency/allocator path, not proof of a leak's root cause.
+RSS can include file-backed pages; it is not a private-memory metric. Samples
+also include small diagnostic bookkeeping allocations. Do not assert a portable
+memory threshold or turn this synthetic loop into a per-request service estimate.
+
+Do not drop shared caches, trim allocators, or add serving-time GC to make the
+numbers look smaller. A dependency replacement or version change requires its
+own reproducible comparison and correctness/lifecycle validation.
diff --git a/benchmarks/host_weight_runtime/safetensors_retention.py b/benchmarks/host_weight_runtime/safetensors_retention.py
new file mode 100644
index 000000000..55795e7ef
--- /dev/null
+++ b/benchmarks/host_weight_runtime/safetensors_retention.py
@@ -0,0 +1,120 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Linux CPU diagnostic: repeated safetensors materialization versus view reuse."""
+
+from __future__ import annotations
+
+import argparse
+import gc
+import json
+import os
+import platform
+import tempfile
+import time
+import weakref
+from pathlib import Path
+
+
+def positive_int(value: str) -> int:
+    parsed = int(value)
+    if parsed <= 0:
+        raise argparse.ArgumentTypeError("must be positive")
+    return parsed
+
+
+def sample(phase: str, iterations: int, loop_seconds: float) -> dict[str, object]:
+    gc.collect()
+    counters = {}
+    for line in Path("/proc/self/smaps_rollup").read_text().splitlines():
+        fields = line.split()
+        if len(fields) == 3 and fields[2] == "kB":
+            counters[fields[0].removesuffix(":")] = int(fields[1]) * 1024
+    return {
+        "phase": phase,
+        "iterations": iterations,
+        "loop_seconds": loop_seconds,
+        "rss_bytes": counters["Rss"],
+        "private_bytes": counters["Private_Clean"] + counters["Private_Dirty"],
+        "anonymous_bytes": counters["Anonymous"],
+        "fd_count": len(tuple(Path("/proc/self/fd").iterdir())),
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--mode", choices=("get_tensor", "reuse"), required=True)
+    parser.add_argument(
+        "--tensor-elements", type=positive_int, default=64, help="Number of float32 elements in the synthetic tensor"
+    )
+    parser.add_argument("--iterations", type=positive_int, default=1_000_000)
+    parser.add_argument("--sample-every", type=positive_int, default=100_000)
+    parser.add_argument("--warmup", type=positive_int, default=1000)
+    args = parser.parse_args()
+    if not Path("/proc/self/smaps_rollup").is_file():
+        parser.error("requires Linux /proc/self/smaps_rollup")
+
+    preparation_start = time.monotonic()
+    import safetensors
+    import torch
+    from safetensors import safe_open
+    from safetensors.torch import save_file
+
+    torch.set_num_threads(1)
+    torch.set_num_interop_threads(1)
+    samples = [sample("before_file", 0, 0.0)]
+    with tempfile.TemporaryDirectory(prefix="safetensors-retention-") as directory:
+        path = Path(directory) / "synthetic.safetensors"
+        save_file({"weight": torch.arange(args.tensor_elements, dtype=torch.float32)}, str(path))
+        with safe_open(path, framework="pt", device="cpu") as reader:
+            cached = reader.get_tensor("weight")
+            assert torch.equal(cached, torch.arange(args.tensor_elements, dtype=torch.float32))
+            for _ in range(args.warmup):
+                tensor = reader.get_tensor("weight") if args.mode == "get_tensor" else cached
+                del tensor
+            samples.append(sample("baseline", 0, 0.0))
+            preparation_seconds = time.monotonic() - preparation_start
+            completed = 0
+            loop_seconds = 0.0
+            while completed < args.iterations:
+                count = min(args.sample_every, args.iterations - completed)
+                start = time.monotonic()
+                for _ in range(count):
+                    tensor = reader.get_tensor("weight") if args.mode == "get_tensor" else cached
+                last_tensor = weakref.ref(tensor)
+                del tensor
+                loop_seconds += time.monotonic() - start
+                completed += count
+                snapshot = sample("loop", completed, loop_seconds)
+                snapshot["last_tensor_alive"] = last_tensor() is not None
+                if args.mode == "get_tensor":
+                    assert last_tensor() is None, "diagnostic retained a transient tensor"
+                samples.append(snapshot)
+            del cached
+        del reader
+        samples.append(sample("closed", completed, loop_seconds))
+        assert last_tensor() is None, "last tensor survived reader/view teardown"
+
+    print(
+        json.dumps(
+            {
+                "schema_version": 1,
+                "arguments": vars(args),
+                "python": platform.python_version(),
+                "torch": torch.__version__,
+                "safetensors": safetensors.__version__,
+                "kernel": platform.release(),
+                "hostname": platform.node(),
+                "pid": os.getpid(),
+                "cpu_affinity": sorted(os.sched_getaffinity(0)),
+                "torch_threads": torch.get_num_threads(),
+                "pythonmalloc": os.environ.get("PYTHONMALLOC", "default"),
+                "preparation_seconds": preparation_seconds,
+                "samples": samples,
+            },
+            indent=2,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/benchmarks/kernels/bench_qwen_select01_modulation.py b/benchmarks/kernels/bench_qwen_select01_modulation.py
new file mode 100644
index 000000000..9a97c8de3
--- /dev/null
+++ b/benchmarks/kernels/bench_qwen_select01_modulation.py
@@ -0,0 +1,333 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Benchmark the Qwen-Image-Edit select01 modulation hot path.
+
+This script intentionally starts with the current PyTorch implementation. It is
+used as the before/after baseline for SGLang PR #20395/#21318 style fusion:
+
+* layernorm + scale/shift + binary select01 gate
+* residual + gated update + layernorm + scale/shift + binary select01 gate
+
+Run on a CUDA machine for actionable numbers, for example:
+
+    python benchmarks/kernels/bench_qwen_select01_modulation.py \
+        --device cuda --dtype bf16 --seq-lens 4096 8192 16384 \
+        --output-json /tmp/qwen_select01_baseline.json
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import statistics
+import sys
+import time
+from collections.abc import Callable
+from pathlib import Path
+
+import torch
+import torch.nn.functional as F
+
+for candidate in Path(__file__).resolve().parents:
+    if (candidate / "vllm_omni").is_dir():
+        if str(candidate) not in sys.path:
+            sys.path.insert(0, str(candidate))
+        break
+
+from vllm_omni.diffusion.layers.qwen_select01_modulation import (  # noqa: E402
+    fused_layernorm_select01,
+    fused_residual_layernorm_select01,
+)
+
+
+def _dtype(name: str) -> torch.dtype:
+    return {
+        "fp32": torch.float32,
+        "float32": torch.float32,
+        "fp16": torch.float16,
+        "float16": torch.float16,
+        "bf16": torch.bfloat16,
+        "bfloat16": torch.bfloat16,
+    }[name]
+
+
+def _select01_modulation(
+    mod_params: torch.Tensor,
+    index: torch.Tensor | None,
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    shift, scale, gate = mod_params.chunk(3, dim=-1)
+
+    if index is None:
+        return scale.unsqueeze(1), shift.unsqueeze(1), gate.unsqueeze(1)
+
+    actual_batch = shift.size(0) // 2
+    shift_0, shift_1 = shift[:actual_batch], shift[actual_batch:]
+    scale_0, scale_1 = scale[:actual_batch], scale[actual_batch:]
+    gate_0, gate_1 = gate[:actual_batch], gate[actual_batch:]
+
+    idx = index.unsqueeze(-1) == 0
+    shift = torch.where(idx, shift_0.unsqueeze(1), shift_1.unsqueeze(1))
+    scale = torch.where(idx, scale_0.unsqueeze(1), scale_1.unsqueeze(1))
+    gate = torch.where(idx, gate_0.unsqueeze(1), gate_1.unsqueeze(1))
+    return scale, shift, gate
+
+
+def _native_layernorm_select01(
+    x: torch.Tensor,
+    mod_params: torch.Tensor,
+    index: torch.Tensor,
+    eps: float,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    scale, shift, gate = _select01_modulation(mod_params, index)
+    out = F.layer_norm(x.float(), (x.shape[-1],), eps=eps).to(x.dtype)
+    return out * (1 + scale) + shift, gate
+
+
+def _native_residual_layernorm_select01(
+    x: torch.Tensor,
+    residual: torch.Tensor,
+    residual_gate: torch.Tensor,
+    mod_params: torch.Tensor,
+    index: torch.Tensor,
+    eps: float,
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    scale, shift, gate = _select01_modulation(mod_params, index)
+    residual_out = residual + residual_gate * x
+    out = F.layer_norm(residual_out.float(), (residual_out.shape[-1],), eps=eps).to(residual_out.dtype)
+    return out * (1 + scale) + shift, residual_out, gate
+
+
+def _time_cuda(fn: Callable[[], object], warmup: int, iters: int) -> list[float]:
+    for _ in range(warmup):
+        fn()
+    torch.accelerator.synchronize()
+
+    times: list[float] = []
+    for _ in range(iters):
+        start = torch.cuda.Event(enable_timing=True)
+        end = torch.cuda.Event(enable_timing=True)
+        start.record()
+        fn()
+        end.record()
+        torch.accelerator.synchronize()
+        times.append(float(start.elapsed_time(end)))
+    return times
+
+
+def _reset_peak_memory_stats(device: torch.device) -> None:
+    reset_peak_memory_stats = getattr(torch.accelerator, "reset_peak_memory_stats", None)
+    if reset_peak_memory_stats is None:
+        reset_peak_memory_stats = getattr(getattr(torch, device.type), "reset_peak_memory_stats")
+    reset_peak_memory_stats(device)
+
+
+def _max_memory_allocated(device: torch.device) -> int:
+    max_memory_allocated = getattr(torch.accelerator, "max_memory_allocated", None)
+    if max_memory_allocated is None:
+        max_memory_allocated = getattr(getattr(torch, device.type), "max_memory_allocated")
+    return int(max_memory_allocated(device))
+
+
+def _time_cpu(fn: Callable[[], object], warmup: int, iters: int) -> list[float]:
+    for _ in range(warmup):
+        fn()
+
+    times: list[float] = []
+    for _ in range(iters):
+        t0 = time.perf_counter()
+        fn()
+        times.append((time.perf_counter() - t0) * 1000.0)
+    return times
+
+
+def _summarize(times: list[float]) -> dict[str, float]:
+    ordered = sorted(times)
+    return {
+        "median_ms": statistics.median(ordered),
+        "min_ms": ordered[0],
+        "p20_ms": ordered[max(0, int(len(ordered) * 0.20) - 1)],
+        "p80_ms": ordered[min(len(ordered) - 1, int(len(ordered) * 0.80))],
+    }
+
+
+def _make_inputs(
+    batch: int,
+    seq_len: int,
+    hidden_size: int,
+    dtype: torch.dtype,
+    device: torch.device,
+) -> dict[str, torch.Tensor]:
+    torch.manual_seed(0)
+    return {
+        "x": torch.randn(batch, seq_len, hidden_size, device=device, dtype=dtype),
+        "residual": torch.randn(batch, seq_len, hidden_size, device=device, dtype=dtype),
+        "residual_gate": torch.randn(batch, 1, hidden_size, device=device, dtype=dtype),
+        "mod_params": torch.randn(batch * 2, hidden_size * 3, device=device, dtype=dtype),
+        "index": torch.randint(0, 2, (batch, seq_len), device=device, dtype=torch.int64),
+    }
+
+
+def _bench_one(
+    name: str,
+    fn: Callable[[], object],
+    device: torch.device,
+    warmup: int,
+    iters: int,
+) -> dict[str, object]:
+    if device.type == "cuda":
+        _reset_peak_memory_stats(device)
+        times = _time_cuda(fn, warmup, iters)
+        peak_memory_mb = _max_memory_allocated(device) / 1024**2
+    else:
+        times = _time_cpu(fn, warmup, iters)
+        peak_memory_mb = None
+
+    return {
+        "name": name,
+        **_summarize(times),
+        "peak_memory_mb": peak_memory_mb,
+    }
+
+
+def _run(args: argparse.Namespace) -> dict[str, object]:
+    device = torch.device(args.device)
+    if device.type == "cuda" and not torch.cuda.is_available():
+        raise SystemExit("CUDA is not available on this machine.")
+
+    dtype = _dtype(args.dtype)
+    rows: list[dict[str, object]] = []
+
+    for seq_len in args.seq_lens:
+        tensors = _make_inputs(args.batch_size, seq_len, args.hidden_size, dtype, device)
+        impls = ["native"] if args.impl == "native" else ["fused"] if args.impl == "fused" else ["native", "fused"]
+
+        def first_norm() -> object:
+            return _native_layernorm_select01(
+                tensors["x"],
+                tensors["mod_params"],
+                tensors["index"],
+                args.eps,
+            )
+
+        def residual_norm() -> object:
+            return _native_residual_layernorm_select01(
+                tensors["x"],
+                tensors["residual"],
+                tensors["residual_gate"],
+                tensors["mod_params"],
+                tensors["index"],
+                args.eps,
+            )
+
+        callables: list[tuple[str, Callable[[], object]]] = []
+        if "native" in impls:
+            callables.extend(
+                [
+                    ("native_layernorm_select01", first_norm),
+                    ("native_residual_layernorm_select01", residual_norm),
+                ]
+            )
+        if "fused" in impls:
+
+            def fused_first_norm() -> object:
+                return fused_layernorm_select01(
+                    tensors["x"],
+                    tensors["mod_params"],
+                    tensors["index"],
+                    args.eps,
+                )
+
+            def fused_residual_norm() -> object:
+                return fused_residual_layernorm_select01(
+                    tensors["x"],
+                    tensors["residual"],
+                    tensors["residual_gate"].expand_as(tensors["residual"]),
+                    tensors["mod_params"],
+                    tensors["index"],
+                    args.eps,
+                )
+
+            callables.extend(
+                [
+                    ("fused_layernorm_select01", fused_first_norm),
+                    ("fused_residual_layernorm_select01", fused_residual_norm),
+                ]
+            )
+
+        if args.check and "fused" in impls:
+            ref_norm, ref_gate = first_norm()
+            actual_norm, actual_gate = fused_layernorm_select01(
+                tensors["x"],
+                tensors["mod_params"],
+                tensors["index"],
+                args.eps,
+            )
+            torch.testing.assert_close(actual_norm, ref_norm, atol=args.check_atol, rtol=args.check_rtol)
+            torch.testing.assert_close(actual_gate, ref_gate, atol=0, rtol=0)
+            ref_norm, ref_residual, ref_gate = residual_norm()
+            actual_norm, actual_residual, actual_gate = fused_residual_layernorm_select01(
+                tensors["x"],
+                tensors["residual"],
+                tensors["residual_gate"].expand_as(tensors["residual"]),
+                tensors["mod_params"],
+                tensors["index"],
+                args.eps,
+            )
+            torch.testing.assert_close(actual_norm, ref_norm, atol=args.check_atol, rtol=args.check_rtol)
+            torch.testing.assert_close(actual_residual, ref_residual, atol=args.check_atol, rtol=args.check_rtol)
+            torch.testing.assert_close(actual_gate, ref_gate, atol=0, rtol=0)
+
+        for name, fn in callables:
+            row = _bench_one(name, fn, device, args.warmup, args.iters)
+            row.update(
+                {
+                    "batch_size": args.batch_size,
+                    "seq_len": seq_len,
+                    "hidden_size": args.hidden_size,
+                    "dtype": args.dtype,
+                    "device": str(device),
+                }
+            )
+            rows.append(row)
+            print(
+                f"{name:<38} B={args.batch_size:<2} L={seq_len:<6} C={args.hidden_size:<5} "
+                f"median={row['median_ms']:.4f} ms p20={row['p20_ms']:.4f} p80={row['p80_ms']:.4f}"
+            )
+
+    result = {
+        "benchmark": "qwen_select01_modulation",
+        "torch": torch.__version__,
+        "cuda_available": torch.cuda.is_available(),
+        "gpu": torch.cuda.get_device_name(device) if device.type == "cuda" else None,
+        "rows": rows,
+    }
+
+    if args.output_json:
+        output_path = Path(args.output_json)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        output_path.write_text(json.dumps(result, indent=2), encoding="utf-8")
+
+    return result
+
+
+def _parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    default_device = "cuda" if torch.cuda.is_available() else "cpu"
+    parser.add_argument("--device", default=default_device)
+    parser.add_argument("--dtype", default="bf16", choices=["fp32", "float32", "fp16", "float16", "bf16", "bfloat16"])
+    parser.add_argument("--batch-size", type=int, default=1)
+    parser.add_argument("--seq-lens", type=int, nargs="+", default=[4096, 8192, 16384])
+    parser.add_argument("--hidden-size", type=int, default=3072)
+    parser.add_argument("--eps", type=float, default=1e-6)
+    parser.add_argument("--warmup", type=int, default=20)
+    parser.add_argument("--iters", type=int, default=100)
+    parser.add_argument("--impl", choices=["native", "fused", "all"], default="native")
+    parser.add_argument("--check", action="store_true")
+    parser.add_argument("--check-atol", type=float, default=5e-2)
+    parser.add_argument("--check-rtol", type=float, default=5e-2)
+    parser.add_argument("--output-json")
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    _run(_parse_args())
diff --git a/benchmarks/kernels/benchmark_ming_istft.py b/benchmarks/kernels/benchmark_ming_istft.py
new file mode 100644
index 000000000..b67c9bbfc
--- /dev/null
+++ b/benchmarks/kernels/benchmark_ming_istft.py
@@ -0,0 +1,218 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Measure Ming ISTFT and optionally its pretrained streaming AudioVAE decoder.
+
+Example (no model weights needed for the operator benchmark):
+    python benchmarks/kernels/benchmark_ming_istft.py --compile --iterations 100
+
+Add --decoder to measure the published decoder with fixed synthetic latents.
+This is a decoder-stage benchmark, not text-to-speech serving latency.
+"""
+
+import argparse
+import json
+import statistics
+import time
+from collections.abc import Callable
+from functools import partial
+
+import torch
+
+from vllm_omni.model_executor.models.common.ming.audio_dsp import ISTFT
+from vllm_omni.model_executor.models.common.ming.fused_istft import fused_istft
+
+
+def measure(operation: Callable, warmup: int, iterations: int) -> dict:
+    for _ in range(warmup):
+        operation()
+    torch.accelerator.synchronize()
+    samples = []
+    for _ in range(iterations):
+        start = time.perf_counter()
+        operation()
+        torch.accelerator.synchronize()
+        samples.append((time.perf_counter() - start) * 1000)
+    torch.accelerator.reset_peak_memory_stats()
+    before = torch.accelerator.memory_allocated()
+    operation()
+    torch.accelerator.synchronize()
+    return {
+        "p50_ms": statistics.median(samples),
+        "min_ms": min(samples),
+        "max_ms": max(samples),
+        "stdev_ms": statistics.pstdev(samples),
+        "extra_peak_mib": (torch.accelerator.max_memory_allocated() - before) / 1024**2,
+    }
+
+
+def native_post_fft(module, frames, audio, window):
+    """The native middle-chunk post-FFT sequence, isolated from cuFFT."""
+    count = frames.shape[-1]
+    size = (count - 1) * module.hop_length + module.win_length
+
+    def fold(value):
+        return torch.nn.functional.fold(
+            value, output_size=(1, size), kernel_size=(1, module.win_length), stride=(1, module.hop_length)
+        )[:, 0, 0, :]
+
+    samples = fold(frames * module.window[None, :, None])
+    samples, audio = module._buffer_process(samples, audio, 0, streaming=True)
+    envelope = fold(module.window.square().expand(1, count, -1).transpose(1, 2))
+    envelope, window = module._buffer_process(envelope, window, 0, streaming=True)
+    if not (envelope > 1e-11).all():
+        raise RuntimeError("ISTFT window envelope underflowed; invalid overlap-add state.")
+    return samples / envelope, audio, window
+
+
+def assert_outputs(actual, reference):
+    maximum = 0.0
+    for value, expected in zip(actual, reference, strict=True):
+        if expected is None:
+            assert value is None
+        else:
+            torch.testing.assert_close(value, expected, atol=5e-7, rtol=1e-5)
+            maximum = max(maximum, (value - expected).abs().max().item())
+    return maximum
+
+
+def benchmark_istft(args):
+    for dtype in (torch.float32, torch.bfloat16):
+        module = ISTFT(3528, 882, 3528).to(device="cuda", dtype=dtype)
+        for count in (16, 100, 400):
+            spec = torch.randn(1, 1765, count, device="cuda", dtype=torch.complex64)
+            _, audio, window = module.forward_native(spec, streaming=True)
+            frames = torch.fft.irfft(spec, 3528, dim=1)
+            for scope in ("post_fft", "istft"):
+                if scope == "post_fft":
+                    native = partial(native_post_fft, module, frames, audio, window)
+                    fused = partial(fused_istft, frames, module.window, 882, audio, window, True, False)
+                else:
+                    native = partial(module.forward_native, spec, audio, window, streaming=True)
+                    fused = partial(module, spec, audio, window, streaming=True)
+                error = assert_outputs(fused(), native())
+                results = {"native": measure(native, args.warmup, args.iterations)}
+                if args.compile:
+                    compiled = torch.compile(native)
+                    compiled_output, reference = compiled(), native()
+                    # Inductor can change BF16 envelope rounding. Report that
+                    # difference without weakening the fused-kernel parity gate.
+                    compiled_matches = all(
+                        torch.allclose(value, expected, atol=5e-7, rtol=1e-5)
+                        for value, expected in zip(compiled_output, reference, strict=True)
+                    )
+                    results["compiled"] = measure(compiled, args.warmup, args.iterations)
+                    results["compiled"]["matches_native_tolerance"] = compiled_matches
+                    results["compiled"]["waveform_max_abs_error"] = (
+                        (compiled_output[0] - reference[0]).abs().max().item()
+                    )
+                results["fused"] = measure(fused, args.warmup, args.iterations)
+                print(
+                    json.dumps(
+                        {
+                            "scope": scope,
+                            "window_dtype": str(dtype),
+                            "frames": count,
+                            "max_abs_error": error,
+                            "results": results,
+                        }
+                    ),
+                    flush=True,
+                )
+
+
+def benchmark_decoder(args):
+    from huggingface_hub import hf_hub_download
+    from safetensors import safe_open
+
+    from vllm_omni.model_executor.models.common.ming.audio_vae import Decoder
+
+    model = "inclusionAI/Ming-omni-tts-0.5B"
+    revision = "9154772e7fbc585907b6237e3190790676f28975"
+    config_path = hf_hub_download(model, "config.json", revision=revision)
+    with open(config_path) as source:
+        config = json.load(source)["audio_tokenizer_config"]
+    kwargs = config["dec_kwargs"]
+    backbone = kwargs["backbone"]
+    backbone["_attn_implementation"] = "sdpa"
+    decoder = Decoder(backbone, kwargs["output_dim"], kwargs["latent_dim"], config["patch_size"])
+    checkpoint = hf_hub_download(model, "model.safetensors", revision=revision)
+    prefix = "audio.decoder."
+    with safe_open(checkpoint, framework="pt") as weights:
+        state = {key.removeprefix(prefix): weights.get_tensor(key) for key in weights.keys() if key.startswith(prefix)}
+    decoder.load_state_dict(state, strict=True)
+    decoder = decoder.eval().to(device="cuda", dtype=torch.bfloat16)
+    chunks = [
+        torch.randn(1, size, kwargs["latent_dim"], device="cuda", dtype=torch.bfloat16) for size in (4, 25, 25, 5)
+    ]
+    istft = decoder.head.istft
+    fused_forward = istft.forward
+
+    def run():
+        cache = state = None
+        outputs = []
+        for index, chunk in enumerate(chunks):
+            output, state, cache = decoder.low_level_reconstruct(
+                chunk, past_key_values=cache, use_cache=True, stream_state=state, last_chunk=index == len(chunks) - 1
+            )
+            outputs.append(output)
+        return torch.cat(outputs, dim=-1)
+
+    istft.forward = istft.forward_native
+    expected = run()
+    istft.forward = fused_forward
+    actual = run()
+    torch.testing.assert_close(actual, expected, atol=5e-7, rtol=1e-5)
+    # Alternate the order to expose drift when the decoder-level gain is small.
+    results = {"native": [], "fused": []}
+    for order in (("native", "fused"), ("fused", "native"), ("native", "fused")):
+        for name in order:
+            istft.forward = istft.forward_native if name == "native" else fused_forward
+            results[name].append(measure(run, args.warmup, args.decoder_iterations))
+    print(
+        json.dumps(
+            {
+                "scope": "pretrained_decoder",
+                "model": model,
+                "revision": revision,
+                "backend": "sdpa",
+                "dtype": "bfloat16",
+                "latent_chunks": [4, 25, 25, 5],
+                "max_abs_error": (actual - expected).abs().max().item(),
+                "results": results,
+            }
+        ),
+        flush=True,
+    )
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--warmup", type=int, default=20)
+    parser.add_argument("--iterations", type=int, default=100)
+    parser.add_argument("--compile", action="store_true")
+    parser.add_argument("--decoder", action="store_true")
+    parser.add_argument("--decoder-iterations", type=int, default=30)
+    args = parser.parse_args()
+    if args.warmup < 0 or min(args.iterations, args.decoder_iterations) < 1:
+        parser.error("warmup must be nonnegative and iteration counts must be positive")
+    torch.manual_seed(0)
+    print(
+        json.dumps(
+            {
+                "torch": torch.__version__,
+                "cuda": torch.version.cuda,
+                "gpu": torch.cuda.get_device_name(),
+                "warmup": args.warmup,
+                "iterations": args.iterations,
+                "decoder_iterations": args.decoder_iterations,
+            }
+        )
+    )
+    with torch.inference_mode():
+        benchmark_istft(args)
+        if args.decoder:
+            benchmark_decoder(args)
+
+
+if __name__ == "__main__":
+    main()
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/qwen2_5_omni/README.md b/benchmarks/qwen2_5_omni/README.md
new file mode 100644
index 000000000..c8aea8980
--- /dev/null
+++ b/benchmarks/qwen2_5_omni/README.md
@@ -0,0 +1,66 @@
+# Qwen2.5-Omni embedding microbenchmark
+
+Measure the host-observed latency of `embed_input_ids` before and after the
+redundant text embedding removal in PR #7477. Both variants use the same real
+checkpoint embedding table, dependencies, inputs and batch shapes. The baseline
+wrapper is extracted from the specified Git commit; the fixed wrapper comes from
+the current checkout. No full model is initialized.
+
+## Run
+
+Use Linux, a CUDA GPU, the project dependencies, and a local
+`Qwen/Qwen2.5-Omni-7B` checkpoint with its safetensors index and weights.
+From the repository root:
+
+```bash
+git fetch origin 01a2f93256975c7ff9565c5414b0fe0225bc4765
+PYTHONPATH="$PWD" OMP_NUM_THREADS=1 python benchmarks/qwen2_5_omni/benchmark_embeddings.py \
+  --model /path/to/Qwen2.5-Omni-7B \
+  --baseline-ref 01a2f93256975c7ff9565c5414b0fe0225bc4765 \
+  --cpu-core 2 --lengths 1172 --warmup 50 --blocks 20 --iterations 20 \
+  --output-dir /tmp/qwen25-embedding-results
+```
+
+Choose a CPU core in your allowed affinity set. For the original CUDA length
+sweep, use `--lengths 512 1172 4096 16384`.
+
+## Method
+
+- BF16 checkpoint embeddings, TP=1, CUDA int32 token IDs, CPU multimodal masks.
+- One pinned CPU core, one PyTorch thread, garbage collection disabled.
+- 50 warmups per variant, then 20 paired blocks of 20 calls with balanced,
+  randomized variant order. Summary: median of block medians.
+- Host latency includes synchronization inside the wrapper. Explicit GPU
+  synchronization before and after the timed call is excluded from host latency.
+  Calling-thread CPU time and synchronized completion time are recorded separately.
+- CPU frequency is sampled at block boundaries; clocks are not locked.
+- Validation checks one text embedding call for the fixed wrapper, two for the
+  multimodal baseline, and `torch.equal` for identical inputs and batch shapes.
+  This does not establish batch invariance or full-model output equality.
+
+Interleaved audio/video uses a valid synthetic multimodal mask. This benchmark
+measures wrapper latency, not E2E throughput.
+
+## Reference results
+
+Original environment: H100 80GB; Python 3.12.3; vLLM 0.29.0+cu129;
+PyTorch 2.13.0+cu129; Transformers 5.14.0; Qwen2.5-Omni-7B BF16.
+At 1172 tokens, the September 13 measurements were:
+
+| Input | Before (μs) | After (μs) | Host latency reduction |
+| --- | ---: | ---: | ---: |
+| Text | 18.81 | 18.66 | 0.80% |
+| Audio | 104.32 | 85.30 | 18.23% |
+| Image | 104.72 | 86.27 | 17.62% |
+| Video | 104.73 | 85.76 | 18.11% |
+| Audio + image + video | 567.92 | 549.54 | 3.24% |
+| Interleaved audio/video | 622.76 | 597.84 | 4.00% |
+
+Results vary between runs and environments. These local savings did not produce
+a consistent E2E throughput improvement in the separate repeated E2E experiment.
+
+## Output
+
+The output directory contains `metadata.json`, `micro-raw.json`,
+`validation.json`, and `summary.json`. Raw records include per-call timings,
+block timestamps and CPU frequency samples. Timer overhead is measured separately.
diff --git a/benchmarks/qwen2_5_omni/benchmark_embeddings.py b/benchmarks/qwen2_5_omni/benchmark_embeddings.py
new file mode 100644
index 000000000..1a5b32435
--- /dev/null
+++ b/benchmarks/qwen2_5_omni/benchmark_embeddings.py
@@ -0,0 +1,306 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Reproduce PR #7477 host-observed embedding-wrapper latency on one CUDA GPU.
+
+Run from the PR checkout with PYTHONPATH=$PWD. Baseline and fixed methods share
+weights and inputs. Only the historical wrapper is loaded from --baseline-ref.
+"""
+
+import argparse
+import ast
+import gc
+import json
+import os
+import random
+import statistics
+import subprocess
+import textwrap
+import time
+from pathlib import Path
+
+import torch
+from safetensors import safe_open
+from torch import nn
+from transformers import Qwen2_5OmniThinkerConfig
+from vllm.model_executor.layers.vocab_parallel_embedding import VocabParallelEmbedding
+from vllm.multimodal.utils import set_mm_embedding_modality
+
+from vllm_omni.model_executor.models.qwen2_5_omni.qwen2_5_omni_thinker import (
+    Qwen2_5OmniThinkerForConditionalGeneration as Thinker,
+)
+from vllm_omni.platforms import current_omni_platform
+
+
+def baseline_method(cls, ref):
+    path = "vllm_omni/model_executor/models/qwen2_5_omni/qwen2_5_omni_thinker.py"
+    source = subprocess.check_output(
+        ["git", "-C", str(Path(__file__).resolve().parents[2]), "show", f"{ref}:{path}"], text=True
+    )
+    tree = ast.parse(source)
+    owner = next(n for n in tree.body if isinstance(n, ast.ClassDef) and n.name == cls.__name__)
+    node = next(n for n in owner.body if isinstance(n, ast.FunctionDef) and n.name == "embed_input_ids")
+    method = textwrap.dedent(ast.get_source_segment(source, node))
+    # Preserve zero-argument super() against the real model class and MRO.
+    factory = "from __future__ import annotations\ndef make_method(cls):\n    __class__ = cls\n"
+    factory += textwrap.indent(method, "    ") + "\n    return embed_input_ids\n"
+    namespace = dict(cls.embed_input_ids.__globals__)
+    exec(compile(factory, f"{ref}:{path}", "exec"), namespace)
+    return namespace["make_method"](cls)
+
+
+parser = argparse.ArgumentParser(description=__doc__)
+parser.add_argument("--model", type=Path, required=True)
+parser.add_argument("--baseline-ref", default="01a2f93256975c7ff9565c5414b0fe0225bc4765")
+parser.add_argument("--cpu-core", type=int, default=sorted(os.sched_getaffinity(0))[0])
+parser.add_argument("--lengths", type=int, nargs="+", default=[1172])
+parser.add_argument("--warmup", type=int, default=50)
+parser.add_argument("--blocks", type=int, default=20)
+parser.add_argument("--iterations", type=int, default=20)
+parser.add_argument("--output-dir", type=Path, default=Path("micro-results"))
+args = parser.parse_args()
+if min(args.lengths) < 300 or min(args.blocks, args.iterations) < 1 or args.warmup < 0:
+    parser.error("Require lengths >= 300, positive blocks/iterations, and nonnegative warmup")
+if args.cpu_core not in os.sched_getaffinity(0):
+    parser.error("CPU core is outside the allowed affinity set")
+ROOT, MODEL, CORE = args.output_dir, args.model, args.cpu_core
+ROOT.mkdir(parents=True, exist_ok=True)
+CONFIG = json.loads((MODEL / "config.json").read_text())["thinker_config"]
+HIDDEN = CONFIG["text_config"]["hidden_size"]
+VOCAB = CONFIG["text_config"]["vocab_size"]
+IDS = {m: CONFIG[m + "_token_index"] for m in ("audio", "image", "video")}
+METHODS = {"baseline": baseline_method(Thinker, args.baseline_ref), "fixed": Thinker.embed_input_ids}
+RESULTS, VALIDATIONS = [], []
+os.sched_setaffinity(0, {CORE})
+torch.set_num_threads(1)
+torch.set_num_interop_threads(1)
+gc.disable()
+
+
+def cpu_frequency():
+    path = Path(f"/sys/devices/system/cpu/cpu{CORE}/cpufreq/scaling_cur_freq")
+    if path.exists():
+        return float(path.read_text()) / 1000
+    for section in Path("/proc/cpuinfo").read_text().split("\n\n"):
+        fields = dict(line.split(":", 1) for line in section.splitlines() if ":" in line)
+        fields = {k.strip(): v.strip() for k, v in fields.items()}
+        if fields.get("processor") == str(CORE):
+            return float(fields.get("cpu MHz", "nan"))
+
+
+def payload(case, length, device):
+    generator = torch.Generator().manual_seed(7451 + length)
+    ids = torch.randint(2, 10000, (length,), generator=generator)
+    specs = {
+        "text": [],
+        "audio": [("audio", 100)],
+        "image": [("image", 16)],
+        "video": [("video", 128)],
+        "mixed": [("audio", 100), ("image", 16), ("video", 128)],
+        "interleaved": [("video", 64), ("audio", 50), ("video", 64), ("audio", 50)],
+    }[case]
+    offset = 44
+    counts = {}
+    for modality, count in specs:
+        ids[offset : offset + count] = IDS[modality]
+        counts[modality] = counts.get(modality, 0) + count
+        offset += count + (0 if case == "interleaved" else 2)
+    mask = torch.zeros(length, dtype=torch.bool)
+    for token in IDS.values():
+        mask |= ids == token
+    mm = [
+        set_mm_embedding_modality(torch.full((count, HIDDEN), i + 1, device=device, dtype=torch.bfloat16), modality)
+        for i, (modality, count) in enumerate(counts.items())
+    ]
+    return ids.to(device=device, dtype=torch.int32), None if case == "text" else mm, None if case == "text" else mask
+
+
+def once(fn, cuda):
+    # Drain preceding work before the host timer; the production function's
+    # own D2H synchronizations remain inside the timed call.
+    if cuda:
+        current_omni_platform.synchronize()
+    w0 = time.perf_counter_ns()
+    c0 = time.thread_time_ns()
+    value = fn()
+    c1 = time.thread_time_ns()
+    w1 = time.perf_counter_ns()
+    if cuda:
+        current_omni_platform.synchronize()
+    w2 = time.perf_counter_ns() if cuda else w1
+    del value
+    return [(w1 - w0) / 1000, (c1 - c0) / 1000, (w2 - w0) / 1000]
+
+
+def measure(functions, device, case, length, scope, rounds=20, iterations=20, warmups=50):
+    cuda = device == "cuda"
+    for fn in functions.values():
+        for _ in range(warmups):
+            once(fn, cuda)
+    order_rng = random.Random(7451 + length + len(case) + len(scope))
+    directions = [i % 2 for i in range(rounds)]
+    order_rng.shuffle(directions)
+    names = list(functions)
+    for block, direction in enumerate(directions):
+        order = names if direction == 0 else names[::-1]
+        for name in order:
+            frequency_start = cpu_frequency()
+            wall_start = time.time()
+            samples = [once(functions[name], cuda) for _ in range(iterations)]
+            wall_end = time.time()
+            RESULTS.append(
+                dict(
+                    device=device,
+                    case=case,
+                    tokens=length,
+                    scope=scope,
+                    variant=name,
+                    block=block,
+                    iterations=iterations,
+                    samples_us=samples,
+                    wall_start=wall_start,
+                    wall_end=wall_end,
+                    cpu_mhz_start=frequency_start,
+                    cpu_mhz_end=cpu_frequency(),
+                )
+            )
+    (ROOT / "micro-raw.json").write_text(json.dumps(RESULTS))
+    current = [r for r in RESULTS if (r["device"], r["case"], r["tokens"], r["scope"]) == (device, case, length, scope)]
+    print(
+        "RESULT",
+        json.dumps(
+            {
+                "device": device,
+                "case": case,
+                "tokens": length,
+                "scope": scope,
+                "host_median_us": {
+                    v: statistics.median(t[0] for r in current if r["variant"] == v for t in r["samples_us"])
+                    for v in names
+                },
+            }
+        ),
+        flush=True,
+    )
+
+
+def build_model(weights, device):
+    model = Thinker.__new__(Thinker)
+    nn.Module.__init__(model)
+    model.config = Qwen2_5OmniThinkerConfig(**CONFIG)
+    model._has_oov_mm_tokens = False
+    table = VocabParallelEmbedding(VOCAB, HIDDEN, params_dtype=torch.bfloat16, disable_tp=True)
+    table.weight = nn.Parameter(weights.to(device), requires_grad=False)
+
+    class LM(nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.embed_tokens = table
+
+        def embed_input_ids(self, ids):
+            return self.embed_tokens(ids)
+
+    model.language_model = LM()
+    return model
+
+
+def validate(model, args, case, length, device):
+    ids, mm, mask = args
+    lm = model.get_language_model()
+    original = lm.embed_input_ids
+    outputs, counts = {}, {}
+    for variant, method in METHODS.items():
+        calls = []
+
+        def counted(tokens):
+            calls.append(tokens.numel())
+            return original(tokens)
+
+        lm.embed_input_ids = counted
+        try:
+            outputs[variant] = method(model, ids, mm, is_multimodal=mask)
+        finally:
+            lm.embed_input_ids = original
+        counts[variant] = len(calls)
+    assert torch.equal(outputs["baseline"], outputs["fixed"])
+    assert counts == {"baseline": 1 if case == "text" else 2, "fixed": 1}
+    VALIDATIONS.append(dict(case=case, tokens=length, device=device, calls=counts, same_input_wrapper_torch_equal=True))
+    (ROOT / "validation.json").write_text(json.dumps(VALIDATIONS, indent=2))
+
+
+@torch.inference_mode()
+def main():
+    import transformers
+    import vllm
+
+    metadata = dict(
+        baseline_ref=args.baseline_ref,
+        checkout=subprocess.check_output(["git", "rev-parse", "HEAD"], text=True).strip(),
+        torch=torch.__version__,
+        vllm=vllm.__version__,
+        transformers=transformers.__version__,
+        gpu=torch.cuda.get_device_name(),
+        cpu_core=CORE,
+        torch_cpu_threads=1,
+        warmup=args.warmup,
+        blocks=args.blocks,
+        iterations=args.iterations,
+        lengths=args.lengths,
+        embedding_shape=[VOCAB, HIDDEN],
+        dtype="bfloat16",
+        input_ids_dtype="int32",
+        mask_device="cpu",
+        start_time=time.time(),
+        metric_order=["host_observed_us", "calling_thread_cpu_us", "synchronized_completion_us"],
+    )
+    index = json.loads((MODEL / "model.safetensors.index.json").read_text())["weight_map"]
+    key = "thinker.model.embed_tokens.weight"
+    with safe_open(MODEL / index[key], framework="pt", device="cpu") as f:
+        weights = f.get_tensor(key)
+    assert weights.shape == (VOCAB, HIDDEN) and weights.dtype == torch.bfloat16
+    model = build_model(weights, "cuda")
+    measure({"timer_floor": lambda: None}, "cuda", "timer", 0, "overhead", rounds=10, iterations=100)
+    for length in args.lengths:
+        for case in ("text", "audio", "image", "video", "mixed", "interleaved"):
+            ids, mm, mask = payload(case, length, "cuda")
+            validate(model, (ids, mm, mask), case, length, "cuda")
+            functions = {
+                variant: (lambda method=method: method(model, ids, mm, is_multimodal=mask))
+                for variant, method in METHODS.items()
+            }
+            measure(
+                functions,
+                "cuda",
+                case,
+                length,
+                "whole_wrapper",
+                rounds=args.blocks,
+                iterations=args.iterations,
+                warmups=args.warmup,
+            )
+    summary = []
+    for length in args.lengths:
+        for case in ("text", "audio", "image", "video", "mixed", "interleaved"):
+            medians = {
+                variant: statistics.median(
+                    statistics.median(sample[0] for sample in record["samples_us"])
+                    for record in RESULTS
+                    if record["tokens"] == length and record["case"] == case and record["variant"] == variant
+                )
+                for variant in METHODS
+            }
+            summary.append(
+                dict(
+                    tokens=length,
+                    case=case,
+                    host_us=medians,
+                    reduction_pct=100 * (1 - medians["fixed"] / medians["baseline"]),
+                )
+            )
+    metadata["end_time"] = time.time()
+    (ROOT / "metadata.json").write_text(json.dumps(metadata, indent=2))
+    (ROOT / "summary.json").write_text(json.dumps(summary, indent=2))
+    print(json.dumps(summary, indent=2))
+
+
+if __name__ == "__main__":
+    main()
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.cuda b/docker/Dockerfile.cuda
index 3881ca2e5..072b12dfa 100644
--- a/docker/Dockerfile.cuda
+++ b/docker/Dockerfile.cuda
@@ -1,4 +1,4 @@
-ARG BASE_IMAGE=vllm/vllm-openai:v0.28.0
+ARG BASE_IMAGE=vllm/vllm-openai:v0.29.0
 FROM ${BASE_IMAGE}
 
 ARG COMMON_WORKDIR=/app
diff --git a/docker/Dockerfile.npu b/docker/Dockerfile.npu
index 0d91c0b32..f83cc512a 100644
--- a/docker/Dockerfile.npu
+++ b/docker/Dockerfile.npu
@@ -1,5 +1,5 @@
 ARG VLLM_ASCEND_IMAGE=quay.io/atlas-ci/vllm-ascend
-ARG VLLM_ASCEND_VERSION=v0.28.0
+ARG VLLM_ASCEND_VERSION=v0.29.0
 ARG VLLM_ASCEND_DEVICE_SUFFIX=
 FROM ${VLLM_ASCEND_IMAGE}:${VLLM_ASCEND_VERSION}${VLLM_ASCEND_DEVICE_SUFFIX}
 
diff --git a/docker/Dockerfile.npu.ci b/docker/Dockerfile.npu.ci
index 0a150fdd8..a25155111 100644
--- a/docker/Dockerfile.npu.ci
+++ b/docker/Dockerfile.npu.ci
@@ -1,5 +1,5 @@
 ARG VLLM_ASCEND_IMAGE=quay.io/atlas-ci/vllm-ascend
-ARG VLLM_ASCEND_VERSION=v0.28.0
+ARG VLLM_ASCEND_VERSION=v0.29.0
 ARG VLLM_ASCEND_DEVICE_SUFFIX=
 FROM ${VLLM_ASCEND_IMAGE}:${VLLM_ASCEND_VERSION}${VLLM_ASCEND_DEVICE_SUFFIX}
 
@@ -44,6 +44,7 @@ RUN python3 -m pip install -U pip && \
       "onnx>=1.16.0" \
       "librosa>=0.10.0" \
       "datasets>=3.0.0" \
+      "torchmetrics==1.9.0" \
       --index-url http://cache-service.nginx-pypi-cache.svc.cluster.local/pypi/simple \
       --trusted-host cache-service.nginx-pypi-cache.svc.cluster.local \
       --default-timeout=60
diff --git a/docker/Dockerfile.rocm b/docker/Dockerfile.rocm
index 597f5d134..48631994f 100644
--- a/docker/Dockerfile.rocm
+++ b/docker/Dockerfile.rocm
@@ -1,16 +1,22 @@
-ARG BASE_IMAGE=vllm/vllm-openai-rocm:v0.28.0
-FROM ${BASE_IMAGE} AS base
+# Keep the ROCm runtime aligned with the vLLM release targeted by
+# 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
+
+# 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
 
-# Declare a variable to know if we want to use the nightly build or the stable build.
 # NOTE: REMINDER to vLLM-Omni rebase maintainer
-# Remember to set `USE_NIGHTLY_BUILD` to 0, when switching back to stable vLLM docker image
-# 1. If vLLM-omni maintainer is forced to use custom commits
-#    during rebasing, they can change the two variables
-# 2. Whenever vLLM upstream has released a stable version,
-#    we should swap over to use stable release ASAP.
-#    We should avoid relying on custom commits.
+# BASE_IMAGE pins the default prebuilt runtime when USE_NIGHTLY_BUILD=0.
+# VLLM_VERSION_OR_COMMIT_HASH is consumed only by the opt-in source rebuild when
+# USE_NIGHTLY_BUILD=1. Keep both aligned with docker/Dockerfile.ci's
+# VLLM_BASE_TAG. This is enforced by tests/buildkite/test_rocm_dockerfile.py. An
+# intentional custom source pin must update that regression in the same change,
+# and should return to the stable release as soon as one is available.
 ARG USE_NIGHTLY_BUILD=0
-ARG VLLM_VERSION_OR_COMMIT_HASH=v0.28.0
+ARG VLLM_VERSION_OR_COMMIT_HASH=v0.29.0
 ARG ARG_PYTORCH_ROCM_ARCH
 ENV PYTORCH_ROCM_ARCH=${ARG_PYTORCH_ROCM_ARCH:-${PYTORCH_ROCM_ARCH}}
 
@@ -38,6 +44,10 @@ RUN if [ "${USE_NIGHTLY_BUILD}" = "1" ]; then \
         rm -rf vllm/.git; \
     fi
 
+# Fail during image construction instead of letting every AMD test fail at
+# runtime when the base image and vLLM-Omni target incompatible vLLM APIs.
+RUN python3 -c "import vllm; from vllm.v1.kv_cache_interface import compute_layout_strides; from vllm.v1.kv_cache_layout import KVCacheLayout; print(f'Validated vLLM {vllm.__version__}')"
+
 # Build TorchCodec after any optional nightly vLLM reinstall so it targets the
 # final torch/ROCm ABI. Keep this layer before COPY . so source changes do not
 # invalidate the expensive native build. FFmpeg development headers are
@@ -58,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' \
@@ -79,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 acfa71588..da7930ae2 100644
--- a/docker/Dockerfile.xpu
+++ b/docker/Dockerfile.xpu
@@ -1,4 +1,4 @@
-# Target vLLM version: v0.28.0. Keep VLLM_VERSION aligned with the target vLLM
+# Target vLLM version: v0.29.0. Keep VLLM_VERSION aligned with the target vLLM
 # release on every rebase.
 #
 # This file layers vLLM-Omni on top of the published upstream XPU image, which
@@ -18,7 +18,7 @@
 #
 # .buildkite/intel/scripts/run-xpu-test.sh automates that pull-then-build fallback.
 ARG VLLM_BASE_IMAGE=vllm/vllm-openai-xpu
-ARG VLLM_VERSION=v0.28.0
+ARG VLLM_VERSION=v0.29.0
 ARG VLLM_BASE=${VLLM_BASE_IMAGE}:${VLLM_VERSION}
 
 FROM ${VLLM_BASE} AS vllm-omni
@@ -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 aa84f2819..da55af813 100644
--- a/docs/.nav.yml
+++ b/docs/.nav.yml
@@ -71,6 +71,7 @@ nav:
       - Overview and Compatibility:
         - Overview: user_guide/diffusion_features.md
         - Feature Compatibility: user_guide/feature_compatibility.md
+      - Device-side Video Postprocessing: user_guide/diffusion/device_side_video_postprocess.md
       - CPU Offloading:
         - Overview: user_guide/diffusion/cpu_offload.md
         - Model-Level: user_guide/diffusion/offloader/module_offload.md
@@ -135,6 +136,7 @@ nav:
           - Mooncake Store Connector: design/feature/omni_connectors/mooncake_store_connector.md
           - Mooncake Transfer Engine Connector: design/feature/omni_connectors/mooncake_transfer_engine_connector.md
           - Mori Transfer Engine Connector: design/feature/omni_connectors/mori_transfer_engine_connector.md
+          - NIXL Connector: design/feature/omni_connectors/nixl_connector.md
           - Shared Memory Connector: design/feature/omni_connectors/shared_memory_connector.md
           - Yuanrong Store Connector: design/feature/omni_connectors/yuanrong_connector.md
           - Yuanrong Transfer Engine Connector: design/feature/omni_connectors/yuanrong_transfer_engine_connector.md
@@ -159,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/api/README.md b/docs/api/README.md
index b2d4ea1ba..db760506e 100644
--- a/docs/api/README.md
+++ b/docs/api/README.md
@@ -5,6 +5,9 @@
 Main entry points for vLLM-Omni inference and serving.
 
 - [vllm_omni.entrypoints.async_omni.AsyncOmni][]
+- [vllm_omni.entrypoints.async_omni_base.AsyncOmniBase][]
+- [vllm_omni.entrypoints.duplex_omni.DuplexOmni][]
+- [vllm_omni.entrypoints.duplex_omni.DuplexSessionHandle][]
 - [vllm_omni.engine.cfg_companion_tracker.CfgCompanionTracker][]
 - [vllm_omni.entrypoints.cli.benchmark.base.OmniBenchmarkSubcommandBase][]
 - [vllm_omni.entrypoints.cli.benchmark.main.OmniBenchmarkSubcommand][]
@@ -17,12 +20,13 @@ Main entry points for vLLM-Omni inference and serving.
 
 ## Clients
 
-Client libraries that talk to a running vLLM-Omni server (the full-duplex Realtime client and its per-model session presets).
+Client libraries for full-duplex sessions: the Realtime WebSocket client, the in-process client over `DuplexOmni`, and the per-model session presets.
 
 - [vllm_omni.clients.duplex.AudioDelta][]
 - [vllm_omni.clients.duplex.AudioFormat][]
 - [vllm_omni.clients.duplex.ConnectionResumed][]
 - [vllm_omni.clients.duplex.DuplexClient][]
+- [vllm_omni.clients.duplex.DuplexClientBase][]
 - [vllm_omni.clients.duplex.DuplexClientError][]
 - [vllm_omni.clients.duplex.DuplexConnectionError][]
 - [vllm_omni.clients.duplex.DuplexEvent][]
@@ -44,6 +48,7 @@ Client libraries that talk to a running vLLM-Omni server (the full-duplex Realti
 - [vllm_omni.clients.duplex.TextDelta][]
 - [vllm_omni.clients.duplex.TranscriptDelta][]
 - [vllm_omni.clients.duplex.WebSocketTransport][]
+- [vllm_omni.clients.inline_duplex.InlineDuplexClient][]
 
 ## Inputs
 
diff --git a/docs/assets/WeChat.jpg b/docs/assets/WeChat.jpg
index 0e91feee5..f55fa90f3 100644
Binary files a/docs/assets/WeChat.jpg and b/docs/assets/WeChat.jpg differ
diff --git a/docs/cli/bench/serve.md b/docs/cli/bench/serve.md
index a162c001a..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.
@@ -316,8 +318,12 @@ arrives, checkpointing the response's history position so a later committed user
 outputs are ineligible and omitted from the official manifest; `audio_clipped_bytes` records output beyond the rounded video
 horizon.
 
-TTFT, TTFP, and RTF start at client receipt of `response.created`. TPOT/ITL use engine stage-0 timing; ITL is emitted only when
-every token interval is present.
+Per-response TTFT and TTFP start when the server begins executing the native model-turn request that owns the response. RTF
+continues to use client receipt of `response.created` through the last audio packet, divided by emitted audio duration. Global
+TTFT, TTFP, and RTF cover the complete input-stream window. TPOT/ITL use engine stage-0 timing; ITL is emitted only when every
+token interval is present within a continuous generation segment. Model-unit pacing and gaps between generation segments are
+excluded from TPOT/ITL. Raw request metrics retain `response_created_to_first_text_ms` and
+`response_created_to_first_audio_ms` as client-envelope diagnostics.
 
 The checked-in local performance configuration measures four deterministic cases from each OmniInteract subset (12 videos
 total), with no benchmark warmups and a maximum concurrency of two. Each subset also sends one readiness request before its
@@ -339,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 90b9ffae0..db204bdd5 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`,
@@ -82,6 +83,7 @@ depends on the installed kernels and model path.
 | --- | --- | --- | --- | --- |
 | `SPEAKER_SAMPLES_DIR` | Filesystem path; default `~/.cache/vllm-omni/speakers` | Speech server; read when speaker storage initializes | Environment-only setting. The directory is created; filesystem errors propagate. | Stable |
 | `SPEAKER_MAX_UPLOADED` | Integer; default `1000` | Speech server; read when speaker storage initializes | Environment-only setting. A non-integer logs a warning and uses `1000`; range is not otherwise validated. | Stable |
+| `VLLM_OMNI_ABORT_TIMEOUT` | Float seconds; default `2` | Engine abort wait for Videos DELETE and `generate()` cancel/error cleanup; read when `async_omni` imports | Environment-only setting. A non-float raises `ValueError` during import. | Experimental |
 | `VLLM_OMNI_ASYNC_OUTPUT_TIMEOUT` | Float seconds; default `600` | Diffusion engine async-output wait in `step_streaming`; resolved per call on the request path, not at import | Environment-only setting. A non-float or `<=0` value warns once and uses the default. | Experimental |
 | `VLLM_OMNI_EVENT_DRIVEN_ORCH` | `1`, `true`, `yes` or `on` enables; default `0` (off) | Orchestration loop and the serving-side final-output drain; read once when the `Orchestrator` is constructed | Environment-only setting. Values are stripped and case-normalized; any unrecognized value leaves the legacy poll loop selected. | Experimental |
 | `VLLM_OMNI_INPUT_WAIT_TIMEOUT_S` | Float seconds; default `600`; `<=0` disables | Full-payload input coordinator, not async-chunk transfer; read when the scheduler module imports in each worker | Environment-only setting. A non-float logs a warning and uses `600`. | Stable operational control |
@@ -90,6 +92,13 @@ depends on the installed kernels and model path.
 | `VLLM_VIDEO_ASYNC_CHUNK` | `on` or `off`; default `on` | Streaming video output; read on attribute access | Environment-only setting. Values are trimmed and case-normalized; an invalid value warns once and uses `on`. | Experimental |
 | `VLLM_VIDEO_AUDIO_DELTA_MODE` | `fast` or `slow`; default `fast` | Streaming video audio deltas; read on attribute access | Environment-only setting. Values are trimmed and case-normalized; an invalid value warns once and uses `fast`. | Experimental |
 
+### NIXL stage transfer
+
+| Name | Type and default | Applies to and read time | Precedence and invalid values | Lifecycle |
+| --- | --- | --- | --- | --- |
+| `VLLM_OMNI_NIXL_LEASE_S` | Float seconds; default `3600` | Unclaimed producer payload expiry; connector construction | Nonempty environment value overrides `lease_seconds`; empty falls back to config/default. Invalid floats raise `ValueError`. Claimed READ allocations never expire by time. | Experimental |
+| `VLLM_OMNI_NIXL_XFER_TIMEOUT_S` | Float seconds; default `300` | Receiver READ wait; connector construction | Nonempty environment value overrides `transfer_timeout_s`; empty falls back to config/default. Invalid floats raise `ValueError`. Timeout does not cancel DMA or release active allocations. | Experimental |
+
 ### Server storage
 
 Storage names use Pydantic's nested-settings delimiter (`__`). They are read
@@ -112,6 +121,7 @@ settings.
 
 | Name | Type and default | Applies to and read time | Precedence and invalid values | Lifecycle |
 | --- | --- | --- | --- | --- |
+| `VLLM_OMNI_FUSED_QK_NORM_ROPE_MIN_TOKENS` | Non-negative integer; unset or empty means each consumer's own default (Boogu-Image: `2048`) | Token gate of the shared `fused_qk_norm_rope` op: a rotary table is packed for the fused kernel only when it spans at least this many positions (`B*S`); read at forward time | Environment-only. `0` = always fuse; a very large value disables the fused path. Any other value raises `ValueError` on the first forward. The crossover is host-dependent; re-benchmark before overriding. | Experimental performance control |
 | `VLLM_OMNI_SKIP_NVFP4_NAN_CLAMP` | Boolean truthy spellings: `1`, `true`, `yes`, `on`; default false | ModelOpt NVFP4 compatibility patch; read when `vllm_omni.patch` imports | Environment-only escape hatch. Any other value means false. Set only to diagnose the upstream NaN-scale issue. | Diagnostic and temporary |
 | `VLLM_OMNI_USE_QUACK_FP8` | Boolean truthy spellings: `1`, `true`, `yes`, `on`; unset means hardware auto-detection | FP8 scaled matrix multiplication; evaluated when quack capability is selected | A set value overrides auto-detection. Any non-truthy value forces quack off. If quack cannot load, vLLM-Omni warns and falls back to FlashInfer. | Experimental performance control |
 
diff --git a/docs/configuration/stage_configs.md b/docs/configuration/stage_configs.md
index 855390739..2540b19d9 100644
--- a/docs/configuration/stage_configs.md
+++ b/docs/configuration/stage_configs.md
@@ -17,6 +17,7 @@ Common `PipelineConfig` fields include:
 | ------- | ------------- |
 | `model_type` | Pipeline identifier used during model and config resolution. |
 | `default_deploy_config_name` | Bundled deploy YAML loaded when the user does not pass `deploy_config`. |
+| `duplex_plugin` | Dotted path of the model's `DuplexModelPlugin`. Set only for full-duplex models; it makes `vllm-omni serve` run the model through `DuplexOmni` (a server whose every surface runs on a duplex session) and the engine host a `DuplexOrchestrator` with the plugin loaded. |
 | `model_arch` | Default Hugging Face architecture for the pipeline. |
 | `hf_architectures` | Architecture names used to identify checkpoints whose `model_type` is shared. |
 | `hf_config_predicate` | Optional predicate used to select between pipelines with otherwise identical HF metadata. |
@@ -38,7 +39,7 @@ Common `StagePipelineConfig` fields include:
 | `custom_process_input_func` | Processor applied to this stage's incoming payload. |
 | `custom_process_next_stage_input_func` | Processor used for full-payload handoff to the next stage. |
 | `async_chunk_process_next_stage_input_func` | Processor used for async chunk handoff. |
-| `sampling_constraints` | Model-owned sampling constraints that deploy defaults cannot override. |
+| `sampling_constraints` | Model-owned sampling constraints that deploy defaults cannot override. Scalar values replace deploy defaults; required `stop_token_ids` extend and deduplicate them. |
 
 To add or change topology, define and register a new pipeline variant. Use
 deploy YAML only for runtime placement, resource sizing, connectors, and other
@@ -52,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. MiniCPM-o 4.5 deploy YAMLs set `"duplex"` so `/v1/realtime` and chat share the same profile. |
+| `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). |
@@ -97,7 +98,7 @@ Each entry under `stages:` accepts any `StageDeployConfig` field directly (no ne
 | `devices` | str \| null | optional | `null` | Device list assigned to this stage. The number of device ids must equal this stage's local world size (`tensor_parallel_size` × local data-parallel size × `pipeline_parallel_size`, or `num_replicas` × that product for a replica pool); a mismatch fails early — see the note below. |
 | `output_connectors` | dict \| null | optional | `null` | Keyed by `to_stage_<n>`; values are names registered under top-level `connectors:`. |
 | `input_connectors` | dict \| null | optional | `null` | Keyed by `from_stage_<n>`; values are names registered under top-level `connectors:`. |
-| `default_sampling_params` | dict \| null | optional | `null` | Baseline sampling params. Deep-merged with pipeline `sampling_constraints` (pipeline wins). |
+| `default_sampling_params` | dict \| null | optional | `null` | Baseline sampling params. Merged with pipeline `sampling_constraints`; scalar constraints win, while required `stop_token_ids` are appended and deduplicated. |
 | `engine_extras` | dict | optional | `{}` | Catch-all for engine fields not listed above; deep-merged across overlays and forwarded to the stage engine. |
 
 **Note:** a stage's `devices` count must equal its local world size (`tensor_parallel_size` × `data_parallel_size_local` × `pipeline_parallel_size`, falling back to global `data_parallel_size` when the local size is unset), or `num_replicas` × that product for a replica pool. A mismatch fails early and names the offending stage. A top-level `--tensor-parallel-size` is broadcast to every stage, so it can make a single-GPU stage violate this contract ([issue #5003](gh-issue:5003)); fix that case with `--stage-overrides` (set `tensor_parallel_size` and `devices` together per stage) or set TP only on the multi-GPU stage.
@@ -289,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/contributing/ci/ci_settings.md b/docs/contributing/ci/ci_settings.md
index 885ebd528..4032891c0 100644
--- a/docs/contributing/ci/ci_settings.md
+++ b/docs/contributing/ci/ci_settings.md
@@ -15,7 +15,8 @@ Canonical layout (prefer these paths for new changes):
 │   │   ├── skip_ci.py               # skip-ci decision (docs / skip-mark / CI YAML paths)
 │   │   ├── upload_pipeline.py       # Bootstrap + test-pipeline uploader (CUDA/NPU)
 │   │   └── resolve_skip_ci.sh       # Shell helpers for AMD/Intel bootstrap
-│   └── ci_mirror_hardwares.yml      # CUDA uploader presets (referenced by name only)
+│   ├── ci_mirror_hardwares.yml      # CUDA/NPU hardware presets (referenced by name only)
+│   └── ci_source_file_dependencies.yml  # L2–L5 path-prefix presets (referenced by name only)
 ├── cuda/                            # Primary NVIDIA CUDA CI
 │   ├── pipeline.yml                 # Bootstrap entry (hook upload)
 │   ├── bootstrap-upload-steps.yml   # Bootstrap child steps (upload_pipeline --upload)
@@ -34,6 +35,7 @@ Canonical layout (prefer these paths for new changes):
 ├── amd/
 │   ├── test-amd-ready.yml           # L2 job definitions (template input)
 │   ├── test-amd-merge.yml           # L3 job definitions
+│   ├── test-amd-nightly.yml         # Nightly full-model jobs (experimental)
 │   ├── test-template-amd-omni.j2    # Renders final pipeline.yaml
 │   └── scripts/
 │       ├── bootstrap-amd-omni.sh    # Entry: skip-ci → Jinja → upload
@@ -63,7 +65,7 @@ Canonical layout (prefer these paths for new changes):
 | -------- | ---------------- | -------------- | ---------------- | -------------------- |
 | **CUDA** | `cuda/pipeline.yml` | `test-ready.yml`, `test-merge.yml`, `test-nightly.yml`, `test-weekly.yml` | `upload_pipeline.py --upload` (expands uploader-only keys) | omit `mirror_hardwares` (from `-m`) / preset string + `MIRROR_HW` |
 | **NPU** | `npu/pipeline-npu.yml` | `test-npu-ready.yml`, `test-npu-nightly.yml` | `upload_pipeline.py --upload` | `mirror_hardwares: a2b3_npu_1` / `a2b3_npu_4` / `a3_npu_2` |
-| **AMD** | `amd/scripts/bootstrap-amd-omni.sh` | `test-amd-ready.yml`, `test-amd-merge.yml` | Jinja (`test-template-amd-omni.j2`) → `pipeline upload` | `agent_pool` + `mirror_hardwares: [amdproduction]` (array, template filter) |
+| **AMD** | `amd/scripts/bootstrap-amd-omni.sh` | `test-amd-ready.yml`, `test-amd-merge.yml`, `test-amd-nightly.yml` | Jinja (`test-template-amd-omni.j2`) → `pipeline upload` | `agent_pool` + `mirror_hardwares: [amdproduction]` (array, template filter) |
 | **Intel** | `intel/scripts/bootstrap-intel-omni.sh` | `intel/pipeline-intel.yml` (steps inline) | Direct `pipeline upload` | Inline `agents.queue` on each step |
 
 ## Platform configuration style
@@ -108,19 +110,21 @@ Canonical layout (prefer these paths for new changes):
 
     Inferred form: unset/`empty` `MIRROR_HW` matches `H100` or `L4` in `-m` (both present → H100); no match skips the step. `MIRROR_HW=b200` must appear in `-m` or the step is skipped. The uploader does **not** rewrite pytest `-m`; B200 collection comes from the YAML expression and from tests that declare `B200` in `hardware_test` / `hardware_marks` (for example `res={"cuda": ["H100", "B200"]}`). `MIRROR_HW` must be empty or `b200` (case-insensitive); unknown values (for example `b20o`) **fail the upload**. A CUDA preset string such as `mirror_hardwares: h100_4` is skipped when `MIRROR_HW=b200`. Unset `MIRROR_HW` keeps string presets. NPU presets ignore `MIRROR_HW`. A `mirror_hardwares` name that is not a key in `ci_mirror_hardwares.yml` **fails the upload**.
 
+    **Path filter in YAML:** `source_file_dependencies: <preset>` (string, or a list of preset names)—preset names in [`common/ci_source_file_dependencies.yml`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/common/ci_source_file_dependencies.yml). Required on **E2E Test** leaf jobs in L2/L3, and on L4/L5 leaf jobs that should be diff-gated on PR labels; see [Step filtering](#step-filtering).
+
     **Conventions**
 
     - **`depends_on`:** leaf jobs depend on `upload-ready-pipeline`, `upload-merge-pipeline`, etc.
     - **`group` / `label`:** `:card_index_dividers:` groups; labels like `Diffusion · Qwen Image Test`.
     - **`commands`:** `timeout … pytest …` with markers and `--run-level` for the pipeline level.
-    - **`source_file_dependencies`:** required on **E2E Test** leaf jobs in L2/L3; see [Step filtering](#step-filtering).
+    - **`source_file_dependencies`:** required on **E2E Test** leaf jobs in L2/L3, and on L4/L5 leaf jobs that should be diff-gated on PR labels; name a job key from `ci_source_file_dependencies.yml` (see [Step filtering](#step-filtering)). The key must list every script the step runs; `commands` is not scanned.
 
     **Adding a job**
 
     1. Pick the level file (`test-ready.yml` / `test-merge.yml` / `test-nightly.yml` / `test-weekly.yml`).
     2. Add a step under the right **group** (usually **E2E Test** for model pytest).
-    3. Set `label`, `commands`, `mirror_hardwares`, `depends_on: upload-ready-pipeline` (or `upload-merge-pipeline` / `upload-nightly-pipeline` / `upload-weekly-pipeline`).
-    4. For L2/L3 E2E, add `source_file_dependencies` (pytest + model + deploy YAML prefixes).
+    3. Set `label`, `commands`, `mirror_hardwares`, `depends_on: upload-<level>-pipeline`.
+    4. For L2–L5 jobs that should be diff-gated, add a job key in `common/ci_source_file_dependencies.yml` and set `source_file_dependencies: <key>` on the step. YAML anchors hold model business-code paths only. The job key (`{model}_function` / `_perf` / `_accuracy` / `_reliability` / `_doc` / `_cov`) aliases that anchor and lists the pytest / example / benchmark scripts the step actually runs. The uploader does **not** parse `commands` for path filters—omitting a script from the key means editing that script will not select the job.
     5. Dry-run:
 
     ```bash
@@ -144,6 +148,8 @@ Canonical layout (prefer these paths for new changes):
     - A5: `a5_npu_2`, `a5_npu_4`, `a5_npu_8`, `a5_npu_16`
     - 310P: `310p_npu_1`, `310p_npu_2`, `310p_npu_4`
 
+    **Path filter in YAML:** same `source_file_dependencies` presets as CUDA, on **L4** leaf jobs in `test-npu-nightly.yml`. Filtering applies on the PR `nightly-test` label; `main` + `NIGHTLY=1` keeps every job. If no job-key prefix matches, a change to the pipeline YAML being uploaded, or to any path under `source_filter_fallback`, keeps every job in that upload. See [Step filtering](#step-filtering).
+
     **Conventions**
 
     - **`depends_on: upload-ready-pipeline`** (or `upload-nightly-pipeline`) ties jobs to bootstrap upload keys.
@@ -153,7 +159,7 @@ Canonical layout (prefer these paths for new changes):
 
     1. Edit `test-npu-ready.yml` (L2) or `test-npu-nightly.yml` (L4).
     2. Add a step with `mirror_hardwares` (add a new preset in `ci_mirror_hardwares.yml` first if needed).
-    3. Set `commands` to your pytest file and markers.
+    3. Set `commands` to your pytest file and markers. For L4, set `source_file_dependencies` to a job key from `ci_source_file_dependencies.yml` that aliases the model anchor and lists that pytest file.
     4. Dry-run:
 
     ```bash
@@ -166,9 +172,9 @@ Canonical layout (prefer these paths for new changes):
 
     **Bootstrap:** [`amd/scripts/bootstrap-amd-omni.sh`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/amd/scripts/bootstrap-amd-omni.sh)—skip-ci, diff filtering, Jinja render, then `buildkite-agent pipeline upload`.
 
-    **Test YAML (data):** `amd/test-amd-ready.yml` (L2 / `ready`), `test-amd-merge.yml` (L3 / `merge-test` and `main`). On a PR carrying both labels, AMD combines both suites behind one image build. PR builds without either tier label retain the legacy L2 fallback for compatibility with the `amd-test` trigger. `DEBUG_TEST_YAML` remains an explicit override. AMD has no L4 file yet, so `nightly-test` does not select an additional suite.
+    **Test YAML (data):** `amd/test-amd-ready.yml` (L2 / `ready`), `test-amd-merge.yml` (L3 / `merge-test` and ordinary `main`), and experimental `test-amd-nightly.yml` (`full_model` / `nightly-test` or `main` with `NIGHTLY=1`). Multiple PR tier labels combine their suites behind one image build. PR builds that reach the bootstrap without a tier label retain the legacy ready-suite fallback. `DEBUG_TEST_YAML` accepts `ready`, `merge`, and `nightly` as an explicit override. During nightly burn-in every AMD nightly leaf is non-blocking.
 
-    **Trigger boundary:** AMD label handling has two layers. First, the external `vllm-omni-amd-ci` Buildkite pipeline condition decides whether a GitHub label event creates a build. Only after that build starts does this repository's bootstrap inspect all current PR labels and select L2, L3, or both. Repository-side selection therefore cannot make a `merge-test` event start AMD CI by itself. The external condition must admit both `ready` and `merge-test`, while preserving the legacy `amd-test` trigger and non-PR `main` / scheduled builds. For PR builds without a `DEBUG_TEST_YAML` override, an unreadable label set fails the bootstrap instead of silently selecting the wrong tier. Debug overrides skip label lookup and are validated directly; invalid values, including whitespace-only values, fail the bootstrap. Keep `nightly-test` out of the AMD condition until an AMD L4 suite exists; otherwise it would start a build without providing nightly coverage.
+    **Trigger boundary:** AMD label handling has two layers. First, the external `vllm-omni-amd-ci` Buildkite pipeline condition decides whether a GitHub label event creates a build. Only after that build starts does this repository's bootstrap inspect all current PR labels and select the ready, merge, nightly, or combined suites. Repository-side selection therefore cannot start AMD CI by itself. AMD-only nightly validation uses both `amd-test` and `nightly-test`: the external condition should accept an event for either label only when the complete PR label set contains both. `amd-test` admits the AMD pipeline, while `nightly-test` makes the bootstrap select `NIGHTLY_TESTS:test-amd-nightly.yml`. Existing `ready` / `merge-test` behavior and non-PR `main` / scheduled builds remain separate. For PR builds without a `DEBUG_TEST_YAML` override, an unreadable label set fails the bootstrap instead of silently selecting the wrong tier. Debug overrides skip label lookup and are validated directly; invalid values, including whitespace-only values, fail the bootstrap. Until the paired-label condition is configured, use an authorized manual Buildkite build with `DEBUG_TEST_YAML=nightly` and verify that the bootstrap reports only the nightly suite.
 
     **Rendering:** [`test-template-amd-omni.j2`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/amd/test-template-amd-omni.j2) wraps data steps with `amd-build` image build and `amd_<agent_pool>` queues. Do **not** hand-edit generated `pipeline.yaml`.
 
@@ -184,7 +190,7 @@ Canonical layout (prefer these paths for new changes):
 
     **Adding a job**
 
-    1. Edit `test-amd-ready.yml` or `test-amd-merge.yml`.
+    1. Edit `test-amd-ready.yml`, `test-amd-merge.yml`, or `test-amd-nightly.yml`.
     2. Copy a neighboring block: `label`, `agent_pool`, `mirror_hardwares`, `commands`, optional `grade`.
     3. Regenerate via bootstrap / Jinja; update `skip_ci.py` if you add a new YAML path.
 
@@ -213,7 +219,7 @@ PR diffs drive **two independent skip layers**. Both read changed files from git
 | Layer | Script | When | What is skipped | Where you configure |
 | ----- | ------ | ---- | --------------- | ------------------- |
 | **Bootstrap** | [`skip_ci.py`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/common/scripts/skip_ci.py) + [`upload_pipeline.py`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/common/scripts/upload_pipeline.py) | Before child test pipelines upload (`cuda/pipeline.yml`, `npu/pipeline-npu.yml`, AMD/Intel bootstraps) | Entire default CI, or whole L2/L3 upload for a platform | Whitelists in `skip_ci.py`; bootstrap `if` injected by step `key` in `upload_pipeline.py` |
-| **Step filter** | [`upload_pipeline.py`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/common/scripts/upload_pipeline.py) | While uploading CUDA L2/L3 YAML | Individual Buildkite steps inside `test-ready.yml` / `test-merge.yml` | `source_file_dependencies` on each step or group |
+| **Step filter** | [`upload_pipeline.py`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/common/scripts/upload_pipeline.py) | While uploading CUDA L2–L5 YAML | Individual Buildkite steps inside `test-ready.yml` / `test-merge.yml` / `test-nightly.yml` / `test-weekly.yml` | `source_file_dependencies` key on each step (presets in `ci_source_file_dependencies.yml`) |
 
 **Changed files** (both layers):
 
@@ -240,7 +246,7 @@ Label triggers (`ready`, `merge-test`) are unchanged—diff-aware logic only red
 | Non-qualifying skip-mark and no CI YAML | normal CI | all on |
 | Diff unavailable | normal CI | all on |
 
-**`skip_all` exceptions (CUDA/NPU bootstrap only):** PR labels (`nightly-test`, `merge-test`, `weekly-test`, `ready`, …) do **not** revive jobs under `skip_all`. On `main`, scheduled `NIGHTLY=1` still builds the image and uploads L4; `WEEKLY=1` or `NON_CRITICAL=1` still builds the image and uploads L5 (CUDA). `WEEKLY=1` on `main` also uploads L2/L3 with `--e2e`.
+**`skip_all` exceptions:** For CUDA/NPU, PR labels (`nightly-test`, `merge-test`, `weekly-test`, `ready`, …) do **not** revive jobs under `skip_all`; on `main`, scheduled `NIGHTLY=1` still builds the image and uploads L4, while `WEEKLY=1` or `NON_CRITICAL=1` still builds the image and uploads L5 (CUDA). `WEEKLY=1` on `main` also uploads L2/L3 with `--e2e`. AMD applies `skip_ci.py gate` only to selected ready/merge specs, so an explicitly selected AMD nightly spec (`nightly-test`, `NIGHTLY=1`, or a nightly debug override) remains runnable even for a docs-only diff.
 
 **Yaml-gated nightly/weekly:** L4/L5 upload steps keep their normal label / `NIGHTLY` / `WEEKLY` / `NON_CRITICAL` conditions (for example PR `nightly-test` still uploads nightly). Only L2/L3 upload steps are matrix-gated.
 
@@ -257,6 +263,7 @@ Register new files in `L2_YAML_FILES`, `L3_YAML_FILES`, or `L45_YAML_FILES` in `
 | L3 | `.buildkite/cuda/test-merge.yml` | cuda |
 | L3 | `.buildkite/amd/test-amd-merge.yml` | amd |
 | L4/L5 | `.buildkite/cuda/test-nightly.yml`, `test-weekly.yml` | cuda |
+| L4/L5 | `.buildkite/amd/test-amd-nightly.yml` | amd |
 | L4/L5 | `.buildkite/npu/test-npu-nightly.yml` | npu |
 
 ##### Yaml-gated category branches
@@ -289,7 +296,7 @@ Docs/skip-mark mixed with any row below follows the same matrix.
 | CUDA ready + AMD merge | G4 | `cuda/l2` + `amd/l3` |
 | CUDA ready + AMD ready | G2 | `cuda/l2` + `amd/l2` |
 | CUDA merge + AMD merge | G3 | `cuda/l3` + `amd/l3` |
-| Only nightly / weekly / npu-nightly YAML | G1 | (none) |
+| Only nightly / weekly / amd-nightly / npu-nightly YAML | G1 | (none) |
 | CUDA ready + nightly | G5 | `cuda/l2` |
 | CUDA merge + nightly | G6 | `cuda/l3` |
 | CUDA ready + merge + nightly | G7 | `cuda/l2` + `cuda/l3` |
@@ -306,40 +313,38 @@ Unit coverage: `tests/buildkite/test_skip_ci.py`.
 
 #### Step filtering {#step-filtering}
 
-CUDA **L2** (`.buildkite/cuda/test-ready.yml`) and **L3** (`.buildkite/cuda/test-merge.yml`) only. Bootstrap upload entry: `upload_pipeline.py --upload .buildkite/cuda/bootstrap-upload-steps.yml`.
+CUDA **L2** (`.buildkite/cuda/test-ready.yml`), **L3** (`.buildkite/cuda/test-merge.yml`), **L4** (`.buildkite/cuda/test-nightly.yml`), **L5** (`.buildkite/cuda/test-weekly.yml`), and NPU **L4** (`.buildkite/npu/test-npu-nightly.yml`). Bootstrap upload entry: `upload_pipeline.py --upload .buildkite/cuda/bootstrap-upload-steps.yml` (or `npu/bootstrap-upload-steps.yml`).
+
+**When filtering applies:** **PR label** uploads (`ready`, `merge-test`, `nightly-test`, `weekly-test`) and **post-merge `main` L3** (`test-merge.yml`). Scheduled **`main` + env** uploads that pass `--all` (`NIGHTLY=1`, `WEEKLY=1` / `NON_CRITICAL=1`) or `--e2e` (`WEEKLY=1` on L2/L3) keep every selected job and still strip the key. If **no** job-key prefix matches the diff, a change to the pipeline YAML being uploaded, or any path under the `source_filter_fallback` key in `ci_source_file_dependencies.yml`, keeps every job in that upload. `source_filter_fallback` is not a job key — do not attach it to a step. When any job-key prefix already matches, normal filtering wins (the fallback does not expand the selection).
 
 **Uploader-only keys** — removed before Buildkite sees the YAML; never used at runtime on agents:
 
 | Key | Purpose |
 | --- | ------- |
-| `source_file_dependencies` | List of path **prefixes**. If any changed file equals a prefix or starts with `prefix/`, keep the step (or group); otherwise omit it. |
+| `source_file_dependencies` | Named preset (or list of presets) from [`ci_source_file_dependencies.yml`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/common/ci_source_file_dependencies.yml). The uploader expands only that key; it does **not** scan `commands`. If any changed file equals a listed prefix or starts with `prefix/`, keep the step (or group); otherwise omit it. Inline path-prefix lists are still accepted. |
 | `mirror_hardwares` | Expand to `agents` + `plugins` (+ optional `image`) from `ci_mirror_hardwares.yml`. |
 
 ### Policy
 
-- **Always uploaded** (no key): groups outside **E2E Test**—Simple Test, Diffusion unit tests, Engine/Model Executor, Distributed, Custom Pipeline, Entrypoints (L2), LoRA / Entrypoints (L3).
-- **Diff-gated**: every **E2E Test** leaf job. List the smallest prefix set per step—pytest file(s), model code under `vllm_omni/model_executor/models/` or `vllm_omni/diffusion/models/`, plus `stage_input_processors/` and `vllm_omni/deploy/*.yaml` when applicable. A **group** may define the key instead; the whole group drops if no prefix matches.
+- **Always uploaded** (no key): L2/L3 groups outside **E2E Test**—Simple Test, Diffusion unit tests, Engine/Model Executor, Distributed, Custom Pipeline, Entrypoints (L2), LoRA / Entrypoints (L3).
+- **Diff-gated**: every **E2E Test** leaf job in L2/L3, L4 nightly leaf jobs (CUDA and NPU), and L5 weekly jobs whose `if` includes the `weekly-test` label (Reliability / Perf). Jobs gated only by `WEEKLY=1` or `NON_CRITICAL=1` have no `source_file_dependencies`. Registry layout: YAML anchors are model business code only (`vllm_omni/model_executor/models/`, `vllm_omni/diffusion/models/`, plus `stage_input_processors/` and `vllm_omni/deploy/*.yaml` when applicable). Job keys alias the anchor and **also** list the scripts that job runs (pytest files, `run_cov_split.sh --offline` / `--online` targets, example README runners). Feature keys stay cross-cutting. A **group** may define the key instead; the whole group drops if no prefix matches.
 
 ### YAML examples
 
 ```yaml
       - label: "Diffusion · Qwen Image Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_qwen_image.py
-          - vllm_omni/diffusion/models/qwen_image/
+        source_file_dependencies: diffusion_qwen_image_function
+        # diffusion_qwen_image_function: *qwen_image + tests/e2e/online_serving/test_qwen_image.py
         commands:
           - pytest -s -v tests/e2e/online_serving/test_qwen_image.py -m 'core_model' ...
         mirror_hardwares: h100_1
 
       - label: "TTS · Qwen3-TTS CustomVoice Test"
-        source_file_dependencies:
-          - tests/e2e/online_serving/test_qwen3_tts_customvoice.py
-          - vllm_omni/model_executor/models/qwen3_tts/
-          - vllm_omni/model_executor/stage_input_processors/qwen3_tts.py
-          - vllm_omni/deploy/qwen3_tts.yaml
+        source_file_dependencies: tts_qwen3_tts_function
+        # tts_qwen3_tts_function: *qwen3_tts + tests/e2e/online_serving/test_qwen3_tts_customvoice.py
         commands:
           - pytest -s -v tests/e2e/online_serving/test_qwen3_tts_customvoice.py ...
-        mirror_hardwares: l4_4
+        mirror_hardwares: l4_1
 ```
 
 ### Local dry-run
@@ -443,15 +448,16 @@ plugin, which provides the agent. `l4_*` jobs run on the EKS `l4-k8s` queue
 still needs `mount-buildkite-agent: true`.
 
 List both `run_cov_split.sh` and `pyproject.toml` in every opted-in job's
-`source_file_dependencies` — both change what the job measures, so without them a
+`source_file_dependencies` preset — both change what the job measures, so without them a
 change there is filtered out of normal PR builds and only surfaces in a later
 nightly. `tests/buildkite/test_upload_pipeline.py` covers the filter behavior with
 a synthetic job (it does not pin real merge labels).
-Editing only the surrounding CI YAML still does not schedule them, so a PR that
-touches just the wiring needs a full E2E run (or the commands run on a GPU host)
-to produce artifacts. When checking a new model's
-artifacts, compare `lines-covered` between the online and offline XML rather than
-just confirming both files exist.
+If no job-key prefix matches, editing the pipeline YAML being uploaded, or any
+path under the `source_filter_fallback` registry key, keeps every job in that
+upload (including coverage jobs) so the wiring can be validated before merge.
+When a job-key prefix already matches, bypass does not expand the selection. A
+change to a different pipeline YAML still does not schedule them. When checking a new model's artifacts, compare `lines-covered`
+between the online and offline XML rather than just confirming both files exist.
 
 ### Validation checklist
 
diff --git a/docs/contributing/ci/test_system_overview.md b/docs/contributing/ci/test_system_overview.md
index f432678bc..dde8f2a58 100644
--- a/docs/contributing/ci/test_system_overview.md
+++ b/docs/contributing/ci/test_system_overview.md
@@ -182,6 +182,8 @@ CUDA **L4** (`full_model`) jobs are defined once in [`.buildkite/cuda/test-night
 - **Nightly:** scheduled `main` builds with `NIGHTLY=1` (and PR labels such as `nightly-test` / `omni-test`). Default fleet is typically H100.
 - **Pre-release:** the same L4 suite runs again on extra GPU SKUs before a release (for example B200 via `MIRROR_HW=b200`), so `full_model` coverage is not limited to the nightly machine type.
 
+AMD has an experimental, non-blocking `full_model` nightly vertical slice in [`.buildkite/amd/test-amd-nightly.yml`](https://github.com/vllm-project/vllm-omni/blob/main/.buildkite/amd/test-amd-nightly.yml). It selects ROCm Qwen3-Omni function-expansion, accuracy, documentation-example, and AITER-on smoke coverage on the MI300 pool. AMD-only PR validation uses `amd-test` to admit the external AMD pipeline and `nightly-test` to select this suite; scheduled `main` builds select it with `NIGHTLY=1`. Keep it non-blocking while the lane accumulates stability and completion-time evidence.
+
 How count-form `mirror_hardwares` and `MIRROR_HW` pick a SKU: [CI Settings](./ci_settings.md).
 
 ### L2 / L3 diff-aware CI (CUDA)
diff --git a/docs/design/architecture_overview.md b/docs/design/architecture_overview.md
index 58722ffa0..8b7168824 100644
--- a/docs/design/architecture_overview.md
+++ b/docs/design/architecture_overview.md
@@ -131,13 +131,13 @@ for the validated batching, attention, and quantization combinations.
 
 ### MiniMax-H3: conditioning, denoising, and decode
 
-MiniMax-H3 illustrates logical component and phase boundaries between text
-encoding, task-specific denoising, and media decoding:
-`Text Encoder → DiT → VAE Decoder`. The current registered topology co-locates
-these components in one diffusion stage. These boundaries are useful for
-profiling and offload; independent placement would require a future
-multi-stage `PipelineConfig`. The stage mapping follows the implementation and
-serving recipe; the [release overview](https://minimaxi.com/blog/minimax-h3)
+MiniMax-H3 combines text and reference-media encoding, task-specific denoising,
+and media decoding. Standard serving co-locates these components in one diffusion
+stage. The opt-in
+[disaggregated topology](https://github.com/vllm-project/vllm-omni/blob/main/recipes/MiniMaxAI/MiniMax-H3-Disaggregated.md)
+runs Qwen and the video/audio VAE encoders in Stage 0, then sends their conditioning
+to a Stage 1 containing the DiTs and VAE decoders. The stage mapping follows the
+implementation and serving recipe; the [release overview](https://minimaxi.com/blog/minimax-h3)
 notes that a detailed technical report is forthcoming.
 
 #### Model architecture by component
@@ -149,16 +149,15 @@ notes that a detailed technical report is forthcoming.
 | **VAE Decoder** | Video VAE and audio VAE decode the generated latents and assemble the synchronized output | Decoded video frames and stereo waveform, with FPS and audio sample rate metadata |
 
 Both DiT partitions remain behind one task-selection point; `task` chooses
-which partition runs. In the current implementation, the three logical
-components execute inside one diffusion stage. This is different from
-Qwen3-Omni's three independently scheduled stages, even though both models
-produce synchronized audio and video-like outputs.
+which partition runs.
 
 #### Representative component execution
 
+The following table describes the standard single-stage deployment.
+
 | Logical component | Batching | Attention and execution | Parallelism | Quantization |
 | --- | --- | --- | --- | --- |
-| **Text Encoder** | The current co-located pipeline follows the diffusion request scheduler; independent prompt/reference batching would require a separate multi-stage topology | Qwen3-VL attention and multimodal preprocessing | `--text-encoder-tp-size N` shards the encoder across the first `N` DiT ranks; independent placement is not part of the current topology | BF16/FP32 baseline; the H3 DiT FP8 path does not quantize the text encoder |
+| **Text Encoder** | Follows the diffusion request scheduler | Qwen3-VL attention and multimodal preprocessing | `--text-encoder-tp-size N` shards the encoder across the first `N` DiT ranks | BF16/FP32 baseline; the H3 DiT FP8 path does not quantize the text encoder |
 | **DiT** | The current H3 implementation executes one generation request per diffusion batch; use concurrency for service-level throughput | cuDNN attention for the validated two-GPU consumer profile; TRTLLM attention or FlashAttention-4 on supported Blackwell profiles | TP2 plus text-encoder TP and Ulysses/VAE parallel groups on multi-GPU profiles; DLO/CPU offload trade memory for transfer time | Online FP8 applies to eligible DiT linears and is incompatible with layerwise offload |
 | **VAE Decoder** | Decode follows each generation request; tile/patch work can be distributed even when denoising is not batched | VAE decode kernels rather than DiT attention | VAE patch parallelism and native tiled decode within the diffusion stage | BF16/FP32 baseline; the documented H3 FP8 path leaves both VAEs unchanged |
 
@@ -324,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"]
 
@@ -336,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`.
@@ -361,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/attention_backend_selection.md b/docs/design/feature/attention_backend_selection.md
index 41cbaf3ff..3ae1115b1 100644
--- a/docs/design/feature/attention_backend_selection.md
+++ b/docs/design/feature/attention_backend_selection.md
@@ -76,6 +76,34 @@ preserve common `self` or `cross` policies. A model also decides whether its
 path is compatible with automatic TRTLLM selection, because only the model
 knows whether masking and packing satisfy the kernel contract.
 
+### Model-owned implementation specializations
+
+Use `Attention(..., impl_overrides={backend_name: implementation_class})`
+when a model needs different computation within an existing backend contract.
+The model defines the implementation in its own directory and passes it when
+constructing the layer:
+
+```python
+# MyModelVSAImpl is a model-owned subclass of FastVideoVSAImpl.
+self.attention = Attention(
+    num_heads=num_heads,
+    head_size=head_size,
+    softmax_scale=head_size**-0.5,
+    causal=False,
+    role="self",
+    impl_overrides={"FASTVIDEO_VSA": MyModelVSAImpl},
+)
+```
+
+The override is applied after role/platform selection, keyed by the selected
+backend's `get_name()`. It must subclass the **selected implementation**;
+incompatible platform implementations raise `TypeError`. Unselected overrides
+have no effect. Backend capabilities, constructor options, and shared
+parallel dispatch remain unchanged and must be honored by the specialization.
+
+Use a new backend for a new provider/capability contract. `custom_attention`
+instead owns communication and requires `skip_sequence_parallel=True`.
+
 ## Adding or changing a backend
 
 An implementation change is complete only when it:
@@ -91,8 +119,9 @@ An implementation change is complete only when it:
 
 ## FastVideo VSA model metadata
 
-FastVideo VSA support is scoped to `FastVideo/FastWan2.2-TI2V-5B-Diffusers`, whose text-to-video and image-to-video modes both use `Wan22Pipeline`. It operates on a flattened DiT sequence but partitions tokens in
-the original latent video grid. Wan integrations therefore attach the
+FastWan's text-to-video and image-to-video modes both use `Wan22Pipeline`.
+It operates on a flattened DiT sequence but partitions tokens in the original
+latent video grid. Wan integrations therefore attach the
 post-patch `(T, H, W)` shape as `vsa_dit_seq_shape` attention metadata. The
 backend validates that `T * H * W` equals the sequence length, derives the
 runtime block count, and selects the configured top-k key/value blocks for
@@ -104,3 +133,8 @@ the checkpoint contains those weights. Checkpoints without the projection do
 not allocate or execute it. When top-k selects every block, native checkpoints
 route to SDPA, while FastVideo DMD checkpoints preserve the VSA all-block path
 to retain checkpoint semantics.
+
+MiniMax-H3 supplies `MiniMaxH3VSAImpl` through `impl_overrides`.
+`models/minimax_h3/attention/fastvideo_h3.py` owns its prefix layout, video tiling, and
+learned compression gate. Pooling, block-map construction, and tile64 provider
+calls are shared through `attention/ops/block_sparse.py`.
diff --git a/docs/design/feature/disaggregated_inference.md b/docs/design/feature/disaggregated_inference.md
index ba8c8f9fc..8b94325cb 100644
--- a/docs/design/feature/disaggregated_inference.md
+++ b/docs/design/feature/disaggregated_inference.md
@@ -9,6 +9,7 @@ Backend-specific setup lives in separate docs:
 - [MooncakeStoreConnector](omni_connectors/mooncake_store_connector.md)
 - [MooncakeTransferEngineConnector](omni_connectors/mooncake_transfer_engine_connector.md)
 - [MoriTransferEngineConnector](omni_connectors/mori_transfer_engine_connector.md)
+- [NixlConnector](omni_connectors/nixl_connector.md)
 - [YuanrongConnector](omni_connectors/yuanrong_connector.md)
 - [YuanrongTransferEngineConnector](omni_connectors/yuanrong_transfer_engine_connector.md)
 
@@ -25,6 +26,7 @@ Current connectors operate in D2H2D (device to host to device) mode.
 | Multi node (Mooncake Store) | MooncakeStoreConnector | TCP-based, requires Mooncake Master + metadata server. |
 | Multi node (Mooncake RDMA) | MooncakeTransferEngineConnector | RDMA/TCP direct transfer with managed memory pool. Fastest. |
 | Multi node (Mori RDMA) | MoriTransferEngineConnector | RDMA direct transfer via Mori IOEngine. |
+| Multi node (NIXL) | NixlConnector | NIXL `READ` over UCX; the only backend covering Intel XPU. |
 | Multi node (Yuanrong) | YuanrongConnector | Requires Yuanrong Datasystem + etcd. |
 | Ascend NPU P2P (Yuanrong TE) | YuanrongTransferEngineConnector | Uses Yuanrong TransferEngine directly. Configure NPU device IPv4 and `memory_pool_device: "npu"`. |
 
diff --git a/docs/design/feature/host_weight_runtime.md b/docs/design/feature/host_weight_runtime.md
index a9bb1b0b8..15fce07b8 100644
--- a/docs/design/feature/host_weight_runtime.md
+++ b/docs/design/feature/host_weight_runtime.md
@@ -42,6 +42,11 @@ V1 does not include:
 
 ## Motivation and use cases
 
+For investigating CPU memory retained by dependency tensor materialization,
+see the [standalone safetensors diagnostic](https://github.com/vllm-project/vllm-omni/blob/main/benchmarks/host_weight_runtime/README.md).
+It distinguishes repeated dependency calls from reuse of cached views and does
+not establish per-request HWR leakage.
+
 Model loading can create the same final host representation repeatedly. This
 is especially expensive when loading performs checkpoint decoding, tensor
 renaming, TP slicing, quantization, packing, or scale construction before GPU
@@ -313,8 +318,15 @@ One process per exact identity owns a build; other workers wait and then acquire
 leases for the published artifact. Publication is invisible until all payloads
 and metadata are validated, hashed, fsynced, and atomically renamed.
 
-`coordination_timeout_seconds` bounds filesystem lock acquisition. It does not
-cancel synchronous validation, a producer that has already started, or atomic
+`coordination_timeout_seconds` bounds domain-initialization and lookup/build
+lock acquisition. Store construction and each later resolution or publication
+operation have separate budgets from the same wait policy, rather than one
+end-to-end startup deadline. A domain-init timeout follows the retryable domain
+failure policy below. After contention ends, a fresh runtime construction can
+retry initialization; the timed-out runtime retains its original failure.
+
+The coordination budget does not cancel filesystem I/O, synchronous validation,
+a producer that has already started, or atomic
 publication. A hung in-process producer therefore blocks its owning process and
 must be handled by external process supervision. Enforceable producer
 cancellation requires a future process-isolated producer contract.
diff --git a/docs/design/feature/model_local_kv_caches.md b/docs/design/feature/model_local_kv_caches.md
new file mode 100644
index 000000000..371b989ff
--- /dev/null
+++ b/docs/design/feature/model_local_kv_caches.md
@@ -0,0 +1,132 @@
+# Model-local KV caches
+
+Some models keep their attention KV as HuggingFace `transformers` cache objects
+instead of using the engine's paged KV manager. Each such model declares what it
+holds by implementing `model_local_kv_specs()`, and
+`OmniGPUModelRunner.load_model` sums and logs the result after load.
+
+## What is and is not already accounted for
+
+This distinction decides what the protocol is for, and an earlier revision of
+this page got it wrong by claiming none of this memory was accounted for.
+
+CUDA-graph capture happens *during* `load_model` -- MiMo in its constructor,
+Qwen3-TTS in `load_weights`. `determine_available_memory()` then samples
+per-process GPU memory through NVML and subtracts it from the requested budget
+(`vllm_omni/worker/base.py`). So the **graph-resident** portion is already
+charged. Subtracting the declared total from the KV budget would double-count
+it.
+
+What is *not* charged is the **per-request** portion, which is allocated after
+profiling. That half is not small: Qwen3-TTS's codec decoder is 4.44 MiB per
+request, so a server at `max_num_seqs=256` reaches roughly 1.1 GiB that no
+per-stage number predicted.
+
+The consumer therefore reports and does not subtract.
+
+## What the four models declare
+
+| Model | Cache | Bounded by | Per row | Rows |
+|---|---|---|---|---|
+| Qwen3-TTS codec decoder (async-chunk only) | sliding `DynamicCache` | `sliding_window - 1 = 71` | 4.44 MiB | `max_num_seqs`, x2 for the working copy |
+| Qwen3-TTS graph pool | retained captures | same | 4.44 MiB | fixed, from captured shapes |
+| MiMo-Audio local transformer | `DynamicCache` | `group_size + max(delay_pattern) = 11` | 704 KiB | `max_num_seqs` |
+| MiMo-Audio graph pool | captured | same | 704 KiB | fixed 261 (bucket sum) |
+| MiniCPM-o Whisper encoder (streaming only) | `EncoderDecoderCache` | `embed_positions` rows = 1500 | 140.62 MiB | fixed 1, per session |
+| ming_flash_omni talker | `StaticCache` | hardcoded `max_cache_len = 2048` | 24.00 MiB | fixed 1 |
+
+**No cache is bounded by `max_model_len`.** Each has its own mechanism: a
+sliding window, a decode-loop trip count, an encoder frame limit, a constant.
+
+**ming's geometry does not exist in this repo.** `self._llm_config` is a
+`Qwen2Config` from the checkpoint, so layers, kv-heads, head-dim and dtype are
+only knowable after load. That is what makes this a runtime query rather than a
+table.
+
+## Lifetime is not multiplicity
+
+`scope` records when memory appears and goes. It does **not** decide how wide
+the allocation is, and an earlier revision that derived scaling from it was
+wrong in two different directions at once:
+
+- ming's talker is per-call but serialized -- `forward` takes
+  `runtime_additional_information[0]` and runs the whole AR loop inline -- so
+  scaling it by `max_num_seqs` over-reported it by that factor.
+- MiniCPM-o's encoder is per *session*, not per sequence, so `max_num_seqs` is
+  simply the wrong number for it.
+
+So width is declared explicitly, by naming the driver. `RowDriver` has two
+values, because two are all the known caches need:
+
+- `FIXED` -- a count the model controls, with `rows_fixed` and a required
+  `rows_reason`. `rows_fixed=1` on a cache that looks per-request is a claim a
+  reviewer must be able to check.
+- `MAX_NUM_SEQS` -- one row per in-flight sequence; only the engine knows the
+  value.
+
+A third value belongs here when a model actually has a cache the engine widens
+by some other number. An earlier revision added one speculatively, for a single
+declarer, and paid for it with a class hierarchy, an engine-capacity object and
+a conditional-annotation field.
+
+`rows` counts row-equivalents at peak and deliberately does not distinguish
+"one allocation N rows wide" from "N allocations of one row". Those cost the
+same, and a revision that tried to carry both got the object topology wrong in
+three of four declarers: MiniCPM-o keeps one cache object per session while
+asserting batch size 1, and both graph pools keep one distinct object per
+captured bucket. The layout belongs in `allocation_note`, where it cannot be
+mistaken for arithmetic.
+
+## Declaring nothing is a valid declaration
+
+A declaration must be inert when its path is. Qwen3-TTS holds KV only in
+async-chunk mode -- stateless decoding runs `_forward_exact`, which calls the
+transformer without `use_cache` -- so the stateless path declares nothing.
+Getting this wrong is easy in both directions, and both have happened here: one
+revision hung the declaration off the CUDA-graph wrapper and reported zero under
+`enforce_eager`, where the eager async-chunk path does allocate; the next
+declared unconditionally and invented roughly a gigabyte for stateless
+deployments.
+
+Where the model cannot see the deciding setting, it declares the honest unit
+and says so in `allocation_note`. MiniCPM-o's encoder cache exists only on the
+streaming path and is one object per session; the session cap is not visible
+from the model, so it declares one session rather than scaling by a number it
+would have to guess at.
+
+## Finding the declarers
+
+`collect_model_local_kv_specs()` walks `named_modules()`. Two wrinkles:
+
+- The runner's `self.model` may be a `CUDAGraphWrapper`, which is not an
+  `nn.Module` but forwards attribute access to its runnable. The walk therefore
+  works either way, but entering through both the wrapper and its runnable would
+  count a root-level declarer twice. The collector calls the supported
+  `unwrap()` accessor first.
+- An owner that is not a submodule at all (Qwen3-TTS's graph wrapper, ming's
+  `MingAudioGenerator`) is reached by one explicit hop from the module that
+  holds it.
+
+## Adding a model
+
+Return one entry per distinct allocation. Prefer `spec_from_hf_config()` and
+pass the same config object the cache is built from; it raises rather than
+guessing when an attribute is missing. `capacity_source` is diagnostic text --
+never branch on it.
+
+## Known limits
+
+Row counts taken from live state after warmup miss caches `transformers` has
+not yet materialized, which makes Qwen3-TTS's graph-pool figure a floor for the
+xvec path.
+
+MiMo's graph-pool cache has no reachable Python object -- it is a local inside
+the captured frame -- so its width comes from the captured bucket list rather
+than from tensors. Its two entries are also mutually exclusive per call: a call
+either replays a bucket or runs eagerly. The sum is the right ceiling for the
+process and the wrong number for a single request.
+
+MiMo captures every bucket gated only on `torch.cuda.is_available()`
+(`mimo_audio_llm.py:670`), so those 179.44 MiB stay resident even when the
+deploy config sets `enforce_eager: true`. Gating it is a one-line change that
+needs a model boot to verify, so it is noted rather than bundled here.
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 96cba8f60..52797b68c 100644
--- a/docs/design/feature/offloader/README.md
+++ b/docs/design/feature/offloader/README.md
@@ -41,7 +41,8 @@ Every backend implements `OffloadBackend`:
 - `is_enabled()` reports lifecycle state.
 
 `disable()` does not promise to restore the pipeline's original device
-placement. The caller owns any subsequent rematerialization.
+placement. It must restore usable parameter and buffer storage before releasing
+backend-owned host weights. The caller owns subsequent device placement.
 
 An enable failure must remove every partially installed hook. Rank-local
 backends restore ordinary tensors so the pipeline can be retried. A failed
@@ -54,9 +55,19 @@ must use distinct hook names and remove only hooks they own.
 ## Discovery and topology
 
 `resolve_offload_plan(pipeline, config)` is the single topology entry point.
-Every backend calls it once when `enable()` starts and then consumes the
-resolved components, block stacks, resident heads, and staged-residency flags
-it returns. Backends do not re-read model declarations.
+The generic model-level and ordinary layerwise paths call it once when
+`enable()` starts and consume its component selection and block stacks.
+Ordinary layerwise offload also respects a resolved `skip_reason`, preserving
+the legacy missing-DiT no-op without placing auxiliary components. Non-block
+DiT and encoder state is placed by resolved block tensor identity, so the
+backend does not rediscover block containers by attribute name.
+
+Two compatibility paths remain outside this completed generic cutover:
+model-level pipelines implementing `SupportsModelCpuOffload` still own their
+custom phase lifecycle (RFC #6648 J4), and distributed layerwise offload still
+reads declarations for nested-submodule staging and loader-owned mmap paths
+(J3). The custom model-level protocol is delegated to before generic plan
+resolution; it must not be subjected to the generic encoder/DiT swap checks.
 
 Pipeline component discovery prefers `SupportsComponentDiscovery` declarations:
 
@@ -73,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
@@ -102,3 +125,17 @@ remains responsible for transfer, synchronization, and storage ownership.
 
 The diffusion [Offloader module design](../../module/diffusion/offloader.md)
 describes how these feature contracts fit into the larger diffusion runtime.
+
+## Backend acceptance tests
+
+`tests/diffusion/offloader/test_backend_plan_contract.py` covers the two
+behaviors the generic cutover changed. A DiT attribute aliasing a streamed
+block must keep the ring's host residency, so placement cannot follow attribute
+names; the CUDA case fails against the previous name-based placement. Both
+backends must then run with their selector helpers and the model declaration
+made unreadable, proving execution consumes the resolved plan alone.
+
+Selection errors, rollback, residency, and enable/disable cycles stay in
+`test_plan_resolver.py`, `test_layerwise_backend.py` and
+`test_sequential_backend.py`. Model-specific phases and executed tied aliases
+remain the J4 contract suite.
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/omni_connectors/nixl_connector.md b/docs/design/feature/omni_connectors/nixl_connector.md
new file mode 100644
index 000000000..7dfd73946
--- /dev/null
+++ b/docs/design/feature/omni_connectors/nixl_connector.md
@@ -0,0 +1,135 @@
+# NixlConnector
+
+## When to Use
+
+Multi-node or intra-node stage transfer over NIXL, which brokers RDMA/shared-memory
+transports through a single API. Useful when the deployment already standardises on
+NIXL for KV transfer, or when the target accelerator has no Mooncake/Mori backend --
+NIXL reaches Intel XPU through UCX's Level Zero support.
+
+## Mechanism
+
+Uses vLLM's `NixlWrapper` (`vllm.distributed.nixl_utils`) to register the producer's
+tensors and let the consumer pull them with a NIXL `READ`.
+
+- Data Plane: NIXL agent-to-agent `READ`, GPU-to-GPU where the backend allows it.
+- Control Plane: a ZMQ ROUTER socket atomically claims the source allocation before
+  returning descriptors. Forwarded `put()` metadata includes the generation and
+  endpoint; the consumer claims that generation before submitting any READ.
+
+Transfer metadata uses schema version 1. Tensor descriptors are grouped by NIXL
+memory type (`DRAM`, `VRAM`, and so on), while each descriptor retains its global
+tensor index so mixed CPU/accelerator payloads can be reconstructed in order.
+
+Payloads are not restricted to tensors. A single tensor or a list of tensors is
+transferred as-is; a nested structure has its tensor leaves extracted and shipped
+alongside a msgpack-encoded skeleton; anything else is msgpack-encoded into one
+uint8 tensor. Mapping and sequence structure is preserved. `msgspec.Struct` values,
+including `OmniPayloadStruct`, are normalised to mappings so their tensor leaves use
+the direct NIXL path rather than CPU object serialisation.
+
+Each NIXL agent uses strict thread synchronization. A consumer performs one short
+metadata query per scheduler poll (10ms by default), which prevents an unavailable
+producer from blocking unrelated requests. The regular transfer-completion handshake
+keeps the configured transfer timeout.
+
+## Installation
+
+CUDA hosts can install the published wheel:
+
+```bash
+pip install nixl
+```
+
+For Intel XPU, use `docker/Dockerfile.xpu`. Its upstream vLLM XPU base image
+provides a matching torch-xpu, UCX with Level Zero support, and NIXL runtime.
+
+## Configuration
+
+```yaml
+connectors:
+  nixl_connector:
+    name: NixlConnector
+    extra:
+      host: "auto"
+      zmq_port: 50061
+      backends: ["UCX"]
+
+stages:
+  - stage_id: 0
+    output_connectors:
+      to_stage_1: nixl_connector
+
+  - stage_id: 1
+    input_connectors:
+      from_stage_0: nixl_connector
+```
+
+Parameters:
+
+- `host`: address the producer binds its handshake socket to (`"auto"` to detect).
+- `zmq_port`: handshake port. If a producer omits it, an ephemeral port is opened
+  for ownership claims and returned in `put()` metadata. The value in the deploy YAML is a
+  base port. Purpose, replica, rank, and producer-stage offsets are added centrally,
+  so colocated connectors and tensor-parallel workers receive distinct endpoints
+  without one config entry per rank.
+- `sender_host` / `sender_zmq_port`: consumer-side override naming the producer's
+  handshake endpoint. Only needed when the consumer cannot learn it from metadata.
+  In replicated deployments, the producer endpoint is carried with each request and
+  selected at `get()` time; it is not mutable connector-wide state.
+  Explicit sender ports are preserved, not recomputed using the receiver replica.
+  Intermediate NIXL stages retain their incoming receiver configuration and a
+  separate outgoing bind configuration, so one worker can receive and publish.
+- `backends`: NIXL backends to register memory with. Defaults to `["UCX"]`.
+- `receive_device`: forces where received tensors land. By default the consumer
+  keeps the producer's device *type* but uses its own current device of that type.
+- `memory_type`: overrides the NIXL memory type, otherwise `DRAM` for CPU tensors
+  and `VRAM` for accelerator tensors.
+- `lease_seconds`: how long a `put()` payload stays registered while waiting to be
+  read (default 3600). The consumer reports completion, so this only bounds payloads
+  nobody has claimed. An internal reaper releases only unclaimed registrations.
+  `VLLM_OMNI_NIXL_LEASE_S` overrides it.
+- `transfer_timeout_s`: how long a `get()` waits for its `READ` to complete
+  (default 300). NIXL 1.3 has no transfer cancellation API, so a timed-out transfer's
+  buffers and registrations remain owned by the connector until NIXL reports a
+  terminal state; `close()` waits for that state before releasing them.
+  `VLLM_OMNI_NIXL_XFER_TIMEOUT_S` overrides it.
+
+### Source ownership and failure limits
+
+Claims and expiry use the same lock. Completion identifies both a payload
+generation and a unique READ claim; duplicate or stale ACKs cannot release a
+different reader or replacement payload. Replacing a claimed key is rejected.
+Terminal errors also release claims; timeout, unknown status, and active sibling
+transfers retain the complete destination bundle and source claim until terminal.
+Zero-element tensors retain their shape/dtype/skeleton positions but never create
+DMA descriptors or registrations.
+
+A lost metadata response, lost completion ACK, or abandoned consumer can retain a
+claim indefinitely. NIXL 1.3 cannot prove remote cancellation, so neither TTL nor
+`cleanup()` frees those allocations. Producer `close()` rejects new work and
+retains its agent, listener and claimed allocations; a later `close()` finishes
+teardown after claims drain. Permanently abandoned claims remain until process
+exit. This favors memory safety over bounded shutdown/memory usage. Only trusted
+peers may access this unauthenticated control plane. Both endpoints must use the
+claim-aware protocol; rolling compatibility with older GET_META clients is not
+provided. Legacy externally-owned metadata without a generation is accepted only
+under the caller's lifetime guarantee, not managed as a leased allocation here.
+
+## Validation
+
+The native CUDA smoke test requires NIXL and at least two visible CUDA devices:
+
+```bash
+UCX_RCACHE_MAX_UNRELEASED=1024 pytest -o addopts='' -q -s \
+  tests/distributed/omni_connectors/test_nixl_connector_native.py
+```
+
+It starts independent producer and consumer processes, loads the real UCX backend,
+performs the ZMQ `GET_META` handshake and a native NIXL `READ` from GPU 0 to GPU 1,
+checks mixed CPU/GPU tensor leaves from an `OmniPayloadStruct`, sends `XFER_DONE`,
+and verifies that producer registrations are released. This validates same-host,
+cross-GPU operation. Inter-node UCX transport is supported by the design but was not
+validated by this test.
+
+For more details, refer to the [NIXL repository](https://github.com/ai-dynamo/nixl).
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/feature/realtime_ar_diffusion.md b/docs/design/feature/realtime_ar_diffusion.md
index 5963befe7..2f86744b1 100644
--- a/docs/design/feature/realtime_ar_diffusion.md
+++ b/docs/design/feature/realtime_ar_diffusion.md
@@ -143,8 +143,20 @@ fraction to select additional resident sessions up to the model-declared cap.
 All model-owned reservations are deducted before the paged self-attention pool
 is allocated.
 
-LingBot reports its persistent full-horizon image-condition tensor. DreamZero
-reports the measured 603 MiB per-session Wan VAE causal-convolution state.
+LingBot advances a session-owned causal Wan VAE encoder for each condition
+block: the opening pixel frame is followed by four zero pixel frames per later
+latent frame. It retains one current condition block, with separate committed
+and in-flight encoder histories so a failed block cannot overwrite committed
+context. The state reservation includes both encoder histories, derived from
+the encoder's convolution input grids, and the streaming decoder cache. These
+caches are released through the same close/reset hooks. Condition encoding
+currently requires the unpatched, non-tiled Wan encoder path; the existing
+decoder's tiling fallback remains independent. Real-weight GPU parity with a
+full-horizon encode still requires validation because the pointwise posterior
+projection now runs per block.
+
+DreamZero reports the measured 603 MiB per-session Wan VAE causal-convolution
+state.
 
 ## Concurrency and routing limits
 
@@ -178,6 +190,24 @@ For LingBot World v2:
 - `lingbot_world/pipeline.py` constructs conditioning, owns small non-KV session state, and
   produces one block plus the standard metadata envelope.
 
+## Ulysses sequence parallelism
+
+LingBot supports pure Ulysses sequence parallelism for both direct and
+AR-Diffusion execution. With Ulysses degree greater than one, hidden tokens,
+camera features, token-expanded timestep modulation, and RoPE tables are sharded
+together. Without SP, timestep modulation retains the frame-broadcast path.
+Self-attention performs the sequence-to-head all-to-all before reading or writing
+paged KV, while static text K/V uses the same local head shard. Text K/V shards
+own compact storage; cross-attention exchanges query/output layouts to use these
+shards. This retains the shared cache geometry and reduces text K/V storage at
+the cost of two all-to-all calls per layer.
+
+The output head projects local tokens before gathering the flow values. For
+the 14B model this reduces the gathered width from 5120 to 64; frame modulation
+uses each shard's global token offset, including shards that split a frame. Only
+`ulysses_mode="strict"` is supported; `advanced_uaa`, Ring, and AllGather-KV modes
+remain unsupported for this model.
+
 ## Non-goals
 
 This contract does not currently provide:
diff --git a/docs/design/feature/sequence_parallel.md b/docs/design/feature/sequence_parallel.md
index d0328bcf6..7ae263b7d 100644
--- a/docs/design/feature/sequence_parallel.md
+++ b/docs/design/feature/sequence_parallel.md
@@ -77,7 +77,9 @@ Use it when plain Ulysses-SP would otherwise fail because:
 
 - `auto_pad=True` pads sequence tokens in `_sp_plan` and requires attention backends that support `attention_mask`.
 - `advanced_uaa` does not depend on mask-based token padding inside Ulysses attention. It is therefore a better fit for non-divisible head counts and uneven Ulysses shard sizes.
-- `auto_pad=True` remains incompatible with Ring attention because the ring backend does not consume `attention_mask`.
+- `auto_pad=True` remains incompatible with Ring attention because the ring backend does not consume arbitrary
+  `attention_mask` values. A model with contiguous suffix padding may instead publish `valid_kv_length`; Ring trims
+  each circulated K/V block against that global valid prefix.
 - `advanced_uaa` is still experimental and hybrid mode remains limited by Ring's equal-shape requirement.
 
 ---
@@ -416,7 +418,7 @@ _sp_plan = {
 | Constraint | Description |
 |------------|-------------|
 | **Attention Backend Compatibility** | The attention backends must support `attention_mask`. Currently only `TORCH_SDPA` and `FLASH_ATTN` (default for diffusion models) are supported. |
-| **Ring Attention Limitation** | Ring attention does not support `attention_mask`. Therefore, when using `auto_pad=True`, the combination of Ulysses + Ring attention is not feasible. |
+| **Ring Attention Limitation** | Ring attention does not support arbitrary `attention_mask` values, so `auto_pad=True` remains incompatible. Contiguous suffix padding is supported when the model publishes the global `valid_kv_length` prefix. |
 
 1. Enable `auto_pad=True` for all sequence-dimension inputs in `_sp_plan`:
 ```python
diff --git a/docs/design/fullduplex-personaplex.md b/docs/design/fullduplex-personaplex.md
index 249554bbb..6d32cd8e3 100644
--- a/docs/design/fullduplex-personaplex.md
+++ b/docs/design/fullduplex-personaplex.md
@@ -20,7 +20,7 @@ The target is the engine-native path:
   -> PersonaPlex Talker
   -> streaming PersonaPlex Code2Wav
   -> PersonaPlex data-plane projector
-  -> response.audio.delta + response.audio_transcript.delta
+  -> response.output_audio.delta + response.output_audio_transcript.delta
 ```
 
 The standalone `/api/chat` and `/v1/audio/duplex` server that accompanied the
@@ -197,7 +197,7 @@ model-neutral native results:
 
 It owns per-request audio and text cursors so a cumulative output cannot replay
 old audio. The generic projector turns each native result into the Realtime
-`response.audio.delta` / `response.audio_transcript.delta` pair (and
+`response.output_audio.delta` / `response.output_audio_transcript.delta` pair (and
 `response.output_text.delta` for text) under one `response_id`; the full
 mapping is the name map in the
 [Realtime Duplex API](../serving/realtime_duplex_api.md) serving guide.
@@ -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 87fb1f79f..324cd5bdc 100644
--- a/docs/design/fullduplex.md
+++ b/docs/design/fullduplex.md
@@ -1,1070 +1,441 @@
-# MiniCPM-o 4.5 Full-Duplex Runtime Architecture
+# Unified Full-Duplex Framework
 
-> Relocation note: after the H20 validation recorded below, the full-duplex
-> implementation moved out of `vllm_omni/experimental/fullduplex/` into the
-> stable tree (`vllm_omni/engine/duplex/`, `vllm_omni/entrypoints/duplex/`,
-> `vllm_omni/model_executor/models/minicpmo_4_5/duplex/`, and companion
-> modules). Module paths in this document reflect the new layout; the runtime
-> evidence was produced on the pre-move tree, which is file-identical apart
-> from module paths.
+This document is the design record of the full-duplex serving framework:
+the engine-resident session model, the typed command/event contract, the
+single model plugin, and the serving/API surfaces built on top of them. It is
+the owner document for `vllm_omni/engine/duplex/**`,
+`vllm_omni/engine/duplex_omni_engine.py`,
+`vllm_omni/engine/duplex_orchestrator.py`,
+`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.
 
 ## Purpose
 
-This document records the runtime architecture implemented by PR #3907, the
-cleanup applied after published commit `e011d936`, and the remaining work that
-must not be advertised as complete. Implemented contracts and future
-architecture work are called out separately below.
+A full-duplex model listens and speaks at the same time: audio streams into
+the model while it produces audio, the model decides when to speak, and the
+user can interrupt. Serving such a model needs a long-lived session with its
+own identity (epoch, turn), ledgers (input, response, playback, history), a
+lease (idle TTL, disconnect grace, resume) and a binding to the resumable
+stage requests that carry the session's audio through the pipeline.
 
-The checkpoint preserves the active runtime path already exercised on H20. It does
-not introduce another reducer, controller, worker provider, or shadow runtime.
+The framework gives that session exactly one owner, keeps the generic
+turn-based stack free of duplex code, and exposes the same session to three
+consumers: the OpenAI Realtime WebSocket route, the in-process Python API and
+the model plugins.
 
-## Review Snapshot
-
-- PR: `vllm-project/vllm-omni#3907`
-- Published head before this refactor: `e011d936`
-- Published base snapshot: `62589203`
-- Published diff: 93 files, approximately `+29.2k/-0.6k`
-- Local runtime and pytest validation: intentionally not used
-- Required validation environment: an NVIDIA H20 CUDA host
-- PR head reviewed for the current cleanup:
-  `f4f78fa555af4d65e46b003022d352ca2ea9d703`
-- Validated tree: the uncommitted refactor synchronized file-for-file to the
-  isolated H20 worktree on 2026-07-20
-
-The current tree has received fresh H20 focused and E2E validation against vLLM
-0.25.0. The final affected matrix includes the pre-response continuation and
-Stage1 CUDA Graph padding regressions. The checked-in MiniCPM profile admits
-two concurrent sessions through an engine-owned limit; a third
-session was rejected and capacity returned after one session closed. The two
-accepted sessions independently completed their audio, transcript, response,
-playback, and close lifecycles. This is isolation and admission evidence for the
-tested two-session deployment, not a production fairness, arbitrary-capacity,
-or failure-recovery claim. The validated paths include the MiniCPM duplex
-runtime extension, typed resumable policy, extracted control plane and clients, request
-preregistration, typed direct-output decision, engine-managed two-session
-capacity in the checked-in deploy profile, separate public/runtime configuration
-channels, private Session ledgers, ordered `session.update`, the MiniCPM runner
-fast path, continuous
-browser input, and the final Realtime input-lifecycle fixes. Exact evidence and
-scope limits are recorded below.
-
-## Scope
-
-The checkpoint keeps these verified contracts:
-
-- MiniCPM Stage0 conversation KV continuity;
-- Stage1 TTS and Token2Wav continuity;
-- model-owned listen/speak decisions on the normal auto-response path;
-- continuous browser PCM upload during assistant playback, without browser VAD
-  or browser-generated input commits;
-- segment EOS and turn EOS as different boundaries;
-- transcript/audio cursors scoped to a response and turn;
-- playback acknowledgement and history commit;
-- Stage0 request metadata routed per batch row rather than inherited from the
-  first request in the batch;
-- Stage0 token timing snapshots and client-observed audio chunk cadence;
-- scheduler data-plane append over a resumable request;
-- stale epoch/turn/response fencing;
-- `/v1/duplex` and OpenAI Realtime projection;
-- optional OpenAI `server_vad` turn detection backed by a process-shared Silero
-  model and per-session VAD state;
-- existing JoyVL behavior.
-
-The checkpoint does not claim:
-
-- scheduler-native KV append;
-- an acoustic-onset-to-cancel latency target across arbitrary client chunk sizes;
-- production multi-session admission, fairness, capacity, or failure recovery;
-- bounded long-session KV;
-- audio/video synchronization beyond one camera frame per model unit (camera
-  frames ride the audio appends as `video_frames`; the wire contract is in the
-  [Realtime Duplex API](../serving/realtime_duplex_api.md) guide).
-
-## Active Runtime Path
-
-The actual path is:
+## Architecture
 
 ```text
-WebSocket
-  -> OmniDuplexSessionHandler
-  -> DuplexSession + MiniCPMO45ServingSessionState
-  -> DuplexRequestClient
-  -> AsyncOmni thin open/append/signal/close proxies
-  -> DuplexControlClient over the engine-owned correlated RPC transport
-  -> DuplexControlPlane + DuplexSessionRuntimeManager
-  -> MiniCPM DuplexRuntimeExtension + engine session/stage bindings
-  -> StagePool
-  -> resumable scheduler request
-  -> MiniCPM Stage0
-  -> Stage1 TTS / Token2Wav
-  -> output processor
-  -> Realtime protocol projection
-  -> WebSocket writer
+              Python users                                WebSocket clients
+        ┌──────────────────────┐                    ┌────────────────────────┐
+        │  InlineDuplexClient  │                    │      DuplexClient      │
+        │  (DuplexClientBase)  │                    │   (DuplexClientBase)   │
+        └──────────┬───────────┘                    └───────────┬────────────┘
+                   │   DuplexSessionHandle                      │ /v1/realtime?duplex=1 (alias /v1/duplex)
+                   │                                            ▼
+                   │                          ┌──────────────────────────────────────┐
+                   │                          │ OmniDuplexSessionHandler (thin)      │
+                   │                          │  websocket I/O, command_from_realtime│
+                   │                          │  event.to_realtime(), attachment /   │
+                   │                          │  resume tokens / replay journal      │
+                   │                          └──────────────────┬───────────────────┘
+                   ▼                                             ▼   DuplexSessionHandle
+        ┌──────────────────────────────────────────────────────────────────────────────┐
+        │ DuplexOmni(AsyncOmni)                      [entrypoints/duplex_omni.py, thin] │
+        │   open_session / get_session / resume_session / detach_session / close_session│
+        │   DuplexSessionHandle: submit(DuplexCommand) / events() -> DuplexEvent       │
+        └──────────────────────────────────────┬───────────────────────────────────────┘
+                                               │ engine.open/close/resume/touch_session_async (RPC)
+                                               │ engine.submit_command_async (one-way)
+                                               ▼
+        ┌──────────────────────────────────────────────────────────────────────────────┐
+        │ DuplexOmniEngine(AsyncOmniEngine) [engine/duplex_omni_engine.py, thin]        │
+        │   loads the plugin, validates session_mode, builds queue messages            │
+        │  └─ DuplexOrchestrator(Orchestrator)            [engine/duplex_orchestrator.py]│
+        │       template seams + DuplexStagePort over the shared stage machinery       │
+        │       ├─ DuplexSessionManager      admission, backpressure, lease reaper,     │
+        │       │                            open/close/resume/touch, command dispatch  │
+        │       └─ DuplexSessionRunner ×N    ONE session state (DuplexEngineSession),   │
+        │                                    ordered mailbox, append planning + stage   │
+        │                                    submit, output projection, response /     │
+        │                                    playback / history, VAD, typed events     │
+        │       plugin: DuplexModelPlugin    (PipelineConfig.duplex_plugin, one/model)  │
+        └──────────────────────────────────────────────────────────────────────────────┘
 ```
 
-The removed typed reducer/facade and worker-provider runtimes were not in this
-path. This refactor continues to modify only the path above.
+In each layer the duplex class extends the turn-based one, which extends
+the shared base. The dependency runs duplex -> turn-based and never the
+reverse, so the turn-based stack is unchanged and the duplex stack reuses
+its request machinery instead of duplicating it:
 
-## State Ownership
+```text
+OmniBase                          OmniEngineBase                        OrchestratorBase
+ ├─ Omni       (sync, turn)        └─ AsyncOmniEngine  (turn requests)   └─ Orchestrator        (turn-based admission)
+ └─ AsyncOmniBase                      └─ DuplexOmniEngine (session msgs)    └─ DuplexOrchestrator  (hosts DuplexSessionManager,
+     └─ AsyncOmni  (EngineClient)                                                                     implements DuplexStagePort)
+         └─ DuplexOmni
 
-The architecture allows several state objects only when their facts are
-orthogonal.
+AsyncOmni._create_engine  -> AsyncOmniEngine     AsyncOmniEngine._create_orchestrator  -> Orchestrator
+DuplexOmni._create_engine -> DuplexOmniEngine    DuplexOmniEngine._create_orchestrator -> DuplexOrchestrator
+```
 
-| Owner | Authoritative facts |
+Each concrete class constructs its collaborator in an explicit factory
+method the base calls at the right moment: `OmniBase.__init__` calls
+`self._create_engine(...)`; `OmniEngineBase._bootstrap_orchestrator` calls
+`self._create_orchestrator(...)` on the orchestrator thread once the stages
+are initialized. `DuplexOmniEngine._create_orchestrator` passes the loaded
+plugin and the session runtime config to `DuplexOrchestrator` directly.
+
+### Design rules
+
+1. **One session authority.** The whole duplex session (config, epoch/turn,
+   ledgers, lease, stage request resources, model state, projection state) is
+   one object, `DuplexEngineSession`, owned by one `DuplexSessionRunner` on
+   the orchestrator loop. Nothing above the engine keeps session state beyond
+   a handle (session id, event queue, capabilities, public session object).
+2. **Typed contract.** Commands into a session are `DuplexCommand`
+   dataclasses (`engine/duplex/commands.py`); outputs are `DuplexEvent`
+   dataclasses (`engine/duplex/events.py`). `command_from_realtime()` and
+   `DuplexEvent.to_realtime()` derive the OpenAI Realtime JSON, so the wire
+   format is never hand-built, and the websocket handler and the inline client
+   share one conversion.
+3. **Generic bases and the turn-based classes have zero duplex vocabulary.**
+   `OmniBase`, `AsyncOmniBase`, `AsyncOmni`, `OmniEngineBase`,
+   `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. **Deployment selects the serving stack.**
+   `vllm-omni serve` constructs `DuplexOmni` when the pipeline declares
+   `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 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
+
+```text
+vllm_omni/
+├── entrypoints/
+│   ├── omni_base.py                 OmniBase (+ abstract _create_engine)
+│   ├── async_omni_base.py           AsyncOmniBase (output pump, _route_engine_message seam)
+│   ├── async_omni.py                AsyncOmni (turn-based requests)
+│   ├── duplex_omni.py               DuplexOmni, DuplexSessionHandle (thin pipe)
+│   ├── duplex/                      SERVING (thin)
+│   │   ├── serving.py               OmniDuplexSessionHandler
+│   │   ├── realtime_input.py        RealtimeEnvelope (query rules, first message), parse_resume_request
+│   │   ├── session_attachment.py    DuplexSessionAttachmentRegistry (resume tokens, replay journal)
+│   │   ├── audio_encoding.py        encode_audio, injected into DuplexOmniEngine for the plugin's data plane
+│   │   ├── 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)
+│   ├── duplex_omni_engine.py        DuplexOmniEngine (session message surface, creates DuplexOrchestrator)
+│   ├── orchestrator.py              OrchestratorBase + Orchestrator
+│   ├── duplex_orchestrator.py       DuplexOrchestrator (+ DuplexOrchestratorRequestState; implements DuplexStagePort)
+│   └── duplex/
+│       ├── 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                 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)
+│           ├── manager.py           DuplexSessionManager (admission, backpressure, reaper, dispatch)
+│           ├── context.py           DuplexSessionContext / DuplexRunState: what the runner shares with its components
+│           ├── emitter.py           SessionEmitter: projection, epoch filter, domain effects of a terminal event
+│           ├── model_channel.py     ModelChannel: submit an append, project stage output, continue a turn
+│           ├── control.py           SessionControl: server VAD and the events that reconfigure it
+│           ├── append_task.py       AppendAttempt: one append in flight and the rollback its failure owes
+│           ├── helpers.py           pure reads and payload builders over a session
+│           ├── lease.py             DuplexLeaseState (idle TTL, disconnect grace, resume generation)
+│           └── overlap_policy.py / commit_policy.py / playback_ledger.py
+├── config/stage_config.py           PipelineConfig.duplex_plugin; DuplexSessionRuntimeConfig
+├── model_executor/models/minicpmo_4_5/duplex/plugin.py   MiniCPMO45DuplexPlugin (+ data_plane, input, policy, ...)
+└── clients/
+    ├── duplex.py                    DuplexClientBase (ABC), DuplexClient (websocket), client-side events
+    ├── inline_duplex.py             InlineDuplexClient (in-process, over DuplexOmni)
+    ├── minicpmo_4_5.py              MiniCPM-o 4.5 session preset
+    └── personaplex.py               PersonaPlex session preset
+```
+
+## Session identity
+
+- **The server allocates every session id.** `DuplexOmni.open_session`
+  generates `duplex-<uuid4 hex>`; a `session_id` / `id` key inside the
+  Realtime session object is ignored (Realtime clients echo the session object
+  back). The allocated id reaches the client in `session.created` and is the
+  only handle for `session.resume`, `close` and every command.
+- **Ids are never reused** within an engine's lifetime, so the id alone
+  identifies a session. There is no incarnation counter: stage request ids are
+  `duplex-s.<b64 session id>.e.<epoch>.r.<role>`, model-side per-session state
+  is keyed by `session_id` alone, and a command, close, touch or resume for an
+  id the manager no longer holds is answered with `unknown_session`.
+- **Staleness inside a live session is epoch-based.** `DuplexFence
+  (session_id, epoch, turn_id)` is an engine-internal identity: every stage
+  request is bound to the fence it was submitted under, cancels advance the
+  epoch, and tracked tasks re-check the epoch after each `await`.
+- **Resume identity** is `(session_id, resume_token, expected_lease_generation)`:
+  the token belongs to the attachment registry, the lease generation is the
+  engine-side compare-and-swap.
+
+## Session lifecycle
+
+```text
+open   DuplexOmni.open_session(config)
+         -> engine.open_session_async(session_id, DuplexSessionConfig)      [RPC]
+         -> DuplexSessionManager.open: admission (max_sessions, closing sessions keep their slot),
+            plugin.validate_client_extra_body / prepare_runtime_config, DuplexEngineSession,
+            Stage0 request id reserved (ensure_stage_request), DuplexSessionRunner.start()
+         -> first event: SessionCreated (announces the allocated id)
+command  handle.submit(DuplexCommand)
+         -> engine.submit_command_async -> DuplexSessionCommandMessage on the request queue [one-way]
+         -> DuplexSessionManager.dispatch: unknown_session / input_backpressure checks, then runner mailbox
+output   DuplexOrchestrator._intercept_stage_output -> runner.on_stage_output -> mailbox -> typed events
+         -> output_sink (DuplexSessionEventMessage) -> DuplexOmni._route_engine_message -> handle.events()
+detach   DuplexOmni.detach_session -> touch(DETACH): engine-owned disconnect grace; expiry -> SessionExpired
+resume   DuplexOmni.resume_session(expected_lease_generation) -> lease CAS; the existing handle is re-entered
+close    DuplexOmni.close_session -> close RPC; the manager tears the runner down, then the stage cleanup
+         (abort submitted requests, release reserved ids), then SessionClosed, then the RPC result: seeing
+         the event means the admission slot is free (it is held until the cleanup succeeded)
+reap     DuplexSessionManager.reaper_loop: idle TTL / disconnect grace expiry, cleanup retries
+```
+
+### Concurrency and ordering model of the runner
+
+Everything below runs on the orchestrator asyncio loop; there is no lock.
+
+- **Single writer per session.** `DuplexEngineSession` is mutated only by its
+  runner. Inputs reach the runner through one mailbox in this order: client
+  commands (from `_request_handler`, in request-queue order), stage outputs
+  (`on_stage_output` enqueues an internal item; it does not mutate the session
+  inline), timers (silence continuation, bounded auto-response) and internal
+  items (deferred overlap promotion, VAD-synthesized commits). The mailbox
+  worker processes items one at a time.
+- **Slow work is not awaited inline.** An `AppendAudio` handler reserves
+  bytes, then schedules a tracked append task on the per-session append tail:
+  the task awaits `_offload(decode/resample/VAD)` on a dedicated
+  `ThreadPoolExecutor` owned by the manager, then `plugin.plan_append`, then
+  `stage_port.submit`. The worker returns to the mailbox immediately, so a
+  later `CancelResponse` is not blocked behind an in-flight append.
+- **Re-validation after every `await`.** A tracked task captures `(epoch,
+  turn_id)` when it starts and re-checks them before the stage submit and
+  before committing ledgers; a task that finds the epoch advanced rolls back
+  its PCM reservation and exits.
+- **Cancel is atomic at the session.** `CancelResponse` / `BargeIn` advance
+  the epoch, cancel tracked append tasks, abort the owned stage bindings
+  through the stage port and emit the cancelled terminal events before
+  yielding. An append task already past its last check is harmless: its stage
+  request is bound to the old epoch's request id, which the abort covers, and
+  the base never emits session-owned outputs to a client.
+- **Ordered event stream.** Because the epoch bump and every emission happen
+  on one loop in program order, nothing can be emitted for an old epoch after
+  its terminal event; `runner.emit()` still drops a terminal carrying a stale
+  epoch and stamps `epoch` on every event for clients that filter
+  defensively. This is a statement about order, not about latency: the engine
+  output queue and each `DuplexSessionHandle` outbox are unbounded and FIFO,
+  so a cancellation is delivered behind whatever audio was already emitted for
+  the response it cancels. A client that must stop quickly cancels its own
+  playback on `response.done` / `audio.cancelled` rather than waiting for the
+  stream to drain. Bounding those buffers and letting an accepted invalidation
+  skip undelivered media is left to the follow-up RFC.
+- **Backpressure before the mailbox.** `DuplexSessionManager.dispatch`
+  checks `max_pending_input_bytes_per_session` and reserves a pending turn for
+  `Commit` before the put; a rejected command is answered with
+  `ErrorEvent(code="input_backpressure")`.
+- **Per-response stage metrics.** `_route_output` computes the per-segment
+  `StageMetrics` before calling `_intercept_stage_output`; the runner
+  accumulates the snapshot into the active response, so
+  `ResponseDone.stage_metrics` and `metadata.vllm_omni.stage_metrics` on the
+  wire keep their meaning.
+
+## Orchestrator seams
+
+`OrchestratorBase` keeps the generic machinery (request handler skeleton,
+abort, collective RPC, output loops, stage error and dead-replica handling,
+`_route_output`, stage forwarding, prewarm, cleanup, shutdown) and offers
+these seams. `DuplexOrchestrator` extends `Orchestrator` rather than sitting
+beside it: a seam it does not override falls through to the turn-based
+implementation, and `_dispatch_message` hands anything that is not a session
+message to `super()`:
+
+| Seam | `Orchestrator` | `DuplexOrchestrator` |
+| --- | --- | --- |
+| `_dispatch_message(msg) -> bool` | `add_request`, `streaming_update`, `add_companion_request`, `interaction` | open/command/close/resume/touch messages -> `DuplexSessionManager` |
+| `_background_tasks()` | — | `[manager.reaper_loop()]` |
+| `_shutdown_extensions()` | — | `await manager.shutdown()` |
+| `_on_stage_submitted(stage_id, request_id, replica_id, req_state)` | — | bind the forwarded stage request to the owning session |
+| `_intercept_stage_output(...) -> bool` | — | hand every session-owned output (Stage0 decision, Stage1 audio) plus its metric snapshot to `runner.on_stage_output`; `True` = do not forward |
+| `_handle_forward_failure(...) -> bool` | — | fail the owning session's response and close the session, keep the loop alive |
+| `_cleanup_request_ids(ids, abort=, release_owners=)` | ignores `release_owners` | brackets `super()` with `close_sessions_for_request_ids` / `defer_request_cleanups` / `finalize_closed_sessions` |
+| `OrchestratorRequestState.session_owned` | never set | set by `ensure_request`: no synthetic terminal, no client emission, no terminal re-forward, no auto-cleanup on finish |
+
+`DuplexOrchestrator` also implements the `DuplexStagePort` ABC the manager and
+runner use (`stage_count`, `sampling_defaults`, `ensure_request`, `submit`,
+`cleanup`, `abort_requests`): the resumable Stage0 request is preregistered at
+open with `DuplexOrchestratorRequestState(session_owned=True, session_id,
+fence)`, submitted with `submit_initial` on the first unit and
+`submit_update` afterwards, and the request's `streaming.bridge_states["duplex"]`
+carries the session identity (`session_id`, `fence`, `epoch`, `turn_id`,
+`model_turn_id`), the public session config and the server-owned runtime
+config for the worker-side model hooks.
+
+## Model plugin
+
+`DuplexModelPlugin` (ABC, `engine/duplex/plugin.py`) is the one class a model
+provides, selected by `PipelineConfig.duplex_plugin`; "is a duplex model" is
+`duplex_plugin is not None`. It merges the engine policy and the session
+policy that used to be two separately configured objects:
+
+| Half | Members |
 | --- | --- |
-| `DuplexSession` | session state, epoch, turn, active/last response, pending input, overlap duration, playback cursor, history |
-| `MiniCPMO45ServingSessionState` | MiniCPM PCM buffer, deferred overlap payload, data-plane task, continuation effect counter |
-| `DuplexWebSocketActor` | inbound mailbox, outbound queue, writer, transport close state, effect task handles |
-| `NativeRealtimeSessionProtocol` | wire-only response/item projection and input-buffer projection |
-| `DuplexSessionRuntimeManager` | fence snapshot, append reservation, completed-operation cache, resource reservations, stage bindings |
-| `DuplexControlPlane` | control-message validation, transactional open/append/update/close, extension invocation, typed segment/output decisions |
-
-Important distinctions:
-
-- Realtime response IDs are projection caches, not domain decision sources.
-- Engine fences duplicate identity across a process boundary by design; they
-  are immutable validation snapshots.
-- Stage bindings are engine resources, not serving response state.
-- `continuation_owner_id` scopes an effect counter either to a visible response
-  or, before `response.created`, to an explicit model turn. A pre-response
-  continuation also revalidates request, epoch, turn state, and model-turn
-  identity immediately before append; it cannot survive turn completion.
-- runtime open/close acknowledgements are handler-local effect bookkeeping,
-  not Session lifecycle.
-
-## Implemented Concurrency Contracts
-
-### Single inbound mailbox
-
-The Actor now uses one:
-
-```python
-asyncio.Queue[event]
-```
-
-This replaces competing control/input/event `Queue.get()` tasks and the
-deferred-event list while preserving WebSocket arrival order. A later close,
-cancel, or clear must not overtake earlier append, playback ACK, or
-session-update events. Slow runtime appends remain background tasks. Cancelling
-their asyncio task does not stop a synchronous callable already running in the
-default executor, so cancellation correctness is provided by the engine fence,
-not by `Task.cancel()`.
-
-Properties covered by focused tests:
-
-- every enqueued event is delivered exactly once;
-- terminal control preserves wire order while cancelling background work;
-- clear and cancel never scan or delete later mailbox events;
-- one writer owns all WebSocket sends.
-
-### Correlated RPC result router
-
-`AsyncOmniEngine` now has one consumer for `rpc_output_queue`. Results route by:
-
-```text
-("duplex", control_id)
-("collective", rpc_id)
-```
-
-The router replaces the global RPC lock. It supports out-of-order replies,
-timeout unregister, late-result rejection, fatal-error broadcast, and close
-unblocking.
-
-Additional lifecycle rules:
-
-- uncorrelated non-fatal errors are not broadcast to unrelated waiters;
-- a latched fatal rejects new calls before they enter the request queue;
-- `EngineDeadError` is broadcast directly to the RPC queue even though the
-  orchestrator consumes that exception during teardown;
-- shutdown closes the router before joining the orchestrator;
-- failure to enqueue shutdown closes the request queue and still attempts a
-  bounded orchestrator join;
-- `StageRuntime` cleanup runs only after the orchestrator has stopped, avoiding
-  concurrent client teardown.
-
-The router removes wait-side head-of-line blocking. The orchestrator request
-handler remains ordered, but executor submission order is not itself a session
-ordering guarantee.
-
-### Extracted control ownership
-
-The generic engine mechanism and the duplex plugin are split by
-responsibility:
-
-| Module | Responsibility |
-| --- | --- |
-| `engine.messages` | ordinary engine queue messages and collective RPC envelopes |
-| `engine.rpc_result_router` | generic correlation routing through each result message's `rpc_correlation_key` |
-| `engine.duplex.contracts` | immutable duplex DTOs, extension/stage protocols, typed decisions, request-ID codec |
-| `engine.duplex.lease` | duplex lease activity, TTL/grace configuration, and expiry records |
-| `engine.duplex.messages` | identity fence and duplex control message/result envelopes |
-| `engine.duplex.runtime` | extension loading, validation, and compatibility exports |
-| `engine.duplex.session` | session resources, fences, append reservations, idempotency cache, binding cleanup |
-| `engine.duplex.control_plane` | control algorithms and the narrow `DuplexStagePort` used to submit and clean up stage requests |
-| `engine.duplex.control_client` | typed control-message construction and calls through the engine-owned correlated RPC transport |
-| `entrypoints.duplex_request_client` | deterministic request identity, client-state preregistration, acknowledgement validation, data-plane collection, rollback |
-
-`Orchestrator`, `AsyncOmniEngine`, and `AsyncOmni` retain explicit wiring and
-compatibility proxies. They no longer own the corresponding duplex algorithms.
-The ControlClient does not own waiters or consume the result queue;
-`RpcResultRouter` remains the single correlation owner for both duplex and
-collective RPC. The ControlPlane receives a narrow stage port rather than the
-Orchestrator object.
-
-Control-plane enablement is independent from extension presence.
-`PipelineConfig.duplex_control_enabled` determines whether an Orchestrator
-constructs a ControlPlane. This preserves extension-free
-`TURN_COMMIT_ONLY` deployments while allowing ordinary deployments to use a
-single `None` fast-path check. The MiniCPM pipeline explicitly enables control
-and separately selects its runtime extension.
-
-### Transactional open and append
-
-Opening a native session registers its engine state and reserves the Stage0
-request resource as one externally atomic operation. If capability, sampling,
-extension, or request-state initialization fails, the ControlPlane removes the
-session, reserved request resources, and any preregistered request state before
-returning the error. Cleanup distinguishes a reserved resource from a submitted
-request, so it does not decrement the running counter for unrelated work.
-Closing a session that never appended also removes the preregistered resource.
-
-Expiry and request-triggered cleanup use a two-step close. The runtime manager
-first marks the session closing but retains it in the admission set. Only a
-successful stage cleanup finalizes and removes the session. A blocked or failed
-cleanup therefore continues to consume its server-owned slot and is retried;
-replacement admission cannot overlap request or KV resources that are still
-owned by the closing session.
-
-Append uses prepare/submit/commit ordering. `prepare_append()` computes the
-next sequence values without mutating the session. Prompt planning and stage
-submission use that reservation, and only a successful submit commits
-`input_seq`, `input_turn_seq`, and the accepted fence. Serving uses a matching
-PCM reservation and consumes bytes only after the append acknowledgement;
-failure or a closed predecessor rolls the bytes back. An `operation_id` caches
-completed append results so a retry cannot submit the same physical append
-twice.
-
-### Ordered append and configuration effects
-
-Native append effects form a per-session tail. Each append awaits its
-predecessor before entering the engine, and `session.update` awaits that same
-tail before changing either the serving aggregate or engine configuration.
-Consequently, an append received before an update uses the old immutable
-sampling snapshot, while the first accepted append after the update uses
-the new generation.
-
-The engine increments `config_generation` when it accepts the replacement
-configuration. At the next append boundary, the control plane rebuilds sampling
-parameters from stage defaults through the model extension. It never mutates
-the snapshot of a segment already in progress.
-
-### Irreversible cancellation fence
-
-Every cancel control carries the cancelled fence and the next session fence.
-The `AsyncOmni` facade preserves both values across the serving,
-entrypoint, engine-message, and orchestrator boundaries. The orchestrator then
-atomically:
-
-1. advances the runtime state to the next fence;
-2. releases and aborts bindings owned by the cancelled fence;
-3. permanently rejects an append that arrives later with the old fence.
-
-Missing `next_fence` is rejected without releasing bindings; the engine never
-advances independently from serving. A late cancel cannot move a session
-backward when the runtime is already on a newer fence. Idle playback clear does
-not send an engine cancel because no runtime resource is being cancelled.
-
-`model_native_duplex` also validates its engine-client contract before opening
-the session. The open, append, signal, and close methods must exist and declare
-the required `fence` arguments; signal must additionally accept `next_fence`.
-An older or custom client that cannot preserve this boundary fails with
-`runtime_contract_invalid` instead of silently running an unfenced native
-session. The generic serving-session adapter retains its compatibility behavior.
-
-`DuplexFence` also carries a server-side session incarnation. Reusing a public
-session ID after close increments that incarnation, and resource request IDs
-include it after the first incarnation. A synchronous append from a closed
-session therefore cannot be accepted by a newly opened session with the same
-public ID. Stale close validates the full fence before removing the runtime
-registry entry or releasing bindings.
-
-## Implemented Serving Ownership
-
-### Session-owned response and overlap state
-
-The Actor no longer stores:
-
-- a Session reference;
-- lifecycle mirror state;
-- active or last response ID;
-- overlap duration;
-- response-in-progress or playback business predicates;
-- runtime open/close acknowledgements.
-
-`DuplexSession.begin_response()` owns both active and last response identity.
-The Session owns overlap accumulation/reset and playback state.
-
-One `native_response_in_progress()` predicate now covers:
-
-- active response ID;
-- active engine request ID;
-- uncommitted ACK-only playback;
-- active generic response task;
-- response-bound append tasks;
-- MiniCPM data-plane task;
-- assistant-generating turn state.
-
-The write-only `MiniCPMO45ServingSessionState.response_emitted` field and a dead
-data-plane task mirror were removed.
-
-### Response-scoped options
-
-`response.create` is represented by an immutable `ResponseCreateOptions` value.
-The Session reserves it for one response, applies it to a response-local copy
-when that response begins, and restores the base session configuration on
-completion, listen, cancellation, or failure. Instructions, voice, modalities,
-temperature, token limit, format, tools, and conversation metadata therefore do
-not mutate the permanent session configuration or leak into a later response.
-
-### Explicit event effects and pure writer
-
-Business paths call `emit_event()`. It serializes domain effects and outbound
-queue insertion with one session-local lock. Deferred append starts outside the
-lock so recursive event emission cannot deadlock.
-
-The writer only:
-
-1. dequeues an event;
-2. applies late stale filtering to streaming model output;
-3. projects the event to the selected wire protocol;
-4. sends JSON.
-
-The writer does not promote overlap, clear input, advance Session state, call
-the engine, or commit history.
-
-### Single terminal acceptance point
-
-Terminal events are accepted or rejected before domain effects run:
-
-```text
-response.done
-response.listen
-audio.cancelled
-input.cancelled
-session.closed
-```
-
-For a terminal carrying an epoch, that epoch must match the current Session.
-Stale cancellation therefore cannot reset overlap belonging to a later turn.
-Once a terminal is accepted and its effect is applied, the writer cannot revoke
-it because close or epoch state changed while it waited in the output queue.
-
-Streaming audio/text deltas still receive late stale filtering at send time,
-which prevents queued old audio from leaking after a cancel or epoch bump.
-
-## Runtime Type Boundary
-
-The stable kernel is deliberately limited to generic engine and scheduler
-mechanisms:
-
-```text
-vllm_omni.engine.messages                  # ordinary queue and collective RPC envelopes
-vllm_omni.engine.rpc_result_router         # generic correlation routing
-vllm_omni.engine.async_engine_utils        # ordinary engine lifecycle helpers
-```
-
-The full-duplex implementation lives in dedicated duplex modules:
-
-```text
-vllm_omni.engine.duplex.runtime
-                                           # extension loading and validation
-vllm_omni.engine.duplex.contracts
-                                           # immutable DTOs and narrow protocols
-vllm_omni.engine.duplex.lease
-                                           # duplex lease primitives
-vllm_omni.engine.duplex.messages
-                                           # duplex identity and queue envelopes
-vllm_omni.engine.duplex.session
-                                           # session transaction implementation
-vllm_omni.engine.duplex.control_plane
-                                           # engine-side control algorithms
-vllm_omni.engine.duplex.control_client
-                                           # correlated control client
-vllm_omni.entrypoints.duplex_request_client
-                                           # entrypoint request/output lifecycle
-```
-
-Stable engine and entrypoint modules import the duplex kernel eagerly at
-module load (top-of-file imports). Duplex behavior remains opt-in: the
-ControlPlane, ControlClient, and request client are *constructed* only on
-duplex-enabled deployments, and the model runtime extension still loads only
-through the dotted-string plugin path. The client-side package
-(`vllm_omni/clients/`, home of the public `DuplexClient`) is never imported
-by runtime code.
-
-`PipelineConfig.duplex_control_enabled` enables the generic mechanism, while
-`PipelineConfig.duplex_runtime_extension` separately selects the model adapter.
-The MiniCPM pipeline opts into both and installs
-`MiniCPMO45DuplexRuntimeExtension`; ordinary pipelines construct neither a
-ControlPlane nor a ControlClient. The model-neutral protocol exposes
-sampling-parameter configuration, append planning, and a typed stage-output
-decision. MiniCPM owns
-stage-specific overrides, PCM-to-token budgeting, force-listen payload policy,
-special-token interpretation, and `listen` response metadata. The generic
-Orchestrator does not parse MiniCPM session keys, `listen_token_id`, or construct
-MiniCPM metadata, and it does not import the adapter.
-
-Extension loading is fail-fast. Startup validates every required callable and
-the number and type of returned stage sampling parameters. Invalid custom
-extensions fail before a session can open.
-
-Direct listen/speak outcomes use `DuplexOutputDecision` on
-`OmniRequestOutput`. That typed envelope is authoritative over inner completion
-metadata for native projection, so a processed output cannot hide a listen
-decision merely because it retains unrelated multimodal metadata.
-
-Generic multimodal chunk accumulation lives in
-`vllm_omni.outputs.multimodal_accumulation`. It owns snapshot replacement,
-DELTA draining, and audio-finality interpretation; `OmniRequestState` only
-invokes that policy while assembling request output. Model output processors no
-longer need to add chunk-retention rules to the main output orchestration file.
-
-The strict chunk-transfer schema still contains `hidden_states.tts` as the
-generic AR-stage-to-TTS handoff and several MiniCPM streaming token IDs as
-compatibility wire fields. The latter are not a preferred generic model
-contract. Moving them behind a model-namespaced metadata envelope requires a
-versioned producer/consumer migration because unknown msgspec fields are
-rejected; silently deleting or renaming them in this checkpoint would break
-existing Stage0-to-Stage1 transfer.
-
-### Public and runtime configuration channels
-
-Control messages carry two independent snapshots:
-
-- `session_config` contains the public Realtime/session values used by serving
-  and model prompt policy;
-- `runtime_config` contains server-derived MiniCPM sampling, scheduler, context
-  reserve, prefix-budget, and resolved reference-audio values.
-
-The MiniCPM serving adapter derives `runtime_config` from deploy/model defaults
-and validated public options. Clients cannot provide private runtime keys in
-`session.create` or `session.update`; response-scoped `extra_body` drops those
-keys rather than turning them into engine policy. The ControlPlane constructs
-sampling parameters only from `runtime_config`,
-while append planning receives both snapshots explicitly. Raw Realtime
-`extra_body` is not used as the engine's sampling-policy channel.
-
-`session.update` prepares both candidates, validates the runtime candidate in
-the engine, and replaces the serving snapshots only after the engine ACK. A
-rejected candidate therefore leaves both the public configuration and runtime
-sampling generation unchanged.
-
-`DeployConfig.duplex_session` is an immutable, server-owned
-`DuplexSessionRuntimeConfig`. These limits are not read from client
-`extra_body` or session payloads:
-
-| Field | Default | Owner | Lifecycle or resource effect |
-| --- | ---: | --- | --- |
-| `idle_ttl_s` | `300.0` | Engine lease manager | Expires an attached or detached session after inactivity; `null` disables only idle expiry. |
-| `disconnect_grace_s` | `30.0` | Engine lease manager and API attachment registry | Bounds how long a detached session may retain engine resources before cleanup. |
-| `reaper_interval_s` | `5.0` | Orchestrator | Sets the cadence for lease expiry and pending cleanup retries. |
-| `resume_replay_ttl_s` | `60.0` | API attachment registry | Expires replay events retained for resume or takeover. |
-| `resume_replay_max_bytes_per_session` | `8388608` | API attachment registry | Bounds each session's replay buffer. |
-| `max_pending_input_bytes_per_session` | `16777216` | API session input ledger | Applies per-session byte backpressure before input is admitted. |
-| `max_pending_turns_per_session` | `4` | API session input ledger | Bounds queued turns that have not completed runtime processing. |
-| `max_sessions` | `1` | Engine session manager | Atomically enforces admission; closing sessions retain capacity until cleanup finalizes. |
-| `completed_append_cache_size` | `256` | Engine session manager | Bounds completed append idempotency records per session. |
-
-Deploy profiles may lower or raise these values to match scheduler capacity,
-but clients cannot override them. The engine remains authoritative for
-admission and cleanup ownership even when the API performs an early check.
-
-### Client-side companion package
-
-The public client surface ships under `vllm_omni/clients/` and stays on the
-consumer side of the boundary above: `vllm_omni.clients.duplex` provides the
-model-agnostic `DuplexClient` (typed events, per-response demux via
-`ResponseHandle`, `session.resume` with acknowledgement-based replay dedup)
-and the `EventCollector` helper used for timing and request-metric summaries.
-Model-specific session defaults live in thin per-model preset modules —
-`vllm_omni.clients.minicpmo_4_5.create_duplex_session_config()` and
-`vllm_omni.clients.personaplex.create_duplex_session_config()` — so the core
-client never imports model packages and the model duplex plugin packages
-never import the client (both directions are enforced by tests:
-`tests/engine/test_duplex_import_boundary.py`,
-`tests/entrypoints/openai_api/test_duplex_capability.py`, and the subprocess
-purity guards in `tests/clients/test_model_session_configs.py`).
-`examples/online_serving/barge_in_client.py` (with its flow companion
-`barge_in_client_flow.md`) is the runnable reference for the client library
-against a live duplex deployment. The wire vocabulary the client speaks —
-every `/v1/realtime?duplex=1` event with its OpenAI-compatibility tier and a
-JSON example, plus the native-to-Realtime name map — is catalogued in the
-[Realtime Duplex API](../serving/realtime_duplex_api.md) serving guide; that
-page derives from the normative contract table above and must be updated
-with it.
-
-## Generic-Path Cleanup
-
-Model-specific `MINICPMO45_PROFILE_LOGS` probes were removed from:
-
-- the generic AR scheduler;
-- orchestrator;
-- AsyncOmni;
-- the generic GPU AR runner.
-
-The cleanup removes the temporary serving and generic-runtime probes. The
-generic AR runner builds `DuplexSamplingRow` values only when the model exposes
-the optional `prepare_duplex_sampling()` hook, then invokes that hook exactly
-once before the normal sampler. Ordinary models do not scan request rows.
-MiniCPM owns force-listen logits, turn-ended state, and its row-local sampling
-policy behind that hook; the runner no longer reads `_minicpmo45_*` attributes
-or retries sampling after matching `TypeError` text.
-
-The scheduler no longer parses serving `session_config`, `extra_body`, or
-`duplex_stage_sampling_params`. Stage-specific overrides are materialized as
-ordinary `SamplingParams` by the model runtime extension before scheduler
-admission. Existing vLLM stop-token, EOS, and max-token handling defines each
-segment boundary; `resumable=True` parks the request for the next streaming
-update. The scheduler does not inspect a duplex dictionary, Realtime
-configuration, or MiniCPM sampling fields.
-
-The generic runner's unused `_duplex_force_listen_applied_segments` cleanup and
-the obsolete `streaming_accumulated_keys` accumulation hook were removed. The
-latter had no model producer after its upstream Qwen removal; streaming input
-still performs the ordinary replacement merge needed by active models.
-
-Local `turn.signal` transitions such as `user_started` and
-`assistant_started` no longer perform an engine RPC. Only cancellation and
-`session.update` cross the engine boundary because those operations change
-runtime resource identity or runtime configuration.
-
-During a stage transition, `StreamingInputState.source_token_decoder` exposes a
-short-lived, model-neutral decoder sourced from the upstream output processor.
-The MiniCPM Stage1 input processor consumes that capability for token-faithful
-delta transcripts. The generic orchestrator no longer installs or names a
-MiniCPM-specific bridge-state key.
-
-The stable API server imports the duplex serving package eagerly and inspects
-the deployment `session_mode` before constructing the duplex handler. Ordinary
-deployments do not create its registries and background state.
-For an enabled deployment, the client still selects the Realtime duplex route
-with `?duplex=1` (or an equivalent explicit true value). Model-name matching is
-not used for routing or native-runtime activation. MiniCPM clients explicitly
-set `extra_body.native_duplex=true`; the canonical way to do so is
-the `vllm_omni.clients.minicpmo_4_5.create_duplex_session_config()` preset,
-which the repository's barge-in example
-(`examples/online_serving/barge_in_client.py`) uses in its session payload.
-
-`DuplexRequestClient` derives the data-plane request identity from the accepted
-fence and preregisters a resumable `ClientRequestState` before the append crosses
-the engine boundary. The acknowledgement must return the same identity or the
-operation fails. Unregistered outputs, including names that merely use the old
-`duplex-` prefix, are dropped. Timeout, cancel, and close remove the
-preregistered state.
-
-## Why Scheduler Changes Remain
-
-Serving cannot preserve model KV after a segment ends. The scheduler must keep
-one resumable request in a waiting state and accept a later update:
-
-```text
-RUNNING
-  -> segment stop
-WAITING_FOR_STREAMING_REQ  (KV retained)
-  -> next append
-RUNNING
-  -> session close
-FINISHED                   (KV released)
-```
-
-Scheduler responsibilities are limited to resumable request state, runtime
-context update, stop/boundary handling, and final release. Scheduler must not
-own response IDs, playback, overlap, Realtime events, or model policy.
-
-## Serving and Compatibility Boundaries
-
-### Normative Realtime event contract
-
-The public contract in this section applies to `/v1/realtime?duplex=1`. Internal
-duplex event names such as `response.output_audio.delta` are projection inputs,
-not additional public aliases. Events for one attachment preserve mailbox
-order; replay after resume preserves the original event order and `event_id`.
-
-Accepted compatibility aliases are normalized before mailbox admission:
-
-| Canonical input event | Accepted aliases | Contract |
-| --- | --- | --- |
-| `input.text.append` | `input_text.append`, `push_text` | Appends text to the open input item. |
-| `input_audio_buffer.append` | `input.audio.append`, `push_chunk` | Appends audio; legacy aliases default to WAV when no format is supplied. |
-| `turn.signal` | `signal_turn` | Sends an explicit turn signal; it does not imply response creation. |
-| `playback.ack` | `audio.playback_ack` | Advances playback/history only for the identified response and attachment. |
-| `session.close` | `close_session`, `close` | Closes the session after previously admitted mailbox events. |
-
-The Realtime projector emits the following response lifecycle. Cardinality is
-scoped to one `response_id` unless stated otherwise.
-
-| Public event | Trigger and ordering | Cardinality |
-| --- | --- | --- |
-| `response.created` | First event for a visible assistant response; precedes its output-item, content-part, speak, text, and audio events. | Exactly once for every visible response. |
-| `response.speak` | The model selected speak; emitted after `response.created` and no later than the first `response.audio.delta`. It carries decision metadata, not transcript text. | At most once. |
-| `response.audio.delta` | Carries one ordered audio chunk. Every emitted audio delta is followed by a `response.audio_transcript.delta` for the same chunk. | Zero or more. |
-| `response.audio_transcript.delta` | Append-only transcript contribution paired with an audio delta; it may be empty for a text-less audio unit and must not repeat or overlap earlier text. | One per audio delta. |
-| `response.audio.done` | Closes the audio stream after its final delta and before response terminal events. It is omitted for a response with no audio or transcript. | At most once. |
-| `response.audio_transcript.done` | Contains the exact concatenation of all non-overlapping transcript deltas for the response. | At most once, and only for a non-empty transcript. |
-| `response.output_item.done` / `conversation.item.done` | Finalize the assistant item after content-part terminal events and before `response.done`. | At most once each. |
-| `response.done` | Terminal event for a created response; follows audio, transcript, content-part, and item terminal events. | Exactly once for every created response that reaches a terminal state. |
-| `rate_limits.updated` | Compatibility event emitted immediately after `response.done`; the current payload has an empty rate-limit list. | Once per emitted `response.done`. |
-| `response.listen` | The model selected listen at a model-unit boundary. It may be emitted without `response.created`; clients must not infer a missing or pending response from it. | Zero or more per session, at most once per model-unit decision. |
-
-Session lifecycle events (`session.created`, `session.updated`,
-`session.resumed`, `session.replaced`, `session.expired`, and
-`session.resync_required`) are session-scoped rather than response-scoped.
-`session.created` is emitted before held response output on a new attachment.
-Cancellation and truncation use terminal status/details on the affected
-response and never reuse that response ID for later model turns.
-
-Compatibility changes must update this table and its protocol contract tests in
-the same change. The golden transcript test requires joined
-`response.audio_transcript.delta` values to equal
-`response.audio_transcript.done.transcript`; response tests separately enforce
-at-most-once `response.speak` and terminal event cardinality.
-
-### Session internal ledgers
-
-`DuplexSession` remains the serving aggregate root and now composes
-`InputBufferState`, `ResponseState`, `PlaybackLedger`, and
-`ConversationHistory`. The ledgers are private. Read-only properties return
-tuples, snapshots, or mapping proxies, and serving modules mutate them through
-Session transition methods for request, response-turn, lifecycle, playback,
-capability replacement, and history. The Realtime session-update parser still
-normalizes individual fields before atomically retaining or rolling back the
-aggregate configuration. Further work may narrow the read-only compatibility
-surface, but it must not introduce another reducer or a second session state
-machine.
-
-### Realtime input ownership
-
-The browser is a continuous PCM producer. While the session is open and the
-microphone is unmuted, it sends `input_audio_buffer.append` every 200 ms,
-including while assistant audio is being generated or played. It does not run
-VAD and does not send `input_audio_buffer.commit`. Native Stage0 consumes the
-stream in approximately one-second model units; MiniCPM listen, speak, and turn
-EOS decisions advance the model conversation.
-
-Explicit Realtime clients may still use `input_audio_buffer.commit` to create a
-conversation item. The translator validates that wire input before producing a
-commit carrying `item_id`. Native auto-response may already have
-streamed those PCM samples into the runtime, so the runner accepts a validated
-commit even when no runtime-side chunk remains. A truly empty explicit buffer
-continues to return `input_audio_buffer_empty`.
-
-The commit-to-response contract is:
-
-| Session state at `input_audio_buffer.commit` | Runtime action | Required event outcome |
-| --- | --- | --- |
-| Auto-response disabled, valid idle input | Commit and retain the input item. | Emit `input_audio_buffer.committed`; emit no response until an explicit `response.create`. |
-| Auto-response enabled, valid idle speech | Submit the final native append for the current model turn. | Emit `input_audio_buffer.committed` before model output. Create a response only on the first visible text/audio output; a model listen decision may end with `response.listen` and no response. |
-| Auto-response enabled, short overlap during an active response | Discard the short overlap as an acknowledgement. | Emit the committed/no-response acknowledgement; do not create or defer a response. |
-| Auto-response enabled, meaningful overlap during an active response | Retain one deferred payload and promote it after the active response terminates. | Emit `input_audio_buffer.committed` with deferred metadata. A later response follows the same visible-output rule and never reuses the prior response ID. |
-| Explicit silence/noise (`is_speech=false`) | Clear the physical input without a runtime append. | Emit the committed/no-response acknowledgement followed by `response.listen`. |
-| Empty or invalid input | Reject without changing response ownership. | Emit one typed `error`; do not emit `response.created`. |
-| Previous response cancelled or truncated and cleanup complete | Apply the corresponding idle rule above. | The prior response remains terminal; any later visible output receives a new response ID. |
-
-Append tasks, explicit commits, cancellation, and deferred promotion are
-serialized by the session actor. Tests cover post-response commits, active
-playback deferral, truncated-response ownership, and two-turn
-response-required execution; the H20 validation record below is the golden
-multi-turn runtime evidence.
-
-During auto-response overlap, `preserve_realtime_input` distinguishes "do not
-append this silent chunk to the native buffer" from "clear the open Realtime
-item". Silent overlap no longer discards earlier user PCM.
-
-The first chunk of one overlapping input item also reserves its target model
-turn. A later Realtime commit uses that reserved identity even if response EOS
-has already advanced the Session turn; clear, cancel, close, and successful
-promotion release the reservation.
-
-### Physical input and model-turn identity
-
-A Realtime input item, an optional `input_audio_buffer.commit`, and a MiniCPM
-model turn are intentionally different identities. The browser normally keeps
-one input stream open without commits. Native Stage0 evaluates that stream in
-approximately one-second model units. A sampled `<|turn_eos|>` closes the
-current model turn and allows a later streamed unit to start another turn.
-Explicitly committed input may also produce only model-listen decisions and no
-spoken response.
-
-Therefore neither `model_turn_id` nor response cardinality is derived from the
-number of physical inputs. `model_turn_id` advances at model EOS. The
-`response-required` fixture may require exactly one response per requested
-turn, but `model-policy` validation must accept additional model-owned responses
-and cannot assert cross-turn transcript independence through physical-input
-attribution.
-Before closing, the model-policy demo drains every created response through
-`response.done`, acknowledges every completed audio playback, and requires a
-bounded quiet interval with no newly created response. This validates lifecycle
-completion without suppressing or overriding the model's listen/speak policy.
-
-### Non-cancel signal semantics
-
-`turn.signal` remains a public compatibility surface for local Session and
-Realtime transitions. Serving forwards only cancellation and `session.update`
-to the engine. The engine rejects arbitrary non-cancel signal names instead of
-returning a misleading supported acknowledgement. `session.update` remains a
-real engine operation because it replaces the configuration consumed by later
-append plans.
-
-## Remaining Architecture Work
-
-The following work is deliberately not hidden inside this checkpoint.
-
-### Serving composition
-
-The generic runner and runtime bridge now depend on the model-neutral
-`ServingRuntimeAdapter` protocol and no longer import MiniCPM modules. The
-`MiniCPMO45ServingRuntimeAdapter` owns MiniCPM serving state, PCM preparation,
-data-plane projection, client/runtime configuration validation, prefix policy,
-and capability projection. `PipelineConfig.duplex_serving_adapter` explicitly
-selects its import path; `AsyncOmniEngine` and `AsyncOmni` carry that path to the
-API server, which passes it into the generic handler. The handler has no model
-default and fails startup when the duplex endpoint is enabled without an
-adapter. Tests may inject an adapter instance directly. Import-boundary tests
-verify that loading the generic runner, bridge, or handler does not load MiniCPM
-modules.
-
-Behavior is still assembled through `DuplexSessionRunnerMixin`,
-`NativeRuntimeBridgeMixin`, and `ChatFallbackProjectorMixin`, so explicit
-adapter composition is only the model-policy boundary, not a completed removal
-of host-method coupling. A later refactor may replace the remaining mixins with
-explicit protocol and effect-runner dependencies while preserving one actor
-mailbox and one `DuplexSession` transition owner. Splitting those components
-must not create a second reducer or concurrent state machine.
-
-The four private Session ledgers are data partitions, not independent owners.
-`DuplexSession` intentionally remains the aggregate root. Further encapsulation
-may narrow compatibility properties, but serving code must continue to perform
-state changes through Session transitions.
-
-### Plugin descriptor and typed payloads
-
-The pipeline currently selects the MiniCPM engine extension and Serving adapter
-through two explicit fields, but there is not yet one versioned plugin descriptor
-that binds those identities in an open handshake. Realtime client payloads do
-not select either implementation. Adding a second native model should first
-introduce that descriptor and reject serving/engine plugin mismatches explicitly.
-
-The stable boundary has typed fences, plans, policies, decisions, and control
-messages, but `session_config`, `runtime_config`, and append payloads still use
-generic mappings or objects at the extension boundary. Model-neutral typed
-session and input-chunk contracts remain follow-up work, especially before
-adding video.
-
-### Output modality policy
-
-The current Realtime duplex contract supports text and audio output. Unknown
-output modalities fail closed with `unsupported_response_modality`; they are
-never silently projected as text. This checkpoint deliberately does not add a
-modality registry because there is only one native text/audio projection path
-to register.
-
-A registry becomes justified when a second non-audio/non-text implementation
-uses the same validation, encoding, lifecycle, and projection contract. At that
-point the abstraction must be extracted from two working adapters and retain
-the same fail-closed behavior. A speculative registry before that condition
-would add selection state without removing any existing branch.
-
-### Performance measurement contract
-
-Stage0 token timing comes only from the engine's per-segment metric snapshot:
-`vllm_ttft_ms`, `vllm_tpot_ms`, and `vllm_itls_ms`. A resumable Stage0 request
-exports its segment-local `num_generation_tokens`; ordinary requests retain the
-existing output-token fallback. Realtime response state clears its metric
-accumulator at `response.created`, combines only model units owned by that
-response, and ignores session-level events with no matching `response_id`.
-Realtime projection carries the result under
-`metadata.vllm_omni.stage_metrics`; clients do not estimate TPOT from transcript
-deltas or subtract cumulative snapshots.
-
-Audio timing uses the client's monotonic receive clock and is partitioned by
-`response_id`. `response_created_to_first_audio_ms` measures projection startup
-after `response.created`; `commit_to_first_audio_ms` measures end-to-end output
-from an explicit input commit. Neither field is called TTFP without naming its
-origin. Reports also include inter-chunk and chunk-duration
-count/mean/p50/p95/max plus maximum chunk gap. Engine and client measurements
-have different clock origins and must not be merged into one timeline.
-
-### Stage1 CUDA Graph boundary
-
-Native Stage1 streaming advances Python-owned request generators and turn
-state on every scheduler step. A full-model CUDA Graph would execute that
-Python control flow only while capturing and then replay stale chunk and turn
-metadata, even if its host-to-device tensor construction were made
-capture-safe. The duplex deploy profile therefore keeps `enforce_eager=false`
-but selects `cudagraph_mode=PIECEWISE` for Stage1. Python orchestration runs on
-every step while fixed-topology compiled regions remain eligible for CUDA
-Graph capture. This is a model execution constraint, not an E2E-only override.
-
-### Resource capabilities
-
-At the time of this snapshot the checked-in MiniCPM duplex deploy profile set
-Stage0 and Stage1 `max_num_seqs` to two and configured the engine runtime
-manager with `max_sessions=2`; the duplex settings have since been folded into
-`vllm_omni/deploy/minicpmo_4_5.yaml`, which admits four sessions
-(`duplex_session.max_sessions: 4`, matching its stage `max_num_seqs`). The
-Realtime capability response advertises
-multi-session and same-replica multi-session support with
-`session_admission_mode="engine_managed"`. Client session fields cannot raise
-this server-owned limit. Fresh E2E evidence covers two concurrent sessions in
-both model-policy and response-required modes, rejection of a third session,
-and admission of a replacement after one accepted session closes. It does not
-establish behavior beyond that configured limit.
-
-Session leases, lease TTL, resumable attachment, orphan reaping, and bounded
-Serving input/backpressure are implemented. A production admission controller,
-KV-aware capacity budgeting, fairness, starvation metrics, and multi-session
-worker-failure recovery remain follow-up work. Capability claims must stay
-limited to the mechanisms and two-session execution shape validated here.
-
-## Validation Evidence
-
-All pytest and runtime evidence for this branch must run on the remote H20.
-
-### Current synchronized tree
-
-The current dirty tree was synchronized to the isolated H20 worktree at
-`/home/admin/workspace/aop_lab/model_runner_v2/vllm-omni-worktrees/pr3907-boundary-cg-0721`.
-
-- Final affected matrix: 661 passed, one network-dependent config test
-  deselected, 20 warnings. It includes the complete MiniCPM native-duplex hook
-  file and all control/session/handler/Orchestrator/import-boundary suites. The
-  run is task `be221f67` (`/tmp/remote_gpu_logs/be221f67.log`). The deselected
-  `test_resolve_when_autodetect_resolves_none` attempted a Hugging Face model
-  lookup and hung in the isolated environment; the duplex deploy-config test
-  passed independently.
-- Stage1 PIECEWISE CUDA Graph validation: the deploy-config assertion first
-  failed with no Stage1 compilation config, then passed in task `3ed6091d`.
-  Server task `95827027` started with `enforce_eager=False`, logged
-  `cudagraph_mode=PIECEWISE`, and captured batch sizes 1, 2, and 4 without the
-  CPU-to-CUDA capture error. The first concurrent E2E exposed graph padding as
-  `request_token_spans` covering three valid rows in a four-row capture. A
-  focused RED/GREEN now verifies both single-request and batched-request
-  padding, and the full MiniCPM hook file passed 47 tests in task `e89dba88`.
-  After the fix, two concurrent response-required sessions each completed two
-  spoken responses, playback acknowledgements, and history lifecycles with no
-  error or stale event. Artifacts are under
-  `/tmp/pr3907_piecewise_response_required_2x2_fixed_20260721`.
-- An exploratory two-session, two-turn model-policy run still left one session
-  waiting after its second input commit while the other session completed both
-  turns. The same liveness symptom was reproduced with Stage1 eager mode before
-  the padding fix, and no Stage1 fatal occurred after the fix. This run is not
-  counted as PIECEWISE acceptance evidence; the remaining Stage0 resumable
-  reactivation path requires separate diagnosis. Artifacts are under
-  `/tmp/pr3907_piecewise_model_policy_2x2_fixed_20260721`.
-- Latest broad affected matrix before the final pre-response continuation fix:
-  608 passed, 19 warnings. This includes the
-  Stage0 row-routing regression, cleanup-held admission regressions,
-  segment-local token accounting, response-owned metric filtering, the generic
-  output-processor suite, direct E2E script execution, and continuous-response
-  overlap ownership. The run is task `e2146318`
-  (`/tmp/remote_gpu_logs/e2146318.log`).
-- The pre-response continuation regression group passed 5 focused tests. The
-  response-required two-turn scenario then passed 5/5 repeated runs in task
-  two-session semantic isolation plus resume, takeover, and
-  admission passed in task `49225794`; model-unit overlap passed in task
-  `3888387d`. The final affected matrix above supersedes the earlier pending
-  rerun requirement.
-- Serving plugin selection was first reproduced as three RED tests: the generic
-  handler silently selected MiniCPM and the pipeline had no explicit Serving
-  adapter field. The final pipeline/import/fail-fast group passed 9 tests in task
-  `4db6d959` (`/tmp/remote_gpu_logs/4db6d959.log`). The token-metric and client
-  audio-cadence producer-to-consumer group passed 8 tests in task `cf80f6b2`
-  (`/tmp/remote_gpu_logs/cf80f6b2.log`).
-- Stable-import isolation was first reproduced as a RED that loaded twelve
-  `experimental.fullduplex` modules. After extracting the kernel and making
-  implementation loading conditional, the isolated import regression passed.
-  The focused ControlPlane/ControlClient/session/runtime/Orchestrator/AsyncOmni
-  suite then passed 139 tests in task `fad613ea`
-  (`/tmp/remote_gpu_logs/fad613ea.log`).
-  After the final contract-import cleanup, the import-boundary, runtime, and
-  lease suites passed 45 tests in task `bc138887`
-  (`/tmp/remote_gpu_logs/bc138887.log`).
-- Concurrency and failure-path hardening now has direct regressions for
-  single-flight cancel/close cleanup, cleanup retry without dropping request
-  resources, failed-replica affinity cleanup and same-address reattachment,
-  append ordering across resume, takeover ownership of pending-turn
-  reservations, and a closed-transport send immediately after resumable
-  credentials are delivered. The final focused resume/takeover group passed 5
-  tests in task `dc2ac96e` (`/tmp/remote_gpu_logs/dc2ac96e.log`).
-- Stage1 batching regression: the focused test first failed because only the
-  first request in `runtime_additional_information` reached the talker. After
-  routing every request by `request_token_spans`, preserving per-row terminal
-  flags, and emitting request-keyed sparse audio, the complete MiniCPM duplex
-  hook file passed 42 tests.
-- Stage0 batching regression: two requests in one batch now retain different
-  `duplex_prompt_token_ids` and `special_token_ids`. The model emits row-aligned
-  payload elements, so Stage0 no longer copies request zero's duplex metadata to
-  later sessions.
-- Admission finalization regressions cover `max_sessions=1` with blocked and
-  failed expiry cleanup plus request-triggered cleanup. Every replacement is
-  rejected with `resource_exhausted` until stage resources are cleaned and the
-  old session is explicitly finalized.
-- Resumable token accounting exports each model unit's native generation-token
-  count instead of recounting the request's cumulative token IDs. Realtime
-  response state resets and accumulates those segment snapshots, and the client
-  ignores unowned session-level metrics while summarizing a response.
-- Engine-owned admission and two-session model-policy E2E: two random session
-  IDs were admitted and remained isolated, a third was rejected with
-  `resource_exhausted`, closing one accepted session returned capacity, and a
-  random replacement session was admitted. The capability projection reported
-  `configured_limit=2`, `advertised_multi_session=true`, and
-  `session_admission_mode=engine_managed`. In the same run one session selected
-  speak and the other selected listen without identity leakage. Detach/resume
-  advanced attachment generation from one to two and rotated its token; active
-  takeover rejected all four writes from the replaced connection. The run is
-  task `1d9dd1ed` (`/tmp/remote_gpu_logs/1d9dd1ed.log`), with artifacts under
-  `/tmp/pr3907_resume_takeover_native_metrics`.
-- Concurrent two-session, two-turn response-required E2E: both sessions produced
-  two complete spoken responses, committed two playback acknowledgements and
-  history records, and emitted no error, cancel, truncate, or stale events. The
-  semantically distinct inputs produced isolated transcripts containing
-  "当时" and "一加一" respectively. Per-response Stage0 output counts were 20,
-  38, 32, and 33 tokens rather than cumulative request totals. The run is task
-  `a16f1467` (`/tmp/remote_gpu_logs/a16f1467.log`), with artifacts under
-  `/tmp/pr3907_semantic_2turn_native_metrics`.
-- Disconnect-grace E2E: a detached session expired after the configured
-  30-second engine grace, and a later resume was rejected with
-  `session_resume_expired`. The run is task `9872d50c`, with artifacts under
-  `/tmp/pr3907_0719_disconnect_grace_expiry`.
-- A separate black-box takeover client exercised the current backend with two
-  semantically distinct concurrent inputs. Active resume replayed 17 events
-  including five audio deltas and committed playback history; takeover rejected
-  all four stale-attachment sends, emitted `session.replaced`, and preserved
-  attachment/session isolation. Both transcripts contained only their expected
-  semantic token. The client task is `6773bd34`
-  (`/tmp/remote_gpu_logs/6773bd34.log`), with artifacts under
-  `/tmp/pr3907_gaohan_final_takeover`. The backend task was `5abcd1ee`.
-- Across the final response-required, overlap, and resume/takeover runs, engine
-  Stage0 TTFT ranged from 31.17 to 310.18 ms, TPOT from 15.18 to 21.18 ms, and
-  reported ITL p95 from 16.35 to 32.83 ms. Explicit
-  `commit_to_first_audio_ms` ranged from 386.80 to 1033.25 ms, while the
-  client-monotonic maximum audio chunk gap ranged from 388.30 to 1316.37 ms.
-  These are response-scoped observations from a small, warm-state-sensitive
-  sample, not an SLO claim. The slowest response still does not satisfy a 200 ms
-  end-to-end first-output target.
-- Post-merge focused handler/demo/Web/Stage0/runner/video suite: 324 passed,
-  19 warnings. The run is task `f78cb7a8`
-  (`/tmp/remote_gpu_logs/f78cb7a8.log`). The Web contract explicitly rejects
-  browser VAD markers and browser-generated input commits while the merged
-  video path retains camera-frame admission.
-- No-response listen and residual accounting: the focused handler regressions
-  passed after first reproducing both failures. A model-listen unit without a
-  Realtime response no longer defers the next committed input, and three
-  consecutive 1.2-second `pcm_f32le` inputs each returned pending input bytes
-  to zero.
-- Model-unit overlap E2E: the second physical input streamed while the first
-  response remained active. Seven overlap decisions had
-  `defer_runtime_append=false`; the one-second model-unit boundary occurred
-  before the first `response.done`, and no barge-in, cancel, truncate, stale, or
-  error event occurred. The model-policy contract accepts a later unit ending
-  the continuous response instead of requiring a second physical-input-owned
-  response. The two response-owned Stage0 snapshots independently reported 20
-  tokens / 152.8 ms TTFT and 19 tokens / 43.3 ms TTFT. The run is task
-  `a4977622` (`/tmp/remote_gpu_logs/a4977622.log`), with artifacts under
-  `/tmp/pr3907_overlap_native_metrics_scoped`.
-- The split multi-session E2E runner is directly executable from the repository
-  even when another installed package owns the top-level `tests` name. Its
-  script-import and continuous-terminal regressions passed in task `f11b106c`.
-- Pinned response-required E2E: the first 1400 ms of the pinned fixture produced
-  one complete spoken response, five audio/transcript deltas, and one playback
-  history commit, with symmetric created/audio-done/done lifecycle and no
-  duplicate `response.speak`. The client task is `a76dec52`
-  (`/tmp/remote_gpu_logs/a76dec52.log`).
-- Continuous-input model-policy E2E: 36 browser-like 200 ms chunks produced
-  seven model-listen decisions with zero input commits and no
-  error/cancel/truncate/stale events. The client task is `fb256595`; artifacts
-  are in `/tmp/minicpmo_pr3907_continuous_model_policy_20260718`.
-- Three-response continuous-input E2E: three consecutive 9469 ms streams,
-  composed of the original fixture plus four seconds of silence, produced three
-  spoken responses in one session. All three completed `response.done`, audio
-  transcript, playback ACK, and history commit; the run had 22 audio/transcript
-  deltas, zero input commits, and no error/cancel/truncate/stale events. This is
-  lifecycle evidence, not semantic cross-input independence, because the same
-  fixture was repeated. The client task is `2a5f29f0`; artifacts are in
-  `/tmp/minicpmo_pr3907_continuous_three_response_20260718`.
-- The fresh validation backend was stopped after the E2E runs and GPU0/1 returned
-  to baseline. Audio-quality and ASR evaluation were not rerun for these
-  lifecycle-only changes. Other GPU workloads were not modified.
-
-### Regression lineage
-
-Earlier synchronized checkpoints passed broader affected matrices before the
-extension, policy, and ledger consolidation. Those runs were useful while
-developing the refactor but are superseded by the current file-identical H20
-matrix and E2E evidence above; they are intentionally omitted to avoid mixing
-different trees in the acceptance argument.
-
-### Focused suites
-
-- RPC router and AsyncOmni shutdown/error routing;
-- orchestrator fatal and duplex control paths;
-- WebSocket Actor mailbox and writer;
-- duplex protocol and Session ownership;
-- Realtime handler, terminal ordering, overlap, playback ACK;
-- scheduler resumable boundary;
-- MiniCPM runner and Stage0/Stage1 lifecycle.
-
-### E2E contract
-
-Run two deliberately separate fixture contracts:
-
-- model-policy uses three distinct inputs, no transcript hints, 200 ms
-  real-time pacing, and continuous input with no browser commit. It allows
-  natural listen or speak decisions and assumes no 1:1 mapping between
-  physical inputs, model turns, and responses;
-- response-required uses `minicpmo_pr3907_jiayan_16k.wav` pinned to SHA-256
-  `2e5fd4eb3ee434ce107ee3a0591fa624a33f7683c7462f45fe651c443c9af941`,
-  sends its first 1400 ms, and requires one complete spoken response.
-  It is an output-lifecycle fixture, not evidence that arbitrary no-hint,
-  real-time input must select speak;
-- late and old-response playback ACK handling in the affected test matrix;
-- final model-policy response drain before `session.close`;
-- close/disconnect with no post-terminal audio;
-- transcript delta/final consistency;
-- generated WAV validity and external ASR sanity.
-
-Distinct-input fixtures must also be semantically distinct. Different files or
-waveform hashes containing the same greeting can legitimately produce the same
-reply and are not sufficient evidence for cross-turn transcript independence.
-
-For each run record the exact SHA/worktree, command, server log, client log,
-WAV path, and cleanup result.
-
-## Acceptance Criteria
-
-This checkpoint is ready to publish only when:
-
-- one mailbox passes exactly-once and wire-order tests;
-- cancel advances the engine fence even when the old append continues in an
-  executor, and the next-epoch append remains accepted;
-- request completion removes MiniCPM helper and model-owned force-listen state;
-- RPC fatal/close wakes every waiter and no new work enters after terminal;
-- Session is the only serving response/overlap authority;
-- stale terminal events cannot mutate a newer epoch;
-- an accepted terminal cannot be dropped by the writer;
-- no duplicate `response.speak` or transcript delta appears;
-- Stage0 KV continuity and Stage1 turn reset pass;
-- the real H20 multi-turn audio E2E passes;
-- ordinary non-duplex paths in the affected matrix still pass;
-- no local path, proxy token, temporary profiling probe, or test-only switch is present.
-
-Passing this checkpoint supports the statement:
-
-> Single-session, model-owned MiniCPM-o 4.5 native duplex is reviewable on the
-> validated H20 configuration.
-
-It does not support claims for an acoustic-onset barge-in latency target across
-arbitrary client chunk sizes, multi-session production concurrency, bounded
-long-session KV, or scheduler-native append. Camera-frame input
-(`video_frames`) landed after this snapshot and is covered by its own E2E
-test rather than by the evidence above.
+| engine policy | `configure_sampling_params(runtime_config, defaults)`, `plan_append(...) -> DuplexAppendPlan` (the resumable Stage0 prompt for one unit), `decide_output(...) -> DuplexOutputDecision \| None` (e.g. the listen decision on a finished Stage0 segment) |
+| session policy | `capabilities(max_sessions)`, `validate_client_extra_body`, `prepare_runtime_config(config, model_config)` (server-owned runtime keys, reference audio resolution), `runtime_config_for_update`, `runtime_config_for_function_output`, `create_session_state() -> DuplexModelSessionState`, `data_plane: DuplexDataPlane` (projects raw stage outputs into internal events), `data_plane_context(...)` |
+
+`DuplexOmniEngine._validate_deployment` loads the plugin before any stage
+starts; `DuplexSessionManager.__init__` validates it against the stage
+sampling defaults once the stage pools exist. Plugin hooks that may block
+(`prepare_runtime_config` fetching `ref_audio`) are awaited in `open()` and
+offloaded from the loop.
+
+The MiniCPM-o 4.5 plugin (`model_executor/models/minicpmo_4_5/duplex/plugin.py`)
+is the only integration in this framework version. PersonaPlex and Nemotron
+VoiceChat still carry their pre-framework duplex code (runtime extension plus
+serving adapter) and are therefore not served over this framework yet: their
+pipelines declare no `duplex_plugin`, so they run turn-based until the
+follow-up PRs port them (RFC vllm-omni#7181, PR 2/3).
+
+## Serving
+
+`OmniDuplexSessionHandler.handle_realtime_session(websocket)`:
+
+1. accept; build the `RealtimeEnvelope` (autostart / default session from
+   query params, `event_id` correlation, error rendering through the typed
+   `ErrorEvent`);
+2. handshake: first message `session.update` -> `omni.open_session(session)`
+   (the id inside the payload is ignored; the allocated id is announced in
+   `session.created` together with `resume_token` / `attachment_generation`
+   when the model supports resume); `session.resume(session_id, resume_token,
+   last_received_server_event_seq)` -> `attachment.authenticate_resume` ->
+   `omni.resume_session`;
+3. reader loop: JSON -> `RealtimeEnvelope.translate` (`translate_realtime_command`
+   with the session's declared audio defaults) -> `handle.submit`;
+   envelope-level errors (invalid JSON, oversize frame, unknown type,
+   event acks) are answered locally;
+4. writer pump (session-scoped, survives reconnects): `async for ev in
+   handle.events(): attachment.send_event(ev.to_realtime())`, journaling
+   for replay until the journal overflows (`session.resync_required`);
+5. disconnect: a resumable session is detached (`attachment.detach` +
+   `omni.detach_session`, engine-owned grace); a superseded socket's
+   disconnect is a no-op; a non-resumable session is closed. Takeover sends
+   `session.replaced` to the old socket and closes it.
+
+## Validation
+
+- CPU suites: `tests/engine/duplex/**` (session, lease, manager, runner,
+  plugin, events, commands), `tests/engine/test_duplex_orchestrator.py`,
+  `tests/engine/test_duplex_omni_engine.py`,
+  `tests/entrypoints/test_duplex_omni.py`,
+  `tests/entrypoints/duplex/test_duplex_serving.py`,
+  `tests/entrypoints/openai/test_duplex_session_attachment.py`,
+  `tests/entrypoints/openai_api/test_duplex_api_server.py` (the duplex
+  server: pipeline probe, app state, routes, warmup gate),
+  `tests/entrypoints/duplex/test_chat_completions_adapter.py`,
+  `tests/clients/**`, `tests/engine/test_duplex_import_boundary.py`,
+  `tests/model_executor/models/minicpmo_4_5/duplex/**`,
+  `tests/worker/test_native_duplex_hooks.py`.
+- GPU: `examples/online_serving/minicpmo/realtime_duplex_demo.py` (one turn
+  over the websocket), `examples/online_serving/barge_in_client.py` (cancel
+  during playback; `--inline` drives the same scenario through
+  `InlineDuplexClient`), `tests/e2e/online_serving/run_minicpmo_realtime_duplex_multi_session.py`
+  (admission, resume, takeover, expiry).
diff --git a/docs/design/index.md b/docs/design/index.md
index cff0b1eb3..f70571cb5 100644
--- a/docs/design/index.md
+++ b/docs/design/index.md
@@ -26,6 +26,7 @@ implementation contract; it is not, by itself, a general support claim.
 - [Async Omni Output Materialization](feature/omni_async_output_materialization.md)
 - [Runner-to-model Prefill/Decode Phase Contract](feature/preprocess_phase_contract.md)
 - [Automatic Prefix Caching in Omni Models](feature/prefix_caching.md)
+- [Model-local KV Caches](feature/model_local_kv_caches.md)
 - [Realtime AR-Diffusion Sessions](feature/realtime_ar_diffusion.md)
 
 ### Communication
@@ -35,6 +36,7 @@ implementation contract; it is not, by itself, a general support claim.
 - [Mooncake Store Connector](feature/omni_connectors/mooncake_store_connector.md)
 - [Mooncake Transfer Engine Connector](feature/omni_connectors/mooncake_transfer_engine_connector.md)
 - [Mori Transfer Engine Connector](feature/omni_connectors/mori_transfer_engine_connector.md)
+- [NIXL Connector](feature/omni_connectors/nixl_connector.md)
 - [Shared Memory Connector](feature/omni_connectors/shared_memory_connector.md)
 - [Yuanrong Store Connector](feature/omni_connectors/yuanrong_connector.md)
 - [Yuanrong Transfer Engine Connector](feature/omni_connectors/yuanrong_transfer_engine_connector.md)
diff --git a/docs/design/metrics.md b/docs/design/metrics.md
index 85eb7ac38..874cbd310 100644
--- a/docs/design/metrics.md
+++ b/docs/design/metrics.md
@@ -60,7 +60,7 @@ Upstream per-engine metrics retain the `vllm:` prefix but are now registered by
 
 There are five independent paths for metric collection.
 
-**Path 1: Pipeline-level metrics (`vllm_omni:*`)**
+#### Path 1: Pipeline-level metrics (`vllm_omni:*`)
 
 `OmniPrometheusMetrics` registers the Gauge / Counter / Histogram collectors at import time. It is instantiated once per entrypoint, labeled with the model name. The entrypoint calls its methods as requests progress:
 
@@ -69,7 +69,7 @@ There are five independent paths for metric collection.
 - `request_failed()` — recorded by the cleanup path when a request exits without natural completion. Internally maps to `finished_reason="abort"` on the existing completion Counter.
 - `inc_requests_failed(reason)` — increments the dedicated failure-attribution Counter once per request. Reasons are normalized to the bounded set `client_abort`, `client_disconnect`, `stage_error`, and `unknown`.
 
-**Path 2: Image and diffusion metrics**
+#### Path 2: Image and diffusion metrics
 
 Image and diffusion metrics use two cooperating collectors. `OmniPrometheusMetrics` owns pipeline/stage workload families, while `OmniModalityMetrics` owns per-replica diffusion breakdowns. Finished stage messages are consumed once in `OmniBase._process_single_result`, which prevents replayed terminal messages from incrementing Counters or Histograms twice.
 
@@ -81,15 +81,15 @@ Image and diffusion metrics use two cooperating collectors. `OmniPrometheusMetri
 
 Zero and missing values have different meanings. Valid zero-duration queue observations are recorded, while unavailable optional measurements are omitted instead of being exported as synthetic zeroes. `peak_memory_mb`, `diffusion_forward_s`, `diffusion_kv_load_s`, `vae_decode_s`, and `kv_wait_s` therefore appear only when their data source is active.
 
-**Path 3: Audio modality metrics (`vllm_omni:audio_*`)**
+#### Path 3: Audio modality metrics (`vllm_omni:audio_*`)
 
 `OmniModalityMetrics` registers seven audio families with `{model_name, stage, replica}` (plus an extra `threshold_ms` / `reason` label on the two extra-cardinality Counters). Three observation sites:
 
 - `observe_modality_at_finalize(...)` — called from `omni_base._process_single_result` inside the existing `e2e_done` finalize guard. For `output_type == "audio"` it emits `audio_frames_total`, `audio_duration_s`, `audio_rtf` (or `audio_skipped_requests_total{reason="no_audio_data"}` when no audio was produced). Sample rate is resolved from `engine_outputs.multimodal_output` via `definitions.resolve_audio_sample_rate(...)` (fallback chain mirrors `serving_chat.py`'s audio response path).
-- `observe_audio_first_packet(...)` — called from the OpenAI SSE audio branch in `serving_chat.py` on the first audio packet for a request. The once-per-request guard is held by `ClientRequestState.first_audio_ts`. The `request_arrival_ts` anchor is stored in `ClientRequestState` by `async_omni.generate()`, computed at request entry.
-- `observe_audio_streaming_finalize(...)` — called from `serving_chat.py` after the streaming chunk loop exhausts. It runs the per-chunk player simulation from `vllm_omni/benchmarks/audio_continuity.py` to compute the worst-case underrun and emits `audio_underrun_s` plus (when the request stayed below the threshold) `audio_continuity_ok_total{threshold_ms}`. Per-chunk PCM byte counts and arrival timestamps are recorded by the same audio branch that updates `first_audio_ts`.
+- `observe_audio_first_packet(...)` — called from the OpenAI SSE audio branch in `serving_chat.py` and the streaming TTS output paths in `serving_speech.py` on the first non-empty audio payload for a request. Streaming Speech observes the first PCM payload rather than a header-only WAV chunk. HTTP carries the middleware request timestamp through response generation; WebSocket uses the start of each sentence synthesis request. Non-streaming Speech does not emit TTFP and uses `e2e_request_latency_s` for overall latency instead.
+- `observe_audio_streaming_finalize(...)` — called from `serving_chat.py` and `serving_speech.py` after a streaming chunk loop exhausts normally. It runs the per-chunk player simulation from `vllm_omni/benchmarks/audio_continuity.py` to compute the worst-case underrun and emits `audio_underrun_s` plus (when the request stayed below the threshold) `audio_continuity_ok_total{threshold_ms}`. Per-chunk PCM byte counts and arrival timestamps are recorded by the same output paths that update TTFP. Speech records raw PCM payloads before raw/SSE/WebSocket encoding, excludes WAV headers and empty chunks, and does not emit continuity samples for failed, cancelled, or non-streaming requests.
 
-**Path 4: Cross-stage transfer metrics (`vllm_omni:transfer_*`)**
+#### Path 4: Cross-stage transfer metrics (`vllm_omni:transfer_*`)
 
 `OmniTransferMetrics` registers four Histogram families with `{model_name, from_stage, from_replica, to_stage, to_replica}` labels. Each observation corresponds to one physical transfer hop (one chunk between adjacent stages), not the per-request accumulated total — so the histograms track per-transfer distribution.
 
@@ -100,7 +100,7 @@ The hook lives in `OrchestratorAggregator.record_transfer_tx` and `record_transf
 
 Defensive fail-safe: if `transfer_emitter` or `replica_resolver` is missing, or the resolver returns `None` for either side, the emit is skipped silently (the underlying `TransferEdgeStats` accumulation is unaffected).
 
-**Path 5: Per-engine metrics (`vllm:*`, stage/replica wrap)**
+#### Path 5: Per-engine metrics (`vllm:*`, stage/replica wrap)
 
 The Orchestrator instantiates `OmniPrometheusStatLogger` (a thin subclass of upstream `vllm.v1.metrics.loggers.PrometheusStatLogger`) and feeds it scheduler stats and iteration stats after processing each batch of engine outputs. This populates the standard ~37 vLLM metric families (TTFT, ITL, TPOT, KV cache usage, etc.) using the same upstream code path — but with the `engine` label reshaped into `stage` + `replica` so multi-replica deployments produce distinct series per replica. See the next section for the wrap mechanics.
 
@@ -174,7 +174,7 @@ second.
 ### Pipeline (4)
 
 | Metric | Type | Labels | Description |
-|--------|------|--------|-------------|
+| -------- | ------ | -------- | ------------- |
 | `vllm_omni:num_requests_running` | Gauge | `model_name` | Requests currently executing across all stages |
 | `vllm_omni:num_requests_waiting` | Gauge | `model_name` | Requests queued but not yet scheduled |
 | `vllm_omni:requests_success_total` | Counter | `model_name`, `finished_reason` | Total requests by completion reason ({stop, length, abort, ...}); aborts cover client-disconnect / cancellation paths in addition to upstream `FinishReason.ABORT` |
@@ -183,7 +183,7 @@ second.
 ### Image and diffusion service-level metrics
 
 | Metric | Type | Labels | Description |
-|--------|------|--------|-------------|
+| -------- | ------ | -------- | ------------- |
 | `vllm_omni:stage_gen_time_s` | Histogram | `model_name`, `stage`, `stage_type` | Stage submit to finished output; includes in-stage queueing |
 | `vllm_omni:request_queue_wait_s` | Histogram | `model_name` | Orchestration-layer queue wait; a present zero is recorded |
 | `vllm_omni:stage_waiting_requests` | Gauge | `model_name`, `stage` | Sum of the latest waiting snapshots across live replicas in the stage |
@@ -200,7 +200,7 @@ second.
 Labels: `{model_name, stage, replica}`.
 
 | Metric | Type | Description |
-|--------|------|-------------|
+| -------- | ------ | ------------- |
 | `vllm_omni:diffusion_exec_s` | Histogram | Core diffusion-step execution time per request |
 | `vllm_omni:diffusion_exec_per_step_s` | Histogram | Core diffusion execution divided by inference-step count |
 | `vllm_omni:diffusion_preprocess_s` | Histogram | Diffusion input preprocessing time |
@@ -218,7 +218,7 @@ The optional breakdown and memory families are sparse by design: when an engine
 Labels: `{model_name, stage, replica}` plus the listed extra label.
 
 | Metric | Type | Extra label | Description |
-|--------|------|-------------|-------------|
+| -------- | ------ | ------------- | ------------- |
 | `vllm_omni:audio_ttfp_s` | Histogram | — | Time from request arrival to first audio packet/frame |
 | `vllm_omni:audio_duration_s` | Histogram | — | Audio content duration (`audio_frames / sample_rate`) |
 | `vllm_omni:audio_rtf` | Histogram | — | Real-time factor `stage_gen_time_s / audio_duration_s` (SLO `< 1`); uses `RTF_BUCKETS` |
@@ -227,12 +227,29 @@ Labels: `{model_name, stage, replica}` plus the listed extra label.
 | `vllm_omni:audio_continuity_ok_total` | Counter | `threshold_ms` | Incremented when the request's worst underrun stayed below `threshold_ms` |
 | `vllm_omni:audio_skipped_requests_total` | Counter | `reason` | Silent-loss counter — code2wav rejected malformed codec input and returned `200 OK` with empty audio |
 
+### Speech streaming (2)
+
+Labels: `{model_name}` plus the listed extra label.
+
+| Metric | Type | Extra label | Description |
+| -------- | ------ | ------------- | ------------- |
+| `vllm_omni:speech_stream_aborted_total` | Counter | `reason` | Interrupted audio generators, including before first PCM; reasons: `cancelled`, `closed`, `engine_dead`, `error` |
+| `vllm_omni:speech_stream_completed_total` | Counter | — | Normally completed audio generators; does not confirm client receipt |
+
+Scope: started Speech audio generators (raw/SSE/WebSocket), counted once per
+generation; WebSocket counts each sentence. Chat, non-streaming Speech, and
+failures before generator execution are excluded. Interrupted streams do not
+emit continuity or underrun samples.
+
+Interruption ratio: `aborted / (aborted + completed)`, using increments over the
+same time window and summing all reasons per model.
+
 ### Cross-stage transfer (4)
 
 Labels: `{model_name, from_stage, from_replica, to_stage, to_replica}`.
 
 | Metric | Type | Description |
-|--------|------|-------------|
+| -------- | ------ | ------------- |
 | `vllm_omni:transfer_size_bytes` | Histogram | Per-transfer payload size in bytes |
 | `vllm_omni:transfer_tx_s` | Histogram | Sender-side time (serialize + submit to connector) |
 | `vllm_omni:transfer_rx_s` | Histogram | Receiver-side time (recv + deserialize) |
@@ -245,8 +262,8 @@ After the wrap, every upstream `vllm:*` family — TTFT, ITL, TPOT, e2e latency,
 ## Naming Convention
 
 - All time-bearing metrics use the `_s` suffix (values in seconds). Two bucket families are used:
-  - `SECONDS_BUCKETS` (0.05 s – 300 s) for e2e / generation / TTFP style values.
-  - `SECONDS_FAST_BUCKETS` (0.001 s – 60 s) for fine-grained cross-stage transfer and audio-underrun values that need millisecond-level resolution.
+    - `SECONDS_BUCKETS` (0.05 s – 300 s) for e2e / generation / TTFP style values.
+    - `SECONDS_FAST_BUCKETS` (0.001 s – 60 s) for fine-grained cross-stage transfer and audio-underrun values that need millisecond-level resolution.
 - Counters use the `_total` suffix (auto-appended by `prometheus_client`).
 - Sizes use the `_bytes` suffix.
 - All omni-specific families are prefixed `vllm_omni:`. The upstream `unregister_vllm_metrics()` function is monkey-patched to a scoped version that still strips upstream `vllm:*` collectors (so multi-engine init within one process does not crash on duplicate registration) but preserves anything prefixed `vllm_omni:` / `vllm_omni`.
diff --git a/docs/design/module/engine_orchestration.md b/docs/design/module/engine_orchestration.md
index d4dbf51a2..df22f3ce1 100644
--- a/docs/design/module/engine_orchestration.md
+++ b/docs/design/module/engine_orchestration.md
@@ -16,6 +16,7 @@ required_reviewers:
   - "@yenuo26"
   - "@NickCao"
 primary_code_paths:
+  - vllm_omni/engine/omni_engine_base.py
   - vllm_omni/engine/async_omni_engine.py
   - vllm_omni/engine/async_engine_utils.py
   - vllm_omni/engine/orchestrator.py
@@ -28,8 +29,12 @@ related_code_paths:
   - vllm_omni/engine/stage_pool.py
   - vllm_omni/outputs/output_processor.py
   - vllm_omni/distributed/omni_coordinator/**
-  # Duplex kernel design is owned by ../fullduplex.md; listed here because the
-  # orchestrator hosts the duplex control plane.
+  # The duplex siblings (DuplexOmniEngine / DuplexOrchestrator) and the
+  # engine-resident session framework are owned by ../fullduplex.md; listed
+  # here because they fill the template seams of OmniEngineBase and
+  # OrchestratorBase.
+  - vllm_omni/engine/duplex_omni_engine.py
+  - vllm_omni/engine/duplex_orchestrator.py
   - vllm_omni/engine/duplex/**
 depends_on:
   - input_output_modality_contracts.md
@@ -48,6 +53,8 @@ validation_paths:
   - tests/engine/test_cfg_companion_lifecycle.py
   - tests/engine/test_rpc_result_router.py
   - tests/engine/duplex/**
+  - tests/engine/test_duplex_orchestrator.py
+  - tests/engine/test_duplex_omni_engine.py
   - tests/engine/test_duplex_import_boundary.py
 upstream_refs:
   - vllm.v1.engine.EngineCoreRequest
diff --git a/docs/design/module/entrypoints.md b/docs/design/module/entrypoints.md
index a0dee90b9..0c0ba8439 100644
--- a/docs/design/module/entrypoints.md
+++ b/docs/design/module/entrypoints.md
@@ -19,7 +19,9 @@ required_reviewers:
 primary_code_paths:
   - vllm_omni/entrypoints/omni.py
   - vllm_omni/entrypoints/async_omni.py
+  - vllm_omni/entrypoints/async_omni_base.py
   - vllm_omni/entrypoints/omni_base.py
+  - vllm_omni/entrypoints/duplex_omni.py
   - vllm_omni/entrypoints/cli/**
   - vllm_omni/entrypoints/openai/**
   - vllm_omni/entrypoints/openpi/**
@@ -27,14 +29,14 @@ primary_code_paths:
   - vllm_omni/entrypoints/stage_utils.py
   - vllm_omni/entrypoints/utils.py
   - vllm_omni/entrypoints/duplex/**
-  - vllm_omni/entrypoints/duplex_request_client.py
   - vllm_omni/clients/**
+  - vllm_omni/protocol/**
 primary_path_exceptions:
   - path: vllm_omni/entrypoints/openai/errors.py
     owner: error_contracts.md
   - path: vllm_omni/entrypoints/duplex/**
     owner: ../fullduplex.md
-  - path: vllm_omni/entrypoints/duplex_request_client.py
+  - path: vllm_omni/entrypoints/duplex_omni.py
     owner: ../fullduplex.md
   - path: vllm_omni/clients/**
     owner: ../fullduplex.md
@@ -42,7 +44,9 @@ related_code_paths:
   - vllm_omni/errors.py
   - vllm_omni/inputs/**
   - vllm_omni/outputs/**
+  - vllm_omni/engine/omni_engine_base.py
   - vllm_omni/engine/async_omni_engine.py
+  - vllm_omni/engine/duplex_omni_engine.py
   - vllm_omni/config/**
   - vllm_omni/deploy/**
 depends_on:
@@ -50,10 +54,13 @@ 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
-  - tests/entrypoints/test_async_omni_duplex.py
+  - tests/entrypoints/test_duplex_omni.py
+  - tests/entrypoints/duplex/**
+  - tests/entrypoints/openai_api/test_duplex_api_server.py
   - tests/entrypoints/test_serve.py
   - tests/entrypoints/test_stream_finish_reason.py
   - tests/entrypoints/openai/**
@@ -89,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`.
@@ -103,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
@@ -136,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/host_weight_runtime.md b/docs/design/module/host_weight_runtime.md
index ac92711fc..c97561667 100644
--- a/docs/design/module/host_weight_runtime.md
+++ b/docs/design/module/host_weight_runtime.md
@@ -136,8 +136,16 @@ so only when it is marked retryable; unsupported capabilities, identity
 collisions, producer failures, and publication failures remain visible as
 startup failures.
 
-`coordination_timeout_seconds` bounds acquisition of lookup and build locks; it
-is not a hard wall-clock deadline for in-process validation, production, or
+`coordination_timeout_seconds` bounds acquisition of the domain-initialization
+lock and lookup/build locks. Store construction and each later resolution or
+publication operation receive separate coordination budgets from the same
+`WaitPolicy`; they do not share an end-to-end startup deadline. A domain-init
+lock timeout is a retryable domain failure: preferred mode may fall back and
+required mode fails. Retrying initialization requires constructing a fresh
+runtime after contention ends; a waiter never cancels or unlocks the owner.
+
+The coordination budget is not a hard wall-clock deadline for filesystem I/O,
+in-process validation, production, or
 atomic publication. Once this V1 implementation becomes the producer, the
 synchronous producer and publication run to completion. A hung producer blocks
 its owning process and requires external process supervision; enforceable
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 ff766cbb3..dda68b793 100644
--- a/docs/features/comfyui.md
+++ b/docs/features/comfyui.md
@@ -13,7 +13,6 @@ It can send model inference requests to either a locally running vLLM-Omni servi
 !!! tip
     If you run both ComfyUI and vLLM-Omni on the same device, you can create separate virtual environments and use different Python versions for them.
 
-
 ## Installation
 
 Copy the `apps/ComfyUI-vLLM-Omni` folder to the `custom_nodes` subfolder of your ComfyUI installation. Your directory should look like `ComfyUI/custom_nodes/ComfyUI-vLLM-Omni`.
@@ -21,9 +20,10 @@ Copy the `apps/ComfyUI-vLLM-Omni` folder to the `custom_nodes` subfolder of your
 If you are running ComfyUI during copying, you should restart ComfyUI to load this extension.
 
 !!! tip
-    You can use utility websites such as https://download-directory.github.io/ to download a subdirectory of a repo. Also checkout community discussions (e.g., https://stackoverflow.com/questions/7106012/download-a-single-folder-or-directory-from-a-github-repository) for more info.
+    You can use utility websites such as <https://download-directory.github.io/> to download a subdirectory of a repo. Also checkout community discussions (e.g., <https://stackoverflow.com/questions/7106012/download-a-single-folder-or-directory-from-a-github-repository>) for more info.
 
 On the device and virtual environment you run ComfyUI, launch ComfyUI with
+
 ```bash
 cd ComfyUI
 
@@ -35,6 +35,7 @@ python main.py --cpu
 ```
 
 On the device and virtual environment you run vLLM-Omni, start a model service with
+
 ```bash
 vllm serve The_Model_ID_to_Serve --omni --port 8000
 ```
@@ -50,12 +51,27 @@ 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**)
 
 !!! info
     The node UI and feature designs are intended to match vLLM-Omni online serving interfaces. It cannot offer more than what the interfaces support.
 
+Every node carries the vLLM-Omni mark in its title bar and is tinted by what it outputs, so a graph is readable at a glance:
+
+| Colour | Nodes | What they produce |
+| --- | --- | --- |
+| Blue | Generate Image, Generate Video, Multimodality Understanding, TTS, TTS Voice Clone | A generated image, video, audio, or text. These are the only nodes that reach a server. |
+| Amber | AR / Diffusion / Multi-Stage Sampling Params | Sampling parameters that apply to any model |
+| Purple | Qwen TTS Params, Wan Video Params, MiniMax-H3 Video Params | Parameters that only one model family accepts |
+| Red | LoRA, FastH3 Deployment | Which weights the server is expected to have loaded |
+| Teal | Video References | Reference media |
+
+Recolouring a node by hand (right click -> Colors) overrides its tint, and the choice is kept.
+
+**Generate Video** takes a clip length in seconds (`duration`), not a frame count. Frames stay the wire unit and are derived with the node's `fps`, so the length is always measured against the rate that is actually served; models that accept only certain frame counts still round to their own lattice server-side. Graphs saved before this widget existed stored `num_frames` in its place and are converted on load, using the fps recorded alongside it -- the browser console names every node it rewrites.
+
 To build a simple workflow yourself,
 
 - Drag a generation node onto the canvas.
@@ -66,6 +82,18 @@ To build a simple workflow yourself,
     - For some multi-stage models like BAGEL, [only one stage's sampling parameters are exposed and tunable via vLLM-Omni's online serving API](https://docs.vllm.ai/projects/vllm-omni/en/latest/user_guide/examples/online_serving/bagel/). Thus, these models are treated as single-stage ones. Please check the vLLM-Omni documentation on how to correctly set each model's sampling parameters.
     - For multi-stage models where all stages are either autoregression or diffusion, you can also connect only a single Sampling Params node, indicating that this set of sampling parameters will be used for all stages.
 
+## MiniMax H3 text-to-video workflow
+
+The **MiniMax H3 Text to Video** template uses the existing remote Generate Video,
+H3 Params, sampling, and Remote LoRA nodes. It includes Base settings and an
+optional Turbo preset, with native resolution, 24 FPS, and `17k+5` frame counts.
+ComfyUI receives the generated video and audio from the server; it does not load
+H3 weights locally. Configure the server-side LoRA path before enabling Turbo.
+
+See the [H3 workflow guide](https://github.com/vllm-project/vllm-omni/blob/main/apps/ComfyUI-vLLM-Omni/docs/minimax-h3-t2v.md)
+for server setup, template import, Turbo configuration, recorded validation,
+and saved-video/audio checks.
+
 ## Examples & Screenshots
 
 Please read the [ComfyUI integration's README](https://github.com/vllm-project/vllm-omni/tree/main/apps/ComfyUI-vLLM-Omni) for more info.
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/getting_started/installation/gpu/rocm.inc.md b/docs/getting_started/installation/gpu/rocm.inc.md
index d15bba2eb..83efe0c62 100644
--- a/docs/getting_started/installation/gpu/rocm.inc.md
+++ b/docs/getting_started/installation/gpu/rocm.inc.md
@@ -1,11 +1,23 @@
+<!-- markdownlint-disable MD001 MD025 -->
+
 # --8<-- [start:requirements]
 
 - GPU: Validated on gfx942 (It should be supported on the AMD GPUs that are supported by vLLM.)
 
 # --8<-- [end:requirements]
+
 # --8<-- [start:set-up-using-python]
 
-vLLM-Omni current recommends the steps in under setup through Docker Images.
+For ROCm, vLLM-Omni currently recommends the setup steps through Docker Images.
+
+vLLM-Omni depends on the matching major/minor release of vLLM. The 0.29
+development line uses vLLM 0.29.x. Published 0.28.0 wheels and images use vLLM
+0.28.x.
+
+The Dockerfile's `BASE_IMAGE` pin applies only to Docker builds. The
+`vllm-omni` package does not install vLLM as a dependency, so non-Docker source
+installs must install the matching ROCm vLLM release explicitly before
+installing vLLM-Omni, as shown below.
 
 # --8<-- [start:pre-built-wheels]
 
@@ -14,6 +26,7 @@ vLLM-Omni current recommends the steps in under setup through Docker Images.
 These pre-built wheel instructions install the published vLLM-Omni 0.28.0 release. For the 0.29 development line, use the source-install instructions below.
 
 vLLM-Omni is built based on vLLM. Please install it with command below.
+
 ```bash
 uv pip install vllm==0.28.0+rocm723 --extra-index-url https://wheels.vllm.ai/rocm/0.28.0/rocm723
 ```
@@ -36,6 +49,7 @@ uv pip install onnxruntime-rocm
 # --8<-- [start:build-wheel-from-source]
 
 #### Installation of vLLM
+
 If you do not need to modify source code of vLLM, you can directly install the stable 0.29.0 release version of the library
 
 ```bash
@@ -45,7 +59,9 @@ uv pip install vllm==0.29.0+rocm723 --extra-index-url https://wheels.vllm.ai/roc
 The pre-built 0.29.0 vLLM wheel targets ROCm 7.2.3. If you need a different ROCm stack or want to reuse an existing PyTorch installation, build vLLM from source instead.
 
 #### Installation of vLLM-Omni
+
 Since vllm-omni is rapidly evolving, it's recommended to install it from source
+
 ```bash
 git clone https://github.com/vllm-project/vllm-omni.git
 cd vllm-omni
@@ -71,15 +87,31 @@ python3 setup.py develop
 
 #### Build docker image
 
+The source build defaults to the published upstream base image
+`vllm/vllm-openai-rocm:v0.29.0`, aligned with the vLLM release used by CI.
+Older or custom bases must provide the vLLM APIs checked by the Dockerfile's
+image-build canary. This upstream base is distinct from the prebuilt
+`vllm/vllm-omni-rocm` images discussed below; their published-tag availability
+is tracked in [#7405](https://github.com/vllm-project/vllm-omni/issues/7405).
+
 ```bash
 DOCKER_BUILDKIT=1 docker build -f docker/Dockerfile.rocm -t vllm-omni-rocm .
 ```
 
+To select the upstream ROCm base explicitly, pass `BASE_IMAGE`:
+
+```bash
+DOCKER_BUILDKIT=1 docker build \
+  -f docker/Dockerfile.rocm \
+  --build-arg BASE_IMAGE=vllm/vllm-openai-rocm:v0.29.0 \
+  -t vllm-omni-rocm .
+```
+
 #### Launch the docker image
 
 ##### Launch with OpenAI API Server
 
-```
+```bash
 docker run --rm \
 --group-add=video \
 --ipc=host \
@@ -97,7 +129,7 @@ vllm-omni-rocm \
 
 ##### Launch with interactive session for development
 
-```
+```bash
 docker run --rm -it \
 --network=host \
 --group-add=video \
@@ -119,7 +151,9 @@ vllm-omni-rocm
 vLLM-Omni offers an official docker image for deployment. These images are built on top of vLLM docker images and available on Docker Hub as [vllm/vllm-omni-rocm](https://hub.docker.com/r/vllm/vllm-omni-rocm/tags). The version of vLLM-Omni indicates which release of vLLM it is based on.
 
 #### Launch vLLM-Omni Server
+
 Here's an example deployment command that has been verified on 2 x MI300's:
+
 ```bash
 docker run --rm \
   --group-add=video \
@@ -136,8 +170,10 @@ docker run --rm \
   --model Qwen/Qwen3-Omni-30B-A3B-Instruct --omni --port 8091
 ```
 
-#### Launch an interactive terminal with prebuilt docker image.
+#### Launch an interactive terminal with prebuilt docker image
+
 If you want to run in dev environment you can launch the docker image as follows:
+
 ```bash
 docker run --rm -it \
   --network=host \
diff --git a/docs/getting_started/installation/npu/npu.inc.md b/docs/getting_started/installation/npu/npu.inc.md
index 9ff477522..21127caf2 100644
--- a/docs/getting_started/installation/npu/npu.inc.md
+++ b/docs/getting_started/installation/npu/npu.inc.md
@@ -10,25 +10,25 @@ The recommended way to use vLLM-Omni on NPU is through the vLLM-Ascend pre-built
 === "A2"
 
     ```bash
-    export IMAGE=quay.io/atlas-ci/vllm-ascend:v0.28.0
+    export IMAGE=quay.io/atlas-ci/vllm-ascend:v0.29.0
     ```
 
 === "A3"
 
     ```bash
-    export IMAGE=quay.io/atlas-ci/vllm-ascend:v0.28.0-a3
+    export IMAGE=quay.io/atlas-ci/vllm-ascend:v0.29.0-a3
     ```
 
 === "A5"
 
     ```bash
-    export IMAGE=quay.io/atlas-ci/vllm-ascend:v0.28.0-a5
+    export IMAGE=quay.io/atlas-ci/vllm-ascend:v0.29.0-a5
     ```
 
 === "310P (Experimental)"
 
     ```bash
-    export IMAGE=quay.io/atlas-ci/vllm-ascend:v0.28.0-310p
+    export IMAGE=quay.io/atlas-ci/vllm-ascend:v0.29.0-310p
     ```
 
 ```bash
@@ -53,7 +53,7 @@ docker run --rm \
 
 # Inside the container, install vLLM-Omni from source
 cd /vllm-workspace
-git clone -b v0.28.0 https://github.com/vllm-project/vllm-omni.git
+git clone -b v0.29.0rc1 https://github.com/vllm-project/vllm-omni.git
 cd vllm-omni
 pip install -v -e . --no-build-isolation
 # or VLLM_OMNI_TARGET_DEVICE=npu pip install -v -e .
@@ -71,10 +71,10 @@ We are keeping [issue #886](https://github.com/vllm-project/vllm-omni/issues/886
 
 # --8<-- [start:installation-main]
 
-You can also install vLLM-Omni from the latest main branch if you want to use the latest features or bug fixes. Use the aligned vLLM-Ascend v0.28.0 image described above, and check [issue #886](https://github.com/vllm-project/vllm-omni/issues/886) for the status of the latest vLLM-Omni commit on NPU.
+You can also install vLLM-Omni from the latest main branch if you want to use the latest features or bug fixes. Use the aligned vLLM-Ascend v0.29.0 image described above, and check [issue #886](https://github.com/vllm-project/vllm-omni/issues/886) for the status of the latest vLLM-Omni commit on NPU.
 
 ```bash
-# Inside the vLLM-Ascend v0.28.0 container, install vLLM-Omni from main
+# Inside the vLLM-Ascend v0.29.0 container, install vLLM-Omni from main
 cd /vllm-workspace
 git clone https://github.com/vllm-project/vllm-omni.git
 cd vllm-omni
@@ -103,7 +103,7 @@ Here's an example deployment command that has been verified on 4 x NPUs:
 === "A2"
 
     ```bash
-    export IMAGE=quay.io/ascend/vllm-omni:v0.28.0
+    export IMAGE=quay.io/ascend/vllm-omni:v0.29.0
     docker run --rm \
         --name vllm-omni-a2 \
         --shm-size=64g \
@@ -127,7 +127,7 @@ Here's an example deployment command that has been verified on 4 x NPUs:
 === "A3"
 
     ```bash
-    export IMAGE=quay.io/ascend/vllm-omni:v0.28.0-a3
+    export IMAGE=quay.io/ascend/vllm-omni:v0.29.0-a3
     docker run --rm \
         --name vllm-omni-a3 \
         --shm-size=64g \
@@ -151,7 +151,7 @@ Here's an example deployment command that has been verified on 4 x NPUs:
 === "A5"
 
     ```bash
-    export IMAGE=quay.io/ascend/vllm-omni:v0.28.0-a5
+    export IMAGE=quay.io/ascend/vllm-omni:v0.29.0-a5
     docker run --rm \
         --name vllm-omni-a5 \
         --shm-size=64g \
@@ -175,7 +175,7 @@ Here's an example deployment command that has been verified on 4 x NPUs:
 === "310P (Experimental)"
 
     ```bash
-    export IMAGE=quay.io/ascend/vllm-omni:v0.28.0-310p
+    export IMAGE=quay.io/ascend/vllm-omni:v0.29.0-310p
     docker run --rm \
         --name vllm-omni-310p \
         --shm-size=64g \
diff --git a/docs/mkdocs/hooks/generate_api_readme.py b/docs/mkdocs/hooks/generate_api_readme.py
index 3130e688f..d236c1129 100644
--- a/docs/mkdocs/hooks/generate_api_readme.py
+++ b/docs/mkdocs/hooks/generate_api_readme.py
@@ -25,8 +25,8 @@ CATEGORIES = {
     "clients": {
         "name": "Clients",
         "description": (
-            "Client libraries that talk to a running vLLM-Omni server "
-            "(the full-duplex Realtime client and its per-model session presets)."
+            "Client libraries for full-duplex sessions: the Realtime WebSocket client, "
+            "the in-process client over `DuplexOmni`, and the per-model session presets."
         ),
     },
     "inputs": {
diff --git a/docs/mkdocs/hooks/generate_argparse.py b/docs/mkdocs/hooks/generate_argparse.py
index 4c3ad3373..ea0fc9e0c 100644
--- a/docs/mkdocs/hooks/generate_argparse.py
+++ b/docs/mkdocs/hooks/generate_argparse.py
@@ -2,6 +2,7 @@
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
 import ast
+import json
 import logging
 import re
 import sys
@@ -124,6 +125,7 @@ def extract_omni_serve_subparser_init():
                         "make_arg_parser": lambda parser: parser,  # no-op for doc
                         "_ensure_vllm_platform": lambda: None,  # no-op for doc
                         "_nonneg_finite_float": float,
+                        "_json_object": json.loads,
                         "_parse_stage_overrides": __import__("json").loads,
                         "VLLM_SUBCMD_PARSER_EPILOG": "",
                         "logger": logger,
diff --git a/docs/mkdocs/hooks/search_index.py b/docs/mkdocs/hooks/search_index.py
index 1b9e268d9..8cf23e869 100644
--- a/docs/mkdocs/hooks/search_index.py
+++ b/docs/mkdocs/hooks/search_index.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
 """Reduce browser search-index memory for generated API reference pages."""
 
 from material.plugins.search.plugin import SearchIndex
diff --git a/docs/models/supported_models.md b/docs/models/supported_models.md
index 756f4be6a..d53cbe41a 100644
--- a/docs/models/supported_models.md
+++ b/docs/models/supported_models.md
@@ -59,6 +59,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` | ✅︎ | ✅︎ | ✅︎ | ✅︎ | — |
@@ -69,9 +70,10 @@ th {
 | `StableDiffusionXLPipeline` | Stable-Diffusion-XL | `stabilityai/stable-diffusion-xl-base-1.0` | ✅︎ | ✅︎ | ✅︎ | ✅︎ | — |
 | `StableDiffusion3Pipeline` | Stable-Diffusion-3 | `stabilityai/stable-diffusion-3.5-medium` | ✅︎ | ✅︎ | | ✅︎ | — |
 | `CosyVoice3Model` | CosyVoice3 | `FunAudioLLM/Fun-CosyVoice3-0.5B-2512` | ✅︎ | ✅︎ | | ✅︎ | — |
+| `AuKForConditionalGeneration` | AuK / AuK-Flash (instruction-driven speech generation and editing) | `tencent/AuK`, `tencent/AuK-Flash` (with `Qwen/Qwen2.5-Omni-3B`; assemble with `tools/prepare_auk_checkpoint.py`) | ✅︎ | | | | [Repository](https://github.com/vllm-project/vllm-omni/blob/main/recipes/Tencent/AuK-H100.md) |
 | `OmniVoiceModel` | OmniVoice | `k2-fsa/OmniVoice` | ✅︎ | | | ✅︎ | — |
 | `VoxCPM2TalkerForConditionalGeneration` | VoxCPM2 | `openbmb/VoxCPM2` | ✅︎ | | | ✅︎ | — |
-| `DotsTTSForConditionalGeneration` | dots.tts | `dots-studio/dots.tts-soar` | ✅︎ | | | | — |
+| `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) |
 | `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` | ✅︎ | ✅︎ | ✅︎ | ✅︎ | — |
@@ -86,7 +88,7 @@ th {
 | `Qwen3TTSForConditionalGeneration` | Qwen3-TTS-12Hz-1.7B-Base | `Qwen/Qwen3-TTS-12Hz-1.7B-Base` | ✅︎ | ✅︎ | ✅︎ | ✅︎ | — |
 | `MingTTSForConditionalGeneration` | Ming-omni-tts dense 0.5B | `inclusionAI/Ming-omni-tts-0.5B` | ✅︎ | | | ✅︎ | — |
 | `GLMTTSForConditionalGeneration` | GLM-TTS | `zai-org/GLM-TTS` | ✅︎ | | | | — |
-| `MossTTSNanoForCausalLM` | MOSS-TTS-Nano | `OpenMOSS-Team/MOSS-TTS-Nano` | ✅︎ | | | | — |
+| `MossTTSNanoForCausalLM` | MOSS-TTS-Nano | `OpenMOSS-Team/MOSS-TTS-Nano` | ✅︎ | | ✅︎ | | [Repository](https://github.com/vllm-project/vllm-omni/blob/main/recipes/OpenMOSS/MOSS-TTS-Nano-NPU.md) |
 | `MossTTSDelayModel` | MOSS-TTS, MOSS-TTSD, MOSS-SoundEffect, MOSS-VoiceGenerator | `OpenMOSS-Team/MOSS-VoiceGenerator` | ✅︎ | | | | — |
 | `MossTTSRealtime` | MOSS-TTS-Realtime | `OpenMOSS-Team/MOSS-TTS-Realtime` | ✅︎ | | | | — |
 | `HiggsAudioV2ForConditionalGeneration` | Higgs-Audio v2 | `bosonai/higgs-audio-v2-generation-3B-base` | ✅︎ | | | | — |
@@ -105,12 +107,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` | ✅︎ | | ✅︎ | | — |
+| `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/README.md b/docs/serving/README.md
index 8167f4c9b..472ab2a49 100644
--- a/docs/serving/README.md
+++ b/docs/serving/README.md
@@ -145,15 +145,22 @@ interchangeably.
 | Incremental text input for speech synthesis | `WS /v1/audio/speech/stream` | Send text events and receive audio | [Streaming Text to Speech](speech_api.md#streaming-text-input-websocket) |
 | Live video understanding | `WS /v1/video/chat/stream` | Send video frames and receive text/audio | [Streaming Video Input](video_stream_api.md) |
 | Turn-based realtime audio | `WS /v1/realtime` | Stream one audio input and receive transcript/audio events | [Realtime Audio](realtime_api.md) |
-| Continuous speech-to-speech interaction | `WS /v1/realtime?duplex=1` or `WS /v1/duplex` | Listen and speak concurrently with session control | [Full Duplex](full_duplex_api.md) |
+| Continuous speech-to-speech interaction | `WS /v1/realtime?duplex=1` (alias `WS /v1/duplex`) | Listen and speak concurrently with session control | [Full Duplex](full_duplex_api.md) |
 | Generated video chunks | `WS /v1/realtime/video` | Start a diffusion request and receive fragmented MP4 | [Streaming Video Output](streaming_video_output_api.md) |
 | Robot policy inference | `WS /v1/realtime/robot/openpi` | Send MessagePack observations and receive action arrays | [OpenPI Robot Policy](openpi_api.md) |
 
 All six routes are model- or configuration-dependent. In particular,
-`/v1/realtime` is not full duplex unless the client sets `duplex=1` and the
-deployment explicitly enables duplex sessions. Clients should also verify the
-duplex capability payload because the query-parameter form falls back to the
-ordinary realtime handler when duplex is unavailable.
+`/v1/realtime` is full duplex when the model is a duplex model (its pipeline
+declares a `duplex_plugin` and the deploy configuration sets
+`session_mode: duplex`); a stock Realtime client needs no vendor query
+parameter, and `duplex=0` is the explicit opt-out. Such a server serves the
+websocket route plus `POST /v1/chat/completions`, and no other turn-based
+HTTP route. On a duplex server that chat route is not the turn-based path:
+each request runs on a short-lived duplex session, so it holds one of
+`duplex_session.max_sessions` for its lifetime and answers at the model's
+real-time pace -- see [Full Duplex](full_duplex_api.md). Clients should
+also verify the duplex capability payload because the query-parameter form
+falls back to the ordinary realtime handler when duplex is unavailable.
 
 ## Related Endpoints
 
diff --git a/docs/serving/full_duplex_api.md b/docs/serving/full_duplex_api.md
index f648d6fdb..9b3eceb58 100644
--- a/docs/serving/full_duplex_api.md
+++ b/docs/serving/full_duplex_api.md
@@ -15,40 +15,68 @@ capability gates, see the [Realtime Duplex API guide](realtime_duplex_api.md).
 
 | Endpoint | Protocol | Recommended use |
 | --- | --- | --- |
-| `WS /v1/realtime?duplex=1` | OpenAI Realtime-style event projection | Applications and browser clients |
-| `WS /v1/duplex` | Native vLLM-Omni duplex events | Runtime integration and low-level testing |
-
-Both endpoints use the same duplex engine and require the same model-side
-adapter. Prefer the Realtime projection unless the native lifecycle events are
-specifically required.
+| `WS /v1/realtime?duplex=1` | OpenAI Realtime-style events (the normative contract) | Applications and browser clients |
+| `WS /v1/duplex` | Alias of `/v1/realtime?duplex=1` (same protocol, same handler) | Clients that prefer a dedicated path |
+| Python: `DuplexOmni` / `InlineDuplexClient` | Typed commands and events in-process | Embedding the model without a server |
 
 ## Enable Full Duplex
 
-The route becomes usable only when the deployment configuration explicitly
-sets:
+A model is served full duplex when its registered pipeline declares a
+`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". 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
+alongside the live websocket sessions, with the request options the chat
+service supports. It is wired only when the model's plugin declares
+`DuplexCapabilities.supports_chat_completions`; on any other duplex model the
+route reports "not available". A model that should not serve the route at all
+lists it in the deploy configuration's `endpoint_restrictions`.
+
+The deploy configuration of such a model must agree:
 
 ```yaml
 session_mode: duplex
 ```
 
-The selected model pipeline must also provide a duplex serving adapter.
-Model-native deployments configure the corresponding engine runtime extension
-and control plane as part of their registered pipeline.
+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
 
-    `WS /v1/duplex` fails with `Duplex API is not available` when duplex is not
-    enabled. By contrast, `/v1/realtime?duplex=1` falls back to the ordinary
-    turn-based realtime handler when no duplex handler exists. Confirm that
+    On a deployment that is *not* duplex, `WS /v1/duplex` fails with
+    `Duplex API is not available` and `/v1/realtime?duplex=1` falls back to the
+    ordinary turn-based realtime handler. Confirm that
     `session.created.session.capabilities` is present before treating the
     connection as full duplex.
 
-The current unified-runtime integrations are:
-
-- MiniCPM-o 4.5, using `vllm_omni/deploy/minicpmo_4_5.yaml`
-  (`session_mode: duplex`);
-- PersonaPlex, whose default `vllm_omni/deploy/personaplex.yaml` enables duplex;
-- Nemotron VoiceChat, via its registered duplex plugin package.
+**MiniCPM-o 4.5** (`vllm_omni/deploy/minicpmo_4_5.yaml`) is the only model
+served over this endpoint today. PersonaPlex and Nemotron VoiceChat still carry
+their pre-framework duplex code: their pipelines declare no `duplex_plugin`, so
+they run turn-based until the follow-up PRs port them to the plugin contract
+(RFC [vllm-omni#7181](https://github.com/vllm-project/vllm-omni/issues/7181)).
 
 JoyVL is a separate HTTP interaction orchestrator and does not use these
 WebSocket endpoints. See [Standalone Experimental Servers](standalone_servers.md).
@@ -86,7 +114,7 @@ A typical `/v1/realtime?duplex=1` session follows this lifecycle:
 3. Send `input_audio_buffer.append` events while microphone audio arrives.
 4. Send `input_audio_buffer.commit` at a user-turn boundary when required by
    the model policy.
-5. Consume `response.created`, transcript deltas, `response.audio.delta`, and
+5. Consume `response.created`, transcript deltas, `response.output_audio.delta`, and
    `response.done` or `response.listen` events.
 6. Send `playback.ack` after audio has been played when the session advertises
    playback acknowledgement support.
@@ -101,22 +129,23 @@ deferred, treated as a short acknowledgement, or used to interrupt output.
 The `session.created` payload includes capability fields such as
 `supports_barge_in`, `supports_playback_ack`, `supports_multi_session`,
 `supports_session_resume`, and `chunk_period_ms`. Treat this payload as the
-runtime contract.
+runtime contract and branch on the flags, never on the model name: a model
+that supports native overlapping speech may still advertise
+`supports_barge_in=false` when destructive output interruption and model-state
+rewind are not validated for it. Capacity and session-resume behavior also
+depend on the selected deployment configuration. The per-model table lives in
+the [Realtime Duplex API guide](realtime_duplex_api.md#capability-negotiation-by-model).
 
-For example, PersonaPlex supports native overlapping speech but currently
-advertises `supports_barge_in=false`; destructive output interruption and
-model-state rewind have not been validated for that integration. Capacity and
-session-resume behavior also depend on the selected deployment configuration.
+## Python API
 
-## Native Protocol
+`vllm_omni.entrypoints.duplex_omni.DuplexOmni` runs the same engine-resident
+sessions in-process: `open_session()` returns a `DuplexSessionHandle` whose
+`submit()` takes typed `DuplexCommand` objects and whose `events()` yields
+typed `DuplexEvent` objects (each with a `to_realtime()` wire rendering).
+`vllm_omni.clients.inline_duplex.InlineDuplexClient` exposes that handle
+behind the `DuplexClient` API. See the
+[Realtime Duplex API guide](realtime_duplex_api.md#using-the-python-api).
 
-`WS /v1/duplex` exposes lower-level lifecycle names including
-`session.create`, `input_audio_buffer.append`, `turn.signal`, `playback.ack`,
-and `session.close`. It returns native session, input, response, overlap, and
-error events. This protocol is experimental and may evolve with the runtime;
-applications should use the provided Realtime client where possible.
-
-See the [MiniCPM-o example](https://github.com/vllm-project/vllm-omni/tree/main/examples/online_serving/minicpmo),
-[PersonaPlex example](https://github.com/vllm-project/vllm-omni/tree/main/examples/online_serving/personaplex),
+See the [MiniCPM-o example](https://github.com/vllm-project/vllm-omni/tree/main/examples/online_serving/minicpmo)
 and the [full-duplex runtime design](../design/fullduplex.md)
 for model-specific validation and architecture details.
diff --git a/docs/serving/realtime_api.md b/docs/serving/realtime_api.md
index 153564140..e44ff7ed0 100644
--- a/docs/serving/realtime_api.md
+++ b/docs/serving/realtime_api.md
@@ -43,8 +43,8 @@ event is base64-encoded raw PCM16.
 | Client to server | `input_audio_buffer.commit` with `final: true` | Marks the end of input |
 | Server to client | `transcription.delta` | Carries incremental response text |
 | Server to client | `transcription.done` | Carries final text and token usage |
-| Server to client | `response.audio.delta` | Carries incremental PCM16 response audio |
-| Server to client | `response.audio.done` | Marks the end of response audio |
+| Server to client | `response.output_audio.delta` | Carries incremental PCM16 response audio |
+| Server to client | `response.output_audio.done` | Marks the end of response audio |
 | Server to client | `error` | Reports an invalid event, model, or audio payload |
 
 A minimal client sends events in this order:
@@ -63,7 +63,7 @@ engine is consuming the stream.
 ## Audio Handling
 
 - Input is mono PCM16 at 16 kHz for the Qwen3-Omni example.
-- `response.audio.delta.audio` contains base64-encoded PCM16 bytes.
+- `response.output_audio.delta.audio` contains base64-encoded PCM16 bytes.
 - Read `sample_rate_hz` from each audio event instead of assuming an output
   rate. Qwen3-Omni output is typically 24 kHz.
 - Concatenate audio deltas in receive order to construct the output waveform.
diff --git a/docs/serving/realtime_duplex_api.md b/docs/serving/realtime_duplex_api.md
index d37d02291..cd8832c82 100644
--- a/docs/serving/realtime_duplex_api.md
+++ b/docs/serving/realtime_duplex_api.md
@@ -1,17 +1,47 @@
 # Realtime Duplex API
 
 vLLM-Omni serves full-duplex speech models over a WebSocket endpoint,
-`/v1/realtime`, that speaks the OpenAI Realtime vocabulary plus a
+`/v1/realtime?duplex=1`, that speaks the OpenAI Realtime vocabulary plus a
 set of duplex extensions: the model decides when to listen and when to speak,
 the user can talk over the assistant, playback progress is reported back so
 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 handler is enabled by either a model-native `session_mode: duplex`
-deployment or an explicit `duplex_session` configuration for turn-based
-Server VAD. The runtime architecture is described in
-[Full-Duplex Runtime (MiniCPM-o 4.5)](../design/fullduplex.md).
+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
 
@@ -26,11 +56,24 @@ vllm-omni serve openbmb/MiniCPM-o-4_5 \
 ```
 
 `vllm_omni/deploy/minicpmo_4_5.yaml` declares `session_mode: duplex` and
-`duplex_session.max_sessions: 4`, which mounts the WebSocket routes
-`ws://<host>:8099/v1/realtime` (this page) and `ws://<host>:8099/v1/duplex`
-(the native dialect for raw-protocol clients) next to the usual HTTP API.
-PersonaPlex and Nemotron VoiceChat use `vllm_omni/deploy/personaplex.yaml` and
-`vllm_omni/deploy/nemotron_labs_voicechat_duplex.yaml` in the same way.
+`duplex_session.max_sessions: 4`. Because the MiniCPM-o 4.5 pipeline declares a
+`duplex_plugin`, `vllm-omni serve` runs it through `DuplexOmni`: the server
+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 in duplex mode.
+
+`/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.
+
+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
 
@@ -81,25 +124,24 @@ ships a preset:
 
 | Preset | Input / output audio | What it sets |
 | --- | --- | --- |
-| `vllm_omni.clients.minicpmo_4_5.create_duplex_session_config(ref_audio=...)` | 16 kHz `pcm16` / 24 kHz `pcm16` | `extra_body.native_duplex=True` (opt in to the model-native lane), `force_listen_count=0`, `overlap_policy="listen_only"`, `playback_commit_policy="ack_only"`; `ref_audio` is the assistant voice clip |
+| `vllm_omni.clients.minicpmo_4_5.create_duplex_session_config(ref_audio=...)` | 16 kHz `pcm16` / 24 kHz `pcm16` | `force_listen_count=0`, `overlap_policy="listen_only"`, `playback_commit_policy="ack_only"`; `ref_audio` is the assistant voice clip |
 | `vllm_omni.clients.personaplex.create_duplex_session_config(voice="NATF2.pt", persona="")` | 24 kHz `pcm_f32le` / 24 kHz `pcm16` | bundled `.pt` voice prompt and the persona as `instructions` |
 | `SessionConfig(...)` | 16 kHz `pcm16` / 24 kHz `pcm16` | model-neutral defaults; pass `extra_body`, `turn_detection`, `overlap_policy`, `playback_commit_policy`, `instructions`, `voice`, `temperature` yourself |
 
 Keyword overrides on a preset replace the corresponding `SessionConfig`
 field, e.g. `create_duplex_session_config(ref_audio=..., temperature=0.6)`.
 
-Constructor options: `session_id` (names the session the client creates; it
-does not resume or take over an existing session — entering the client always
-performs the `session.update` handshake), `reconnect` (a `ReconnectPolicy`,
-default five attempts with 0.25–4 s jittered backoff; `None` disables
-auto-resume), `heartbeat_interval_s` (default 30 s; `None` disables the lease
-heartbeat), `handshake_timeout_s`, and `connect` (a custom transport factory,
-used by tests and benchmarks). Resume is supported only as automatic reconnect
-within the same `DuplexClient` instance (see
-[Reconnect and resume](#reconnect-and-resume)); re-attaching from a new client
-or process requires the wire-level `session.resume` handshake
-(`resume_token`, `incarnation`, `last_received_server_event_seq`), which this
-client does not expose.
+Constructor options: `reconnect` (a `ReconnectPolicy`, default five
+attempts with 0.25–4 s jittered backoff; `None` disables auto-resume),
+`heartbeat_interval_s` (default 30 s; `None` disables the lease heartbeat),
+`handshake_timeout_s`, and `connect` (a custom transport factory, used by
+tests and benchmarks). The session id is allocated by the server and becomes
+`client.session_id` once `session.created` arrives; a client cannot choose
+it. Resume is supported only as automatic reconnect within the same
+`DuplexClient` instance (see [Reconnect and resume](#reconnect-and-resume));
+re-attaching from a new client or process requires the wire-level
+`session.resume` handshake (`resume_token`,
+`last_received_server_event_seq`), which this client does not expose.
 
 ### Stream audio and commit a turn
 
@@ -195,7 +237,7 @@ the stamped `event_id`.
 On a transport drop the client reconnects with the `ReconnectPolicy` backoff
 and sends `session.resume` from the last acknowledged `server_event_seq`.
 Replayed events are deduplicated, consumers see one `ConnectionResumed`
-event, and `client.incarnation` / `client.resume_token` are refreshed. The
+event, and `client.resume_token` is refreshed. The
 server keeps a detached session alive for `disconnect_grace_s` (30 s by
 default); after that a resume fails with `session_resume_expired`. Resume is
 gated by `capabilities.supports_session_resume` (MiniCPM-o 4.5 and Nemotron
@@ -238,9 +280,67 @@ definitions out of the dependency-free client. `audio_bytes(response_id)`, `coun
 `openai-realtime-duplex` benchmark backend (`vllm-omni bench serve`) is built
 on the same helpers.
 
+## Using the Python API
+
+`vllm_omni.entrypoints.duplex_omni.DuplexOmni` is the in-process Python API
+of a duplex model: sessions run inside the engine, and the class only opens,
+resumes and closes them and pipes typed commands in and typed events out
+through a `DuplexSessionHandle`.
+
+```python
+from vllm_omni.engine.duplex.commands import AppendAudio, Commit
+from vllm_omni.engine.duplex.events import AudioDelta, SessionClosed
+from vllm_omni.entrypoints.duplex_omni import DuplexOmni
+
+omni = DuplexOmni(model="openbmb/MiniCPM-o-4_5", trust_remote_code=True)
+async with await omni.open_session({"modalities": ["audio", "text"], "ref_audio": ref_audio_data_url}) as session:
+    async def consume():
+        async for event in session.events():          # typed DuplexEvent objects
+            if isinstance(event, AudioDelta):
+                play(event.audio)
+            elif isinstance(event, ResponseDone):
+                break                                  # one turn is enough here
+    task = asyncio.create_task(consume())
+    await session.submit(AppendAudio(audio=pcm16_bytes, format="pcm16", sample_rate_hz=16000))
+    await session.submit(Commit())
+    await task
+# leaving the block closes the session (the last event is SessionClosed)
+```
+
+`open_session` takes a `DuplexSessionConfig` or the same Realtime `session`
+object the WebSocket handshake takes; the session id is always allocated by
+`DuplexOmni`. `DuplexSessionHandle` offers `submit(command)` plus one
+convenience wrapper per command (`append_audio`, `commit`, `create_response`,
+`cancel_response`, `barge_in`, `ack_playback`, `update`, `create_item`,
+`delete_item`, `truncate_item`, `heartbeat`, ...). `events()` is a
+single-consumer async iterator that ends after `session.closed` /
+`session.expired`; rejected commands come back as `ErrorEvent`s on it.
+Every event renders the wire JSON with `to_realtime()`, so anything written
+against the WebSocket protocol works unchanged on the typed stream.
+
+`vllm_omni.clients.inline_duplex.InlineDuplexClient` wraps a `DuplexOmni`
+behind the `DuplexClient` API, so the same application code runs in-process
+(no server) or over the network:
+
+```python
+from vllm_omni.clients.inline_duplex import InlineDuplexClient
+from vllm_omni.clients.minicpmo_4_5 import create_duplex_session_config
+
+config = create_duplex_session_config(ref_audio=audio_data_url(Path("reference_voice.wav")))
+async with InlineDuplexClient(omni, model="openbmb/MiniCPM-o-4_5", config=config) as client:
+    await client.stream_pcm(question)
+    await client.commit()
+    async for response in client.responses():
+        ...
+```
+
+`examples/online_serving/barge_in_client.py --inline` drives the barge-in
+scenario this way. The inline client has no transport, so it has no
+reconnect, resume, heartbeat or event-acknowledgement machinery.
+
 ## API Reference
 
-This section is the complete wire contract of `/v1/realtime`: how
+This section is the complete wire contract of `/v1/realtime?duplex=1`: how
 the dialect relates to the OpenAI Realtime protocol, which surfaces each
 model's capability flags gate, a catalogue of every client-to-server and
 server-to-client event, and a JSON example for each. `DuplexClient` speaks
@@ -253,21 +353,26 @@ its protocol tests.
 
 ### Endpoint and transport
 
-The endpoint is `ws(s)://<host>/v1/realtime`. Bare connections select the
-session handler when the deployment declares either `session_mode: duplex`
-or `duplex_session`. `?duplex=1` remains a compatibility alias, while
-`?duplex=0` selects the legacy Realtime handler. Optional query parameters
-are `model`, `session_id`,
-`autostart` (`0` means resume-only), `resume`, and `native_duplex`
-(`minicpmo45_native_duplex` is accepted as a deprecated alias and folded
-into the canonical name). Every message is one JSON object per WebSocket
+The endpoint is `ws(s)://<host>/v1/realtime`. On a deployment whose pipeline
+declares a `duplex_plugin` and whose deploy configuration declares
+`session_mode: duplex`, a bare connection is already a duplex session, so a
+stock Realtime client needs no vendor query parameter. `?duplex=1` (`1`,
+`true` or `on`) is the spelling this page uses and stays valid;
+`?duplex=0` (`0`, `false`, `off`) explicitly opts out and selects the
+turn-based Realtime handler, which a duplex server does not mount --
+that connection is answered with `Realtime API is not available`.
+`ws(s)://<host>/v1/duplex` is an alias that always selects the duplex
+handler. Optional query parameters are `model`, `autostart` (`0` means
+resume-only) and `resume`. Every message is one JSON object per WebSocket
 text frame, discriminated by `type`. Inbound events are applied in arrival
 order through one per-session mailbox; outbound events preserve that order
 and carry a monotonically increasing `server_event_seq`, which is the replay
 cursor for `session.resume`. Client events may carry an `event_id`, echoed in
 `error.error.event_id` when the event is rejected.
 
-Session identity is `(session_id, incarnation)`; `attachment_generation`
+Session identity is the server-allocated `session_id` (`duplex-<uuid>`,
+announced in `session.created`; a `session_id` the client puts in the session
+object is ignored, and ids are never reused); `attachment_generation`
 names the current socket; `epoch` is the interruption fence that advances on
 every cancel, clear, or barge-in; `turn_id` counts committed model turns;
 `response_id` (item id `item_<response_id>`) names one assistant utterance.
@@ -281,12 +386,13 @@ with no OpenAI counterpart.
 
 The event vocabulary is uniform, but several surfaces are gated by the
 `capabilities` object the server returns in `session.created`; a client must
-branch on those flags rather than on the model name. The current model
-plugins advertise:
+branch on those flags rather than on the model name. MiniCPM-o 4.5 is the
+only model on the plugin contract today; the other two columns record what
+their integrations advertise once the follow-up PRs port them:
 
 | Capability | MiniCPM-o 4.5 | PersonaPlex | Nemotron VoiceChat | Gated surface |
 | --- | --- | --- | --- | --- |
-| `implementation_level` | `model_native_duplex` (when `extra_body.native_duplex=true`) | `model_native_duplex` | `model_native_duplex` | model-owned `response.listen` / `response.speak`; the chat-fallback lane otherwise |
+| `implementation_level` | `model_native_duplex` | `model_native_duplex` | `model_native_duplex` | model-owned `response.listen` / `response.speak` (constant: every duplex model is model-native) |
 | `chunk_period_ms` | 1000 | 80 | 80 | the model unit that `response.listen` decisions and camera frames align to |
 | `supports_session_resume` | yes | no | yes | `session.resume`, `session.resumed`, `session.replaced`, replay after a transport drop |
 | `supports_barge_in` | yes | no | no | `barge_in`, `turn.signal{event:"barge_in"}`, `overlap_policy=barge_in_on_speech`, `turn_detection.server_vad` |
@@ -311,13 +417,13 @@ work unmodified. The overlap falls into the three tiers used by the event catalo
 | Direction | Messages |
 | --- | --- |
 | Client → server | `session.update`, `input_audio_buffer.append` / `.commit` / `.clear`, `conversation.item.create` / `.retrieve` / `.truncate` / `.delete`, `response.create`, `response.cancel`, `output_audio_buffer.clear` (OpenAI: WebRTC-only; here also a WebSocket event) |
-| Server → client | `error` (same `{type, code, message, event_id, param}` envelope and the same classes `invalid_request_error` / `server_error` / `rate_limit_error`), `session.created`, `session.updated`, `input_audio_buffer.committed` / `.cleared` / `.speech_started` / `.speech_stopped`, `conversation.item.created` / `.added` / `.done` / `.deleted` / `.retrieved` / `.truncated`, `conversation.item.input_audio_transcription.completed`, `response.created`, `response.done`, `response.output_item.added` / `.done`, `response.content_part.added` / `.done`, `response.audio.delta` / `.done`, `response.audio_transcript.delta` / `.done`, `response.output_text.delta` / `.done`, `response.function_call_arguments.delta` / `.done`, `rate_limits.updated`, `output_audio_buffer.cleared` |
+| Server → client | `error` (same `{type, code, message, event_id, param}` envelope and the same classes `invalid_request_error` / `server_error` / `rate_limit_error`), `session.created`, `session.updated`, `input_audio_buffer.committed` / `.cleared` / `.speech_started` / `.speech_stopped`, `conversation.item.created` / `.added` / `.done` / `.deleted` / `.retrieved` / `.truncated`, `conversation.item.input_audio_transcription.completed`, `response.created`, `response.done`, `response.output_item.added` / `.done`, `response.content_part.added` / `.done`, `response.output_audio.delta` / `.done`, `response.output_audio_transcript.delta` / `.done`, `response.output_text.delta` / `.done`, `response.function_call_arguments.delta` / `.done`, `rate_limits.updated`, `output_audio_buffer.cleared` |
 | Session fields | `model`, `modalities` / `output_modalities`, `instructions`, `voice`, `input_audio_format` / `output_audio_format` (beta spelling) **and** `audio.input.format` / `audio.output.format` objects (GA spelling), `turn_detection.server_vad {threshold, prefix_padding_ms, silence_duration_ms}`, `input_audio_transcription`, `input_audio_noise_reduction`, `tools`, `tool_choice`, `temperature`, `max_response_output_tokens`, `speed`, `tracing` |
 | Object shapes | `realtime.session`, `realtime.item`, `realtime.response`; item content parts `input_text` / `input_audio` / `output_text` / `output_audio`; `function_call` and `function_call_output` items; `previous_item_id` chaining; `output_index` / `content_index` addressing |
 | Sequencing | `response.created → output_item.added → content_part.added → deltas → *.done → content_part.done → output_item.done → response.done → rate_limits.updated`; `speech_started → speech_stopped → committed` |
 
 The server deliberately emits and accepts **both** the beta and the GA
-spellings at once (`response.audio.delta` alongside `output_modalities`,
+spellings at once (`response.output_audio.delta` alongside `output_modalities`,
 `conversation.item.added` alongside `conversation.item.created`) so either
 generation of OpenAI client parses the stream.
 
@@ -327,9 +433,9 @@ A stock client ignores the extra keys; the extensions are additive.
 
 | Message | Extension |
 | --- | --- |
-| `session.created` / `session.updated` | top-level `incarnation`, `attachment_generation`, `resume_token`; inside `session`: `state`, `turn_state`, `epoch`, `turn_id`, `active_request_id`, `active_response_id`, `active_response_turn_id`, `overlap_policy`, `overlap_*_ms/rms`, `playback_commit_policy`, `playback`, `capabilities`, `ref_audio`, `extra_body`, `idle_timeout_s`, `response_format` |
+| `session.created` / `session.updated` | top-level `attachment_generation`, `resume_token`; inside `session`: `state`, `turn_state`, `epoch`, `turn_id`, `active_request_id`, `active_response_id`, `active_response_turn_id`, `overlap_policy`, `overlap_*_ms/rms`, `playback_commit_policy`, `playback`, `capabilities`, `ref_audio`, `extra_body`, `idle_timeout_s`, `response_format` |
 | `response.created` / `response.done` / `response.listen` | `response_id` at top level; the raw duplex event under `response.metadata` (`duplex_event`); `status_details.reason` uses vLLM reasons (`barge_in`, `client_cancelled`, `new_response`, …) |
-| `response.audio.delta` | `format`, `sample_rate_hz`, `metadata{session_id, epoch, model_speak, end_of_turn, audio_duration_ms, audio_text_marks, playback}` |
+| `response.output_audio.delta` | `format`, `sample_rate_hz`, `metadata{session_id, epoch, model_speak, end_of_turn, audio_duration_ms, audio_text_marks, playback}` |
 | `response.speak` (inserted before the first delta) | not an OpenAI event, but rides the OpenAI response envelope (`response_id`, `item_id`, `output_index`, `content_index`) |
 | `input_audio_buffer.append` | `is_speech`, `video_frames` (+ `max_slice_nums`), `duration_ms`, `audio_end_ms`, per-event `format` / `sample_rate_hz` |
 | `input_audio_buffer.commit` | `final`, `response_create`, `is_speech:false` (silence declaration) |
@@ -343,14 +449,9 @@ Semantic divergences hidden behind shared names:
   before any commit; a commit may end in `response.listen` and no
   response, and the model may open a response with no commit at all.
   OpenAI: commit ⇒ item, `response.create` ⇒ exactly one response.
-- With `turn_detection={"type":"server_vad"}`, omitted `interrupt_response`
-  defaults to `false` on turn-based models such as Qwen3-Omni, enabling
-  endpointing and automatic responses without interruption. Explicit `true`
-  is rejected there. Model-native duplex keeps the `true` default and rejects
-  `false`; its VAD implies `overlap_policy=barge_in_on_speech`.
-  This capability-dependent default differs from OpenAI's `true` default;
-  the effective configuration is returned in `session.created` / `session.updated`.
-  `semantic_vad` is unsupported.
+- `turn_detection.interrupt_response=false` is rejected;
+  `create_response` is ignored; `semantic_vad` is unsupported; the VAD
+  runs per session (Silero) and implies `overlap_policy=barge_in_on_speech`.
 - `rate_limits.updated` is always an empty list (compatibility only).
 - Cancellation never reuses a `response_id`; truncation is driven by
   `playback.ack` as well as `conversation.item.truncate`.
@@ -359,11 +460,11 @@ Semantic divergences hidden behind shared names:
 
 | Area | Messages / fields |
 | --- | --- |
-| Session lifetime | `session.heartbeat` / `session.heartbeat_ack`, `session.event_ack`, `session.close` / `session.closed`, `session.resume` / `session.resumed` / `session.replaced` / `session.expired` / `session.resync_required`; `server_event_seq`, `resume_token`, `incarnation`, `attachment_generation`; query params `?duplex=1`, `autostart`, `resume`, `native_duplex` |
+| Session lifetime | `session.heartbeat` / `session.heartbeat_ack`, `session.event_ack`, `session.close` / `session.closed`, `session.resume` / `session.resumed` / `session.replaced` / `session.expired` / `session.resync_required`; `server_event_seq`, `resume_token`, `attachment_generation`; query params `?duplex=1`, `autostart`, `resume` |
 | Turn-taking | `response.speak`, `response.listen`, `overlap.decision`, `overlap_policy`, `barge_in`, `turn.signal`, `input.cancel`, `input.text.append`, `epoch` / `turn_id` fencing, `force_listen` |
 | Playback truth | `playback.ack` / `playback.acknowledged`, `playback_commit_policy` (`ack_only` \| `commit_all_on_done`), `playback{generated_ms, sent_ms, played_ms, committed_ms}`, `history_committed`, `audio_text_marks` |
-| Model negotiation | `capabilities{implementation_level, supports_input_append, supports_barge_in, supports_session_resume, chunk_period_ms, input_modes, …}`, `ref_audio`, `extra_body` (`auto_response`, `native_duplex` — deprecated alias `minicpmo45_native_duplex` is folded into it, `force_listen_count`, `duplex_initial_user_text`) |
-| Diagnostics | `runtime.control`, `duplex.function_call.done`, the full error-code vocabulary (`REALTIME_ERROR_TYPES_BY_CODE` in `vllm_omni/entrypoints/duplex/realtime_state.py`) |
+| Model negotiation | `capabilities{implementation_level, supports_input_append, supports_barge_in, supports_session_resume, chunk_period_ms, input_modes, …}`, `ref_audio`, `extra_body` (`auto_response`, `force_listen_count`, `duplex_initial_user_text`) |
+| Diagnostics | `duplex.function_call.done`, the full error-code vocabulary (`REALTIME_ERROR_TYPES_BY_CODE` in `vllm_omni/engine/duplex/events.py`) |
 
 #### Consequences for clients
 
@@ -381,14 +482,61 @@ Semantic divergences hidden behind shared names:
   the Tier 3 surface on top of the same Tier 1 events, so both kinds of
   client can share one deployment and one event log.
 
+### Turn-based Chat audio metadata
+
+For turn-based models served through Chat fallback, non-empty audio choices
+produced by the Omni Chat audio encoder include `audio_metadata`, in both
+streaming and complete Chat responses. Text-only choices do not require it.
+
+| Field | Meaning |
+| --- | --- |
+| `format` | Encoding of the returned audio, such as `pcm` or `wav`; `pcm16` requests normalize to `pcm`. |
+| `sample_rate_hz` | Sample rate used by the encoder, in samples per second. |
+| `frame_count` | Samples per channel in this chunk, or in the complete waveform for a non-streaming choice. Not a byte count. |
+| `channels` | Number of audio channels. |
+
+These values describe the waveform after audio transformations. Compressed
+formats may add codec padding that is not included in `frame_count`.
+The encoder uses a model-reported sample rate when available; Qwen3-Omni
+currently omits it and uses the existing 24 kHz default. This metadata does
+not independently determine a model's sample rate.
+
+Chat fallback requests the session's output format explicitly. Its internal
+`response.output_audio.delta` carries `format`, `sample_rate_hz`, `channels`,
+and `audio_duration_ms`. The Realtime endpoint exposes output `format` and
+`sample_rate_hz` on `response.audio.delta`, with duration in
+`metadata.audio_duration_ms`; it does not currently forward `channels`.
+The duration is cumulative for the response:
+integer frames are summed before converting to milliseconds and rounding down.
+Non-empty audio without valid metadata, or a sample-rate change within one
+response, fails that fallback response with `response_error`.
+
+In this Chat fallback path, `response.done.response.metadata.playback` reports:
+
+- `generated_ms`: cumulative source-waveform duration.
+- `sent_ms`: cumulative audio accepted into the server output path, including
+  queued or journaled audio. A journaled event remains accepted if the
+  subsequent send fails; this is not proof of socket delivery.
+- `played_ms`: cumulative playback reported by the client.
+- `committed_ms`: playback position used for history reconciliation.
+
+The native model path still records audio before sending; it does not yet
+share Chat fallback's output-acceptance timing. Only client playback reports
+establish what was played. The existing duration-proportional text truncation
+remains an approximation, not word-level audio alignment.
+
 ### Event catalogue
 
 Every event type the Realtime route accepts or emits, with a worked example in the next section: 21
-client→server and 42 server→client. Aliases (`push_chunk`,
-`input.audio.append`, `input_text.append`, `push_text`, `signal_turn`,
-`audio.playback_ack`, `close_session`, `close`, `session_close`) share the
-payload of their canonical event and are not listed separately; the alias
-table lives in the normative contract section of [Full-Duplex Runtime (MiniCPM-o 4.5)](../design/fullduplex.md).
+client→server and 42 server→client. Aliases (`input_text.append`,
+`push_text`, `signal_turn`, `audio.playback_ack`, `close_session`, `close`)
+share the payload of their canonical event and are not listed
+separately; the alias table is `translate_realtime_command` in
+`vllm_omni/engine/duplex/realtime_commands.py`. The pre-Realtime WAV-append
+aliases `push_chunk` and `input.audio.append` are **not** accepted on this
+route: send `input_audio_buffer.append` with one of the supported input
+formats (`pcm16`, `pcm_s16le`, `s16le`, `pcm_f32le`, `g711_ulaw`,
+`g711_alaw`).
 
 #### Client to server
 
@@ -398,18 +546,18 @@ table lives in the normative contract section of [Full-Duplex Runtime (MiniCPM-o
 | `session.heartbeat` | 3 | Keepalive; refreshes the engine session lease. |
 | `session.event_ack` | 3 | Acknowledges received server events by `server_event_seq`; trims the resume replay journal. |
 | `session.close` | 3 | Graceful close; answered with `session.closed`. |
-| `session.resume` | 3 | Re-attach a live session on a new socket (`resume_token`, `incarnation`, `last_received_server_event_seq`). |
+| `session.resume` | 3 | Re-attach a live session on a new socket (`session_id`, `resume_token`, `last_received_server_event_seq`). |
 | `input_audio_buffer.append` | 2 | Append one audio chunk. OpenAI name; extended with `is_speech`, `video_frames`, `duration_ms`, `audio_end_ms`, per-event `format`/`sample_rate_hz`. |
 | `input_audio_buffer.commit` | 2 | Seal the buffered utterance into a user item. OpenAI name; extended with `final`, `response_create`, `is_speech:false`. |
 | `input.commit` | 3 | Alias of `input_audio_buffer.commit` accepted by the runner. |
 | `input_audio_buffer.clear` | 1 | Drop un-committed input audio. |
 | `input.cancel` | 3 | Cancel pending input; advances `epoch`. |
-| `input.text.append` | 3 | Append text to the open input item (chat-fallback lane only). |
+| `input.text.append` | 3 | Append text input; model-native sessions reject it with `native_text_append_unsupported`. |
 | `conversation.item.create` | 1 | Add a completed user item (text, audio, or `function_call_output`) to history. |
 | `conversation.item.retrieve` | 1 | Fetch a stored item by id. |
 | `conversation.item.delete` | 1 | Delete a stored item by id. |
 | `conversation.item.truncate` | 1 | Truncate an assistant item's audio/transcript at `audio_end_ms`. |
-| `response.create` | 1 | Explicitly request a response with per-response overrides. |
+| `response.create` | 1 | Explicitly request a response with per-response overrides. Requires committed audio input; otherwise `response_create_without_input`. |
 | `response.cancel` | 1 | Cancel the active (or named) response; advances `epoch`. |
 | `output_audio_buffer.clear` | 1 | Discard queued output audio; advances `epoch` (OpenAI: WebRTC-only, here also WebSocket). |
 | `barge_in` | 3 | Explicit hard interrupt; requires `capabilities.supports_barge_in`. |
@@ -420,10 +568,10 @@ table lives in the normative contract section of [Full-Duplex Runtime (MiniCPM-o
 
 | Event type | Tier | Description |
 | --- | --- | --- |
-| `session.created` | 2 | Session opened. OpenAI name; adds `incarnation`, `attachment_generation`, `resume_token` and vLLM-Omni keys inside `session` (`epoch`, `turn_id`, `playback`, `capabilities`, ...). |
+| `session.created` | 2 | Session opened. OpenAI name; adds `attachment_generation`, `resume_token` and vLLM-Omni keys inside `session` (`id` is the server-allocated session id, `epoch`, `turn_id`, `playback`, `capabilities`, ...). |
 | `session.updated` | 2 | Echo of the effective session config after every `session.update` (same extended `session` object). |
 | `session.heartbeat_ack` | 3 | Reply to `session.heartbeat`. |
-| `session.closed` | 3 | Last event on the socket; `reason` ∈ `session_close`, `timeout`, `disconnect`, ... |
+| `session.closed` | 3 | Last event on the socket, emitted once the engine released the session; `reason` ∈ `client_close`, `disconnect`, `timeout`, `transport_error`, `shutdown`, ... |
 | `session.resumed` | 3 | Resume accepted; carries the new `attachment_generation` and rotated `resume_token`; journaled events are replayed after it. |
 | `session.replaced` | 3 | Sent to the superseded socket when another socket resumes the session. |
 | `session.expired` | 3 | Engine lease reaped (`disconnect_grace_expired`, `idle_ttl_expired`); socket closes after it. |
@@ -443,12 +591,12 @@ table lives in the normative contract section of [Full-Duplex Runtime (MiniCPM-o
 | `response.output_item.added` | 1 | Assistant item (or `function_call` item) attached to the response. |
 | `response.content_part.added` | 1 | Audio/text content part opened on the assistant item. |
 | `response.speak` | 3 | Model chose to speak (native lane); at most once per response, before the first audio delta. |
-| `response.audio.delta` | 2 | One ordered audio chunk. OpenAI name; adds `format`, `sample_rate_hz`, `metadata{epoch, model_speak, end_of_turn, audio_text_marks, playback}`. |
-| `response.audio_transcript.delta` | 1 | Transcript text paired one-to-one with each audio delta. |
+| `response.output_audio.delta` | 2 | One ordered audio chunk. OpenAI name; adds `format`, `sample_rate_hz`, `metadata{epoch, model_speak, end_of_turn, audio_text_marks, playback}`. |
+| `response.output_audio_transcript.delta` | 1 | Transcript text paired one-to-one with each audio delta. |
 | `response.output_text.delta` | 1 | Text delta for text-modality responses. |
 | `response.output_text.done` | 1 | Final text of a text-modality response. |
-| `response.audio.done` | 1 | Audio stream closed for the response. |
-| `response.audio_transcript.done` | 1 | Full transcript (concatenation of the deltas). |
+| `response.output_audio.done` | 1 | Audio stream closed for the response. |
+| `response.output_audio_transcript.done` | 1 | Full transcript (concatenation of the deltas). |
 | `response.content_part.done` | 1 | Content part finalized with its transcript/text. |
 | `response.output_item.done` | 1 | Assistant item finalized. |
 | `response.done` | 2 | Terminal event; `status` ∈ `completed` \| `cancelled` \| `failed`. OpenAI name; vLLM-Omni `status_details.reason` values and raw duplex event under `metadata`. |
@@ -459,8 +607,8 @@ table lives in the normative contract section of [Full-Duplex Runtime (MiniCPM-o
 | `duplex.function_call.done` | 3 | Raw fallback when a model tool call is malformed. |
 | `output_audio_buffer.cleared` | 1 | Reply to `output_audio_buffer.clear`. |
 | `playback.acknowledged` | 3 | Reply to `playback.ack`; returns the playback ledger and `history_committed`. |
-| `overlap.decision` | 3 | How an append that overlapped an active response was handled (`drop` \| `listen` \| `barge_in`). |
-| `runtime.control` | 3 | Diagnostic: an engine control signal was partially unsupported. |
+| `overlap.decision` | 3 | How an append that overlapped an active response was handled (`drop` \| `listen` \| `barge_in`); details under `metadata`. |
+| `turn.event` | 3 | A turn-taking signal the session accepted (`event`, resulting `turn_state`). |
 | `error` | 2 | Error envelope. OpenAI shape and classes; vLLM-Omni error codes. |
 
 ### Message examples
@@ -479,7 +627,6 @@ additionally carries `"server_event_seq": <int>` (omitted below for brevity).
   "event_id": "evt_0001",
   "session": {
     "model": "openbmb/MiniCPM-o-4_5",
-    "session_id": "sess_demo_01",
     "modalities": ["audio", "text"],
     "instructions": "You are a concise voice assistant.",
     "input_audio_format": "pcm16",
@@ -492,7 +639,6 @@ additionally carries `"server_event_seq": <int>` (omitted below for brevity).
     "idle_timeout_s": 300,
     "extra_body": {
       "auto_response": true,
-      "native_duplex": true,
       "force_listen_count": 0
     }
   }
@@ -504,13 +650,12 @@ additionally carries `"server_event_seq": <int>` (omitted below for brevity).
 ```json
 {
   "type": "session.created",
-  "incarnation": 0,
   "attachment_generation": 1,
   "resume_token": "rt_3f9c…",
   "session": {
     "object": "realtime.session",
     "type": "realtime",
-    "id": "sess_demo_01",
+    "id": "duplex-5f2a…",
     "model": "openbmb/MiniCPM-o-4_5",
     "state": "open",
     "turn_state": "idle",
@@ -563,7 +708,7 @@ additionally carries `"server_event_seq": <int>` (omitted below for brevity).
 `session.created` and every later `session.update`)
 
 ```json
-{"type": "session.updated", "session": {"object": "realtime.session", "id": "sess_demo_01", "…": "…"}}
+{"type": "session.updated", "session": {"object": "realtime.session", "id": "duplex-5f2a…", "…": "…"}}
 ```
 
 `C→S session.heartbeat` / `S→C session.heartbeat_ack`
@@ -573,7 +718,7 @@ additionally carries `"server_event_seq": <int>` (omitted below for brevity).
 ```
 
 ```json
-{"type": "session.heartbeat_ack", "session_id": "sess_demo_01"}
+{"type": "session.heartbeat_ack", "session_id": "duplex-5f2a…"}
 ```
 
 `C→S session.event_ack`
@@ -589,7 +734,7 @@ additionally carries `"server_event_seq": <int>` (omitted below for brevity).
 ```
 
 ```json
-{"type": "session.closed", "session_id": "sess_demo_01", "reason": "session_close"}
+{"type": "session.closed", "session_id": "duplex-5f2a…", "epoch": 3, "reason": "client_close", "event": {"type": "session.closed", "reason": "client_close"}}
 ```
 
 `C→S session.resume` (new socket, `?duplex=1&autostart=0`)
@@ -597,8 +742,7 @@ additionally carries `"server_event_seq": <int>` (omitted below for brevity).
 ```json
 {
   "type": "session.resume",
-  "session_id": "sess_demo_01",
-  "incarnation": 0,
+  "session_id": "duplex-5f2a…",
   "resume_token": "rt_3f9c…",
   "last_received_server_event_seq": 40
 }
@@ -610,8 +754,8 @@ events with `server_event_seq > 40` are replayed in order)
 ```json
 {
   "type": "session.resumed",
-  "session_id": "sess_demo_01",
-  "incarnation": 0,
+  "session_id": "duplex-5f2a…",
+  "session": {"id": "duplex-5f2a…", "state": "open", "epoch": 3, "turn_id": 2, "...": "the engine's current session object"},
   "attachment_generation": 2,
   "resume_token": "rt_a71e…"
 }
@@ -620,19 +764,19 @@ events with `server_event_seq > 40` are replayed in order)
 `S→C session.replaced` (sent to the superseded socket, which is then closed)
 
 ```json
-{"type": "session.replaced", "session_id": "sess_demo_01", "attachment_generation": 1}
+{"type": "session.replaced", "session_id": "duplex-5f2a…", "attachment_generation": 1}
 ```
 
 `S→C session.expired`
 
 ```json
-{"type": "session.expired", "session_id": "sess_demo_01", "incarnation": 0, "reason": "disconnect_grace_expired"}
+{"type": "session.expired", "session_id": "duplex-5f2a…", "reason": "disconnect_grace_expired"}
 ```
 
 `S→C session.resync_required`
 
 ```json
-{"type": "session.resync_required", "session_id": "sess_demo_01", "reason": "journal_gap"}
+{"type": "session.resync_required", "session_id": "duplex-5f2a…", "reason": "journal_gap"}
 ```
 
 #### Input
@@ -653,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
 {
@@ -723,7 +870,7 @@ silence/noise declaration (no runtime append; answered with `response.listen`)
   "item_id": "item_9b2d…",
   "event": {
     "type": "input.committed",
-    "session_id": "sess_demo_01",
+    "session_id": "duplex-5f2a…",
     "turn_id": 1,
     "epoch": 0,
     "history_len": 1,
@@ -753,7 +900,7 @@ deferred commit during an active response (`event.response_create_deferred`)
   "type": "input_audio_buffer.committed",
   "previous_item_id": "item_9b2d…",
   "item_id": "item_c044…",
-  "event": {"type": "input.committed", "session_id": "sess_demo_01", "turn_id": 2, "epoch": 0, "history_len": 3, "response_create_deferred": true, "message": {"…": "…"}}
+  "event": {"type": "input.committed", "session_id": "duplex-5f2a…", "turn_id": 2, "epoch": 0, "history_len": 3, "response_create_deferred": true, "message": {"…": "…"}}
 }
 ```
 
@@ -830,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`
@@ -862,7 +1013,7 @@ deferred commit during an active response (`event.response_create_deferred`)
     "status_details": null,
     "output": [],
     "modalities": ["audio", "text"],
-    "metadata": {"duplex_event": {"type": "response.created", "session_id": "sess_demo_01", "response_id": "resp_01", "epoch": 0, "turn_id": 1}}
+    "metadata": {"duplex_event": {"type": "response.created", "session_id": "duplex-5f2a…", "response_id": "resp_01", "epoch": 0, "turn_id": 1}}
   }
 }
 ```
@@ -898,15 +1049,15 @@ deferred commit during an active response (`event.response_create_deferred`)
   "item_id": "item_resp_01",
   "output_index": 0,
   "content_index": 0,
-  "metadata": {"session_id": "sess_demo_01", "epoch": 0, "model_speak": true}
+  "metadata": {"session_id": "duplex-5f2a…", "epoch": 0, "model_speak": true}
 }
 ```
 
-`S→C response.audio.delta` (one ~1 s unit, 24 kHz PCM16)
+`S→C response.output_audio.delta` (one ~1 s unit, 24 kHz PCM16)
 
 ```json
 {
-  "type": "response.audio.delta",
+  "type": "response.output_audio.delta",
   "response_id": "resp_01",
   "item_id": "item_resp_01",
   "output_index": 0,
@@ -915,7 +1066,7 @@ deferred commit during an active response (`event.response_create_deferred`)
   "format": "pcm16",
   "sample_rate_hz": 24000,
   "metadata": {
-    "session_id": "sess_demo_01",
+    "session_id": "duplex-5f2a…",
     "epoch": 0,
     "model_speak": true,
     "end_of_turn": false,
@@ -926,10 +1077,10 @@ deferred commit during an active response (`event.response_create_deferred`)
 }
 ```
 
-`S→C response.audio_transcript.delta` (exactly one per audio delta)
+`S→C response.output_audio_transcript.delta` (exactly one per audio delta)
 
 ```json
-{"type": "response.audio_transcript.delta", "response_id": "resp_01", "item_id": "item_resp_01", "output_index": 0, "content_index": 0, "delta": "It is sunny"}
+{"type": "response.output_audio_transcript.delta", "response_id": "resp_01", "item_id": "item_resp_01", "output_index": 0, "content_index": 0, "delta": "It is sunny"}
 ```
 
 `S→C response.output_text.delta` / `response.output_text.done` (text modality)
@@ -942,14 +1093,14 @@ deferred commit during an active response (`event.response_create_deferred`)
 {"type": "response.output_text.done", "response_id": "resp_02", "item_id": "item_resp_02", "output_index": 0, "content_index": 0, "text": "Tomorrow looks cloudy."}
 ```
 
-`S→C response.audio.done` / `response.audio_transcript.done`
+`S→C response.output_audio.done` / `response.output_audio_transcript.done`
 
 ```json
-{"type": "response.audio.done", "response_id": "resp_01", "item_id": "item_resp_01", "output_index": 0, "content_index": 0}
+{"type": "response.output_audio.done", "response_id": "resp_01", "item_id": "item_resp_01", "output_index": 0, "content_index": 0}
 ```
 
 ```json
-{"type": "response.audio_transcript.done", "response_id": "resp_01", "item_id": "item_resp_01", "output_index": 0, "content_index": 0, "transcript": "It is sunny, 24 degrees."}
+{"type": "response.output_audio_transcript.done", "response_id": "resp_01", "item_id": "item_resp_01", "output_index": 0, "content_index": 0, "transcript": "It is sunny, 24 degrees."}
 ```
 
 `S→C response.content_part.done`
@@ -980,7 +1131,7 @@ deferred commit during an active response (`event.response_create_deferred`)
     "status": "completed",
     "status_details": null,
     "output": [{"id": "item_resp_01", "object": "realtime.item", "type": "message", "role": "assistant", "status": "completed", "content": [{"type": "output_audio", "transcript": "It is sunny, 24 degrees."}]}],
-    "metadata": {"type": "response.done", "session_id": "sess_demo_01", "response_id": "resp_01", "epoch": 0, "committed": true, "playback": {"generated_ms": 2400, "sent_ms": 2400, "played_ms": 2400, "committed_ms": 2400}}
+    "metadata": {"type": "response.done", "session_id": "duplex-5f2a…", "response_id": "resp_01", "epoch": 0, "committed": true, "playback": {"generated_ms": 2400, "sent_ms": 2400, "played_ms": 2400, "committed_ms": 2400}}
   }
 }
 ```
@@ -1006,9 +1157,9 @@ deferred commit during an active response (`event.response_create_deferred`)
 ```json
 {
   "type": "response.listen",
-  "session_id": "sess_demo_01",
+  "session_id": "duplex-5f2a…",
   "epoch": 0,
-  "response": {"object": "realtime.response", "status": "listening", "metadata": {"type": "response.listen", "session_id": "sess_demo_01", "epoch": 0, "reason": "model_listen"}}
+  "response": {"object": "realtime.response", "status": "listening", "metadata": {"type": "response.listen", "session_id": "duplex-5f2a…", "epoch": 0, "reason": "model_listen"}}
 }
 ```
 
@@ -1055,7 +1206,7 @@ function-call response (Nemotron VoiceChat tools)
 raw fallback when a model tool call is malformed (`call_id`/`name` missing)
 
 ```json
-{"type": "duplex.function_call.done", "event": {"type": "function_call.done", "session_id": "sess_demo_01", "epoch": 0, "call_id": null, "name": null, "arguments": "{"}}
+{"type": "duplex.function_call.done", "event": {"type": "function_call.done", "session_id": "duplex-5f2a…", "epoch": 0, "call_id": null, "name": null, "arguments": "{"}}
 ```
 
 #### Playback
@@ -1071,7 +1222,7 @@ raw fallback when a model tool call is malformed (`call_id`/`name` missing)
   "type": "playback.acknowledged",
   "event": {
     "type": "playback.acknowledged",
-    "session_id": "sess_demo_01",
+    "session_id": "duplex-5f2a…",
     "epoch": 0,
     "item_id": "item_resp_01",
     "played_ms": 1000,
@@ -1096,20 +1247,17 @@ truncating ack after an interruption (what was actually heard)
 ```json
 {
   "type": "overlap.decision",
-  "session_id": "sess_demo_01",
+  "session_id": "duplex-5f2a…",
   "epoch": 0,
   "policy": "listen_only",
   "action": "listen",
   "reason": "long_overlap_speech",
-  "overlap_ms": 1400,
-  "buffer_audio": true,
-  "defer_runtime_append": true,
-  "force_listen": true
+  "metadata": {"overlap_ms": 1400, "buffer_audio": true, "defer_runtime_append": true, "force_listen": true}
 }
 ```
 
 ```json
-{"type": "overlap.decision", "session_id": "sess_demo_01", "epoch": 0, "policy": "barge_in_on_speech", "action": "barge_in", "reason": "server_vad_utterance_active"}
+{"type": "overlap.decision", "session_id": "duplex-5f2a…", "epoch": 0, "policy": "barge_in_on_speech", "action": "barge_in", "reason": "server_vad_utterance_active"}
 ```
 
 server-VAD session (`session.update` fragment) and the annotated append the
@@ -1123,12 +1271,6 @@ translator forwards internally (shown for reference; clients never see it)
 {"type": "input_audio_buffer.append", "audio": "…", "format": "pcm16", "sample_rate_hz": 16000, "is_speech": true, "force_listen": true, "vad": {"backend": "silero", "is_speech": true, "speech_active": true, "speech_started": true, "speech_stopped": false, "speech_probability": 0.93}}
 ```
 
-`S→C runtime.control` (only when an engine signal was partially unsupported)
-
-```json
-{"type": "runtime.control", "session_id": "sess_demo_01", "epoch": 1, "result": {"…": "redacted engine control result"}}
-```
-
 #### Errors
 
 `S→C error` — Realtime shape
@@ -1154,71 +1296,80 @@ translator forwards internally (shown for reference; clients never see it)
 ```
 
 ```json
-{"type": "error", "error": {"type": "rate_limit_error", "code": "duplex_session_busy", "message": "duplex session capacity reached (max_sessions=4)"}}
+{"type": "error", "error": {"type": "rate_limit_error", "code": "resource_exhausted", "message": "duplex_session_capacity_exhausted: limit=4"}}
 ```
 
 Handshake-stage errors (before the Realtime projector is bound) use the
 flat native shape:
 
 ```json
-{"type": "error", "error": "Unknown or expired duplex session: sess_demo_01", "code": "session_resume_expired"}
+{"type": "error", "error": "Unknown or expired duplex session: duplex-5f2a…", "code": "session_resume_expired"}
 ```
 
 #### Coverage
 
 The examples above cover every event type the Realtime route emits or
 accepts (verified by diffing the `type` literals in
-`vllm_omni/entrypoints/duplex/` against this document). Not shown, because
-they never reach a `/v1/realtime?duplex=1` client unprojected: the native
-`/v1/duplex` dialect (`session.create` / `open_session` / `session.config`,
-`input.committed`, `input.cancelled`, `audio.cancelled`,
-`response.output_audio.delta`, `response.text.delta`, `response.message`,
-`function_call.done`) — their Realtime projections are the examples above
-(see the name map at the end of this section) — and the runner-internal markers `__timeout__`,
-`__disconnect__`, `__replaced_attachment__`. Input aliases (`push_chunk`,
-`input.audio.append`, `input_text.append`, `push_text`, `signal_turn`,
-`audio.playback_ack`, `close_session`, `close`, `session_close`) share the
-payload of their canonical event (see the alias table in [Full-Duplex Runtime (MiniCPM-o 4.5)](../design/fullduplex.md)).
+`vllm_omni/engine/duplex/events.py` and `vllm_omni/engine/duplex/commands.py`
+against this document). Not shown, because they never reach a client
+unprojected: the session-internal events the runner produces
+(`input.committed`, `input.cancelled`, `audio.cancelled`,
+`response.output_audio.delta`, `response.text.delta`, `function_call.done`)
+— their Realtime projections are the examples above (see the name map at the
+end of this section). Every public event is a typed `DuplexEvent` whose
+`to_realtime()` is the wire object; every client event is parsed into a
+typed `DuplexCommand` by `command_from_realtime()`.
 
-#### Native to Realtime name map
+#### Internal to Realtime name map
 
-The native `/v1/duplex` dialect is what the session runner produces; the
-Realtime projector renames and fans out these events before they reach a
-`/v1/realtime?duplex=1` client.
+The session runner emits these session-internal events; the Realtime
+projector (`vllm_omni/engine/duplex/realtime_events.py`) renames and fans
+them out into typed events before they reach a client.
 
-| Native / internal event | Realtime projection |
+| Internal event | Realtime projection |
 | --- | --- |
-| `session.create` (`open_session`, `session.config`) | first `session.update` |
 | `input.committed` | `conversation.item.added` / `conversation.item.created`, `input_audio_buffer.committed`, `conversation.item.input_audio_transcription.completed`, `conversation.item.done` |
 | `input.cancelled` | `input_audio_buffer.cleared` |
-| `response.output_audio.delta` (with `audio_transcript`) | optional `response.speak`, then `response.audio.delta` and `response.audio_transcript.delta` |
-| `response.output_audio.done` / `response.output_text.done` | `response.audio.done` / `response.output_text.done` |
+| `response.output_audio.delta` (with `audio_transcript`) | optional `response.speak`, then `response.output_audio.delta` and `response.output_audio_transcript.delta` |
+| `response.output_audio.done` / `response.output_text.done` | `response.output_audio.done` / `response.output_text.done` |
 | `response.text.delta` | `response.output_text.delta` |
-| `response.message` (chat-fallback raw chunk) | passed through |
 | `audio.cancelled` | optional `output_audio_buffer.cleared`, then the cancelled terminal events and `response.done` with `status: "cancelled"` |
 | `function_call.done` | `response.created`, `response.output_item.added` (`function_call` item), `response.function_call_arguments.delta` / `.done`, `response.output_item.done`, `response.done` |
 | `playback.acknowledged` | `playback.acknowledged` (wrapped verbatim under `event`) |
-| `runtime.control`, `session.resumed`, `session.replaced`, `session.expired`, `session.resync_required`, `session.heartbeat_ack` | passed through unchanged |
+| `session.resumed`, `session.replaced`, `session.expired`, `session.resync_required`, `session.heartbeat_ack` | passed through unchanged |
 
 ## Known Limitations
 
+- Only MiniCPM-o 4.5 is served over this endpoint today; PersonaPlex and
+  Nemotron VoiceChat arrive with the follow-up PRs that port them to the
+  plugin contract.
 - Several surfaces are capability-gated per model (see *Capability
   negotiation by model* above): PersonaPlex does not support session resume,
   barge-in, or audio truncation; Nemotron VoiceChat does not support barge-in
   or audio truncation; camera frames are consumed only by MiniCPM-o 4.5; tool
   calls are produced only by Nemotron VoiceChat.
-- `turn_detection` supports `server_vad` or `null`, not `semantic_vad`.
-  Turn-based models support endpointing without interruption, including
-  `create_response=false` for explicit response creation. Model-native duplex
-  requires `interrupt_response=true` and `create_response=true`.
+- A response is generated from committed **audio**, so the OpenAI text-prompt
+  shape does not drive one: `conversation.item.create` with an `input_text`
+  part adds the item to history, but a following `response.create` with no
+  committed audio is rejected with `response_create_without_input`, and
+  `input.text.append` is rejected with `native_text_append_unsupported`.
+  Text-to-speech has its own shape here — put the text in
+  `extra_body.duplex_initial_user_text` on `session.update`, then stream audio
+  units (silence is enough). The seeded turn is what the model answers.
+- `turn_detection` supports only `server_vad` with `interrupt_response=true`;
+  `semantic_vad`, `interrupt_response=false`, and `create_response` are not
+  supported.
 - `input_audio_transcription` and `input_audio_noise_reduction` are accepted
   and echoed but no separate transcription or noise-reduction stage runs;
   transcripts come from the model.
 - `rate_limits.updated` is emitted for compatibility only and always carries
   an empty list.
 - Session capacity is bounded by `duplex_session.max_sessions` in the deploy
-  configuration; admission beyond it fails with `duplex_session_busy` or
-  `resource_exhausted`.
-- The native `/v1/duplex` route speaks the internal dialect and does not
-  support `session.resume`; use `/v1/realtime?duplex=1` for the contract on
-  this page.
+  configuration; admission beyond it fails with `resource_exhausted`
+  (`rate_limit_error`, retryable).
+- 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 f0658f278..c0b8fe5e2 100644
--- a/docs/serving/speech_api.md
+++ b/docs/serving/speech_api.md
@@ -6,8 +6,9 @@ vLLM-Omni provides an OpenAI-compatible API for text-to-speech (TTS) generation.
 - **Fish Speech S2 Pro** (`fishaudio/s2-pro`) -- Dual-AR TTS with DAC codec. Supports text-to-speech and voice cloning via reference audio. Output: 44.1 kHz.
 - **Voxtral TTS** (`mistralai/Voxtral-4B-TTS-2603`) -- AR + FlowMatching TTS with preset voices. Output: 24 kHz.
 - **CosyVoice3** (`FunAudioLLM/Fun-CosyVoice3-0.5B-2512`) -- 2-stage talker + flow-matching code2wav. Voice cloning via `ref_audio` + `ref_text` (no presets). Output: 24 kHz.
+- **Gepard-1.0** (`nineninesix/gepard-1.0`) -- single-stage native-AR TTS with a 22.05 kHz NanoCodec. Zero-shot default voice only.
 
-See the [Supported Models](#supported-models) section below for the full list, including OmniVoice, VoxCPM2, and MOSS-TTS-Nano.
+See the [Supported Models](#supported-models) section below for the full list, including OmniVoice, VoxCPM2, MOSS-TTS-Nano, and Breeze-TTS-2.
 
 !!! tip "Deployment recipes"
     TTS deployment recipes are published at
@@ -40,11 +41,16 @@ vllm serve mistralai/Voxtral-4B-TTS-2603 --omni --port 8091
 # CosyVoice3 (voice cloning only — supply ref_audio + ref_text per request)
 vllm serve FunAudioLLM/Fun-CosyVoice3-0.5B-2512 \
     --omni --port 8091 --trust-remote-code
+
+# Gepard-1.0 (zero-shot default voice; packaged gepard.yaml)
+vllm-omni serve nineninesix/gepard-1.0 --omni --port 8091 --trust-remote-code \
+    --stage-init-timeout 900 \
+    --deploy-config vllm_omni/deploy/gepard.yaml
 ```
 
 ### Generate Speech
 
-**Using curl:**
+**Qwen3-TTS CustomVoice, using curl:**
 
 ```bash
 curl -X POST http://localhost:8091/v1/audio/speech \
@@ -56,7 +62,24 @@ curl -X POST http://localhost:8091/v1/audio/speech \
     }' --output output.wav
 ```
 
-**Using Python:**
+**Gepard-1.0, using curl:**
+
+Gepard accepts `input` (required), `voice` (`"default"`), `response_format`,
+`stream` / `stream_format`, `max_new_tokens`, and `seed`. Unsupported fields
+include `speed`, `language`, `instructions`, `task_type`, `ref_audio`,
+`ref_text`, `extra_params`, and `word_timestamps`.
+
+```bash
+curl -X POST http://localhost:8091/v1/audio/speech \
+    -H "Content-Type: application/json" \
+    -d '{
+        "input": "Hello, this is Gepard speaking.",
+        "voice": "default",
+        "seed": 7
+    }' --output output.wav
+```
+
+**Qwen3-TTS CustomVoice, using Python:**
 
 ```python
 import httpx
@@ -498,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.
@@ -761,6 +793,28 @@ Fish Speech uses `ref_audio` and `ref_text` for voice cloning (no `task_type` ne
 | ------- | ------------- |
 | `FunAudioLLM/Fun-CosyVoice3-0.5B-2512` | Voice cloning from `ref_audio` + `ref_text`. No built-in voice presets — upload a voice or pass `ref_audio`/`ref_text` per request. |
 
+### Gepard-1.0
+
+| Model | Description |
+| ----- | ----------- |
+| `nineninesix/gepard-1.0` | Zero-shot native-AR TTS. 22.05 kHz mono. `voice` must be omitted or `"default"`. |
+
+Gepard request fields:
+
+| Field | Behavior |
+| ----- | -------- |
+| `input` | Required. Empty/whitespace-only returns 400. |
+| `voice` | Omitted or `"default"` only. Other values 400. |
+| `response_format` | `wav` default. Non-streaming: `wav`/`pcm`/`flac`/`mp3`. `opus` returns 400 (22.05 kHz is not an Opus sample rate). Streaming: `pcm`/`wav` only. |
+| `stream` / `stream_format` | SSE (`speech.audio.*`) and raw `audio` byte streaming. |
+| `speed` | Must be `1.0`. Gepard has no native speed control. |
+| `max_new_tokens` | Frame budget (1 token = 1 frame = 1024 samples ≈ 46.4 ms). Default 1000 from deploy YAML; adapter bounds 1..4096. |
+| `seed` | Optional. Reaches the in-model 32-head sampler. The packaged YAML currently pins `seed: 42`, so serving is deterministic by default until that pin is removed. |
+| `extra_params` | Any key returns 400, including `temperature`/`top_p`/`top_k`. |
+| Cloning / style fields | `ref_audio`, `ref_text`, `speaker_embedding`, `instructions`, `language`, `task_type`, `word_timestamps`, and similar declared-but-unsupported fields return 400. |
+
+See the [Gepard section of the online TTS hub](../user_guide/examples/online_serving/text_to_speech.md#gepard-10) for launch commands. Native-AR recompute preemption is a known limitation under concurrency.
+
 ### OmniVoice
 
 | Model | Description |
@@ -777,12 +831,52 @@ hidden-state dtype before the output projection. Consequently, a float32 stage c
 | ------- | ------------- |
 | `openbmb/VoxCPM2` | TTS + voice cloning with built-in speaker presets and uploaded-voice support. Accepts `voice` (preset or uploaded) or `ref_audio` + optional `ref_text`. |
 
+#### Startup LoRA adapter
+
+To serve a fine-tuned VoxCPM2 voice, set
+`voxcpm2_runtime_config.startup_lora_path` in the stage's `hf_overrides`.
+Copy `vllm_omni/deploy/voxcpm2.yaml` to a local deploy config and add this key
+alongside its existing runtime settings:
+
+```yaml
+# Under stages[0].engine_extras.hf_overrides.voxcpm2_runtime_config:
+startup_lora_path: /absolute/path/to/adapter
+```
+
+Then launch with the modified config:
+
+```bash
+vllm serve openbmb/VoxCPM2 --omni --deploy-config /absolute/path/to/voxcpm2-lora.yaml
+```
+
+The directory must be accessible to the worker and contain the native VoxCPM2
+training export: `lora_config.json` (with a `lora_config` object containing
+`r`, `alpha`, enabled groups, and target module names) and
+`lora_weights.safetensors`. PEFT checkpoints and pickle checkpoints are not
+accepted. Missing, unexpected, non-finite, or incorrectly shaped adapter
+tensors fail model loading rather than silently loading a partial adapter.
+
+The adapter is merged into the base LM, residual LM, LocDiT, and optional
+projection layers selected by its configuration, after base weight loading
+and before compilation or CUDA graph capture. All requests use that adapter;
+`voice` still selects a reference voice, not a LoRA adapter. Changing adapters
+requires restarting the server. Runtime loading/unloading, per-request
+multi-LoRA selection, and `load_format=dummy` are not supported by this path.
+Weight fusion rounds to the base model's dtype, so numerical and speech-quality
+parity should be checked against the upstream adapter on your deployment.
+
 ### MOSS-TTS-Nano
 
 | Model | Description |
 | ------- | ------------- |
 | `OpenMOSS-Team/MOSS-TTS-Nano` | Voice cloning only. Requires `ref_audio` (or an uploaded `voice`); no built-in voice presets. `ref_text` is accepted but ignored — upstream's `voice_clone` mode does not consume a transcript. |
 
+### Breeze-TTS-2
+
+| Model | Description |
+| ------- | ------------- |
+| `BreezeBlue/Breeze-TTS-2` | Two-stage AR TTS (T5Gemma2 + Qwen3 talker with a depth decoder, bundled Qwen3-TTS codec) at 24 kHz. Four modes are selected from the request fields: plain (`input` + speaker tag `voice`, `S0`..`S9`), voice design (`instructions`), voice clone (`ref_audio` + `ref_text`, exactly one clip), and voice direction (reference + `instructions`). Greedy decoding only: `sample_rate` must be `24000`, `speed` must be `1.0`, and `guidance_scale`/`cfg_scale` other than `1.0`, `negative_prompt`, `temperature`/`top_p`/`top_k` overrides, `language`, and `speaker_embedding` are rejected. Streaming returns PCM `speech.audio.delta` events. See [`recipes/BreezeBlue/Breeze-TTS-2.md`](https://github.com/vllm-project/vllm-omni/blob/main/recipes/BreezeBlue/Breeze-TTS-2.md). |
+
 ## Error Responses
 
 ### 400 Bad Request
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/video_stream_api.md b/docs/serving/video_stream_api.md
index e1f583991..23aa4cb08 100644
--- a/docs/serving/video_stream_api.md
+++ b/docs/serving/video_stream_api.md
@@ -45,11 +45,19 @@ WebSocket /v1/video/chat/stream
 | Server -> Client | `response.start` | none | Query generation started. |
 | Server -> Client | `response.text.delta` | `delta` | Incremental text output. |
 | Server -> Client | `response.text.done` | `text` | Final text output for the query. |
-| Server -> Client | `response.audio.delta` | `data`, `format` | Incremental generated audio, base64 WAV. |
-| Server -> Client | `response.audio.done` | none | Audio output finished. |
+| Server -> Client | `response.output_audio.delta` | `data`, `format` | Incremental generated audio, base64 WAV. |
+| Server -> Client | `response.output_audio.done` | none | Audio output finished. |
 | Server -> Client | `session.done` | none | Session closed. |
 | Server -> Client | `error` | `message` | Recoverable protocol or generation error. |
 
+### Frame Consumption Reporting
+
+When buffered frames include client-supplied `frame_id` values, the server emits `video.frames.consumed` after the first engine output. Its `frame_ids`, `frames`, and `latest_pts_ms` describe the images included in that query's prompt.
+
+Queries stride-sample the buffered frames, keeping the last frame, then exclude frames already known to have failed decoding. Excluded frames are not replaced with other buffered frames. Frames whose background decoding has not finished remain eligible through the image URL path.
+
+**Bugfix compatibility note:** `video.frames.consumed` now excludes known decode failures that were already excluded from the prompt. Older versions could report those frames and their timestamps as consumed. The event name and fields are unchanged; an empty selection reports empty lists and `latest_pts_ms: null`.
+
 ### `session.config` Fields
 
 | Field | Type | Default | Description |
@@ -60,10 +68,24 @@ WebSocket /v1/video/chat/stream
 | `max_frames` | integer, 1-256 | `50` | Maximum retained frame buffer size. Oldest frames are evicted first. |
 | `system_prompt` | string or null | null | Optional custom system prompt. |
 | `use_audio_in_video` | bool | `true` | Include streamed audio chunks in multimodal video understanding when audio is present. |
-| `sampling_params_list` | list or null | null | Optional per-stage sampling parameter overrides. |
+| `sampling_params_list` | list or null | null | Optional per-stage parameter dictionaries. Each provided entry replaces that stage's deployment sampling settings. |
 | `enable_frame_filter` | bool | `true` | Enable EVS near-duplicate frame filtering. |
 | `frame_filter_threshold` | float, 0.0-1.0 | `0.95` | EVS similarity threshold. Higher keeps more frames; lower drops more near-duplicates. |
 
+Sampling parameter bugfix: `sampling_params_list` is now forwarded to the engine;
+earlier versions accepted this field but silently used deployment defaults instead.
+Each provided entry constructs a fresh `SamplingParams` for that stage in pipeline
+order; it is not merged with that stage's deployment defaults. Fields absent from a
+provided entry use `SamplingParams` constructor defaults. Only omitted trailing
+stages keep their deployment defaults. An omitted, `null`, or empty list keeps the
+engine defaults. Invalid sampling parameters return an `error` when the query is
+submitted.
+
+For example, `[{"temperature": 0.2, "max_tokens": 64}]` configures the thinker while
+the talker and code2wav retain their deployment defaults. With only
+`[{"temperature": 0.2}]`, the thinker's `max_tokens` and `top_p` use constructor
+defaults, not its YAML values.
+
 ### Legacy Aliases
 
 The server accepts these legacy field names and rewrites them before validation. New clients should send the canonical names above.
diff --git a/docs/serving/videos_api.md b/docs/serving/videos_api.md
index 09f023d27..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 |
@@ -109,6 +113,16 @@ curl -L "http://localhost:8091/v1/videos/${video_id}/content" -o output.mp4
 The final content is available from `/v1/videos/{video_id}/content` after the
 job status becomes `completed`.
 
+`queued` means the request is still waiting for diffusion scheduler admission.
+The status changes to `in_progress` when the scheduler first selects the
+request for execution.
+
+`DELETE /v1/videos/{video_id}` issues a bounded engine abort
+(`VLLM_OMNI_ABORT_TIMEOUT`, default 2s), then cancels the frontend
+task. Cancellation cleanup is also bounded and best-effort: it confirms
+the abort was queued, and the current request batch may still drain.
+The job is then re-read so a completed save is not orphaned.
+
 ### Synchronous Response
 
 `POST /v1/videos/sync` blocks until generation finishes and returns raw video
@@ -204,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
@@ -234,6 +291,48 @@ curl -X POST http://localhost:8091/v1/videos/sync \
   -o output.mp4
 ```
 
+## Output Encoding
+
+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
+is encoded while later chunks are still decoding, so host transfer and CPU
+encoding overlap the remaining decode instead of following it. The response is
+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, "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. 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 and Wan 2.2 (T2V, I2V, and S2V) implement it,
+and other models ignore the flag and take the full-decode path.
+
 ## Storage
 
 Set `VLLM_OMNI_SERVER_STORAGE__PATH` to control where asynchronous video outputs are
diff --git a/docs/usage/metrics.md b/docs/usage/metrics.md
index 184a76eef..1e0c1d068 100644
--- a/docs/usage/metrics.md
+++ b/docs/usage/metrics.md
@@ -12,7 +12,7 @@ curl http://localhost:8000/metrics
 ## Metric Namespaces
 
 | Prefix | Source | Present when |
-|--------|--------|--------------|
+| -------- | -------- | -------------- |
 | `vllm_omni:` | vLLM-Omni orchestrator / audio modality / cross-stage transfer | Pipeline-dependent |
 | `vllm:` | Upstream vLLM engine, wrapped by `OmniPrometheusStatLogger` to expose `{stage, replica}` | Pipeline includes an LLM (AR) stage |
 | `http_` / `process_` | Uvicorn / Python runtime | Always |
@@ -24,7 +24,7 @@ Defined in `vllm_omni/metrics/prometheus.py`. Track request lifecycle across the
 ### Request counts
 
 | Metric | Type | Labels | Description |
-|--------|------|--------|-------------|
+| -------- | ------ | -------- | ------------- |
 | `vllm_omni:num_requests_running` | Gauge | `model_name` | Pipeline-global in-flight requests (dispatched to engine, not yet finalized) |
 | `vllm_omni:num_requests_waiting` | Gauge | `model_name` | Requests waiting in the Orchestrator queue |
 | `vllm_omni:requests_success_total` | Counter | `model_name`, `finished_reason` | Total requests by completion reason. `finished_reason` ∈ {`stop`, `length`, `abort`, ...} mirroring upstream `vllm:request_success_total`; aborts cover client disconnect / cancellation paths in addition to upstream `FinishReason.ABORT` |
@@ -32,15 +32,15 @@ Defined in `vllm_omni/metrics/prometheus.py`. Track request lifecycle across the
 ### Latency
 
 | Metric | Type | Labels | Description |
-|--------|------|--------|-------------|
+| -------- | ------ | -------- | ------------- |
 | `vllm_omni:e2e_request_latency_s` | Histogram | `model_name` | Pipeline-global end-to-end request latency in seconds |
 
 ## Audio Modality Metrics (`vllm_omni:`)
 
-Emitted at request finalize, except for `audio_ttfp_s` (streaming-hook at the first audio packet) and `audio_underrun_s` / `audio_continuity_ok_total` (streaming finalize, after the chunk stream is exhausted). All carry `{model_name, stage, replica}` plus the listed extra label.
+Emitted at request finalize, except for `audio_ttfp_s` (the first audio packet/frame from streaming Chat or Speech APIs) and `audio_underrun_s` / `audio_continuity_ok_total` (Chat or Speech streaming finalize, after the chunk stream is exhausted). Non-streaming Speech latency is represented by `e2e_request_latency_s`, not TTFP. All audio metrics carry `{model_name, stage, replica}` plus the listed extra label.
 
 | Metric | Type | Extra label | Description |
-|--------|------|-------------|-------------|
+| -------- | ------ | ------------- | ------------- |
 | `vllm_omni:audio_ttfp_s` | Histogram | — | Time from request arrival to first audio packet/frame |
 | `vllm_omni:audio_duration_s` | Histogram | — | Audio content duration (`audio_frames / sample_rate`) |
 | `vllm_omni:audio_rtf` | Histogram | — | Real-time factor (`stage_gen_time_s / audio_duration_s`); streaming TTS SLO red line `< 1`; uses `RTF_BUCKETS` |
@@ -50,13 +50,22 @@ Emitted at request finalize, except for `audio_ttfp_s` (streaming-hook at the fi
 | `vllm_omni:audio_skipped_requests_total` | Counter | `reason` | Silent-loss counter — code2wav rejected malformed codec input and returned `200 OK` with empty audio |
 
 The continuity math comes from `vllm_omni/benchmarks/audio_continuity.py::compute_continuity_stats` so the server-side observation aligns with the bench-side definition.
+For Speech, continuity applies to raw audio, SSE, and WebSocket streaming. WAV headers and empty chunks are excluded; non-streaming Speech requests do not emit continuity samples.
+
+Continuity rate for the default 100 ms threshold can be derived from the successful-continuity counter and the underrun Histogram's request count:
+
+```promql
+sum by (model_name, stage, replica) (rate(vllm_omni:audio_continuity_ok_total{threshold_ms="100"}[5m]))
+/
+sum by (model_name, stage, replica) (rate(vllm_omni:audio_underrun_s_count[5m]))
+```
 
 ## Diffusion Metrics (`vllm_omni:`)
 
 Per-request timing breakdowns for diffusion (image/video) stages. Emitted at request finalize when `stage_metrics.diffusion_metrics` is present. All carry `{model_name, stage, replica}`.
 
 | Metric | Type | Description |
-|--------|------|-------------|
+| -------- | ------ | ------------- |
 | `vllm_omni:diffusion_exec_s` | Histogram | DiT forward pass execution time per request in seconds |
 | `vllm_omni:diffusion_exec_per_step_s` | Histogram | DiT forward pass execution time per denoising step in seconds (`exec_s / num_inference_steps`) |
 | `vllm_omni:diffusion_preprocess_s` | Histogram | Diffusion input preprocessing time per request in seconds |
@@ -80,7 +89,7 @@ rate(vllm_omni:diffusion_preprocess_s_sum[5m])
 Per-physical-transfer histograms tracking the data hop between adjacent stages. Labels `{model_name, from_stage, from_replica, to_stage, to_replica}` let dashboards attribute latency to specific replica edges. `from_replica` / `to_replica` are resolved from the orchestrator's sticky-routing binding (`stage_pool.get_bound_replica_id(request_id)`), so no extra plumbing through `TransferEdgeStats` is needed.
 
 | Metric | Type | Description |
-|--------|------|-------------|
+| -------- | ------ | ------------- |
 | `vllm_omni:transfer_size_bytes` | Histogram | Per-transfer payload size in bytes |
 | `vllm_omni:transfer_tx_s` | Histogram | Sender-side time (serialize + submit to connector) |
 | `vllm_omni:transfer_rx_s` | Histogram | Receiver-side time (recv + deserialize) |
@@ -106,7 +115,7 @@ For the full list of upstream metrics, see [the vLLM docs](https://github.com/vl
 ## Metric Availability by Pipeline Type
 
 | Metric group | Multi-stage LLM (Qwen3-Omni) |
-|---|---|
+| --- | --- |
 | `vllm_omni:` request tracking + latency | With `--log-stats` |
 | `vllm_omni:` audio modality | With `--log-stats`, if pipeline has a talker stage |
 | `vllm_omni:` transfer | With `--log-stats`, if pipeline has ≥ 2 stages |
diff --git a/docs/user_guide/diffusion/attention_backends/fastvideo_vsa.md b/docs/user_guide/diffusion/attention_backends/fastvideo_vsa.md
index c03b9ffde..df6e34b0c 100644
--- a/docs/user_guide/diffusion/attention_backends/fastvideo_vsa.md
+++ b/docs/user_guide/diffusion/attention_backends/fastvideo_vsa.md
@@ -1,24 +1,33 @@
 # FastVideo VSA
 
-FastVideo Variable Sparse Attention (VSA) accelerates the `FastVideo/FastWan2.2-TI2V-5B-Diffusers` model's
-self-attention by partitioning the post-patch latent grid into spatiotemporal
+FastVideo Variable Sparse Attention (VSA) partitions the post-patch latent grid into spatiotemporal
 blocks. For every query block, VSA scores the key/value blocks and computes
 attention only against the selected top-k blocks.
 
-The supported checkpoint provides both text-to-video and image-to-video modes through `Wan22Pipeline`; the separate Wan I2V-14B, S2V, and VACE pipelines are outside this backend's supported scope.
+## Supported models
 
-MiniMax-H3 served with a FastH3 VSA adapter uses a second, H3-specific route
-through the same backend. See the
-[MiniMax-H3 recipe](https://recipes.vllm.ai/MiniMaxAI/MiniMax-H3) for its geometry,
-supported topologies, and commands.
+| Model / checkpoint | Required adapter | Tasks | Sequence parallelism |
+| --- | --- | --- | --- |
+| `FastVideo/FastWan2.2-TI2V-5B-Diffusers` | None | T2V, I2V through `Wan22Pipeline` | Disabled |
+| `MiniMaxAI/MiniMax-H3` | [FastH3 VSA (recipe)](https://github.com/vllm-project/vllm-omni/blob/main/recipes/MiniMaxAI/MiniMax-H3.md#fasth3-adapter) | T2VA | Disabled or pure Ulysses |
+| Wan I2V-14B, S2V, VACE | — | Unsupported | — |
 
-VSA is a CUDA-only, explicitly selected backend. It requires the
-`fastvideo-kernel` package and currently supports non-causal self-attention
-with equal query and key/value sequence lengths. Unsupported shapes, masks,
-dtypes, sequence-parallel execution, or kernel failures fall back to
-`TORCH_SDPA` and emit a warning with the reason. On the Wan route, an active
-sequence-parallel context is one of those fallbacks; the H3 route supports pure
-Ulysses and rejects ring or all-gather sequence parallelism at startup.
+## Installation
+
+Install vLLM-Omni from this checkout with the `vsa` extra:
+
+```bash
+uv pip install -e '.[vsa]'
+```
+
+The extra installs the tested kernel dependency automatically. Prebuilt kernels require
+Linux, Python 3.12, and glibc 2.34 or newer (x86-64 or aarch64). The full
+FastVideo framework and provider environment variables are not required.
+
+`FASTVIDEO_VSA` selects the attention algorithm. On SM120, the H3 integration
+currently executes FastVideo's 64-token Triton block-sparse kernel; it does not
+dispatch to FlashInfer. The `vsa` extra installs `fastvideo-kernel==0.3.4` for
+this execution path.
 
 ## Enable the backend
 
@@ -27,24 +36,18 @@ flag. Use `--fastvideo-vsa-topk` to set the number of key/value blocks retained
 for every query block:
 
 ```bash
-vllm-omni serve <model> \
+vllm serve <model> --omni \
   --diffusion-attention-backend FASTVIDEO_VSA \
   --fastvideo-vsa-topk 64
 ```
 
-The backwards-compatible environment variable selects the backend with the
-default `topk=64`:
+<details markdown="1">
+<summary>Alternative configuration formats</summary>
+
+Equivalent structured configuration:
 
 ```bash
-export DIFFUSION_ATTENTION_BACKEND=FASTVIDEO_VSA
-vllm-omni serve <model>
-```
-
-To tune top-k, pass the CLI backend and top-k flags together as shown above,
-or use the equivalent structured configuration:
-
-```bash
-vllm-omni serve <model> \
+vllm serve <model> --omni \
   --diffusion-attention-config \
   '{"default":{"backend":"FASTVIDEO_VSA","fastvideo_vsa_topk":64}}'
 ```
@@ -73,8 +76,15 @@ stages:
         fastvideo_vsa_topk: 64
 ```
 
+</details>
+
 ## Choose top-k
 
+H3 uses 64-token video blocks and keeps
+all prefix blocks; see the [FastH3 VSA recipe](https://github.com/vllm-project/vllm-omni/blob/main/recipes/MiniMaxAI/MiniMax-H3.md#fasth3-adapter).
+
+### Wan top-k behavior
+
 At runtime the backend logs the sequence shape and derived block count:
 
 ```text
@@ -117,8 +127,16 @@ selecting VSA does not turn a native checkpoint into a distilled model.
 
 ## Verify routing and fallback
 
-Check the startup and first-forward logs instead of assuming that selecting
-the backend guarantees sparse execution:
+VSA is a CUDA-only, explicitly selected backend. It requires the
+`fastvideo-kernel` package and currently supports non-causal self-attention
+with equal query and key/value sequence lengths. Unsupported shapes, masks,
+dtypes, sequence-parallel execution, or kernel failures fall back to
+`TORCH_SDPA` and emit a warning with the reason. On the Wan route, an active
+sequence-parallel context is one of those fallbacks; the H3 route supports pure
+Ulysses and rejects ring or all-gather sequence parallelism at startup.
+H3 accelerator faults propagate instead of attempting dense recovery.
+
+On the Wan route, check the startup and first-forward logs:
 
 - `route=VSA` means top-k block selection is active.
 - `route=VSA_ALL_BLOCKS` means the FastVideo DMD checkpoint retained all
@@ -126,6 +144,10 @@ the backend guarantees sparse execution:
 - `route=SDPA` or `FASTVIDEO_VSA falling back to SDPA: ...` means dense SDPA
   executed; the warning includes the reason.
 
+For H3, check `FastH3 adapter active` at startup and
+`FASTVIDEO_VSA H3 routing` during DiT execution, as described in the
+[model recipe](https://github.com/vllm-project/vllm-omni/blob/main/recipes/MiniMaxAI/MiniMax-H3.md#fasth3-adapter).
+
 The Wan route requires CUDA tensors in FP16 or BF16, 256-token blocks,
 standard `head_size**-0.5` scaling, equal Q/K/V head counts, no attention mask,
 and no active sequence-parallel context. The MiniMax-H3 route uses 64-token
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/device_side_video_postprocess.md b/docs/user_guide/diffusion/device_side_video_postprocess.md
new file mode 100644
index 000000000..910e64457
--- /dev/null
+++ b/docs/user_guide/diffusion/device_side_video_postprocess.md
@@ -0,0 +1,72 @@
+# Device-side video postprocessing
+
+vLLM-Omni can convert decoded WAN2.2 video from normalized floating-point
+`[B, C, T, H, W]` tensors to contiguous `uint8` `[B, T, H, W, C]` frames before
+the worker-to-engine device-to-host transfer. This reduces the transported video
+payload by four times when the original IPC path widens bfloat16 to float32.
+
+The optimization is disabled by default. Enable it with a structured diffusion
+configuration:
+
+```python
+from vllm_omni import Omni
+
+engine = Omni(
+    model="Wan-AI/Wan2.2-TI2V-5B-Diffusers",
+    video_output_transport={"enable_device_postprocess": True},
+)
+```
+
+For the server CLI, pass the same object as JSON:
+
+```bash
+vllm serve Wan-AI/Wan2.2-TI2V-5B-Diffusers --omni \
+  --video-output-transport '{"enable_device_postprocess": true}'
+```
+
+For a deploy configuration, place it on the diffusion stage:
+
+```yaml
+stages:
+  - stage_id: 0
+    video_output_transport:
+      enable_device_postprocess: true
+```
+
+## Runtime contract
+
+WAN2.2 emits decoded video through the typed `DiffusionOutput.media` field. The
+model runner validates and splits the batch into request-local tensors before
+preparing each video for transport. The worker then performs the D2H copy and
+shared-memory IPC using the prepared representation. The engine uses the generic
+media finalizer instead of a model-specific postprocessor.
+
+The runtime leaves the video in normalized floating-point form when:
+
+- `enable_device_postprocess` is false;
+- the requested output type is not `np`; or
+- frame interpolation still requires the floating-point tensor.
+
+These are policy fallbacks, not malformed-contract errors. If the device cannot
+allocate the temporary conversion buffer, the runner logs a warning and prepares
+the request-local float representation instead. Invalid tensor layout, encoding,
+value range, lifecycle state, and non-memory runtime failures still fail before
+IPC.
+
+## Precision
+
+Device preparation converts to float32 before denormalization and quantization.
+For bfloat16 WAN output this is more precise than the historical host path,
+which denormalizes in bfloat16. Relative to that path, values may differ by at
+most one level out of 255. Float32 inputs remain byte-identical after
+quantization.
+
+## Scope
+
+WAN2.2 is the reference migration for the first contract version. Other video
+pipelines continue using their existing output paths until they can declare the
+same typed media contract without bypassing model-specific float consumers such
+as safety checks or audio/video packaging.
+
+See [RFC #6541](https://github.com/vllm-project/vllm-omni/issues/6541) for the
+contract, lifecycle, batching rules, and migration plan.
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/diffusion/parallelism/cfg_parallel.md b/docs/user_guide/diffusion/parallelism/cfg_parallel.md
index 544754403..1e3b998d8 100644
--- a/docs/user_guide/diffusion/parallelism/cfg_parallel.md
+++ b/docs/user_guide/diffusion/parallelism/cfg_parallel.md
@@ -19,6 +19,12 @@ CFG-Parallel accelerates diffusion models by distributing positive and negative
 
 See supported models list in [Supported Models](../../diffusion_features.md#supported-models).
 
+Distilled Cosmos3 checkpoints, including `nvidia/Cosmos3-Super-Image2Video-4Step`,
+run without CFG and reject `--cfg-parallel-size` greater than 1 at startup.
+Use `--ulysses-degree 2` for two-GPU inference. These checkpoints always use
+`guidance_scale=1.0`; other explicitly requested values produce a warning, and
+`negative_prompt` does not affect generation.
+
 ---
 
 ## Quick Start
diff --git a/docs/user_guide/diffusion/regional_compilation.md b/docs/user_guide/diffusion/regional_compilation.md
index 448f19518..364900ff5 100644
--- a/docs/user_guide/diffusion/regional_compilation.md
+++ b/docs/user_guide/diffusion/regional_compilation.md
@@ -34,5 +34,34 @@ that provide their own `setup_compile()` implementation manage their compilation
 policy independently. Compilation is lazy, so backend or graph errors can first
 surface on the initial request.
 
+## Pinning one packed shape (MiniMax-H3)
+
+Compiled regions are keyed by input shape. MiniMax-H3 packs a request into a
+row count that follows the request -- a longer prompt, more frames, a larger
+frame -- and rounds it up to the next 64-row boundary, so two requests can land
+on two different packed lengths.
+
+Under the default `diffusion_compile_dynamic: true` a new packed length is
+absorbed by the dynamic shape, so it is not by itself a recompilation. It still
+hands the backend a shape it has not autotuned, which is the risk this knob
+exists to remove: a fixed-shape deployment (`--no-diffusion-compile-dynamic`)
+recompiles the transformer blocks per shape, and a first-seen large shape can
+push autotuning into its worst-case memory use.
+
+A request pins the length with `extra_args["pad_seq_len"]`:
+
+```python
+sampling_params = SamplingParams(extra_args={"pad_seq_len": 54080})
+```
+
+The value must be a positive multiple of 64 and must cover the rows the request
+actually uses; the packed sequence is then padded to it instead of to the next
+64-row boundary. Pick a bucket that covers every request dimension the
+deployment accepts -- prompt length, frame count, frame size and reference
+blocks all change the used row count. The server logs the effective length as
+`MiniMax H3 packed sequence: ... pad_seq_len=... used=... seq_len=...` whenever
+a request pins it. The padding rows are masked out, so their cost is the
+attention and feed-forward work on those rows.
+
 Use `--enforce-eager` to disable the model runner's generic compile setup.
 Pipelines that compile internally define their own eager-mode behavior.
diff --git a/docs/user_guide/examples/offline_inference/hunyuan_image3.md b/docs/user_guide/examples/offline_inference/hunyuan_image3.md
deleted file mode 100644
index 636aa0c11..000000000
--- a/docs/user_guide/examples/offline_inference/hunyuan_image3.md
+++ /dev/null
@@ -1,35 +0,0 @@
-# HunyuanImage-3.0 Image-to-Text Inference
-
-Source <https://github.com/vllm-project/vllm-omni/tree/main/examples/offline_inference/hunyuan_image3>.
-
-
-This example demonstrates how to run HunyuanImage-3.0 Image-to-Text with the vLLM-Omni.
-
-## Local CLI Usage
-
-Download the example image:
-
-```bash
-wget https://vllm-public-assets.s3.us-west-2.amazonaws.com/vision_model_images/cherry_blossom.jpg
-```
-
-Run example:
-
-```bash
-python image_to_text.py \
-  --image cherry_blossom.jpg \
-  --prompt "<|startoftext|>You are an assistant that understands images and outputs text.<img>Describe the content of the picture."
-```
-
-Key arguments:
-
-- `--model`: Model used. Default is: tencent/HunyuanImage-3.0-Instruct (Optional).
-- `--image`: Path to input image (required).
-- `--prompt`: Text description used to guide image understanding (required).
-
-## Example materials
-
-??? abstract "image_to_text.py"
-    ``````py
-    --8<-- "examples/offline_inference/hunyuan_image3/image_to_text.py"
-    ``````
diff --git a/docs/user_guide/examples/online_serving/qwen3_omni.md b/docs/user_guide/examples/online_serving/qwen3_omni.md
index d4e13fc89..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
@@ -22,7 +34,12 @@ both stages on vLLM's Triton unquantized MoE path and avoids the unstable FlashI
 some GPUs.
 Asynchronous chunk streaming is **enabled by default** within the bundled configuration.
 
+For Thinker pipeline parallelism, configure `pipeline_parallel_size` and `devices`
+on the Thinker stage. Keep Talker and Code2Wav at `pipeline_parallel_size: 1`. The
+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
@@ -46,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 \
@@ -56,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 \
@@ -66,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 \
@@ -91,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 \
@@ -103,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"
@@ -122,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
@@ -132,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 |
@@ -222,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 \
@@ -255,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)
@@ -271,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:
 
@@ -295,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 9a33dc858..c1107ad60 100644
--- a/docs/user_guide/examples/online_serving/text_to_speech.md
+++ b/docs/user_guide/examples/online_serving/text_to_speech.md
@@ -18,6 +18,7 @@ For the full list of supported architectures across all modalities, see
 | --- | --- | --- | --- | --- | --- |
 | CosyVoice3 | `FunAudioLLM/Fun-CosyVoice3-0.5B-2512` | ✓ (`ref_audio`+`ref_text`) | ✓ (PCM stream) | — | — |
 | Fish Speech S2 Pro | `fishaudio/s2-pro` | ✓ (`ref_audio`+`ref_text`) | ✓ (PCM stream) | — | ✓ |
+| Gepard-1.0 | `nineninesix/gepard-1.0` | — (zero-shot default voice) | ✓ (PCM / WAV stream) | `default` only | — |
 | higgs-audio v2 | `bosonai/higgs-audio-v2-generation-3B-base` | ✓ (`ref_audio`+`ref_text`) | ✓ (codec_streaming) | — | — |
 | GLM-TTS | `zai-org/GLM-TTS` | ✓ (`ref_audio`+`ref_text`, required) | ✓ (PCM stream) | — | ✓ |
 | OmniVoice | `k2-fsa/OmniVoice` | (offline only) | — | — | — |
@@ -92,7 +93,7 @@ curl -X POST http://localhost:8091/v1/audio/speech \
     }' --no-buffer | play -t raw -r 24000 -e signed -b 16 -c 1 -
 ```
 
-Adjust the player's sample rate to match the model (44.1 kHz for Fish Speech, 48 kHz for VoxCPM2, 24 kHz for the others).
+Adjust the player's sample rate to match the model (44.1 kHz for Fish Speech, 48 kHz for VoxCPM2, 22.05 kHz for Gepard, 24 kHz for the others).
 
 For full request-shape documentation (all parameters, response formats, error codes), see the [Speech API reference](https://github.com/vllm-project/vllm-omni/tree/main/docs/serving/speech_api.md).
 
@@ -120,6 +121,15 @@ vllm serve FunAudioLLM/Fun-CosyVoice3-0.5B-2512 --omni --port 8091 --trust-remot
 
 Streaming is on by default via `async_chunk: true` in `vllm_omni/deploy/cosyvoice3.yaml`. Pass `--no-async-chunk` (or `NO_ASYNC_CHUNK=1 ./cosyvoice3/run_server.sh`) for the legacy synchronous path.
 
+Cross-request Stage-1 flow batching is opt-in. Enable it in the server environment when concurrent requests should share a flow-estimator call:
+
+```bash
+export COSYVOICE3_BATCH_FLOW=1
+vllm serve FunAudioLLM/Fun-CosyVoice3-0.5B-2512 --omni --port 8091 --trust-remote-code
+```
+
+Batching preserves output lengths and streaming cache alignment, but the different GEMM shapes can produce small waveform differences compared with processing each request separately. Leave `COSYVOICE3_BATCH_FLOW` unset (or set it to `0`) when request-independent numerical behavior is required. Set `COSYVOICE3_BATCH_FLOW_DEBUG=1` to log the observed group-size distribution and enable detailed Stage-1 profiler scopes; diagnostics are disabled by default to avoid per-step profiling overhead.
+
 ### CLI client
 
 The client defaults to the official upstream zero-shot prompt, so it runs without extra flags:
@@ -203,6 +213,61 @@ python fish_speech/gradio_demo.py --api-base http://localhost:8091  # if server
 
 ---
 
+## Gepard-1.0
+
+Single-stage native AR TTS at 22.05 kHz mono. Zero-shot only: omit `voice` or pass `"default"`. Voice cloning from reference audio is not available yet.
+
+### Prerequisites
+
+Same NeMo NanoCodec install as the [offline Gepard section](https://github.com/vllm-project/vllm-omni/tree/main/examples/offline_inference/text_to_speech/README.md#gepard-10). On a host whose CUDA toolkit cannot build kernels — no `nvcc`/`ninja`, or a consumer Blackwell (`sm_120`) card — also `export VLLM_USE_FLASHINFER_SAMPLER=0` before launch. That env is not a deploy-YAML field.
+
+### Launch
+
+```bash
+vllm-omni serve nineninesix/gepard-1.0 --omni --port 8091 --trust-remote-code \
+    --stage-init-timeout 900 \
+    --deploy-config vllm_omni/deploy/gepard.yaml
+# or:
+./gepard/run_server.sh
+```
+
+`--stage-init-timeout 900` matches the online e2e fixture and the offline example. Serve defaults to 300s, which is often too short for a cold download of the talker plus NanoCodec.
+
+The packaged `vllm_omni/deploy/gepard.yaml` must be passed with `--deploy-config`. The checkpoint self-identifies as `qwen3_5_text`, so omitting the YAML launches a diffusion fallback instead of the Gepard pipeline. The YAML sets `async_chunk: false`, `max_num_seqs: 4`, and currently pins `seed: 42`, so serving is deterministic by default until that YAML seed is removed. Pass an explicit per-request `seed` in tests and clients rather than depending on either default.
+
+### Sending requests
+
+```bash
+python examples/online_serving/text_to_speech/gepard/speech_client.py \
+    --text "Hello, this is Gepard speaking."
+
+python examples/online_serving/text_to_speech/gepard/speech_client.py \
+    --text "Hello, this is Gepard speaking." --seed 7 --stream --output output.pcm
+```
+
+Gepard accepts `input` (required), `voice` (`"default"`), `response_format`, `stream` / `stream_format`, `max_new_tokens`, and `seed`. Unsupported fields include `speed`, `language`, `instructions`, `task_type`, `ref_audio`, `ref_text`, `extra_params`, and `word_timestamps`.
+
+```bash
+curl -X POST http://localhost:8091/v1/audio/speech \
+    -H "Content-Type: application/json" \
+    -d '{
+        "input": "Hello, this is Gepard speaking.",
+        "voice": "default",
+        "seed": 7
+    }' --output output.wav
+```
+
+### Notes
+
+- Output: 22.05 kHz mono. `max_new_tokens` is a **frame** budget (1 token = 1 frame = 1024 samples ≈ 46.4 ms at 21.5 fps; adapter bounds 1..4096).
+- Supported request fields: `input` (required), `voice` (`default` only), `response_format` (`wav` default; `wav/pcm/flac/mp3` non-streaming; `opus` 400 because 22.05 kHz is not an Opus sample rate; streaming `pcm/wav` only), `stream` / `stream_format`, `max_new_tokens`, `seed`.
+- Unsupported: `speed`, `extra_params` (including `temperature`/`top_p`/`top_k`), `ref_audio`, `ref_text`, `speaker_embedding`, `task_type`, `instructions`, `language`, and `word_timestamps`.
+- 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.
+- For the request-field table, see the [Speech API Gepard section](https://github.com/vllm-project/vllm-omni/blob/main/docs/serving/speech_api.md#gepard-10).
+
+---
+
 ## higgs-audio v2
 
 2-stage TTS at 24 kHz: a vLLM-native Llama-3.2-3B talker with a DualFFN audio expert (Stage 0) feeding a HiggsAudio codec decoder (Stage 1) that streams chunks back to the client.
@@ -348,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.
@@ -413,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/modelopt.md b/docs/user_guide/quantization/modelopt.md
index d8da4e1a9..07d05730e 100644
--- a/docs/user_guide/quantization/modelopt.md
+++ b/docs/user_guide/quantization/modelopt.md
@@ -204,6 +204,91 @@ omni = Omni(
 | `--linear-backend cutlass` | str | auto | Select the validated CUTLASS linear backend for supported ModelOpt NVFP4 or mixed FP8/NVFP4 diffusion stages |
 | `--moe-backend cutlass` | str | auto | Select the validated CUTLASS MoE backend for supported ModelOpt mixed MoE checkpoints |
 
+## Cosmos3 Mixed-Precision Schedule
+
+The experimental Cosmos3 schedule can use the checkpoint-native quantized GEMM for middle denoising
+steps and dense 16-bit activation execution for selected first and last steps.
+The schedule supports serialized ModelOpt FP8 and NVFP4 checkpoints:
+
+| Detected weight format | Native middle steps | A16 boundary steps |
+|------------------------|---------------------|--------------------|
+| FP8 | W8A8 | W8A16 |
+| NVFP4 | W4A4 | W4A16 |
+
+The native and A16 paths share one quantized weight representation. The A16
+path dequantizes the live backend weight and calls `F.linear`; it does not keep
+a second checkpoint-weight snapshot. Scheduled FP8 currently requires
+serialized tensorwise scales and a backend that retains canonical FP8 weights.
+Scheduled NVFP4 requires a supported CUTLASS-compatible native or FlashInfer
+layout. SmoothQuant, Marlin-repacked FP8, and per-channel/per-token FP8
+schedules fail closed.
+
+The reasoner uses dense A16 execution by default when its weights are FP8 or
+NVFP4. Set the nested `reasoner` field to `native` to retain the checkpoint-native
+W8A8/W4A4 path. A BF16 reasoner remains BF16 in either mode. The schedule
+currently requires tensor parallel size 1 and one active request per worker,
+does not support HSDP, and does not support block-scaled FP8. Its live-weight
+design is compatible with model-level and standard layer-wise offload, but
+those paths still require GPU end-to-end validation. Distributed layer-wise
+offload is rejected because its direct loader bypasses ModelOpt post-load
+transformations.
+
+A checkpoint can opt in by adding a versioned policy to its authoritative
+`transformer/config.json`. The same policy schema is used for FP8 and NVFP4:
+
+```json
+{
+  "quantization_config": {
+    "quant_method": "modelopt",
+    "quant_algo": "FP8",
+    "runtime": {
+      "diffusion_step_policy": {
+        "schema_version": 1,
+        "type": "first_last_n",
+        "index_space": "denoising_loop_iteration",
+        "scope": ["transformer"],
+        "default_mode": "native",
+        "first_steps": {"count": 3, "mode": "a16"},
+        "last_steps": {"count": 3, "mode": "a16"},
+        "overlap": "a16",
+        "reasoner": "a16"
+      }
+    }
+  }
+}
+```
+
+The example preserves the checkpoint's existing `quant_method` and
+`quant_algo`; only `runtime` is added.
+
+When present and valid, the checkpoint policy is the default. An explicit
+runtime object overrides it. To retain ordinary checkpoint-native execution
+for every step, disable only the schedule:
+
+```bash
+vllm serve /path/to/Cosmos3-Nano-modelopt \
+  --omni \
+  --additional-config '{"cosmos3_mixed_precision":{"enabled":false}}'
+```
+
+This does not disable checkpoint quantization; it prevents installation of the
+mixed-step runtime.
+
+```bash
+vllm serve /path/to/Cosmos3-Nano-modelopt \
+  --omni \
+  --additional-config \
+  '{"cosmos3_mixed_precision":{"first_steps":3,"last_steps":3,"reasoner":"a16"}}'
+```
+
+The presence of `cosmos3_mixed_precision` supplies an explicit runtime
+override; an empty object uses the defaults shown above.
+The schedule uses vLLM's selected native backend and fails during loading if
+its live weight layout cannot support A16 dequantization.
+The runtime selects FP8 or NVFP4 from the checkpoint's ModelOpt configuration.
+BF16 linears are untouched. Mixed FP8/NVFP4 checkpoints are not supported by
+this schedule.
+
 ## Validation and Notes
 
 1. Compare the ModelOpt checkpoint against the BF16 baseline with the same
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/diffusion/ar_diffusion_streaming_decode.py b/examples/offline_inference/diffusion/ar_diffusion_streaming_decode.py
new file mode 100644
index 000000000..6c87d4e63
--- /dev/null
+++ b/examples/offline_inference/diffusion/ar_diffusion_streaming_decode.py
@@ -0,0 +1,339 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Stream LingBot-World 2.0 pixels from one stepwise request.
+
+One ``AsyncOmni.generate()`` drives the whole rollout: each AR block leaves
+``post_decode()`` as one video chunk, decoded through that session's own
+temporal VAE cache rather than as an isolated clip. That is what this script
+shows end to end -- chunk *N + 1* continues chunk *N*, so the streamed timeline
+carries the same frame count as an offline whole-clip decode of the same
+latents instead of losing each block's opening frame to a restarted decoder.
+Only the session's first latent frame expands to a single raw frame; on the
+default checkpoint, whose block is three latent frames at a temporal factor of
+four, that is 9 frames for the opening chunk and 12 for every later one.
+
+The decode lives inside the pipeline, keyed by ``request_id``, so nothing here
+owns a VAE: this file is a client of the served path, and the same chunks reach
+a WebSocket client of ``/v1/realtime/video`` unchanged.
+
+Examples::
+
+    python examples/offline_inference/diffusion/ar_diffusion_streaming_decode.py \
+        --image scene.png --prompt "a lit hallway" \
+        --action-script actions.json --output-dir /tmp/lingbot-stream
+
+``--action-script`` is a JSON list with one camera action list per AR block,
+for example ``[[["w"], ["w"], ["w"]], [["a"], [], []]]`` for a checkpoint that
+generates three latent frames per block. The frames per block and temporal
+compression are read off the checkpoint rather than assumed, so the script
+can be repointed with ``--model``.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import math
+import os
+import time
+from collections.abc import Sequence
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    # Only for type hints -- the real imports stay deferred inside run() so
+    # --help and the offline validation helpers don't require a CUDA-enabled
+    # vLLM install.
+    import numpy as np
+
+_MODEL = "robbyant/lingbot-world-v2-14b-causal-fast-diffusers"
+
+
+def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Stream decoded LingBot-World 2.0 video chunks from a single stepwise request.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__,
+    )
+    parser.add_argument("--model", default=_MODEL, help="Hugging Face model ID or local checkpoint path.")
+    parser.add_argument("--image", required=True, help="Initial RGB image.")
+    parser.add_argument("--prompt", required=True, help="Scene prompt for the rollout.")
+    parser.add_argument(
+        "--action-script",
+        required=True,
+        help=(
+            "JSON file holding one camera action list per AR block. "
+            "The per-block frame count is read off the checkpoint, not assumed."
+        ),
+    )
+    parser.add_argument("--output-dir", required=True, help="Directory for decoded frames and metadata.")
+    parser.add_argument("--request-id", default="lingbot-world-stream", help="Request id; also the session id.")
+    parser.add_argument("--height", type=int, default=480)
+    parser.add_argument("--width", type=int, default=832)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--gpu-memory-fraction", type=float, default=0.6)
+    parser.add_argument("--tensor-parallel-size", type=int, default=1)
+    parser.add_argument("--enforce-eager", action="store_true")
+    return parser.parse_args(argv)
+
+
+def _load_action_script(path: Path) -> list[list[list[str]]]:
+    """Parse the per-block camera action script, without assuming its geometry.
+
+    The shape is the one ``sampling_params.extra_args["camera_action_script"]``
+    takes: one entry per AR block, each entry one per-frame action list. How
+    many frames a block holds is a property of the checkpoint, so it is checked
+    in :func:`_validate_against_checkpoint` once the configs have been read.
+    """
+    try:
+        value = json.loads(path.read_text())
+    except json.JSONDecodeError as exc:
+        raise ValueError(f"--action-script is not valid JSON: {exc.msg}.") from None
+    if not isinstance(value, list) or not value:
+        raise ValueError("--action-script must be a non-empty JSON list of per-block action lists.")
+    script: list[list[list[str]]] = []
+    for block_index, block in enumerate(value):
+        if not isinstance(block, list) or not block:
+            raise ValueError(f"--action-script block {block_index} must be a non-empty list of frame action lists.")
+        frames: list[list[str]] = []
+        for frame in block:
+            if not isinstance(frame, list) or any(not isinstance(action, str) for action in frame):
+                raise ValueError(f"--action-script block {block_index} frames must contain only action strings.")
+            frames.append(list(frame))
+        script.append(frames)
+    return script
+
+
+def _model_config_json(model: str, relative_path: str) -> dict[str, Any]:
+    """Read one config file out of a local checkpoint or a Hub repo."""
+    if os.path.isdir(model):
+        return json.loads((Path(model) / relative_path).read_text())
+    from huggingface_hub import hf_hub_download
+
+    return json.loads(Path(hf_hub_download(repo_id=model, filename=relative_path)).read_text())
+
+
+def _checkpoint_geometry(model: str) -> tuple[int, int]:
+    """Read ``(frames_per_block, temporal_compression)`` off the checkpoint.
+
+    The pipeline takes both from the model --
+    ``transformer.config.num_frames_per_block`` and
+    ``vae.config.scale_factor_temporal`` -- so hardcoding 3 and 4 here would
+    silently build a wrong action script and an inconsistent ``num_frames`` the
+    moment ``--model`` points at a checkpoint with different geometry.
+    """
+    transformer_config = _model_config_json(model, "transformer/config.json")
+    vae_config = _model_config_json(model, "vae/config.json")
+    if "num_frames_per_block" not in transformer_config:
+        raise ValueError(
+            f"{model}'s transformer/config.json declares no num_frames_per_block, "
+            "so this checkpoint does not generate AR blocks and cannot be streamed this way."
+        )
+    frames_per_block = int(transformer_config["num_frames_per_block"])
+    temporal_compression = int(vae_config.get("scale_factor_temporal", 4))
+    if frames_per_block <= 0 or temporal_compression <= 0:
+        raise ValueError(
+            "the checkpoint reports a non-positive block geometry "
+            f"(num_frames_per_block={frames_per_block}, scale_factor_temporal={temporal_compression})."
+        )
+    return frames_per_block, temporal_compression
+
+
+def _validate_against_checkpoint(
+    script: list[list[list[str]]], *, frames_per_block: int, temporal_compression: int
+) -> int:
+    """Check the script against the checkpoint and return the frame count to request."""
+    for block_index, block in enumerate(script):
+        if len(block) != frames_per_block:
+            raise ValueError(
+                f"--action-script block {block_index} holds {len(block)} frame action lists, but this "
+                f"checkpoint generates {frames_per_block} latent frames per AR block."
+            )
+    return (len(script) * frames_per_block - 1) * temporal_compression + 1
+
+
+def _validate_args(args: argparse.Namespace) -> tuple[Path, Path, Path]:
+    image = Path(args.image).expanduser().resolve()
+    action_script = Path(args.action_script).expanduser().resolve()
+    output_dir = Path(args.output_dir).expanduser().resolve()
+    if not image.is_file():
+        raise ValueError("--image must point to an existing file.")
+    if not action_script.is_file():
+        raise ValueError("--action-script must point to an existing JSON file.")
+    if not args.prompt.strip():
+        raise ValueError("--prompt must contain non-whitespace text.")
+    if args.height <= 0 or args.width <= 0 or args.height % 16 or args.width % 16:
+        raise ValueError("--height and --width must be positive multiples of 16.")
+    if args.tensor_parallel_size <= 0:
+        raise ValueError("--tensor-parallel-size must be positive.")
+    if not math.isfinite(args.gpu_memory_fraction) or not 0 < args.gpu_memory_fraction <= 1:
+        raise ValueError("--gpu-memory-fraction must be in (0, 1].")
+    if not args.request_id.strip():
+        raise ValueError("--request-id must contain non-whitespace text.")
+    return image, action_script, output_dir
+
+
+def _as_frames(value: Any) -> np.ndarray:
+    """Normalize one streamed chunk to ``[T, H, W, 3]`` uint8.
+
+    ``output_type="np"`` reaches the client as a float array in ``[0, 1]``,
+    with or without the leading batch axis depending on how the formatter
+    unwrapped it; a nested list is the ``"pil"`` shape. Anything else means
+    the chunk is not pixels -- most likely the request still asked for
+    latents -- and is worth failing on rather than saving.
+    """
+    import numpy as np
+    import PIL.Image
+    import torch
+
+    if isinstance(value, list):
+        if len(value) == 1 and isinstance(value[0], list):
+            value = value[0]
+        if value and all(isinstance(frame, PIL.Image.Image) for frame in value):
+            return np.stack([np.asarray(frame.convert("RGB")) for frame in value])
+    if isinstance(value, torch.Tensor):
+        value = value.detach().float().cpu().numpy()
+    if not isinstance(value, np.ndarray):
+        raise RuntimeError(f"Expected decoded pixels from each AR block, got {type(value).__name__}.")
+    if value.ndim == 5 and value.shape[0] == 1:
+        value = value[0]
+    if value.ndim != 4 or value.shape[-1] != 3:
+        raise RuntimeError(f"Expected one [T, H, W, 3] pixel chunk per AR block, got shape {tuple(value.shape)}.")
+    if value.dtype != np.uint8:
+        value = (np.clip(value, 0.0, 1.0) * 255.0).round().astype(np.uint8)
+    return value
+
+
+def _chunk_metadata(output: Any) -> dict[str, Any]:
+    multimodal = getattr(output, "multimodal_output", None) or {}
+    metadata = multimodal.get("metadata") if isinstance(multimodal, dict) else None
+    ar_diffusion = metadata.get("ar_diffusion") if isinstance(metadata, dict) else None
+    if not isinstance(ar_diffusion, dict):
+        raise RuntimeError("Streamed chunk is missing its ar_diffusion metadata envelope.")
+    return dict(ar_diffusion)
+
+
+async def run(argv: Sequence[str] | None = None) -> Path:
+    args = parse_args(argv)
+    image, action_script_path, output_dir = _validate_args(args)
+    camera_action_script = _load_action_script(action_script_path)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Imports stay below pure input validation so --help and helper tests do not
+    # require a CUDA-enabled vLLM installation.
+    import numpy as np
+
+    from vllm_omni.entrypoints.async_omni import AsyncOmni
+    from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+    frames_per_block, temporal_compression = _checkpoint_geometry(args.model)
+    num_chunks = len(camera_action_script)
+    num_frames = _validate_against_checkpoint(
+        camera_action_script,
+        frames_per_block=frames_per_block,
+        temporal_compression=temporal_compression,
+    )
+
+    engine = AsyncOmni(
+        model=args.model,
+        engine_backend="vllm_omni.experimental.ar_diffusion.engine.ARDiffusionEngine",
+        enforce_eager=args.enforce_eager,
+        tensor_parallel_size=args.tensor_parallel_size,
+        max_num_seqs=1,
+        # One request, many chunks: the stepwise contract from #6844. Streaming
+        # output is what turns each post_decode() into a delivered chunk.
+        step_execution=True,
+        diffusion_streaming_output=True,
+        model_config={
+            "ar_diffusion_height": args.height,
+            "ar_diffusion_width": args.width,
+            "ar_diffusion_kv_config": {
+                "gpu_memory_fraction": args.gpu_memory_fraction,
+                "warmup_cudagraph": True,
+            },
+        },
+    )
+    sampling = OmniDiffusionSamplingParams(
+        height=args.height,
+        width=args.width,
+        num_frames=num_frames,
+        num_inference_steps=4,
+        max_sequence_length=512,
+        seed=args.seed,
+        # Pixels, not latents: this is what routes the chunk through the
+        # session's streaming VAE decode instead of handing back a tensor.
+        output_type="np",
+        extra_args={"flow_shift": 5.0, "camera_action_script": camera_action_script},
+    )
+    prompt = {"prompt": args.prompt, "multi_modal_data": {"image": str(image)}}
+
+    measurements: list[dict[str, Any]] = []
+    t_start = time.perf_counter()
+    first_frame_at: float | None = None
+    chunk_started = t_start
+    try:
+        async for output in engine.generate(prompt, sampling, request_id=args.request_id):
+            images = getattr(output, "images", None)
+            if not images:
+                continue
+            if len(images) != 1:
+                raise RuntimeError("Expected exactly one decoded chunk per AR block.")
+            frames = _as_frames(images[0])
+            now = time.perf_counter()
+            if first_frame_at is None:
+                first_frame_at = now - t_start
+            chunk_index = len(measurements)
+            metadata = _chunk_metadata(output)
+
+            np.save(output_dir / f"chunk_{chunk_index:03d}.npy", frames)
+            (output_dir / f"chunk_{chunk_index:03d}.json").write_text(
+                json.dumps(metadata, indent=2, sort_keys=True) + "\n"
+            )
+            measurements.append(
+                {
+                    "chunk_index": chunk_index,
+                    "chunk_latency_seconds": now - chunk_started,
+                    "frames": int(frames.shape[0]),
+                    "frame_shape": list(frames.shape),
+                    "metadata": metadata,
+                }
+            )
+            chunk_started = now
+            print(json.dumps(measurements[-1], sort_keys=True), flush=True)
+    finally:
+        engine.shutdown()
+
+    delivered_frames = sum(int(chunk["frames"]) for chunk in measurements)
+    summary_path = output_dir / "summary.json"
+    summary_path.write_text(
+        json.dumps(
+            {
+                "request_id": args.request_id,
+                "chunks_delivered": len(measurements),
+                "chunks_expected": num_chunks,
+                "frames_delivered": delivered_frames,
+                "frames_expected": num_frames,
+                # The point of session-owned decode: a streamed rollout carries
+                # the same frame timeline as an offline decode of the same
+                # latents. Per-chunk decode would deliver fewer, because every
+                # block would re-expand its own opening frame.
+                "matches_offline_frame_timeline": delivered_frames == num_frames,
+                "time_to_first_frame_seconds": first_frame_at,
+                "total_seconds": time.perf_counter() - t_start,
+                "chunks": measurements,
+            },
+            indent=2,
+            sort_keys=True,
+        )
+        + "\n"
+    )
+    return summary_path
+
+
+def main(argv: Sequence[str] | None = None) -> Path:
+    return asyncio.run(run(argv))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/offline_inference/diffusion/lingbot_world_v2.py b/examples/offline_inference/diffusion/lingbot_world_v2.py
index 590442c4d..0eb2027b1 100644
--- a/examples/offline_inference/diffusion/lingbot_world_v2.py
+++ b/examples/offline_inference/diffusion/lingbot_world_v2.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
 """Generate a LingBot-World v2 video from an image and camera trajectory.
 
 The official checkpoint is licensed separately under CC BY-NC-SA and is
@@ -32,7 +32,6 @@ import numpy as np
 _MODEL = "robbyant/lingbot-world-v2-14b-causal-fast-diffusers"
 _MAX_SEQUENCE_LENGTH = 512
 _MAX_PIXEL_AREA = 480 * 832
-_MAX_RAW_FRAMES = 117
 _MAX_SOURCE_CAMERA_FRAMES = 4096
 _TEMPORAL_COMPRESSION = 4
 _LATENT_FRAMES_PER_BLOCK = 3
@@ -99,6 +98,7 @@ def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
         default=1,
         help="Number of GPUs used for tensor parallelism inside the DiT.",
     )
+    parser.add_argument("--ulysses-degree", type=int, default=1, help="Pure Ulysses sequence parallel degree.")
     parser.add_argument("--flow-shift", type=float, default=5.0, help="Positive FlowUniPC scheduler shift.")
     parser.add_argument("--fps", type=int, default=16, help="Frames per second in the exported MP4.")
     parser.add_argument("--output", default="lingbot_world_v2.mp4", help="Output MP4 path.")
@@ -158,6 +158,8 @@ def build_omni_kwargs(
 
     if args.tensor_parallel_size <= 0:
         raise ValueError("--tensor-parallel-size must be a positive integer.")
+    if args.ulysses_degree <= 0:
+        raise ValueError("--ulysses-degree must be a positive integer.")
     flow_shift = _positive_finite(args.flow_shift, "--flow-shift")
     model_path = Path(args.model).expanduser()
     model = str(model_path.resolve()) if model_path.exists() else args.model
@@ -165,6 +167,7 @@ def build_omni_kwargs(
         "model": model,
         "flow_shift": flow_shift,
         "tensor_parallel_size": args.tensor_parallel_size,
+        "ulysses_degree": args.ulysses_degree,
         "enforce_eager": args.enforce_eager,
         "model_config": {"lingbot_action_root": str(paths.action_root)},
     }
@@ -187,8 +190,6 @@ def build_request(
         raise ValueError("--height * --width must not exceed 480 * 832 pixels.")
     if args.num_frames <= 0:
         raise ValueError("--num-frames must be a positive integer.")
-    if args.num_frames > _MAX_RAW_FRAMES:
-        raise ValueError("--num-frames must not exceed 117 raw frames.")
     if args.num_frames > paths.camera_frames:
         raise ValueError("Camera arrays must contain at least --num-frames frames.")
     if (args.num_frames - 1) % _TEMPORAL_COMPRESSION:
diff --git a/examples/offline_inference/diffusion/lingbot_world_v2_realtime.py b/examples/offline_inference/diffusion/lingbot_world_v2_realtime.py
index d98fe06f9..f0f1043ab 100644
--- a/examples/offline_inference/diffusion/lingbot_world_v2_realtime.py
+++ b/examples/offline_inference/diffusion/lingbot_world_v2_realtime.py
@@ -1,13 +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
 """Run LingBot-World 2.0 as an in-process realtime AR-Diffusion session.
 
 This example exercises the internal session API. It is not a public HTTP or
 WebSocket protocol. Each JSONL event advances the world by one three-latent
-frame AR block and writes the latent plus its identity metadata. The current
-scoped implementation supports at most ten ticks per generation epoch because
-its image condition is bounded to 117 pixel frames; reset or create a session
-to start a new world.
+frame AR block and writes the latent plus its identity metadata. Session-owned
+causal VAE encoder state produces each condition block without retaining or
+repeating a full image-condition horizon.
 """
 
 from __future__ import annotations
@@ -24,8 +23,6 @@ from typing import Any
 _MODEL = "robbyant/lingbot-world-v2-14b-causal-fast-diffusers"
 _CAMERA_ACTION_SCHEMA = "lingbot.camera_actions.v1"
 _FRAMES_PER_BLOCK = 3
-# ((117 pixel frames - 1) / VAE temporal factor 4 + 1) / 3 latent frames.
-_MAX_REALTIME_TICKS = 10
 
 
 def _camera_event_data(frames: list[list[str]]) -> dict[str, Any]:
@@ -41,7 +38,7 @@ def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
     parser.add_argument(
         "--events",
         required=True,
-        help="JSONL file with one prompt/action event per AR block; at most 10 events.",
+        help="JSONL file with one prompt/action event per AR block.",
     )
     parser.add_argument("--output-dir", required=True, help="Directory for chunk latents and metadata.")
     parser.add_argument("--session-id", default="lingbot-world", help="Persistent world session identifier.")
@@ -84,12 +81,6 @@ def _load_events(path: Path) -> list[dict[str, Any]]:
         events.append({"event_id": event_id, "prompt": prompt, "frames": frames})
     if not events:
         raise ValueError("events file must contain at least one event.")
-    if len(events) > _MAX_REALTIME_TICKS:
-        raise ValueError(
-            "events file must contain at most "
-            f"{_MAX_REALTIME_TICKS} events because the current LingBot realtime "
-            "image-condition horizon is 117 pixel frames."
-        )
     event_ids = [event["event_id"] for event in events]
     if event_ids != sorted(set(event_ids)):
         raise ValueError("event_id values must be unique and strictly increasing.")
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/hunyuan_image3/README.md b/examples/offline_inference/hunyuan_image3/README.md
deleted file mode 100644
index b4d5af2c7..000000000
--- a/examples/offline_inference/hunyuan_image3/README.md
+++ /dev/null
@@ -1,154 +0,0 @@
-# HunyuanImage-3.0-Instruct
-
-This example runs HunyuanImage-3.0-Instruct offline with the unified deploy
-YAMLs under `vllm_omni/deploy/`.
-
-## Deploy Configs
-
-| File | Topology | Default use |
-| :--- | :--- | :--- |
-| `vllm_omni/deploy/hunyuan_image_3_moe.yaml` | AR + DiT | Default for `text2img` and `img2img`. |
-| `vllm_omni/deploy/hunyuan_image3_ar.yaml` | AR only | Default for `img2text` and `text2text`. |
-| `vllm_omni/deploy/hunyuan_image3_dit.yaml` | DiT only | Standalone diffusion stage. Pass it explicitly with `--deploy-config`. |
-
-The example chooses a deploy config automatically when `--deploy-config` is
-omitted:
-
-| `--modality` | `mode` passed to Omni | Default deploy |
-| :--- | :--- | :--- |
-| `text2img` | `text-to-image` | `hunyuan_image_3_moe.yaml` |
-| `img2img` | `image-editing` | `hunyuan_image_3_moe.yaml` |
-| `img2text` | `image-to-text` | `hunyuan_image3_ar.yaml` |
-| `text2text` | `text-to-text` | `hunyuan_image3_ar.yaml` |
-
-`--modality` is an offline example convenience flag. It maps to the internal
-`mode` argument passed to `Omni(...)` by this script. HunyuanImage3 uses
-separate deploy YAMLs for AR + DiT, AR-only, and DiT-only topologies, so the
-stage topology is selected by the deploy file rather than by YAML mode
-overrides.
-
-Online serving does not expose a `--modality` flag or accept `mode` as an API
-request field. Choose the deploy topology when starting the server with
-`--deploy-config`, then use the OpenAI-compatible endpoint and request shape for
-the scenario. The `modalities` request field is used by the chat completions
-path; the image endpoints infer the image task from the endpoint and payload.
-
-| Online scenario | Server deploy | Request |
-| :--- | :--- | :--- |
-| Text to image | `--deploy-config vllm_omni/deploy/hunyuan_image_3_moe.yaml` | `POST /v1/images/generations`, or `POST /v1/chat/completions` with `"modalities": ["image"]`. |
-| Image editing | `--deploy-config vllm_omni/deploy/hunyuan_image_3_moe.yaml` | `POST /v1/images/edits`. |
-| Image/text to text | `--deploy-config vllm_omni/deploy/hunyuan_image3_ar.yaml` | `POST /v1/chat/completions` for text output, for example with `"modalities": ["text"]`. |
-| DiT-only image generation | `--deploy-config vllm_omni/deploy/hunyuan_image3_dit.yaml` | `POST /v1/images/generations`. |
-
-## Run Examples
-
-Text to image, using the default AR + DiT deploy:
-
-```bash
-python examples/offline_inference/hunyuan_image3/end2end.py \
-  --model tencent/HunyuanImage-3.0-Instruct \
-  --modality text2img \
-  --prompts "A cute cat sitting on a windowsill watching the sunset"
-```
-
-Image editing, using the default AR + DiT deploy:
-
-```bash
-python examples/offline_inference/hunyuan_image3/end2end.py \
-  --model tencent/HunyuanImage-3.0-Instruct \
-  --modality img2img \
-  --image-path /path/to/image.png \
-  --prompts "Make the petals neon pink"
-```
-
-Image to text, using the AR-only deploy:
-
-```bash
-python examples/offline_inference/hunyuan_image3/end2end.py \
-  --model tencent/HunyuanImage-3.0-Instruct \
-  --modality img2text \
-  --image-path /path/to/image.jpg \
-  --prompts "Describe the content of the picture."
-```
-
-Text to text, using the AR-only deploy:
-
-```bash
-python examples/offline_inference/hunyuan_image3/end2end.py \
-  --model tencent/HunyuanImage-3.0-Instruct \
-  --modality text2text \
-  --prompts "What is the capital of France?"
-```
-
-Standalone DiT, using the DiT-only deploy explicitly:
-
-```bash
-python examples/offline_inference/hunyuan_image3/end2end.py \
-  --model tencent/HunyuanImage-3.0-Instruct \
-  --modality text2img \
-  --deploy-config vllm_omni/deploy/hunyuan_image3_dit.yaml \
-  --prompts "A cinematic portrait of an astronaut in a greenhouse"
-```
-
-Override the default full AR + DiT deploy explicitly:
-
-```bash
-python examples/offline_inference/hunyuan_image3/end2end.py \
-  --model tencent/HunyuanImage-3.0-Instruct \
-  --modality text2img \
-  --deploy-config vllm_omni/deploy/hunyuan_image_3_moe.yaml \
-  --prompts "A cute cat"
-```
-
-## Additional Config
-
-You can pass diffusion worker `additional_config` from the offline example as a JSON object.
-This maps to the upstream vLLM `VllmConfig.additional_config` platform extension field:
-https://docs.vllm.ai/en/stable/api/vllm/config/#vllm.config.VllmConfig.additional_config
-
-```bash
-python end2end.py --modality text2img \
-                  --prompts "A cute cat" \
-                  --additional-config '{"torchair_graph_config":{"enabled":true}}'
-```
-
-
-## Key Arguments
-
-| Argument | Description |
-| :--- | :--- |
-| `--deploy-config` | Optional path for unified deploy YAML overrides. |
-| `--additional-config` | JSON object forwarded to diffusion worker `additional_config`. |
-| `--modality` | Offline-only convenience flag. One of `text2img`, `img2img`, `img2text`, `text2text`. It selects prompt formatting, internal `mode`, and default deploy config for this script. Online serving uses `--deploy-config` plus the endpoint and, for chat completions, request `modalities` instead. |
-| `--steps` | Number of diffusion inference steps for image generation. |
-| `--guidance-scale` | Classifier-free guidance scale for image generation. |
-| `--height`, `--width` | Output image size for `text2img`. |
-| `--bot-task` | Override prompt mode. `none`, `think`, `recaption`, `think_recaption`, or `vanilla`. |
-| `--sys-type` | Override the system prompt type, for example `en_unified` or `en_vanilla`. |
-| `--vae-use-tiling` | Enable VAE tiling for memory reduction. |
-
-## Notes
-
-- `hunyuan_image3_ar.yaml` is a 4-card AR-only text/comprehension deploy.
-- `hunyuan_image3_dit.yaml` is a single-stage DiT deploy with `stage_id: 0`.
-- Platform-specific overrides are included in the unified deploy YAMLs.
-
-## Prompt Format
-
-HunyuanImage-3.0-Instruct uses an instruct chat template:
-
-```text
-<|startoftext|>{system_prompt}
-
-User: {<img>?}{user_prompt}
-
-Assistant: {trigger_tag?}
-```
-
-- `<img>`: Placeholder for each input image (single token; expanded by the multimodal pipeline).
-- Trigger tags: `<think>` for CoT and `<recaption>` for recaptioning, placed after `Assistant: `.
-- System prompt: Auto-selected from `task` and `bot_task`.
-- `bot_task='vanilla'` with `task='t2i'` uses the bare pretrain template.
-
-The shared `vllm_omni.diffusion.models.hunyuan_image3.prompt_utils.build_prompt_tokens()`
-helper handles segment-by-segment tokenization and matches HF `apply_chat_template`.
diff --git a/examples/offline_inference/hunyuan_image3/end2end.py b/examples/offline_inference/hunyuan_image3/end2end.py
deleted file mode 100644
index fbe4289be..000000000
--- a/examples/offline_inference/hunyuan_image3/end2end.py
+++ /dev/null
@@ -1,321 +0,0 @@
-"""
-HunyuanImage-3.0-Instruct unified end-to-end inference script.
-"""
-
-import argparse
-import json
-import os
-from pathlib import Path
-
-from vllm_omni.diffusion.models.hunyuan_image3.prompt_utils import (
-    MAX_IMAGES_PER_REQUEST,
-    build_prompt_tokens,
-    resolve_stop_token_ids,
-    resolve_sys_type,
-)
-from vllm_omni.entrypoints.omni import Omni
-from vllm_omni.inputs.data import OmniPromptType
-
-_REPO_ROOT = Path(__file__).resolve().parents[3]
-_DEFAULT_DEPLOY_CONFIG = str(_REPO_ROOT / "vllm_omni" / "deploy" / "hunyuan_image_3_moe.yaml")
-_DEFAULT_AR_DEPLOY_CONFIG = str(_REPO_ROOT / "vllm_omni" / "deploy" / "hunyuan_image3_ar.yaml")
-
-_MODALITY_TASK_MAP: dict[str, tuple[str, str | None]] = {
-    "text2img": ("t2i", "think"),
-    "img2img": ("it2i", "think"),
-    "img2text": ("i2t", None),
-    "text2text": ("t2t", None),
-}
-
-_MODALITY_DEFAULT_DEPLOY_CONFIG = {
-    "text2img": _DEFAULT_DEPLOY_CONFIG,
-    "img2img": _DEFAULT_DEPLOY_CONFIG,
-    "img2text": _DEFAULT_AR_DEPLOY_CONFIG,
-    "text2text": _DEFAULT_AR_DEPLOY_CONFIG,
-}
-
-_MODALITY_MODE = {
-    "text2img": "text-to-image",
-    "img2img": "image-editing",
-    "img2text": "image-to-text",
-    "text2text": "text-to-text",
-}
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(description="HunyuanImage-3.0-Instruct end-to-end inference.")
-    parser.add_argument("--model", default="tencent/HunyuanImage-3.0-Instruct", help="Model name or local path.")
-    parser.add_argument(
-        "--modality",
-        default="text2img",
-        choices=list(_MODALITY_TASK_MAP),
-    )
-    parser.add_argument("--prompts", nargs="+", default=None, help="Input text prompts.")
-    parser.add_argument(
-        "--image-path",
-        type=str,
-        default=None,
-        help="Input image path(s) for img2img/img2text. Comma-separated for multi-image (up to 3).",
-    )
-    parser.add_argument("--output", type=str, default=".", help="Output directory to save results.")
-    parser.add_argument("--steps", type=int, default=50, help="Number of inference steps.")
-    parser.add_argument("--guidance-scale", type=float, default=5.0, help="Classifier-free guidance scale.")
-    parser.add_argument("--seed", type=int, default=42, help="Random seed.")
-    parser.add_argument("--height", type=int, default=None, help="Output image height.")
-    parser.add_argument("--width", type=int, default=None, help="Output image width.")
-    parser.add_argument("--vae-use-tiling", action="store_true", help="Enable VAE tiling.")
-    parser.add_argument(
-        "--bot-task",
-        type=str,
-        default=None,
-        choices=["none", "think", "recaption", "think_recaption", "vanilla"],
-        help="Override prompt mode. Default: auto from --modality.",
-    )
-    parser.add_argument("--sys-type", type=str, default=None, help="Override system prompt type.")
-    parser.add_argument("--deploy-config", type=str, default=None, help="Custom deploy YAML path.")
-    parser.add_argument(
-        "--stream",
-        action="store_true",
-        default=False,
-        help="Enable streaming CoT display; print AR text token-by-token in real time.",
-    )
-    parser.add_argument("--log-stats", action="store_true", default=False)
-    parser.add_argument("--init-timeout", type=int, default=300, help="Initialization timeout in seconds.")
-    parser.add_argument("--enforce-eager", action="store_true", help="Disable torch.compile.")
-    parser.add_argument(
-        "--diffusion-kv-cache-dtype",
-        type=str,
-        default=None,
-        help="Diffusion attention KV cache dtype, for example 'fp8'. Separate from vLLM --kv-cache-dtype.",
-    )
-    parser.add_argument(
-        "--diffusion-kv-cache-skip-steps",
-        type=str,
-        default=None,
-        help="Denoising step selector to keep diffusion KV cache in native dtype, for example '0,1,4-6'.",
-    )
-    parser.add_argument(
-        "--diffusion-kv-cache-skip-layers",
-        type=str,
-        default=None,
-        help="Transformer layer selector to keep diffusion KV cache in native dtype, for example '0-2,10'.",
-    )
-    parser.add_argument(
-        "--additional-config",
-        type=str,
-        default=None,
-        help=(
-            "JSON object forwarded to Omni/additional_config, for example "
-            '\'{"torchair_graph_config":{"enabled":true}}\'. Different platforms may support different '
-            "configs. Make sure the configs are valid for the platform you are using. "
-            "Contents must be hashable."
-        ),
-    )
-
-    return parser.parse_args()
-
-
-def parse_additional_config(raw_value: str | None) -> dict | None:
-    """Parse a JSON string into an additional_config mapping."""
-    if raw_value is None:
-        return None
-
-    try:
-        additional_config = json.loads(raw_value)
-    except json.JSONDecodeError as exc:
-        raise ValueError(f"Invalid --additional-config JSON: {exc}") from exc
-
-    if additional_config is None:
-        return None
-    if not isinstance(additional_config, dict):
-        raise ValueError(f"--additional-config must decode to a JSON object, got {type(additional_config).__name__}")
-    return additional_config
-
-
-def main():
-    args = parse_args()
-    os.makedirs(args.output, exist_ok=True)
-    additional_config = parse_additional_config(args.additional_config)
-
-    task, default_bot_task = _MODALITY_TASK_MAP[args.modality]
-    if args.bot_task is None:
-        bot_task: str | None = default_bot_task
-    elif args.bot_task == "none":
-        bot_task = None
-    else:
-        bot_task = args.bot_task
-
-    deploy_config = args.deploy_config or _MODALITY_DEFAULT_DEPLOY_CONFIG[args.modality]
-
-    omni_kwargs = {
-        "model": args.model,
-        "vae_use_tiling": args.vae_use_tiling,
-        "log_stats": args.log_stats,
-        "init_timeout": args.init_timeout,
-        "enforce_eager": args.enforce_eager,
-        "mode": _MODALITY_MODE[args.modality],
-        "diffusion_kv_cache_dtype": args.diffusion_kv_cache_dtype,
-        "diffusion_kv_cache_skip_steps": args.diffusion_kv_cache_skip_steps,
-        "diffusion_kv_cache_skip_layers": args.diffusion_kv_cache_skip_layers,
-    }
-
-    if additional_config is not None:
-        omni_kwargs["additional_config"] = additional_config
-    omni_kwargs["deploy_config"] = deploy_config
-
-    omni = Omni(**omni_kwargs)
-
-    prompts = args.prompts or ["A cute cat"]
-    input_images: list = []
-    if args.modality in ("img2img", "img2text"):
-        if not args.image_path:
-            raise ValueError(f"--image-path required for {args.modality}, got: {args.image_path}")
-        from PIL import Image
-
-        image_paths = [p.strip() for p in args.image_path.split(",") if p.strip()]
-        if len(image_paths) > MAX_IMAGES_PER_REQUEST:
-            raise ValueError(
-                f"--image-path accepts at most {MAX_IMAGES_PER_REQUEST} images for "
-                f"HunyuanImage-3.0 IT2I, got {len(image_paths)}: {args.image_path}"
-            )
-        for image_path in image_paths:
-            if not os.path.exists(image_path):
-                raise ValueError(f"Image path does not exist: {image_path}")
-            input_images.append(Image.open(image_path).convert("RGB"))
-        if not input_images:
-            raise ValueError(f"--image-path produced no usable paths: {args.image_path!r}")
-
-    from transformers import AutoTokenizer
-
-    tokenizer = AutoTokenizer.from_pretrained(args.model, trust_remote_code=True)
-    mm_image_payload = (input_images[0] if len(input_images) == 1 else input_images) if input_images else None
-
-    formatted_prompts: list[OmniPromptType] = []
-    for prompt in prompts:
-        build_kwargs: dict = {"task": task, "bot_task": bot_task, "sys_type": args.sys_type}
-        if input_images:
-            build_kwargs["num_images"] = len(input_images)
-        result = build_prompt_tokens(prompt, tokenizer, **build_kwargs)
-        token_ids = result.token_ids
-        effective_sys_type = args.sys_type or resolve_sys_type(bot_task)
-
-        prompt_dict: dict = {
-            "prompt_token_ids": token_ids,
-            "prompt": prompt,
-            "use_system_prompt": effective_sys_type,
-        }
-        if args.modality == "text2img":
-            prompt_dict["modalities"] = ["image"]
-        elif args.modality == "img2img":
-            prompt_dict["modalities"] = ["image"]
-            prompt_dict["multi_modal_data"] = {"image": mm_image_payload}
-            prompt_dict["height"] = input_images[0].height
-            prompt_dict["width"] = input_images[0].width
-        elif args.modality == "img2text":
-            prompt_dict["modalities"] = ["text"]
-            prompt_dict["multi_modal_data"] = {"image": mm_image_payload}
-        else:
-            prompt_dict["modalities"] = ["text"]
-        formatted_prompts.append(prompt_dict)
-
-    from vllm.sampling_params import RequestOutputKind
-
-    params_list = list(omni.default_sampling_params_list)
-
-    from vllm_omni.inputs.data import OmniDiffusionSamplingParams
-
-    if (args.height is None) != (args.width is None):
-        raise ValueError("--height and --width must both be specified or both omitted.")
-    user_specified_size = args.height is not None and args.width is not None
-    if args.modality in ("img2text", "text2text"):
-        ar_image_size = "auto"
-    elif user_specified_size:
-        ar_image_size = f"{args.width}x{args.height}"
-    else:
-        ar_image_size = None
-    ar_stop_token_ids = resolve_stop_token_ids(
-        task=task, bot_task=bot_task, tokenizer=tokenizer, image_size=ar_image_size
-    )
-    print(
-        f"[AR Config] task={task}, bot_task={bot_task}, image_size={ar_image_size}, stop_token_ids={ar_stop_token_ids}"
-    )
-    for sp in params_list:
-        if isinstance(sp, OmniDiffusionSamplingParams):
-            sp.num_inference_steps = args.steps
-            sp.guidance_scale = args.guidance_scale
-            sp.guidance_scale_provided = True
-            if args.seed is not None:
-                sp.seed = args.seed
-            if args.modality == "text2img":
-                sp.height = args.height
-                sp.width = args.width
-        elif hasattr(sp, "stop_token_ids"):
-            sp.stop_token_ids = ar_stop_token_ids
-            # When --stream is set, request DELTA output from the AR stage
-            # so we can display CoT text token-by-token in real time.
-            if args.stream and hasattr(sp, "output_kind"):
-                sp.output_kind = RequestOutputKind.DELTA
-
-    print(f"\n{'=' * 60}")
-    print("HunyuanImage-3.0 Generation Configuration:")
-    print(f"  Model: {args.model}")
-    print(f"  Modality: {args.modality}")
-    print(f"  Prompt task: {task}")
-    print(f"  Bot task: {bot_task}")
-    print(f"  Deploy config: {deploy_config}")
-    print(f"  Num stages: {omni.num_stages}")
-    if args.modality in ("text2img", "img2img"):
-        print(f"  Inference steps: {args.steps}")
-        print(f"  Guidance scale: {args.guidance_scale}")
-        print(f"  Seed: {args.seed}")
-        print(f"  diffusion_kv_cache_dtype: {args.diffusion_kv_cache_dtype}")
-        print(f"  diffusion_kv_cache_skip_steps: {args.diffusion_kv_cache_skip_steps}")
-        print(f"  diffusion_kv_cache_skip_layers: {args.diffusion_kv_cache_skip_layers}")
-    if args.modality == "text2img":
-        print(f"  Output size: {args.width}x{args.height}")
-    if args.image_path:
-        print(f"  Input image: {args.image_path}")
-    if additional_config is not None:
-        print(f"  Additional config: {additional_config}")
-    print(f"  Prompts: {prompts}")
-    print(f"{'=' * 60}\n")
-
-    # When --stream is set, print AR CoT text token-by-token in real time.
-    # Otherwise, collect and print the full AR text once when stage 0 finishes.
-    omni_outputs = omni.generate(
-        prompts=formatted_prompts,
-        sampling_params_list=params_list,
-        py_generator=True,
-        use_tqdm=False,
-    )
-    img_idx = 0
-    for req_output in omni_outputs:
-        ro = req_output
-        stage_id = getattr(req_output, "stage_id", None)
-
-        # AR stage text — each CompletionOutput.text is already a delta when
-        # output_kind=DELTA, so we can print it directly (matching the pattern
-        # in serving_chat.py).
-        if stage_id == 0 and ro and getattr(ro, "outputs", None):
-            for o in ro.outputs:
-                text = getattr(o, "text", "") or ""
-                if text:
-                    print(text, end="", flush=True)
-            # Non-streaming: one shot with full text — emit a trailing newline.
-            if not args.stream:
-                print(flush=True)
-
-        # Collect images from diffusion stage
-        images = getattr(req_output, "images", None)
-        if not images and ro and hasattr(ro, "images"):
-            images = ro.images
-        if images:
-            for j, img in enumerate(images):
-                save_path = os.path.join(args.output, f"output_{img_idx}_{j}.png")
-                img.save(save_path)
-                print(f"\n[Output] Saved image to {save_path}")
-            img_idx += 1
-
-
-if __name__ == "__main__":
-    main()
diff --git a/examples/offline_inference/image_to_image/image_edit.py b/examples/offline_inference/image_to_image/image_edit.py
index 91a5ce658..4985117f6 100644
--- a/examples/offline_inference/image_to_image/image_edit.py
+++ b/examples/offline_inference/image_to_image/image_edit.py
@@ -96,6 +96,7 @@ from typing import Any
 import torch
 from PIL import Image
 
+from vllm_omni.diffusion.data import logger
 from vllm_omni.diffusion.utils.image_output import extract_images_from_outputs
 from vllm_omni.diffusion.utils.param_utils import apply_declared_extra_args
 from vllm_omni.entrypoints.omni import Omni
@@ -103,6 +104,8 @@ from vllm_omni.entrypoints.openai.stage_params import clone_sampling_params
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 from vllm_omni.model_extras import (
     build_image_to_image_prompt,
+    get_ar_input_builder,
+    get_ar_tokenizer_validator,
     get_extra_body_params,
     get_model_class_name,
     should_init_extra_args_for_non_diffusion_stages,
@@ -110,6 +113,91 @@ from vllm_omni.model_extras import (
 from vllm_omni.platforms import current_omni_platform
 
 
+def _apply_ar_stage_inputs(
+    ar_input_builder: Any,
+    *,
+    model: str,
+    prompt_text: str,
+    extra_body: dict[str, Any],
+    num_images: int,
+    height: int | None,
+    width: int | None,
+    prompt_dict: dict[str, Any],
+    sampling_params_list: list[Any],
+    text_output: bool = False,
+    trust_remote_code: bool = False,
+    validate_tokenizer: Any | None = None,
+    allow_tokenizer_fallback: bool = False,
+) -> None:
+    """Apply a model's declared AR-stage inputs to the request in place.
+
+    Mirrors the helper in ``text_to_image.py``: loads the tokenizer for
+    byte-for-byte HF-parity AR tokenization, asks the model's
+    ``ar_input_builder`` for the AR prefill + stop tokens, and writes them
+    onto ``prompt_dict`` and the non-diffusion (AR) stage params.
+    Model-agnostic -- only the declared-hook contract is assumed.
+
+    ``trust_remote_code`` must be threaded in from the caller's own resolved
+    ``--trust-remote-code`` flag -- this is a separate tokenizer load outside
+    the main engine, so it needs the same explicit user opt-in rather than
+    defaulting to trusting whatever ``--model`` was passed.
+
+    ``validate_tokenizer``, when the model declares one via
+    ``get_ar_tokenizer_validator``, is called on a successfully-loaded real
+    tokenizer -- outside the load's try/except, so a validation failure (a
+    model/tokenizer revision drifting from hardcoded special-token ids)
+    raises instead of being swallowed into the string-prompt fallback.
+
+    ``allow_tokenizer_fallback`` (default ``False``, i.e. fail fast): a
+    tokenizer load failure normally raises, since silently degrading to the
+    string-prompt form can produce a request that completes with subtly
+    wrong stop tokens instead of surfacing the real problem (missing
+    ``--trust-remote-code``, network/cache issue, etc.). Set ``True`` only
+    for explicit unit tests or a deliberate offline-compat run where the
+    caller has already decided a degraded prompt is acceptable.
+    """
+    try:
+        from transformers import AutoTokenizer
+
+        ar_tokenizer: Any | None = AutoTokenizer.from_pretrained(model, trust_remote_code=trust_remote_code)
+    except Exception as exc:  # noqa: BLE001 - re-raised unless the caller opts into the fallback
+        if not allow_tokenizer_fallback:
+            raise
+        logger.warning(f"AR tokenizer load failed ({exc}); falling back to string prompt (no BPE parity).")
+        ar_tokenizer = None
+
+    if ar_tokenizer is not None and validate_tokenizer is not None:
+        validate_tokenizer(ar_tokenizer)
+
+    ar_inputs = ar_input_builder(
+        prompt=prompt_text,
+        tokenizer=ar_tokenizer,
+        extra_body=extra_body,
+        num_images=num_images,
+        height=height,
+        width=width,
+        text_output=text_output,
+    )
+
+    if ar_inputs.prompt_token_ids is not None:
+        prompt_dict["prompt_token_ids"] = ar_inputs.prompt_token_ids
+    elif ar_inputs.prompt is not None:
+        prompt_dict["prompt"] = ar_inputs.prompt
+    if ar_inputs.use_system_prompt:
+        prompt_dict["use_system_prompt"] = ar_inputs.use_system_prompt
+    prompt_dict["modalities"] = ar_inputs.modalities
+
+    # Apply stop_token_ids to exactly the stage(s) the builder names -- not
+    # "whichever stage isn't a diffusion stage," which would misfire on any
+    # future topology with more than one non-diffusion stage.
+    for stage_index in ar_inputs.stage_indices:
+        if stage_index >= len(sampling_params_list):
+            continue
+        stage_params = sampling_params_list[stage_index]
+        if not isinstance(stage_params, OmniDiffusionSamplingParams) and hasattr(stage_params, "stop_token_ids"):
+            stage_params.stop_token_ids = ar_inputs.stop_token_ids
+
+
 def parse_profiler_config(value: str) -> dict[str, Any]:
     try:
         config = json.loads(value)
@@ -419,6 +507,22 @@ 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(
+        "--trust-remote-code",
+        action="store_true",
+        help="Trust and execute custom modeling code from the model repo (required by e.g. HunyuanImage-3.0).",
+    )
+    parser.add_argument(
+        "--allow-tokenizer-fallback",
+        action="store_true",
+        help=(
+            "For models with a declared ar_input_builder (e.g. HunyuanImage-3.0): if loading "
+            "the AR tokenizer fails, degrade to the string-prompt form (no BPE parity) instead "
+            "of failing the run. Off by default -- a tokenizer load failure usually means a "
+            "missing --trust-remote-code or a network/cache issue that's worth surfacing, not "
+            "silently masking with a possibly-wrong prompt."
+        ),
+    )
     return parser.parse_args()
 
 
@@ -492,6 +596,8 @@ def main():
     )
     if args.enforce_eager is not None:
         omni_kwargs["enforce_eager"] = args.enforce_eager
+    if args.trust_remote_code:
+        omni_kwargs["trust_remote_code"] = True
     if args.deploy_config:
         omni_kwargs["deploy_config"] = args.deploy_config
     omni = Omni(**omni_kwargs)
@@ -585,6 +691,26 @@ def main():
     if not diffusion_replaced and len(sampling_params_list) == 1:
         sampling_params_list = [diffusion_params]
 
+    # Models with an AR text stage (e.g. HunyuanImage3 image-editing) declare an
+    # ar_input_builder; build the AR prefill + stop tokens declaratively from the
+    # plain prompt + reference image count + extra_args. Others are untouched.
+    ar_input_builder = get_ar_input_builder(model_class_name)
+    if ar_input_builder is not None:
+        _apply_ar_stage_inputs(
+            ar_input_builder,
+            model=args.model,
+            prompt_text=args.prompt,
+            extra_body=extra_args_from_cli,
+            num_images=len(input_images),
+            height=args.height,
+            width=args.width,
+            prompt_dict=prompt_dict,
+            sampling_params_list=sampling_params_list,
+            trust_remote_code=args.trust_remote_code,
+            validate_tokenizer=get_ar_tokenizer_validator(model_class_name),
+            allow_tokenizer_fallback=args.allow_tokenizer_fallback,
+        )
+
     outputs = omni.generate(prompt_dict, sampling_params_list=sampling_params_list)
     generation_end = time.perf_counter()
     generation_time = generation_end - generation_start
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 bc7ccbf31..57f2371b6 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
@@ -24,6 +24,8 @@ from vllm_omni.model_extras import (
     build_text_to_image_prompt as build_model_text_to_image_prompt,
 )
 from vllm_omni.model_extras import (
+    get_ar_input_builder,
+    get_ar_tokenizer_validator,
     get_extra_body_params,
     get_model_class_name,
     should_init_extra_args_for_non_diffusion_stages,
@@ -56,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]:
@@ -378,10 +381,123 @@ 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",
+        help="Trust and execute custom modeling code from the model repo (required by e.g. HunyuanImage-3.0).",
+    )
+    parser.add_argument(
+        "--allow-tokenizer-fallback",
+        action="store_true",
+        help=(
+            "For models with a declared ar_input_builder (e.g. HunyuanImage-3.0): if loading "
+            "the AR tokenizer fails, degrade to the string-prompt form (no BPE parity) instead "
+            "of failing the run. Off by default -- a tokenizer load failure usually means a "
+            "missing --trust-remote-code or a network/cache issue that's worth surfacing, not "
+            "silently masking with a possibly-wrong prompt."
+        ),
+    )
     current_omni_platform.pre_register_and_update(parser)
     return parser.parse_args()
 
 
+def _apply_ar_stage_inputs(
+    ar_input_builder: Any,
+    *,
+    model: str,
+    prompt_text: str,
+    extra_body: dict[str, Any],
+    num_images: int,
+    height: int | None,
+    width: int | None,
+    prompt_dict: dict[str, Any],
+    sampling_params_list: list[Any],
+    text_output: bool = False,
+    trust_remote_code: bool = False,
+    validate_tokenizer: Any | None = None,
+    allow_tokenizer_fallback: bool = False,
+) -> None:
+    """Apply a model's declared AR-stage inputs to the request in place.
+
+    Loads the model tokenizer (for byte-for-byte HF-parity segment
+    tokenization) and asks the model's ``ar_input_builder`` for the AR
+    prefill + stop tokens, then writes them onto ``prompt_dict`` and the
+    non-diffusion (AR) stage sampling params. Kept model-agnostic: the
+    example only knows the declared-hook contract.
+
+    ``trust_remote_code`` must be threaded in from the caller's own resolved
+    ``--trust-remote-code`` flag -- this is a separate tokenizer load outside
+    the main engine, so it needs the same explicit user opt-in rather than
+    defaulting to trusting whatever ``--model`` was passed.
+
+    ``validate_tokenizer``, when the model declares one via
+    ``get_ar_tokenizer_validator``, is called on a successfully-loaded real
+    tokenizer -- outside the load's try/except, so a validation failure (a
+    model/tokenizer revision drifting from hardcoded special-token ids)
+    raises instead of being swallowed into the string-prompt fallback.
+
+    ``allow_tokenizer_fallback`` (default ``False``, i.e. fail fast): a
+    tokenizer load failure normally raises, since silently degrading to the
+    string-prompt form can produce a request that completes with subtly
+    wrong stop tokens instead of surfacing the real problem (missing
+    ``--trust-remote-code``, network/cache issue, etc.). Set ``True`` only
+    for explicit unit tests or a deliberate offline-compat run where the
+    caller has already decided a degraded prompt is acceptable.
+    """
+    try:
+        from transformers import AutoTokenizer
+
+        ar_tokenizer: Any | None = AutoTokenizer.from_pretrained(model, trust_remote_code=trust_remote_code)
+    except Exception as exc:  # noqa: BLE001 - re-raised unless the caller opts into the fallback
+        if not allow_tokenizer_fallback:
+            raise
+        logger.warning(f"AR tokenizer load failed ({exc}); falling back to string prompt (no BPE parity).")
+        ar_tokenizer = None
+
+    if ar_tokenizer is not None and validate_tokenizer is not None:
+        validate_tokenizer(ar_tokenizer)
+
+    ar_inputs = ar_input_builder(
+        prompt=prompt_text,
+        tokenizer=ar_tokenizer,
+        extra_body=extra_body,
+        num_images=num_images,
+        height=height,
+        width=width,
+        text_output=text_output,
+    )
+
+    if ar_inputs.prompt_token_ids is not None:
+        prompt_dict["prompt_token_ids"] = ar_inputs.prompt_token_ids
+    elif ar_inputs.prompt is not None:
+        prompt_dict["prompt"] = ar_inputs.prompt
+    if ar_inputs.use_system_prompt:
+        prompt_dict["use_system_prompt"] = ar_inputs.use_system_prompt
+    prompt_dict["modalities"] = ar_inputs.modalities
+
+    # Apply stop_token_ids to exactly the stage(s) the builder names -- not
+    # "whichever stage isn't a diffusion stage," which would misfire on any
+    # future topology with more than one non-diffusion stage.
+    for stage_index in ar_inputs.stage_indices:
+        if stage_index >= len(sampling_params_list):
+            continue
+        stage_params = sampling_params_list[stage_index]
+        if not isinstance(stage_params, OmniDiffusionSamplingParams) and hasattr(stage_params, "stop_token_ids"):
+            stage_params.stop_token_ids = ar_inputs.stop_token_ids
+
+
 def main():
     args = parse_args()
     generator = torch.Generator(device=current_omni_platform.device_type).manual_seed(args.seed)
@@ -456,7 +572,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,
@@ -470,11 +585,17 @@ def main():
         omni_kwargs["tensor_parallel_size"] = args.tensor_parallel_size
     if args.enforce_eager is not None:
         omni_kwargs["enforce_eager"] = args.enforce_eager
+    if args.trust_remote_code:
+        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:
@@ -510,6 +631,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
@@ -614,6 +739,30 @@ def main():
     if not diffusion_replaced and len(sampling_params_list) == 1:
         sampling_params_list = [diffusion_params]
 
+    # Models with an AR text stage (e.g. HunyuanImage3) declare an
+    # ar_input_builder. When present, build the AR prefill token-ids and AR
+    # 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)
+    # 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,
+            prompt_text=args.prompt,
+            extra_body=user_extra,
+            num_images=0,
+            height=args.height,
+            width=args.width,
+            prompt_dict=prompt_dict,
+            sampling_params_list=sampling_params_list,
+            trust_remote_code=args.trust_remote_code,
+            validate_tokenizer=get_ar_tokenizer_validator(model_class_name),
+            allow_tokenizer_fallback=args.allow_tokenizer_fallback,
+        )
+
     outputs = omni.generate(prompt_dict, sampling_params_list=sampling_params_list)
 
     generation_end = time.perf_counter()
diff --git a/examples/offline_inference/text_to_speech/README.md b/examples/offline_inference/text_to_speech/README.md
index a8a273026..36d1b44ee 100644
--- a/examples/offline_inference/text_to_speech/README.md
+++ b/examples/offline_inference/text_to_speech/README.md
@@ -13,11 +13,13 @@ 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 |
 | CosyVoice3 | `FunAudioLLM/Fun-CosyVoice3-0.5B-2512` | 2 (talker + code2wav) | ✓ | ✓ | — | 24 kHz |
 | Fish Speech S2 Pro | `fishaudio/s2-pro` | dual-AR | ✓ | ✓ | — | 44.1 kHz |
-| Gepard-1.0 | `nineninesix/gepard-1.0` | single (native AR + NanoCodec) | — (zero-shot; cloning WIP) | — (serving WIP) | zero-shot | 22.05 kHz |
+| Gepard-1.0 | `nineninesix/gepard-1.0` | single (native AR + NanoCodec) | — (zero-shot; cloning later) | ✓ (online) | zero-shot | 22.05 kHz |
 | GLM-TTS | `zai-org/GLM-TTS` | 2 (AR + DiT) | ✓ (required) | ✓ | — | 24 kHz |
 | Ming-omni-tts | `inclusionAI/Ming-omni-tts-0.5B` | 2 (AR + audio VAE) | ✓ | ✓ | style / IP / dialect / TTA / podcast | 44.1 kHz |
 | Ming-flash-omni-TTS | `Jonathan1909/Ming-flash-omni-2.0` | single (talker only) | — (caption-controlled) | — | style / IP / basic captions | 44.1 kHz |
@@ -25,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 |
@@ -52,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
@@ -90,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.
@@ -101,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',
@@ -114,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 \
@@ -130,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 \
@@ -142,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.
 
@@ -155,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 \
@@ -165,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.
@@ -185,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." \
@@ -199,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.
 
@@ -217,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 \
@@ -225,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 \
@@ -235,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 \
@@ -245,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`.
@@ -257,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
@@ -279,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`.
@@ -292,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"
@@ -303,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." \
@@ -314,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.
@@ -327,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 \
@@ -340,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 \
@@ -349,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 \
@@ -357,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 \
@@ -365,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 \
@@ -373,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.
 
@@ -383,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.
@@ -413,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 \
@@ -436,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.
 
@@ -449,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
@@ -478,19 +534,22 @@ 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 only for now; the `/v1/audio/speech` adapter is a follow-up PR.
-- Deploy config: `vllm_omni/deploy/gepard.yaml` (the example's default; copy it and pass `--deploy-config` to change it).
+- 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)).
+- Deploy config: `vllm_omni/deploy/gepard.yaml` (the example's default; copy it and pass `--deploy-config` to change it). Online serving **must** pass `--deploy-config vllm_omni/deploy/gepard.yaml` because the checkpoint self-identifies as `qwen3_5_text`.
 - Generation length and reproducibility are stage settings, not script flags. One output token is one audio frame, so `max_tokens` in the YAML is the frame budget; `seed` makes the in-model 32-head sampling reproducible. The script deliberately passes no `SamplingParams`: one supplied by a caller replaces the stage defaults wholesale rather than merging, which would drop the pipeline's stop token and run every request to `max_tokens`.
 - Text length: short texts are repeated internally to match the training layout (the checkpoint's `text_repetition` block); the upper bound is the stage's `max_model_len`, enforced by the engine. Empty text is rejected rather than voiced.
 - `VLLM_GEPARD_GREEDY=1` swaps the 32-head Gumbel-max sampling for argmax, for reproducible comparisons that do not depend on a seed.
@@ -500,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:
@@ -507,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 \
@@ -514,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." \
@@ -523,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.
@@ -590,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 \
@@ -614,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.
@@ -629,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 \
@@ -643,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 \
@@ -652,15 +698,48 @@ 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
+
 - `--num-prompts N` replicates the prompt for performance measurement.
 - `--concurrency M` requires `--streaming` and must evenly divide `--num-prompts`.
 - Run `--help` for the full argument surface.
+
+---
+
+## Breeze-TTS-2
+
+Two-stage AR TTS (T5Gemma2 + Qwen3 talker with a depth decoder → bundled Qwen3-TTS codec) at 24 kHz mono. The prompt builder picks one of four templates automatically: plain, voice design (`--instruction`), clone (`--ref-audio` + `--ref-text`), or voice direction (reference + `--instruction`).
+
+### Quick start
+
+```bash
+python examples/offline_inference/text_to_speech/breeze_tts_2/end2end.py \
+    --model BreezeBlue/Breeze-TTS-2 \
+    --text "Hello, this is Breeze TTS 2 running on vLLM Omni."
+```
+
+### Voice direction
+
+```bash
+python examples/offline_inference/text_to_speech/breeze_tts_2/end2end.py \
+    --text "We need to discuss what happened last night." \
+    --ref-audio /path/to/reference.wav \
+    --ref-text "The exact transcript of the reference audio." \
+    --instruction "Speak slowly with a restrained, serious tone."
+```
+
+### Notes
+
+- Output: 24 kHz mono WAV; `--max-new-tokens` caps generated frames (80 ms each).
+- Speaker tags `--voice S0`..`S9` (default `S0`) select the timbre in non-reference modes; with `--ref-audio` the timbre comes from the reference clip.
+- Deploy config: `vllm_omni/deploy/breeze_tts_2.yaml` (auto-loaded by HF `model_type`); see [`recipes/BreezeBlue/Breeze-TTS-2.md`](../../../recipes/BreezeBlue/Breeze-TTS-2.md) for the online-serving recipe.
diff --git a/examples/offline_inference/text_to_speech/breeze_tts_2/end2end.py b/examples/offline_inference/text_to_speech/breeze_tts_2/end2end.py
new file mode 100644
index 000000000..942ead792
--- /dev/null
+++ b/examples/offline_inference/text_to_speech/breeze_tts_2/end2end.py
@@ -0,0 +1,204 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Offline Breeze-TTS-2 inference example (two-stage talker + codec pipeline).
+
+Uses the async-chunk deploy config (vllm_omni/deploy/breeze_tts_2.yaml).
+Reference checkpoint: BreezeBlue/Breeze-TTS-2.
+"""
+
+from __future__ import annotations
+
+import os
+import time
+from pathlib import Path
+
+import soundfile as sf
+import torch
+from transformers import AutoConfig
+
+from vllm_omni import Omni
+from vllm_omni.model_executor.models.breeze_tts_2.prompt_builder import (
+    BreezeTTS2PromptBuilder,
+)
+from vllm_omni.utils.tracking_parser import TrackingArgumentParser
+
+REPO_ROOT = Path(__file__).resolve().parents[4]
+SAMPLE_RATE = 24_000
+
+
+def parse_args():
+    parser = TrackingArgumentParser(description="Offline Breeze-TTS-2 inference")
+    parser.add_argument(
+        "--model",
+        type=str,
+        default="BreezeBlue/Breeze-TTS-2",
+        help="Breeze-TTS-2 model path or HuggingFace repo ID.",
+    )
+    parser.add_argument(
+        "--text",
+        type=str,
+        default="Hello, this is Breeze TTS 2 running on vLLM Omni.",
+        help="Text to synthesize.",
+    )
+    parser.add_argument(
+        "--voice",
+        type=str,
+        default="S0",
+        help="Speaker tag such as S0..S9.",
+    )
+    parser.add_argument(
+        "--instruction",
+        type=str,
+        default=None,
+        help="Optional style instruction (voice design / voice direction).",
+    )
+    parser.add_argument(
+        "--ref-audio",
+        type=str,
+        default=None,
+        help="Optional reference wav path for cloning (requires --ref-text).",
+    )
+    parser.add_argument(
+        "--ref-text",
+        type=str,
+        default=None,
+        help="Exact transcript of the reference audio.",
+    )
+    parser.add_argument(
+        "--max-new-tokens",
+        type=int,
+        default=None,
+        help="Cap on generated codec frames (one frame is 80 ms of audio).",
+    )
+    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/breeze_tts_2.yaml based on the HF model_type.",
+    )
+    return parser.parse_args()
+
+
+def resolve_template(args) -> str:
+    if args.ref_audio is not None:
+        return "ref_edit_tata" if args.instruction else "ref_clone_tata"
+    return "tts_instruction" if args.instruction else "tts_plain"
+
+
+def reference_payload(ref_audio_path: str | None) -> dict:
+    """Load the reference clip into the payload keys the prompt builder reads.
+
+    ``BreezeTTS2PromptBuilder`` consumes ``ref_audio`` (a waveform) plus
+    ``ref_audio_sample_rate``; a bare path field is not read.
+    """
+    if ref_audio_path is None:
+        return {}
+    waveform, sample_rate = sf.read(ref_audio_path, dtype="float32", always_2d=True)
+    # Down-mix to the single 1-D clip the reference encoder expects.
+    waveform = waveform.mean(axis=1)
+    return {"ref_audio": waveform, "ref_audio_sample_rate": int(sample_rate)}
+
+
+def build_prompt(args) -> dict:
+    config = AutoConfig.from_pretrained(args.model, trust_remote_code=True)
+    reference_encoder = None
+    if args.ref_audio is not None:
+        from vllm_omni.model_executor.models.breeze_tts_2.audio_tokenizer import (
+            BreezeReferenceAudioTokenizer,
+        )
+
+        reference_encoder = BreezeReferenceAudioTokenizer.from_pretrained(
+            args.model,
+            num_codebooks=int(getattr(config, "num_codebooks", 16)),
+            device_map="cpu",
+        )
+    builder = BreezeTTS2PromptBuilder.from_pretrained(
+        args.model,
+        config,
+        reference_audio_encoder=reference_encoder,
+    )
+    payload = {
+        "text": args.text,
+        "speaker": args.voice,
+        **reference_payload(args.ref_audio),
+    }
+    if args.instruction:
+        payload["instruction"] = args.instruction
+    if args.ref_text:
+        payload["ref_text"] = args.ref_text
+    prompt = builder.build(payload, template=resolve_template(args))
+    if args.max_new_tokens is not None:
+        prompt["additional_information"]["breeze_max_new_frames"] = int(args.max_new_tokens)
+    return prompt
+
+
+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,
+    )
+
+    prompt = build_prompt(args)
+
+    print(f"Model       : {args.model}")
+    print(f"Text        : {args.text}")
+    print(f"Template    : {resolve_template(args)}")
+    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_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_speech/qwen3_tts/end2end.py b/examples/offline_inference/text_to_speech/qwen3_tts/end2end.py
index 75f562af6..54b55a193 100644
--- a/examples/offline_inference/text_to_speech/qwen3_tts/end2end.py
+++ b/examples/offline_inference/text_to_speech/qwen3_tts/end2end.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 """Offline inference demo for Qwen3 TTS via vLLM Omni.
 
 Provides single and batch sample inputs for CustomVoice, VoiceDesign, and Base
@@ -166,6 +169,9 @@ def get_custom_voice_query(use_batch_sample: bool = False) -> QueryResult:
                 "language": [language],
                 "speaker": [speaker],
                 "max_new_tokens": [2048],
+                # Optional Code2Wav emit opt-in under deploy.async_chunk.
+                # Independent of prompt-mode non_streaming_mode (#4198 / #6898).
+                "full_utterance_decode": [True],
             }
             inputs.append(
                 {
@@ -185,6 +191,7 @@ def get_custom_voice_query(use_batch_sample: bool = False) -> QueryResult:
             "speaker": [speaker],
             "instruct": [instruct],
             "max_new_tokens": [2048],
+            "full_utterance_decode": [True],
         }
         inputs = {
             "prompt_token_ids": [0] * _estimate_prompt_len(additional_information, model_name),
@@ -226,6 +233,7 @@ def get_voice_design_query(use_batch_sample: bool = False) -> QueryResult:
                 "instruct": [instruct],
                 "max_new_tokens": [2048],
                 "non_streaming_mode": [True],
+                "full_utterance_decode": [True],
             }
             inputs.append(
                 {
@@ -244,6 +252,7 @@ def get_voice_design_query(use_batch_sample: bool = False) -> QueryResult:
             "instruct": [instruct],
             "max_new_tokens": [2048],
             "non_streaming_mode": [True],
+            "full_utterance_decode": [True],
         }
         inputs = {
             "prompt_token_ids": [0] * _estimate_prompt_len(additional_information, model_name),
@@ -291,6 +300,7 @@ def get_base_query(use_batch_sample: bool = False, mode_tag: str = "icl") -> Que
                 "language": [language],
                 "x_vector_only_mode": [x_vector_only_mode],
                 "max_new_tokens": [2048],
+                "full_utterance_decode": [True],
             }
             inputs.append(
                 {
@@ -307,6 +317,7 @@ def get_base_query(use_batch_sample: bool = False, mode_tag: str = "icl") -> Que
             "language": [syn_lang_single],
             "x_vector_only_mode": [x_vector_only_mode],
             "max_new_tokens": [2048],
+            "full_utterance_decode": [True],
         }
         inputs = {
             "prompt_token_ids": [0] * _estimate_prompt_len(additional_information, model_name),
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/barge_in_client.py b/examples/online_serving/barge_in_client.py
index 1ac627d35..b9d95c790 100644
--- a/examples/online_serving/barge_in_client.py
+++ b/examples/online_serving/barge_in_client.py
@@ -14,7 +14,10 @@ Scenario (see ``barge_in_client_flow.md`` for the diagram)
 
 The demo is model-neutral: it drives any duplex model through the public
 :class:`vllm_omni.clients.duplex.DuplexClient` over
-``/v1/realtime?duplex=1``. Model-specific session shape comes from the
+``/v1/realtime?duplex=1``, or — with ``--inline`` — through
+:class:`vllm_omni.clients.inline_duplex.InlineDuplexClient` on an in-process
+:class:`vllm_omni.entrypoints.duplex_omni.DuplexOmni` (no server needed; the
+model loads in this process). Model-specific session shape comes from the
 per-model presets under ``vllm_omni.clients.<model>`` selected with
 ``--preset`` (default ``minicpmo_4_5``, whose model decides listen/speak on
 its own — no VAD).
@@ -31,6 +34,15 @@ then:
         --interrupt-wav follow_up_16k.wav \
         --output-dir ./duplex_out
 
+or, without a server, in-process (``--deploy-config`` is optional and defaults
+to the model's bundled duplex profile):
+
+    python barge_in_client.py --inline \
+        --model /path/to/MiniCPM-o-4_5 \
+        --ref-audio /path/to/reference_voice.wav \
+        --question-wav question_16k.wav \
+        --interrupt-wav follow_up_16k.wav
+
 Input WAVs must be mono 16 kHz PCM16; when a preset's session takes a
 different capture format (the PersonaPlex preset streams 24 kHz float32),
 the audio is converted before streaming. ``--ref-audio`` is required by the
@@ -55,6 +67,7 @@ if str(REPO_ROOT) not in sys.path:
 from vllm_omni.clients.duplex import (  # noqa: E402
     AudioFormat,
     DuplexClient,
+    DuplexClientBase,
     EventCollector,
     SessionConfig,
     acknowledge_collected_playback,
@@ -65,7 +78,7 @@ from vllm_omni.clients.duplex import (  # noqa: E402
 )
 
 _TRANSCRIPT_DELTA_EVENTS = {
-    "response.audio_transcript.delta",
+    "response.output_audio_transcript.delta",
     "response.output_text.delta",
     "response.text.delta",
 }
@@ -139,6 +152,39 @@ def _fold_responses(collector: EventCollector) -> dict[str, dict[str, object]]:
     return out
 
 
+def _make_client(args: argparse.Namespace, config: SessionConfig) -> DuplexClientBase:
+    """Websocket client by default; ``--inline`` drives an in-process DuplexOmni."""
+    if not args.inline:
+        return DuplexClient(
+            args.url,
+            model=args.model,
+            config=config,
+            reconnect=None,
+            heartbeat_interval_s=None,
+            handshake_timeout_s=args.timeout_s,
+        )
+    # Imported lazily: the in-process path loads the model (and its engine
+    # dependencies) in this process, which the websocket path never needs.
+    from vllm_omni.clients.inline_duplex import InlineDuplexClient
+    from vllm_omni.entrypoints.duplex_omni import DuplexOmni
+
+    # Models shipped with custom HF code (MiniCPM-o) need trust_remote_code to
+    # resolve their pipeline; harmless for the others.
+    omni_kwargs: dict[str, object] = {"model": args.model, "trust_remote_code": True}
+    if args.deploy_config:
+        omni_kwargs["deploy_config"] = args.deploy_config
+    omni = DuplexOmni(**omni_kwargs)
+    client = InlineDuplexClient(
+        omni,
+        model=args.model,
+        config=config,
+        handshake_timeout_s=args.timeout_s,
+    )
+    # The client owns no engine; stop the in-process one when the run ends.
+    client.owned_omni = omni  # type: ignore[attr-defined]
+    return client
+
+
 async def run(args: argparse.Namespace) -> int:
     config = _session_config(args.preset, ref_audio_path=args.ref_audio)
     question = _convert_to_session_format(read_pcm16_wav(Path(args.question_wav)), config.input_audio)
@@ -148,105 +194,117 @@ async def run(args: argparse.Namespace) -> int:
     output_dir.mkdir(parents=True, exist_ok=True)
 
     collector = EventCollector()
-    client = DuplexClient(
-        args.url,
-        model=args.model,
-        config=config,
-        reconnect=None,
-        heartbeat_interval_s=None,
-        handshake_timeout_s=args.timeout_s,
-    )
+    client = _make_client(args, config)
     # GREET: open the voice session (handshake happens on enter).
-    async with client:
-        consume_task = asyncio.create_task(collector.consume(client))
+    try:
+        async with client:
+            consume_task = asyncio.create_task(collector.consume(client))
 
-        # ASK: stream the question at realtime pace, then commit the turn.
-        # The model decides on its own to answer (no VAD).
-        print("[1] streaming question ...", file=sys.stderr)
-        await client.stream_pcm(question, chunk_ms=chunk_ms)
-        await client.commit(create_response=False)
-        await wait_for_condition(
-            lambda: collector.count("response.created") > 0,
-            timeout_s=args.timeout_s,
-            label="first response.created",
-        )
-        print("[1] assistant is answering", file=sys.stderr)
+            # ASK: stream the question at realtime pace, then commit the turn.
+            # The model decides on its own to answer (no VAD).
+            print("[1] streaming question ...", file=sys.stderr)
+            await client.stream_pcm(question, chunk_ms=chunk_ms)
+            await client.commit(create_response=False)
+            await wait_for_condition(
+                lambda: collector.count("response.created") > 0,
+                timeout_s=args.timeout_s,
+                label="first response.created",
+            )
+            print("[1] assistant is answering", file=sys.stderr)
 
-        # Let the answer play for a moment, as a listening user would.
-        await asyncio.sleep(args.listen_s)
+            # Let the answer play for a moment, as a listening user would.
+            await asyncio.sleep(args.listen_s)
 
-        # INTERRUPT: talk over the assistant while its audio still streams.
-        # The serving overlap policy decides: enough overlapped speech barges
-        # in (the first response is cancelled) or a short remark is deferred
-        # until the model yields the turn.
-        print("[2] interrupting mid-answer ...", file=sys.stderr)
-        ids_before_interrupt = set(collector.response_ids)
-        await client.stream_pcm(interrupt, chunk_ms=chunk_ms)
-        await client.commit(create_response=False)
+            # INTERRUPT: talk over the assistant while its audio still streams.
+            # The serving overlap policy decides: enough overlapped speech barges
+            # in (the first response is cancelled) or a short remark is deferred
+            # until the model yields the turn.
+            print("[2] interrupting mid-answer ...", file=sys.stderr)
+            ids_before_interrupt = set(collector.response_ids)
+            await client.stream_pcm(interrupt, chunk_ms=chunk_ms)
+            await client.commit(create_response=False)
 
-        # ANSWER AGAIN: wait for a response created *after* the interruption
-        # to finish. The first answer may still be streaming here; matching on
-        # any response.done would let its completion satisfy the wait and cut
-        # off the actual follow-up answer at close.
-        def follow_up_answer_done() -> bool:
-            return any(
-                event.get("type") == "response.done"
-                and collector.response_id(event) is not None
-                and collector.response_id(event) not in ids_before_interrupt
-                for event in collector.events
+            # ANSWER AGAIN: wait for a response created *after* the interruption
+            # to finish. The first answer may still be streaming here; matching on
+            # any response.done would let its completion satisfy the wait and cut
+            # off the actual follow-up answer at close.
+            def follow_up_answer_done() -> bool:
+                return any(
+                    event.get("type") == "response.done"
+                    and collector.response_id(event) is not None
+                    and collector.response_id(event) not in ids_before_interrupt
+                    for event in collector.events
+                )
+
+            await wait_for_condition(
+                follow_up_answer_done,
+                timeout_s=args.timeout_s,
+                label="response.done for the response answering the interruption",
             )
 
-        await wait_for_condition(
-            follow_up_answer_done,
-            timeout_s=args.timeout_s,
-            label="response.done for the response answering the interruption",
-        )
+            # HANG UP: report playback, close the session cleanly.
+            await acknowledge_collected_playback(client, collector)
+            await client.close(timeout_s=args.timeout_s)
+            try:
+                await asyncio.wait_for(consume_task, timeout=5.0)
+            except (asyncio.TimeoutError, asyncio.CancelledError):
+                consume_task.cancel()
 
-        # HANG UP: report playback, close the session cleanly.
-        await acknowledge_collected_playback(client, collector)
-        await client.close(timeout_s=args.timeout_s)
-        try:
-            await asyncio.wait_for(consume_task, timeout=5.0)
-        except (asyncio.TimeoutError, asyncio.CancelledError):
-            consume_task.cancel()
-
-    # Report: one WAV per response; statuses show what the overlap did.
-    responses = _fold_responses(collector)
-    summary: list[dict[str, object]] = []
-    for index, (response_id, item) in enumerate(responses.items(), start=1):
-        audio = item["audio"]
-        assert isinstance(audio, bytes)
-        sample_rate_hz = int(item["sample_rate_hz"])  # type: ignore[arg-type]
-        wav_path = output_dir / f"response_{index}_{item['status']}.wav"
-        if audio:
-            write_pcm16_wav(wav_path, audio, sample_rate_hz=sample_rate_hz)
-        summary.append(
-            {
-                "response_id": response_id,
-                "status": item["status"],
-                "audio_s": round(len(audio) / (sample_rate_hz * 2), 2),
-                "text": item["text"],
-                "wav": wav_path.name if audio else None,
-            }
+        # Report: one WAV per response; statuses show what the overlap did.
+        responses = _fold_responses(collector)
+        summary: list[dict[str, object]] = []
+        for index, (response_id, item) in enumerate(responses.items(), start=1):
+            audio = item["audio"]
+            assert isinstance(audio, bytes)
+            sample_rate_hz = int(item["sample_rate_hz"])  # type: ignore[arg-type]
+            wav_path = output_dir / f"response_{index}_{item['status']}.wav"
+            if audio:
+                write_pcm16_wav(wav_path, audio, sample_rate_hz=sample_rate_hz)
+            summary.append(
+                {
+                    "response_id": response_id,
+                    "status": item["status"],
+                    "audio_s": round(len(audio) / (sample_rate_hz * 2), 2),
+                    "text": item["text"],
+                    "wav": wav_path.name if audio else None,
+                }
+            )
+        (output_dir / "summary.json").write_text(json.dumps(summary, indent=2, ensure_ascii=False))
+        (output_dir / "events.jsonl").write_text(
+            "".join(json.dumps(event, ensure_ascii=False) + "\n" for event in collector.events),
+            encoding="utf-8",
         )
-    (output_dir / "summary.json").write_text(json.dumps(summary, indent=2, ensure_ascii=False))
-    (output_dir / "events.jsonl").write_text(
-        "".join(json.dumps(event, ensure_ascii=False) + "\n" for event in collector.events),
-        encoding="utf-8",
-    )
-    print(json.dumps(summary, indent=2, ensure_ascii=False))
-    cancelled = sum(1 for item in summary if item["status"] == "cancelled")
-    print(
-        f"\n{len(summary)} responses ({cancelled} interrupted); outputs in {output_dir}",
-        file=sys.stderr,
-    )
+        print(json.dumps(summary, indent=2, ensure_ascii=False))
+        cancelled = sum(1 for item in summary if item["status"] == "cancelled")
+        print(
+            f"\n{len(summary)} responses ({cancelled} interrupted); outputs in {output_dir}",
+            file=sys.stderr,
+        )
+    finally:
+        owned_omni = getattr(client, "owned_omni", None)
+        if owned_omni is not None:
+            owned_omni.shutdown()
     return 0
 
 
 def main() -> int:
     parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
     parser.add_argument("--url", default="ws://127.0.0.1:8099/v1/realtime")
-    parser.add_argument("--model", default="openbmb/MiniCPM-o-4_5")
+    parser.add_argument(
+        "--model",
+        default="openbmb/MiniCPM-o-4_5",
+        help="served model name, or the model path with --inline",
+    )
+    parser.add_argument(
+        "--inline",
+        action="store_true",
+        help="run the model in this process through DuplexOmni + InlineDuplexClient instead of connecting to --url",
+    )
+    parser.add_argument(
+        "--deploy-config",
+        default=None,
+        help="deploy YAML for --inline (default: the model's bundled profile)",
+    )
     parser.add_argument(
         "--preset",
         choices=["minicpmo_4_5", "personaplex", "none"],
diff --git a/examples/online_serving/barge_in_client_flow.md b/examples/online_serving/barge_in_client_flow.md
index d32a00e5a..9562d4c9c 100644
--- a/examples/online_serving/barge_in_client_flow.md
+++ b/examples/online_serving/barge_in_client_flow.md
@@ -1,8 +1,10 @@
 # `barge_in_client.py` — what happens, at a glance
 
-The demo plays one everyday conversation pattern against the full-duplex
-server: ask something, get talked-over mid-answer, and see the assistant
-cope. High-level flow below — for the exact wire events, read the
+The demo plays one everyday conversation pattern against a full-duplex
+model: ask something, get talked-over mid-answer, and see the assistant
+cope. It runs either against a server over `/v1/realtime?duplex=1` or, with
+`--inline`, against an in-process `DuplexOmni` — the conversation below is the
+same in both modes. High-level flow — for the exact wire events, read the
 docstring in `barge_in_client.py`.
 
 ```mermaid
@@ -48,7 +50,8 @@ answer is saved as `response_1_cancelled.wav`, a completed one as
 duration per answer.
 
 Companion: the runtime architecture lives in
-[`docs/design/fullduplex.md`](../../docs/design/fullduplex.md); the client
-API is `vllm_omni.clients.duplex.DuplexClient`, documented with the wire
-protocol in
+[`docs/design/fullduplex.md`](../../docs/design/fullduplex.md); the client API is
+`vllm_omni.clients.duplex.DuplexClient` over the websocket and
+`vllm_omni.clients.inline_duplex.InlineDuplexClient` in-process — both are
+documented with the wire protocol in
 [`docs/serving/realtime_duplex_api.md`](../../docs/serving/realtime_duplex_api.md).
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 2836eeb92..ffd50167f 100644
--- a/examples/online_serving/minicpmo/README.md
+++ b/examples/online_serving/minicpmo/README.md
@@ -183,10 +183,20 @@ python examples/online_serving/minicpmo/realtime_duplex_demo.py \
     --output-dir /tmp/minicpmo_realtime_duplex_video_demo
 ```
 
-Detail inside a composite is capped by `scale_resolution=448` at
-`max_slice_nums=1`: official suggests HD slicing (`max_slice_nums=[2, 1]`) for
-stacked frames, which the duplex adapter does not implement yet. Reading small
-text or digits out of a wide scene is limited by that, not by frame timing.
+Stage 0 processes a stacked unit the way official HD mode does
+(`max_slice_nums=[2, 1]`): the base frame keeps its own 66-token block plus the
+patches `get_sliced_grid` cuts for its size at `scale_resolution=448`, and the
+composite adds one block. The wire still rejects a caller-supplied
+`max_slice_nums`, so slicing is Stage 0's decision, not the client's.
+
+That detail costs context. One 960x540 frame is 66 vision tokens per unit and a
+stacked pair is 264, on top of the unit's audio, so the Stage 0 prompt grows by
+277 tokens per second stacked against 79 with a single frame. Against the
+40960-token context this model ships with, a listen-heavy call reaches the limit
+after about 2.5 minutes stacked and about 8.5 minutes unstacked (measured on a
+264 s 960x540 clip). Duplex sessions cannot yet evict old units, so keep
+multi-minute calls on the default `--stack-frames 1`; a stacked session that
+outgrows the context ends with a context-length error.
 
 ## Open the experimental browser client
 
@@ -306,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/barge_in_serve.sh b/examples/online_serving/minicpmo/barge_in_serve.sh
index 6dade8c5c..1aabd3042 100644
--- a/examples/online_serving/minicpmo/barge_in_serve.sh
+++ b/examples/online_serving/minicpmo/barge_in_serve.sh
@@ -5,10 +5,10 @@
 # Server side for barge_in_client.py: start MiniCPM-o 4.5 in native
 # full-duplex mode.
 #
-# The duplex deploy profile registers the WS /v1/duplex endpoint (with
-# /v1/realtime?duplex=1 projecting onto the same handler), enables the
-# engine duplex control plane, and bounds the Thinker/Talker/Code2Wav
-# stages to four live duplex sessions on one GPU. See
+# MiniCPM-o 4.5 declares a duplex plugin, so vllm-omni serve runs it through
+# DuplexOmni: the server is duplex-only (WS /v1/realtime?duplex=1, alias
+# /v1/duplex, plus /v1/models and /health) and bounds the
+# Thinker/Talker/Code2Wav stages to four live duplex sessions on one GPU. See
 # vllm_omni/deploy/minicpmo_4_5.yaml (session_mode: duplex) for the session
 # limits; every other duplex_session knob keeps its runtime default
 # (idle TTL 300s, disconnect grace 30s, 16MiB pending input per session).
@@ -22,4 +22,4 @@ exec vllm-omni serve "$MODEL" \
     --deploy-config vllm_omni/deploy/minicpmo_4_5.yaml \
     --trust-remote-code \
     --host 0.0.0.0 --port "$PORT"
-# duplex endpoints: ws://<host>:$PORT/v1/duplex and /v1/realtime?duplex=1
+# duplex endpoint: ws://<host>:$PORT/v1/realtime?duplex=1 (alias /v1/duplex)
diff --git a/examples/online_serving/minicpmo/realtime_duplex_demo.py b/examples/online_serving/minicpmo/realtime_duplex_demo.py
index 9cbc7f29b..6dc3fd6e7 100644
--- a/examples/online_serving/minicpmo/realtime_duplex_demo.py
+++ b/examples/online_serving/minicpmo/realtime_duplex_demo.py
@@ -63,14 +63,14 @@ class _StreamingOutputWriter:
     def handle(self, event: dict[str, object]) -> None:
         event_type = event.get("type")
         if event_type in {
-            "response.audio_transcript.delta",
+            "response.output_audio_transcript.delta",
             "response.output_text.delta",
         }:
             delta = event.get("delta")
             if isinstance(delta, str) and delta:
                 print(delta, end="", file=sys.stderr, flush=True)
             return
-        if event_type != "response.audio.delta":
+        if event_type != "response.output_audio.delta":
             return
 
         delta = event.get("delta") or event.get("audio")
@@ -445,7 +445,6 @@ async def run_demo(args: argparse.Namespace) -> dict[str, object]:
             ref_audio=_ref_audio_data_url(args.ref_audio),
             temperature=args.temperature,
         ),
-        session_id=args.session_id,
         reconnect=None,
         heartbeat_interval_s=None,
         handshake_timeout_s=args.timeout_s,
@@ -509,12 +508,12 @@ async def run_demo(args: argparse.Namespace) -> dict[str, object]:
 
         audio = collector.audio_bytes()
         first_text_at_s = collector.first_received_at(
-            "response.audio_transcript.delta",
+            "response.output_audio_transcript.delta",
             "response.output_text.delta",
             after_s=commit_sent_at_s,
         )
         first_audio_at_s = collector.first_received_at(
-            "response.audio.delta",
+            "response.output_audio.delta",
             after_s=commit_sent_at_s,
         )
         response_created_at_s = collector.first_received_at(
@@ -536,7 +535,7 @@ async def run_demo(args: argparse.Namespace) -> dict[str, object]:
             for event in collector.events
             if event.get("type")
             in {
-                "response.audio_transcript.delta",
+                "response.output_audio_transcript.delta",
                 "response.output_text.delta",
             }
         ]
@@ -638,7 +637,6 @@ def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser()
     parser.add_argument("--url", default="ws://localhost:8099/v1/realtime?duplex=1")
     parser.add_argument("--model", default="openbmb/MiniCPM-o-4_5")
-    parser.add_argument("--session-id")
     parser.add_argument(
         "--input-wav",
         help="Mono 16 kHz PCM16 clip to stream. Optional when --input-video carries the audio track.",
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 ef2367412..5eb9a2042 100644
--- a/examples/online_serving/qwen3_omni/README.md
+++ b/examples/online_serving/qwen3_omni/README.md
@@ -1,5 +1,7 @@
 # Qwen3-Omni: Online serving
 
+<!-- markdownlint-disable MD028 -->
+
 ## 🛠️ Installation
 
 Please refer to [README.md](../../../README.md)
@@ -12,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.
@@ -19,6 +32,7 @@ Additionally, NPU, ROCm, and XPU per-platform configuration deltas are determini
 `platforms`: section of the corresponding YAML.
 
 To explicitly utilize a custom deployment YAML, mandate the configuration path accordingly:
+
 ```bash
 vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct --omni --port 8091 \
     --deploy-config /path/to/your_deploy_config.yaml
@@ -53,7 +67,7 @@ Use the stage-based CLI when you want to run one stage per process.
 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 \
@@ -63,7 +77,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 \
@@ -73,7 +87,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 \
@@ -153,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
@@ -252,11 +266,12 @@ pattern works for Qwen2.5-Omni — replace `base_config:` with the path to
 ### 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 examples/online_serving/openai_chat_completion_client_for_multimodal_generation.py --model Qwen/Qwen3-Omni-30B-A3B-Instruct --query-type use_image --port 8091 --host "localhost"
@@ -264,7 +279,7 @@ python examples/online_serving/openai_chat_completion_client_for_multimodal_gene
 
 #### Realtime WebSocket client (`openai_realtime_client.py`)
 
-[`openai_realtime_client.py`](./openai_realtime_client.py) connects to **`ws://<host>:<port>/v1/realtime`**, streams a local WAV as **PCM16 mono @ 16 kHz** in fixed-size chunks, and receives **`response.audio.*`**, **`response.output_text.*`**, and transcript events. By default it uses explicit `input_audio_buffer.commit`; pass **`--server-vad`** to let the server detect speech endpoints and commit the turn automatically. The client concatenates audio deltas and writes **`--output-wav`** (model output is typically **24 kHz**). Optional **`--delta-dump-dir`** saves each delta as `delta_000001.wav`, … for debugging.
+[`openai_realtime_client.py`](./openai_realtime_client.py) connects to **`ws://<host>:<port>/v1/realtime`**, streams a local WAV as **PCM16 mono @ 16 kHz** in fixed-size chunks, and receives **`response.output_audio.*`**, **`response.output_text.*`**, and transcript events. By default it uses explicit `input_audio_buffer.commit`; pass **`--server-vad`** to let the server detect speech endpoints and commit the turn automatically. The client concatenates audio deltas and writes **`--output-wav`** (model output is typically **24 kHz**). Optional **`--delta-dump-dir`** saves each delta as `delta_000001.wav`, … for debugging.
 
 Streaming input works well for translation-style use cases; if the Thinker runs while input is still incomplete, consider limiting **`max_tokens`** in your session / server defaults to avoid over-generation.
 
@@ -289,7 +304,7 @@ python openai_realtime_client.py \
 **Arguments:**
 
 | Flag | Default | Description |
-|------|---------|-------------|
+| ------ | --------- | ------------- |
 | `--url` | `ws://localhost:8091/v1/realtime` | Full WebSocket URL including path |
 | `--model` | `Qwen/Qwen3-Omni-30B-A3B-Instruct` | Must match the served model (sent in `session.update`) |
 | `--input-wav` | *(required)* | Input WAV: mono, 16-bit PCM, **16 kHz** |
@@ -297,7 +312,7 @@ python openai_realtime_client.py \
 | `--output-text` | *(optional)* | If set, write final transcription text to this path |
 | `--chunk-ms` | `200` | Size of each uploaded audio chunk (milliseconds of audio) |
 | `--send-delay-ms` | `0` | Delay between chunk sends (simulate realtime upload) |
-| `--delta-dump-dir` | *(optional)* | Directory to write per-`response.audio.delta` WAV files |
+| `--delta-dump-dir` | *(optional)* | Directory to write per-`response.output_audio.delta` WAV files |
 | `--server-vad` | disabled | Enable server-side Silero VAD instead of sending explicit commits |
 | `--num-requests` | `1` | Number of sequential sessions (see `--concurrency`) |
 | `--concurrency` | `1` | Max concurrent WebSocket sessions when `--num-requests` > 1 |
@@ -305,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:
 
@@ -334,7 +342,6 @@ The Python client supports the following command-line arguments:
 - `--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?"`
 - `--speaker`: TTS speaker/voice for audio output when requesting audio (e.g. `ethan`, `chelsie`, `aiden`). Omit to use the model default. Example: `--speaker "chelsie"`
 
-
 For example, to use a local video file with custom prompt:
 
 ```bash
@@ -345,22 +352,22 @@ python examples/online_serving/openai_chat_completion_client_for_multimodal_gene
     --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
 ```
 
-
 ### FAQ
 
 ## 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 |
@@ -496,7 +503,9 @@ print(response.choices[0].message.audio)
 Supported speaker names depend on the model (e.g. `Ethan`, `Chelsie`, `Aiden`). Omit `speaker` to use the default.
 
 ## 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 examples/online_serving/openai_chat_completion_client_for_multimodal_generation.py \
     --query-type use_image \
@@ -521,12 +530,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)
@@ -537,18 +548,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:
 
@@ -561,7 +573,57 @@ 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)
+
+## 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 8a6871580..2a6bca0fe 100644
--- a/examples/online_serving/qwen3_omni/openai_realtime_client.py
+++ b/examples/online_serving/qwen3_omni/openai_realtime_client.py
@@ -6,14 +6,14 @@
 This client:
 1) Reads a local WAV file (must be mono, 16-bit PCM, 16kHz),
 2) Streams PCM16 chunks to /v1/realtime with OpenAI-style events,
-3) Receives response.audio.*, response.output_text.*, and transcript events,
+3) Receives response.output_audio.*, response.output_text.*, and transcript events,
 4) Saves synthesized audio to an output WAV file and optional text file.
 
-By default each ``response.audio.delta`` is treated as an **incremental PCM**
+By default each ``response.output_audio.delta`` is treated as an **incremental PCM**
 chunk and all chunks are concatenated into the final ``--output-wav``.
 
 Optional debugging: pass ``--delta-dump-dir DIR`` to write every
-``response.audio.delta`` payload as ``delta_000001.wav``, ``delta_000002.wav``, …
+``response.output_audio.delta`` payload as ``delta_000001.wav``, ``delta_000002.wav``, …
 
 Usage:
   python 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,
                             },
                         }
                     },
@@ -187,7 +187,7 @@ async def run_client(
             if event_type == "session.created":
                 continue
 
-            if event_type == "response.audio.delta":
+            if event_type == "response.output_audio.delta":
                 sr = event.get("sample_rate_hz")
                 if isinstance(sr, int) and sr > 0:
                     output_sample_rate = sr
@@ -223,16 +223,17 @@ async def run_client(
                     print(f"{log_prefix}text usage: {usage}")
                 continue
 
-            if event_type == "response.audio_transcript.done":
+            if event_type == "response.output_audio_transcript.done":
                 final_audio_transcript = event.get("transcript", "")
                 continue
 
-            if event_type == "response.audio.done":
+            if event_type == "response.output_audio.done":
                 if not server_vad:
                     break
                 continue
 
             if event_type == "response.done" and server_vad:
+                await ws.send(json.dumps({"type": "session.close"}))
                 break
 
             if event_type == "error":
@@ -339,7 +340,7 @@ def main() -> None:
         "--delta-dump-dir",
         type=Path,
         default=None,
-        help="If set, each response.audio.delta is saved as delta_NNNNNN.wav under this directory",
+        help="If set, each response.output_audio.delta is saved as delta_NNNNNN.wav under this directory",
     )
     parser.add_argument(
         "--server-vad",
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 2943eec74..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,13 +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('native_duplex', '1');
-    url.searchParams.set('autostart', '0');
-    return url.toString();
+    return profile.url(config, window.location.href);
   }
 
   function setConnection(label, kind) {
@@ -251,7 +317,7 @@
   }
 
   function microphoneUploadEnabled() {
-    return running && !muted;
+    return running && connectionReady && !muted && (!profile.halfDuplex || !assistantActive);
   }
 
   function flushCapture() {
@@ -268,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));
   }
 
@@ -288,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({
@@ -306,6 +366,7 @@
   }
 
   function requestPlaybackDrain(responseId) {
+    if (!responseHasAudio) { playbackComplete = true; finishResponseIfReady(); return; }
     if (!playbackNode) return;
     playbackNode.port.postMessage({ type: 'drain', responseId: responseId || currentResponseId });
   }
@@ -315,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.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.audio.done':
+      case 'drain':
         requestPlaybackDrain(responseId);
         break;
-      case 'response.audio_transcript.delta':
-        addTranscript('assistant', event.delta || '');
+      case 'text': case 'text-final':
+        handleTranscriptEvent(action);
         break;
-      case 'response.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;
     }
   }
 
@@ -407,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`;
@@ -449,52 +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,
-          native_duplex: 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}`);
       };
     });
   }
@@ -517,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)');
@@ -592,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 = [];
@@ -609,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) {
@@ -634,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';
@@ -661,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 5141a37c2..711fdec6b 100644
--- a/examples/online_serving/text_to_speech/README.md
+++ b/examples/online_serving/text_to_speech/README.md
@@ -14,8 +14,10 @@ For the full list of supported architectures across all modalities, see
 
 | 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) | — | ✓ |
+| Gepard-1.0 | `nineninesix/gepard-1.0` | — (zero-shot default voice) | ✓ (PCM / WAV stream) | `default` only | — |
 | GLM-TTS | `zai-org/GLM-TTS` | ✓ (`ref_audio`+`ref_text`, required) | ✓ (PCM stream) | — | ✓ |
 | IndexTTS-2 | `IndexTeam/IndexTTS-2` | ✓ (`ref_audio` or uploaded `voice`) | `stream=true` response, non-chunk | uploaded audio voice only; no presets | — |
 | IndexTTS-2.5 | native `checkpoints/` bundle | ✓ (`ref_audio` or uploaded `voice`) | `stream=true` response, non-chunk | uploaded audio voice only; no presets | — |
@@ -25,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.
@@ -95,48 +96,52 @@ curl -X POST http://localhost:8091/v1/audio/speech \
     }' --no-buffer | play -t raw -r 24000 -e signed -b 16 -c 1 -
 ```
 
-Adjust the player's sample rate to match the model (44.1 kHz for Fish Speech, 48 kHz for VoxCPM2, 22.05 kHz for IndexTTS-2, and 24 kHz for many others).
+Adjust the player's sample rate to match the model (44.1 kHz for Fish Speech, 48 kHz for VoxCPM2, 22.05 kHz for Gepard and IndexTTS-2, and 24 kHz for many others).
 
 For full request-shape documentation (all parameters, response formats, error codes), see the [Speech API reference](../../../docs/serving/speech_api.md).
 
 ---
 
-## dots.tts
+## Gepard-1.0
 
-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.
+Single-stage native AR TTS at 22.05 kHz mono. Zero-shot only: omit `voice` or pass `"default"`. Voice cloning from reference audio is not available yet.
+
+### Prerequisites
+
+Same NeMo NanoCodec install as the [offline Gepard section](../../offline_inference/text_to_speech/README.md#gepard-10). On a host whose CUDA toolkit cannot build kernels — no `nvcc`/`ninja`, or a consumer Blackwell (`sm_120`) card — also `export VLLM_USE_FLASHINFER_SAMPLER=0` before launch (same note as offline). That env is not a deploy-YAML field.
 
 ### Launch
 
 ```bash
-vllm serve dots-studio/dots.tts-soar --omni --trust-remote-code --port 8091
+vllm-omni serve nineninesix/gepard-1.0 --omni --port 8091 --trust-remote-code \
+    --stage-init-timeout 900 \
+    --deploy-config vllm_omni/deploy/gepard.yaml
+# or:
+./gepard/run_server.sh
 ```
 
+`--stage-init-timeout 900` matches the online e2e fixture and the offline example. Serve defaults to 300s, which is often too short for a cold download of the talker plus NanoCodec.
+
+The packaged `vllm_omni/deploy/gepard.yaml` must be passed with `--deploy-config`. The checkpoint self-identifies as `qwen3_5_text`, so omitting the YAML launches a diffusion fallback instead of the Gepard pipeline. The YAML sets `async_chunk: false`, `max_num_seqs: 4`, and currently pins `seed: 42`, so serving is deterministic by default until that YAML seed is removed. Pass an explicit per-request `seed` in tests and clients rather than depending on either default.
+
 ### 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
+python examples/online_serving/text_to_speech/gepard/speech_client.py \
+    --text "Hello, this is Gepard speaking."
 
-# 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 -
+python examples/online_serving/text_to_speech/gepard/speech_client.py \
+    --text "Hello, this is Gepard speaking." --seed 7 --stream --output output.pcm
 ```
 
+### Notes
+
+- Output: 22.05 kHz mono. `max_new_tokens` is a **frame** budget (1 token = 1 frame = 1024 samples ≈ 46.4 ms at 21.5 fps; adapter bounds 1..4096).
+- Supported request fields: `input` (required), `voice` (`default` only), `response_format` (`wav` default; `wav/pcm/flac/mp3` non-streaming; `opus` 400 because 22.05 kHz is not an Opus sample rate; streaming `pcm/wav` only), `stream` / `stream_format`, `max_new_tokens`, `seed`.
+- Unsupported: `speed`, `extra_params` (including `temperature`/`top_p`/`top_k`), `ref_audio`, `ref_text`, `speaker_embedding`, `task_type`, `instructions`, `language`, and `word_timestamps`.
+- 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.
+
 ---
 
 ## GLM-TTS
@@ -739,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.
@@ -793,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
@@ -1025,3 +1048,63 @@ The demo handles voice-preset selection and reference-audio upload. `voxtral_tts
 - Voice presets are listed on the HF model card (`mistralai/Voxtral-4B-TTS-2603`).
 - Voice cloning is gated upstream and may require a recent `mistral_common`.
 - A standalone CLI client is not yet shipped; the gradio demo is the canonical reference for now.
+
+## Breeze-TTS-2
+
+Two-stage AR TTS (T5Gemma2 + Qwen3 talker with a depth decoder → bundled Qwen3-TTS codec) at 24 kHz mono, from [BreezeBlue](https://huggingface.co/BreezeBlue/Breeze-TTS-2). Four modes are selected automatically from the request fields: plain (`input`), voice design (`instructions`), clone (`ref_audio`+`ref_text`), and voice direction (reference trio + `instructions`).
+
+### Launch
+
+```bash
+vllm serve BreezeBlue/Breeze-TTS-2 --omni --port 8091
+# or:
+./breeze_tts_2/run_server.sh
+```
+
+The deploy config at `vllm_omni/deploy/breeze_tts_2.yaml` auto-loads (async-chunk streaming, 8-frame inter-stage chunks).
+
+### Sending requests
+
+```bash
+# Plain synthesis (speaker tags S0..S9, default S0)
+curl -X POST http://localhost:8091/v1/audio/speech \
+    -H "Content-Type: application/json" \
+    -d '{
+        "input": "Hello, this is Breeze TTS 2 on vLLM-Omni.",
+        "voice": "S0",
+        "response_format": "wav",
+        "sample_rate": 24000
+    }' --output breeze_plain.wav
+
+# Voice direction (clone a reference, then steer the delivery)
+curl -X POST http://localhost:8091/v1/audio/speech \
+    -H "Content-Type: application/json" \
+    -d '{
+        "input": "We need to discuss what happened last night.",
+        "ref_audio": "file:///path/to/reference.wav",
+        "ref_text": "The exact transcript of the reference audio.",
+        "instructions": "Speak slowly with a restrained, serious tone.",
+        "response_format": "wav"
+    }' --output breeze_direction.wav
+```
+
+### Streaming PCM
+
+```bash
+curl -N -X POST http://localhost:8091/v1/audio/speech \
+    -H "Content-Type: application/json" \
+    -d '{
+        "input": "Streaming output from Breeze TTS 2.",
+        "stream": true,
+        "stream_format": "audio",
+        "response_format": "pcm",
+        "sample_rate": 24000
+    }' --output breeze_stream.pcm
+```
+
+### Notes
+
+- Only `sample_rate=24000` is accepted; `speed` must be `1.0`.
+- `guidance_scale`/`cfg_scale` must be `1.0`; `negative_prompt` is rejected (CFG companion support is a follow-up).
+- `instructions` without `ref_audio` is voice design; with `ref_audio`+`ref_text` it is voice direction.
+- See [`recipes/BreezeBlue/Breeze-TTS-2.md`](../../../recipes/BreezeBlue/Breeze-TTS-2.md) for the full recipe and the offline example under [`examples/offline_inference/text_to_speech/breeze_tts_2/`](../../offline_inference/text_to_speech/breeze_tts_2/).
diff --git a/examples/online_serving/text_to_speech/breeze_tts_2/run_server.sh b/examples/online_serving/text_to_speech/breeze_tts_2/run_server.sh
new file mode 100755
index 000000000..83ca27084
--- /dev/null
+++ b/examples/online_serving/text_to_speech/breeze_tts_2/run_server.sh
@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+# Launch Breeze-TTS-2 online serving with the async-chunk deploy config.
+
+set -euo pipefail
+
+MODEL="${1:-BreezeBlue/Breeze-TTS-2}"
+PORT="${PORT:-8091}"
+
+exec vllm-omni serve "${MODEL}" \
+    --deploy-config vllm_omni/deploy/breeze_tts_2.yaml \
+    --omni --port "${PORT}"
diff --git a/examples/online_serving/text_to_speech/gepard/run_server.sh b/examples/online_serving/text_to_speech/gepard/run_server.sh
new file mode 100755
index 000000000..420591288
--- /dev/null
+++ b/examples/online_serving/text_to_speech/gepard/run_server.sh
@@ -0,0 +1,33 @@
+#!/bin/bash
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+# Launch vLLM-Omni server for Gepard-1.0 TTS (zero-shot default voice).
+#
+# Usage:
+#   ./run_server.sh
+#   CUDA_VISIBLE_DEVICES=0 ./run_server.sh
+#
+# Packaged deploy config: vllm_omni/deploy/gepard.yaml (async_chunk=false,
+# 22.05 kHz mono, default seed 42 until the YAML seed is removed).
+# Cold start downloads the talker and NeMo NanoCodec; the serve default of
+# --stage-init-timeout 300 is too tight (offline end2end.py uses 900).
+#
+# On a host whose CUDA toolkit cannot JIT FlashInfer (no nvcc/ninja, or a
+# consumer Blackwell sm_120 card), also:
+#   export VLLM_USE_FLASHINFER_SAMPLER=0
+
+set -e
+
+MODEL="${MODEL:-nineninesix/gepard-1.0}"
+PORT="${PORT:-8091}"
+
+echo "Starting Gepard-1.0 server with model: $MODEL"
+
+vllm-omni serve "$MODEL" \
+    --host 0.0.0.0 \
+    --port "$PORT" \
+    --trust-remote-code \
+    --omni \
+    --stage-init-timeout 900 \
+    --deploy-config vllm_omni/deploy/gepard.yaml
diff --git a/examples/online_serving/text_to_speech/gepard/speech_client.py b/examples/online_serving/text_to_speech/gepard/speech_client.py
new file mode 100755
index 000000000..4db4f1c7d
--- /dev/null
+++ b/examples/online_serving/text_to_speech/gepard/speech_client.py
@@ -0,0 +1,116 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Client for Gepard-1.0 TTS via /v1/audio/speech.
+
+Gepard is zero-shot: omit ``voice`` or pass ``"default"``. Output is 22.05 kHz
+mono. ``seed`` is optional; the packaged deploy YAML currently pins ``seed: 42``
+until that default is removed, so requests without an explicit seed are still
+deterministic.
+
+Examples:
+    python speech_client.py --text "Hello, this is Gepard speaking."
+    python speech_client.py --text "Hello, this is Gepard speaking." --seed 7
+    python speech_client.py --text "Hello, this is Gepard speaking." --stream --output output.pcm
+"""
+
+from __future__ import annotations
+
+import argparse
+
+import httpx
+
+DEFAULT_API_BASE = "http://localhost:8091"
+DEFAULT_API_KEY = "EMPTY"
+DEFAULT_MODEL = "nineninesix/gepard-1.0"
+
+
+def run_tts(args) -> None:
+    payload = {
+        "model": args.model,
+        "input": args.text,
+        "voice": args.voice,
+        "response_format": args.response_format,
+    }
+    if args.seed is not None:
+        payload["seed"] = args.seed
+    if args.max_new_tokens is not None:
+        payload["max_new_tokens"] = args.max_new_tokens
+    if args.stream:
+        payload["stream"] = True
+        payload["stream_format"] = "audio"
+        if args.response_format not in ("pcm", "wav"):
+            print(f"Note: streaming requires pcm/wav; overriding --response-format {args.response_format} to 'pcm'")
+            payload["response_format"] = "pcm"
+
+    print(f"Model: {args.model}")
+    print(f"Text: {args.text}")
+    print(f"Voice: {args.voice}")
+    if args.seed is not None:
+        print(f"Seed: {args.seed}")
+    print("Generating audio...")
+
+    api_url = f"{args.api_base}/v1/audio/speech"
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {args.api_key}",
+    }
+
+    if args.stream:
+        output_path = args.output or ("output.wav" if payload["response_format"] == "wav" else "output.pcm")
+        with httpx.Client(timeout=300.0) as client:
+            with client.stream("POST", api_url, json=payload, headers=headers) as resp:
+                if resp.status_code != 200:
+                    print(f"Error: {resp.status_code}")
+                    print(resp.read().decode())
+                    return
+                total_bytes = 0
+                with open(output_path, "wb") as f:
+                    for chunk in resp.iter_bytes():
+                        f.write(chunk)
+                        total_bytes += len(chunk)
+                print(f"Streamed {total_bytes} bytes to: {output_path}")
+        return
+
+    with httpx.Client(timeout=300.0) as client:
+        response = client.post(api_url, json=payload, headers=headers)
+
+    if response.status_code != 200:
+        print(f"Error: {response.status_code}")
+        print(response.text)
+        return
+
+    output_path = args.output or "output.wav"
+    with open(output_path, "wb") as f:
+        f.write(response.content)
+    print(f"Audio saved to: {output_path}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Gepard-1.0 TTS client")
+    parser.add_argument("--api-base", default=DEFAULT_API_BASE, help="API base URL")
+    parser.add_argument("--api-key", default=DEFAULT_API_KEY, help="API key")
+    parser.add_argument("--model", "-m", default=DEFAULT_MODEL, help="Model name")
+    parser.add_argument("--text", required=True, help="Text to synthesize")
+    parser.add_argument("--voice", default="default", help="Voice name (only 'default' is supported)")
+    parser.add_argument("--seed", type=int, default=None, help="Sampling seed")
+    parser.add_argument(
+        "--max-new-tokens",
+        type=int,
+        default=None,
+        help="Frame budget (1 token = 1 frame ≈ 46.4 ms at 21.5 fps)",
+    )
+    parser.add_argument("--stream", action="store_true", help="Enable streaming (PCM output)")
+    parser.add_argument(
+        "--response-format",
+        default="wav",
+        choices=["wav", "mp3", "flac", "pcm"],
+        help="Audio format (default: wav). Streaming is pcm/wav only. Opus is not supported at 22.05 kHz.",
+    )
+    parser.add_argument("--output", "-o", default=None, help="Output file path")
+    args = parser.parse_args()
+    run_tts(args)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/online_serving/text_to_speech/qwen3_tts/batch_speech_client.py b/examples/online_serving/text_to_speech/qwen3_tts/batch_speech_client.py
index 47fdc3691..1b91905b7 100644
--- a/examples/online_serving/text_to_speech/qwen3_tts/batch_speech_client.py
+++ b/examples/online_serving/text_to_speech/qwen3_tts/batch_speech_client.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 """Batch speech client for Qwen3-TTS via /v1/audio/speech/batch endpoint.
 
 This script demonstrates how to synthesize multiple texts in a single request.
@@ -7,7 +10,7 @@ the reference for each item.
 
 Start the server (with batch-optimized stage settings for best throughput):
 
-    vllm serve Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice \
+    vllm serve Qwen/Qwen3-TTS-12Hz-1.7B-Base \
         --omni \
         --trust-remote-code \
         --stage-overrides '{"0":{"max_num_seqs":4,"gpu_memory_utilization":0.2},
diff --git a/examples/online_serving/text_to_speech/qwen3_tts/gradio_demo.py b/examples/online_serving/text_to_speech/qwen3_tts/gradio_demo.py
index 3c99a82d3..105571f38 100644
--- a/examples/online_serving/text_to_speech/qwen3_tts/gradio_demo.py
+++ b/examples/online_serving/text_to_speech/qwen3_tts/gradio_demo.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 """Gradio demo for Qwen3-TTS with gapless streaming audio playback.
 
 Uses a custom AudioWorklet-based player for gap-free streaming,
@@ -351,7 +354,7 @@ def generate_speech(
         raise gr.Error(f"Failed to decode audio: {e}")
 
 
-def create_app(api_base: str):
+def create_app(api_base: str, task_type: str = "CustomVoice"):
     """Create the FastAPI app with streaming proxy + Gradio UI."""
     fastapi_app = FastAPI()
 
@@ -463,10 +466,11 @@ def create_app(api_base: str):
                     lines=4,
                 )
                 with gr.Row():
-                    task_type = gr.Radio(
+                    task_type_input = gr.Radio(
                         choices=TASK_TYPES,
-                        value="CustomVoice",
+                        value=task_type,
                         label="Task Type",
+                        interactive=False,
                         scale=2,
                     )
                     language = gr.Dropdown(
@@ -479,17 +483,21 @@ def create_app(api_base: str):
                     choices=voices,
                     value=voices[0] if voices else None,
                     label="speaker",
-                    visible=True,
+                    visible=task_type == "CustomVoice",
                     allow_custom_value=True,
                 )
                 instructions = gr.Textbox(
                     label="Instructions",
                     placeholder="e.g., Speak with excitement / A warm, friendly female voice",
                     lines=2,
-                    visible=True,
-                    info="Optional style/emotion instructions",
+                    visible=task_type != "Base",
+                    info=(
+                        "Required: describe the voice style"
+                        if task_type == "VoiceDesign"
+                        else "Optional style/emotion instructions"
+                    ),
                 )
-                with gr.Column(visible=False) as ref_group:
+                with gr.Column(visible=task_type == "Base") as ref_group:
                     ref_audio = gr.Audio(
                         label="Reference Audio (upload for voice cloning)",
                         type="numpy",
@@ -563,7 +571,7 @@ def create_app(api_base: str):
                     autoplay=True,
                     visible=False,
                 )
-                with gr.Column(visible=True) as examples_cv:
+                with gr.Column(visible=task_type == "CustomVoice") as examples_cv:
                     gr.Examples(
                         examples=[
                             [
@@ -588,7 +596,7 @@ def create_app(api_base: str):
                         inputs=[text_input, voice, language, instructions],
                         label="examples",
                     )
-                with gr.Column(visible=False) as examples_vd:
+                with gr.Column(visible=task_type == "VoiceDesign") as examples_vd:
                     gr.Examples(
                         examples=[
                             [
@@ -605,7 +613,7 @@ def create_app(api_base: str):
                         inputs=[text_input, language, instructions],
                         label="examples",
                     )
-                with gr.Column(visible=False) as examples_base:
+                with gr.Column(visible=task_type == "Base") as examples_base:
                     gr.Examples(
                         examples=[
                             [
@@ -653,9 +661,9 @@ def create_app(api_base: str):
                 gr.update(visible=is_base),  # examples_base
             )
 
-        task_type.change(
+        task_type_input.change(
             fn=on_task_change,
-            inputs=[task_type],
+            inputs=[task_type_input],
             outputs=[
                 voice,
                 instructions,
@@ -703,7 +711,7 @@ def create_app(api_base: str):
 
         all_inputs = [
             text_input,
-            task_type,
+            task_type_input,
             voice,
             language,
             instructions,
@@ -788,6 +796,9 @@ def parse_args():
         description="Gradio demo for Qwen3-TTS with gapless AudioWorklet streaming.",
     )
     add_common_args(parser)
+    parser.add_argument(
+        "--task-type", choices=TASK_TYPES, default="CustomVoice", help="Task matching the served checkpoint"
+    )
     return parser.parse_args()
 
 
@@ -796,7 +807,7 @@ def main():
     logging.basicConfig(level=logging.INFO)
     print(f"Connecting to vLLM server at: {args.api_base}")
 
-    app = create_app(args.api_base)
+    app = create_app(args.api_base, task_type=args.task_type)
 
     import uvicorn
 
diff --git a/examples/online_serving/text_to_speech/qwen3_tts/openai_speech_client.py b/examples/online_serving/text_to_speech/qwen3_tts/openai_speech_client.py
index 7b2fecef5..a3f45bce8 100644
--- a/examples/online_serving/text_to_speech/qwen3_tts/openai_speech_client.py
+++ b/examples/online_serving/text_to_speech/qwen3_tts/openai_speech_client.py
@@ -8,25 +8,28 @@ to generate audio from text using Qwen3-TTS models.
 
 Examples:
     # CustomVoice task (predefined speaker)
-    python openai_speech_client.py --text "Hello, how are you?" --voice vivian
+    python openai_speech_client.py --text "Hello, how are you?" --speaker vivian
 
     # CustomVoice with emotion instruction
-    python openai_speech_client.py --text "I'm so happy!" --voice vivian \
+    python openai_speech_client.py --text "I'm so happy!" --speaker vivian \
         --instructions "Speak with excitement"
 
     # VoiceDesign task (voice from description)
     python openai_speech_client.py --text "Hello world" \
+        --model Qwen/Qwen3-TTS-12Hz-1.7B-VoiceDesign \
         --task-type VoiceDesign \
         --instructions "A warm, friendly female voice"
 
     # Base task (voice cloning)
     python openai_speech_client.py --text "Hello world" \
+        --model Qwen/Qwen3-TTS-12Hz-1.7B-Base \
         --task-type Base \
         --ref-audio "https://example.com/reference.wav" \
         --ref-text "This is the reference transcript"
 
     # Base task with pre-computed speaker embedding
     python openai_speech_client.py --text "Hello world" \
+        --model Qwen/Qwen3-TTS-12Hz-1.7B-Base \
         --task-type Base \
         --speaker-embedding embedding.json
 """
diff --git a/examples/online_serving/text_to_speech/qwen3_tts/run_gradio_demo.sh b/examples/online_serving/text_to_speech/qwen3_tts/run_gradio_demo.sh
index d79be3c2a..650797beb 100644
--- a/examples/online_serving/text_to_speech/qwen3_tts/run_gradio_demo.sh
+++ b/examples/online_serving/text_to_speech/qwen3_tts/run_gradio_demo.sh
@@ -1,4 +1,7 @@
 #!/bin/bash
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 # Launch both vLLM server and Gradio demo for Qwen3-TTS
 #
 # Usage:
@@ -179,7 +182,7 @@ fi
 echo ""
 echo "Starting Gradio demo..."
 cd "$SCRIPT_DIR"
-GRADIO_CMD=("python" "gradio_demo.py" "--api-base" "$API_BASE" "--host" "$GRADIO_IP" "--port" "$GRADIO_PORT")
+GRADIO_CMD=("python" "gradio_demo.py" "--api-base" "$API_BASE" "--host" "$GRADIO_IP" "--port" "$GRADIO_PORT" "--task-type" "$TASK_TYPE")
 if [ "$GRADIO_SHARE" = true ]; then
     GRADIO_CMD+=("--share")
 fi
diff --git a/pyproject.toml b/pyproject.toml
index 2584c8c7a..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)
@@ -123,6 +121,11 @@ fa4 = [
     "flash-attn-4[cu13]==4.0.0b18",
 ]
 
+# FastVideo VSA kernels for the supported Linux/Python 3.12 wheel environment.
+vsa = [
+    "fastvideo-kernel==0.3.4",
+]
+
 docs = [
     "mkdocs>=1.5.0",
     "mkdocs-api-autonav",
@@ -376,6 +379,9 @@ ba = "ba"
 SER = "SER"
 # NumPy ndarray.flags.writeable (canonical flag name, not "writable").
 writeable = "writeable"
+# ARPAbet phoneme symbol (Fish Speech phoneme-control token example, e.g.
+# "IY0"), not a typo of "IT".
+IY = "IY"
 # "convnet" abbreviates convolutional network. It appears in the vendored Fish
 # Speech DAC codec identifiers (convnet_type, transconvnet_type) and is not a
 # typo of "convent".
diff --git a/recipes/Boogu/Boogu-Image.md b/recipes/Boogu/Boogu-Image.md
index 0353b9778..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",
@@ -452,6 +486,39 @@ curl -s http://localhost:8091/v1/chat/completions \
 - **Known limitations:** the same single-GPU limitations as Base and Edit apply;
   CPU offload, Cache-DiT, and multi-GPU parallelism are not yet validated.
 
+## Output format and compression
+
+Image requests accept `output_format` (`png`, `jpeg`, or `webp`) and
+`output_compression` (0-100). The default is `png` with the fastest,
+least-compressed PNG encode, which is lossless but produces multi-megabyte
+payloads. For latency-sensitive clients, `output_format: "jpeg"` removes
+almost the entire response-encoding overhead: on a 1024x1024 Turbo request
+the client-observed e2e latency drops from ~900 ms to ~766 ms and the
+payload shrinks from ~3.1 MB to ~0.8 MB. Use `output_compression` to trade
+encode time against payload size when PNG must stay lossless: lower values
+(e.g. 1) compress harder and produce smaller payloads at proportionally
+longer encode times.
+
+## Attention backend
+
+The diffusion attention backend defaults to `FLASH_ATTN` (FlashAttention-2).
+On Hopper-class GPUs (SM90) pass `--diffusion-attention-backend CUDNN_ATTN`
+for a measured ~12% engine-time reduction on Boogu-Image workloads:
+
+```bash
+vllm serve Boogu/Boogu-Image-0.1-Turbo \
+  --omni \
+  --diffusion-attention-backend CUDNN_ATTN \
+  --port 8091
+```
+
+Measured on a 143 GB SM90 card (1024x1024, 4 steps, 5-run mean): stage time
+673 ms with `CUDNN_ATTN` vs 763 ms with the default. Outputs are numerically
+different from FLASH_ATTN (different attention kernel) but visually
+equivalent, deterministic per seed, and decode identically. On datacenter
+Blackwell (SM100 / SM103) use `--diffusion-attention-backend TRTLLM_ATTN`
+instead; it is rejected on SM90.
+
 ## Performance validation
 
 The checked-in single-device A40 measurements remain the current Boogu
diff --git a/recipes/BosonAI/Higgs-Audio-V3-TTS.md b/recipes/BosonAI/Higgs-Audio-V3-TTS.md
index 0391fe03c..5f023fe3f 100644
--- a/recipes/BosonAI/Higgs-Audio-V3-TTS.md
+++ b/recipes/BosonAI/Higgs-Audio-V3-TTS.md
@@ -102,23 +102,28 @@ python examples/online_serving/text_to_speech/higgs_audio_v3/batch_speech_client
 - Key flags: `--trust-remote-code` and `--omni` are required.
 - Output: 24 kHz mono WAV.
 - Voice cloning: `ref_audio` accepts WAV/FLAC/MP3; `ref_text` is optional but improves fidelity.
+- Reference substitution diagnostics: temporarily set `VLLM_LOGGING_LEVEL=DEBUG`
+  before starting the server to see why reference audio substitution was skipped.
+  Count-mismatch messages report the batch-local request index, placeholder count,
+  and reference code row count without logging text or audio content. They do not
+  change the existing fallback behavior; legacy counts describe the current span.
 - Deploy config: `vllm_omni/deploy/higgs_multimodal_qwen3.yaml` (auto-discovered from `model_type`).
-  - `max_num_seqs=16` for both stages.
-  - Stage 0 and Stage 1 default to the same device (`0`) for single-GPU serving.
-  - Stage 0 intentionally keeps `enforce_eager=true`. This preserves the Higgs-specific local MLP CUDA graph path, which is the current high-throughput default.
-  - Stage 1 remains `enforce_eager=true` for the codec decoder.
+    - `max_num_seqs=16` for both stages.
+    - Stage 0 and Stage 1 default to the same device (`0`) for single-GPU serving.
+    - Stage 0 intentionally keeps `enforce_eager=true`. This preserves the Higgs-specific local MLP CUDA graph path, which is the current high-throughput default.
+    - Stage 1 remains `enforce_eager=true` for the codec decoder.
 - Deploy profiles:
-  - High throughput: `vllm_omni/deploy/higgs_multimodal_qwen3_high_throughput.yaml`.
+    - High throughput: `vllm_omni/deploy/higgs_multimodal_qwen3_high_throughput.yaml`.
     Use this for medium/high concurrency. The auto-discovered
     `higgs_multimodal_qwen3.yaml` is kept as a compatibility/default alias for
     this profile.
-  - Low latency: `vllm_omni/deploy/higgs_multimodal_qwen3_low_latency.yaml`.
+    - Low latency: `vllm_omni/deploy/higgs_multimodal_qwen3_low_latency.yaml`.
     Use this for low-concurrency serving (for example c1-c4). It sets Stage 0
     `enforce_eager=false` and enables vLLM `FULL_DECODE_ONLY` CUDA graph through
     YAML `compilation_config`; no environment variable is required.
-  - Profile details: `vllm_omni/deploy/README_higgs_audio_v3.md`.
+    - Profile details: `vllm_omni/deploy/README_higgs_audio_v3.md`.
 - Performance note:
-  - Do not switch the auto-discovered default Stage 0 profile to vLLM
+    - Do not switch the auto-discovered default Stage 0 profile to vLLM
     `FULL_DECODE_ONLY` CUDA graph without an end-to-end throughput and
     audio-quality revalidation. On the H20 SeedTTS c16/full-dataset benchmark,
     the eager Stage 0 path with Higgs local MLP CUDA graph reproduced
@@ -127,5 +132,5 @@ python examples/online_serving/text_to_speech/higgs_audio_v3/batch_speech_client
     capture fix showed lower c1/c4 latency, so the FULL_DECODE profile is kept
     as an explicit low-latency option rather than the throughput default.
 - Known limitations:
-  - Stage 1 (code2wav) must use `enforce_eager=true` (`@torch.inference_mode` incompatible with graph capture).
-  - Stage 0 full-decode CUDA graph is experimental; sampler, delay-state updates, staging, and request postprocess remain outside the graph.
+    - Stage 1 (code2wav) must use `enforce_eager=true` (`@torch.inference_mode` incompatible with graph capture).
+    - Stage 0 full-decode CUDA graph is experimental; sampler, delay-state updates, staging, and request postprocess remain outside the graph.
diff --git a/recipes/BreezeBlue/Breeze-TTS-2.md b/recipes/BreezeBlue/Breeze-TTS-2.md
new file mode 100644
index 000000000..fb26ce91c
--- /dev/null
+++ b/recipes/BreezeBlue/Breeze-TTS-2.md
@@ -0,0 +1,210 @@
+# Breeze-TTS-2
+
+> Text-to-speech serving (plain / voice design / voice clone / voice direction)
+
+## Summary
+
+- Vendor: BreezeBlue
+- Model: `BreezeBlue/Breeze-TTS-2` (`BreezeForConditionalGeneration`)
+- Task: Text-to-speech with speaker tags, natural-language style instructions, single-reference voice cloning, and reference+instruction "voice direction"
+- Mode: Online serving with the OpenAI-compatible `/v1/audio/speech` API (streaming and non-streaming); offline `Omni` example
+- Hardware: 1x NVIDIA L20 48GB (CUDA)
+- Maintainer: Community
+
+## When to use this recipe
+
+Use this recipe when you want a known-good starting point for serving
+Breeze-TTS-2 with vLLM-Omni. Breeze-TTS-2 is a two-stage AR TTS pipeline:
+
+| Stage | Components | Output |
+| ----- | ---------- | ------ |
+| 0 (talker, `LLM_AR`) | T5Gemma2 text encoder + Qwen3 backbone + 2052-way codebook-0 head + 12-layer depth decoder | 16-codebook codec frames |
+| 1 (codec, `LLM_GENERATION`) | Bundled Qwen3-TTS audio tokenizer decoder (Mimi fallback) | 24 kHz mono waveform |
+
+Four prompt modes are selected automatically from the request fields:
+
+| Mode | Trigger | Fields |
+| ---- | ------- | ------ |
+| `tts_plain` | only `input` (default `voice=S0`) | `input`, `voice` |
+| `tts_instruction` (voice design) | `input` + `instructions` | style/emotion/pace directives, not spoken |
+| `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` 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 |
+| ---- | ----- |
+| Tasks | Text-to-speech through `/v1/audio/speech` (online) and the offline `Omni` example |
+| 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`; 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` 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
+
+- Issue: [#6656 [New Model]: Breeze TTS 2](https://github.com/vllm-project/vllm-omni/issues/6656)
+- Related examples under `examples/`:
+  [`examples/online_serving/text_to_speech/breeze_tts_2/`](../../examples/online_serving/text_to_speech/breeze_tts_2/),
+  [`examples/offline_inference/text_to_speech/breeze_tts_2/`](../../examples/offline_inference/text_to_speech/breeze_tts_2/)
+
+## Hardware
+
+- Accelerator model and per-device memory: 1x NVIDIA L20 48GB
+- Number of devices: 1 (both stages are placed on device 0)
+- Device interconnect: not applicable (single device)
+- Host memory: no special requirement; per-request codec state is small
+- Qualification scope: functional serving of all four prompt modes, streaming PCM, and 4 concurrent mixed-mode requests (greedy, `cfg_scale=1.0`). No other accelerator is qualified by this recipe.
+
+## Software environment
+
+- OS: Linux
+- Python: 3.12.12
+- Driver / runtime: NVIDIA driver 580.82.07, CUDA 13.0 (PyTorch 2.13.0+cu130)
+- vLLM version: 0.28.0
+- vLLM-Omni version or commit: the commit that introduced this recipe (branch based on `main` @ `67ef0b64`)
+- Transformers: 5.14.1
+
+## Command
+
+Start the server from the repository root. The deploy config
+(`vllm_omni/deploy/breeze_tts_2.yaml`, async chunk streaming by default)
+auto-loads from the checkpoint's `model_type`; pass it explicitly if you
+customized it:
+
+```bash
+vllm serve BreezeBlue/Breeze-TTS-2 \
+    --deploy-config vllm_omni/deploy/breeze_tts_2.yaml \
+    --omni --port 8091
+```
+
+## Verification
+
+Plain synthesis (speaker tag `S0`..`S9`, default `S0`):
+
+```bash
+curl -X POST http://localhost:8091/v1/audio/speech \
+    -H "Content-Type: application/json" \
+    -d '{
+        "model": "BreezeBlue/Breeze-TTS-2",
+        "input": "Hello, this is Breeze TTS 2 running on vLLM-Omni.",
+        "voice": "S0",
+        "response_format": "wav",
+        "sample_rate": 24000
+    }' --output breeze_plain.wav
+```
+
+Voice design (instruction only, no reference audio):
+
+```bash
+curl -X POST http://localhost:8091/v1/audio/speech \
+    -H "Content-Type: application/json" \
+    -d '{
+        "input": "(laugh) Welcome to our story time.",
+        "instructions": "A warm young woman, clear voice, lively delivery.",
+        "response_format": "wav"
+    }' --output breeze_design.wav
+```
+
+Voice cloning (`ref_audio` and `ref_text` must be provided together):
+
+```bash
+curl -X POST http://localhost:8091/v1/audio/speech \
+    -H "Content-Type: application/json" \
+    -d '{
+        "input": "This is new text spoken in the cloned voice.",
+        "ref_audio": "file:///path/to/reference.wav",
+        "ref_text": "The exact transcript of the reference audio.",
+        "response_format": "wav"
+    }' --output breeze_clone.wav
+```
+
+Voice direction (reference + instruction):
+
+```bash
+curl -X POST http://localhost:8091/v1/audio/speech \
+    -H "Content-Type: application/json" \
+    -d '{
+        "input": "We need to discuss what happened last night.",
+        "ref_audio": "file:///path/to/reference.wav",
+        "ref_text": "The exact transcript of the reference audio.",
+        "instructions": "Speak slowly with a restrained, serious tone.",
+        "response_format": "wav"
+    }' --output breeze_direction.wav
+```
+
+Streaming raw PCM (`stream_format="audio"`):
+
+```bash
+curl -N -X POST http://localhost:8091/v1/audio/speech \
+    -H "Content-Type: application/json" \
+    -d '{
+        "input": "Streaming output from Breeze TTS 2.",
+        "stream": true,
+        "stream_format": "audio",
+        "response_format": "pcm",
+        "sample_rate": 24000
+    }' --output breeze_stream.pcm
+```
+
+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
+
+- **Sample rate**: only `24000` is accepted; other values fail validation
+  before inference.
+- **Speed / seeds / multi-reference**: `speed` must be `1.0`;
+  `task_type=VoiceDesign`, `ref_audio_2`, and speaker embeddings are not
+  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.
+- **Checkpoint layout**: the checkpoint must contain the `audio_tokenizer/`
+  subdirectory (bundled Qwen3-TTS codec) for the default streaming path; the
+  Mimi fallback is used only when that directory is absent and does not
+  support async-chunk streaming.
+- **License**: the reference inference code is Apache 2.0; the checkpoints are
+  distributed under the separate BreezeBlue Research and Non-Commercial
+  License. Commercial use requires written authorization from BreezeBlue.
+
+## Supported features
+
+| Feature | Status | Notes |
+| ------- | ------ | ----- |
+| 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) |
+| Non-greedy sampling | ✗ | greedy decoding only |
+| Prefix caching | ✗ | disabled in the deploy config |
+| Tensor / pipeline parallelism | untested | single-GPU profile only |
+| Quantization | ✗ | not supported in this release |
+| CUDA graphs | not tuned | depth decoder and stage-1 codec run eagerly |
+| Platforms | CUDA | qualified on 1x NVIDIA L20 |
diff --git a/recipes/MammothModa2/MammothModa2.md b/recipes/MammothModa2/MammothModa2.md
index 6dc5f12e9..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,14 +48,59 @@ 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
 
+### Optional FP8 AR KV cache
+
+For CUDA deployments, `mammoth_moda2_fp8_kv.yaml` is an opt-in preset that
+stores the Stage 0 AR KV cache as FP8 E4M3. Stage 1 remains on
+`kv_cache_dtype=auto`; its DiT execution is unaffected. This setting quantizes
+only the autoregressive KV cache. It is neither FP8 weight/activation
+quantization nor vLLM-Omni diffusion KV-cache quantization.
+
+Use the preset in place of the default deploy config:
+
+```bash
+python examples/offline_inference/text_to_image/text_to_image.py \
+  --model ./MammothModa2-Preview \
+  --deploy-config vllm_omni/deploy/mammoth_moda2_fp8_kv.yaml \
+  --prompt "A stylish woman riding a motorcycle in NYC, movie poster style" \
+  --height 1024 \
+  --width 1024 \
+  --seed 42 \
+  --extra-body '{"text_guidance_scale": 4.0, "cfg_range": [0.0, 1.0], "num_inference_steps": 50}' \
+  --output mammoth_t2i.png
+```
+
+The preset was validated on one NVIDIA H800 80GB with CUDA and
+FlashAttention 3. The native and FP8 runs used the same model, code revision,
+and downstream configuration.
+
+| Metric | Native BF16 (`kv_cache_dtype=auto`) | FP8 E4M3 (`fp8_e4m3`) | Change |
+| --- | ---: | ---: | ---: |
+| KV cache memory | 15.59 GiB | 15.55 GiB | -0.04 GiB |
+| GPU KV cache size | 145,904 tokens | 291,232 tokens | +99.6% |
+| Maximum concurrency at 8,192 tokens | 17.81x | 35.55x | +99.6% |
+| Steady-state AR median | 71.191 s | 79.816 s | +12.1% |
+| Steady-state end-to-end median | 83.840 s | 92.473 s | +10.3% |
+| Steady-state DiT median | 12.574 s | 12.561 s | effectively unchanged |
+
+The FP8 run used `kv_cache_dtype=fp8_e4m3` only for Stage 0; Stage 1 used
+`kv_cache_dtype=auto`. The nearly unchanged reserved cache memory holds almost
+twice as many tokens because FP8 reduces the bytes per cached token. This is a
+capacity/concurrency tradeoff: the measured AR and end-to-end latencies were
+higher than the native-BF16 baseline.
+
+1024x1024 fixed-seed smoke test completed successfully with no obvious visual
+failure. FP8 is lossy, so numerical or image-quality equivalence with BF16 is
+not implied.
+
 ### 1x L40S 48GB
 
 > **48 GB config adjustment:** the committed
@@ -57,12 +109,13 @@ cache — see the note under *1x L40S 48GB*.
 > 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
 
@@ -75,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 \
@@ -85,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`:
@@ -132,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-Disaggregated.md b/recipes/MiniMaxAI/MiniMax-H3-Disaggregated.md
index 62f744ee5..54ea616af 100644
--- a/recipes/MiniMaxAI/MiniMax-H3-Disaggregated.md
+++ b/recipes/MiniMaxAI/MiniMax-H3-Disaggregated.md
@@ -1,9 +1,10 @@
-# MiniMax H3 disaggregated text encoder
+# MiniMax H3 disaggregated encoder stage
 
-This opt-in topology runs the Qwen3-VL text encoder as a vLLM stage and sends
-its hidden states and token-role metadata to an encoder-free diffusion stage.
-The standard MiniMax H3 recipes remain single-stage and continue to load the
-text encoder inside the diffusion pipeline.
+This opt-in topology runs the Qwen3-VL text encoder, video VAE encoder, and
+audio WVAE encoder together in a vLLM stage. It sends their conditioning
+payload to an encoder-free diffusion stage. The standard MiniMax H3 recipes
+remain single-stage and continue to run all components inside the diffusion
+pipeline.
 
 ## Start the server
 
@@ -23,6 +24,14 @@ deployment override for the available hardware. Diffusion quantization,
 layerwise offload, distributed layerwise offload, VAE parallelism, and USP
 settings use the same stage 1 options documented in [MiniMax-H3.md](MiniMax-H3.md).
 
+Stage 0's `tensor_parallel_size` defines one shared rank group for all three
+encoder roles; it does not choose each role's execution strategy. The required
+`hf_overrides.minimax_h3_encoder_components` mapping declares those strategies
+explicitly: `text_encoder` uses tensor parallelism, `video_vae` uses patch
+parallelism, and `audio_vae` runs on the group leader. All three role entries
+are mandatory. They share the stage's `max_num_seqs` scheduler and batch limit;
+the configuration does not create independent role schedulers or world sizes.
+
 For example, this five-GPU topology assigns one GPU to the encoder and four
 to the diffusion stage. `--stage-overrides` keeps placement and parallelism
 scoped to the owning stage rather than broadcasting an override to both:
@@ -57,8 +66,12 @@ The Stage 1 VAE patch-parallel options remain independent of offload and
 quantization. See [MiniMax-H3.md](MiniMax-H3.md) for memory requirements and
 hardware-qualified profiles before combining these options.
 
-Stage 1 sets `model_loaded.text_encoder: false`; it must not load or download
-text-encoder weights. This H3 topology explicitly keeps its single-replica
+Stage 1 sets `model_loaded.text_encoder: false` and
+`model_loaded.vae_encoder: false`. It loads only the VAE decoders and skips
+tokenizer, processor, and text-encoder downloads. It requires complete text and
+media conditioning from Stage 0, with no fallback to local encoding.
+
+This H3 topology explicitly keeps its single-replica
 diffusion stage inline, avoiding serialization of decoded video through a
 subprocess. It expects both stages to run in one deployment; cross-node payload
 transport is outside this configuration.
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 b4563c1f7..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,16 +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 quantization cannot be combined with distributed layerwise offload
-  while AllGather is enabled; pass `--dlo-no-use-allgather` in that case.
+- 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 812ed6f30..9eac85ece 100644
--- a/recipes/MiniMaxAI/MiniMax-H3.md
+++ b/recipes/MiniMaxAI/MiniMax-H3.md
@@ -23,6 +23,12 @@ One vLLM-Omni diffusion stage can load both DiTs while instantiating the
 tokenizer, processor, Qwen3-VL text encoder, video VAE, and audio VAE only
 once. Requests select the DiT with `extra_params.task`.
 
+This single-stage recipe uses the default `model_loaded.text_encoder: true` and
+`model_loaded.vae_encoder: true`. Precomputed text conditioning can replace the
+local Qwen call. Setting `model_loaded.text_encoder: false` while leaving
+`model_loaded.vae_encoder: true` requires precomputed text conditioning;
+reference media is still encoded locally.
+
 The generated MP4 contains H.264 video and synchronized stereo audio.
 
 ## Prerequisites
@@ -35,7 +41,7 @@ hf auth login
 export MODEL=MiniMaxAI/MiniMax-H3
 ```
 
-The vLLM-Omni pipeline downloads `FL2VA/**`, `Ref2VA/model_index.json`, and
+By default, the pipeline downloads `FL2VA/**`, `Ref2VA/model_index.json`, and
 `Ref2VA/transformer/**`. It does not download or load the diffusers-format
 `transformer`, `transformer_ref`, or `vae` weights at the repository root, nor
 duplicate Ref2VA copies of shared components.
@@ -819,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
@@ -830,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
@@ -1100,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 |
@@ -1230,25 +1444,21 @@ vllm serve "${MODEL_ROOT}/FL2VA" \
   mode does not support `cache_backend`.
 - The first regional-compile request is a warmup and should not be included in
   steady-state performance measurements.
-- The serving path accepts fewer references than the model supports. H3 documents up
-  to 9 images, 3 video clips, and 3 audio clips (12 files) per Omni Reference
-  request; the current vLLM-Omni path takes exactly one image plus one audio
-  reference, or one or more videos with no separate `audio_reference` (it uses the
-  source soundtracks).
+- Ref2VA accepts up to 9 images, 3 video clips, and 3 audio clips, with at most
+  12 references in total. At least one image or video is required; audio-only
+  requests are rejected.
 - The 768 px short-edge mode is available for T2VA and FL2VA; 1344x768 is the
   documented 16:9 request shape.
 - `--cfg-parallel-size > 1` is rejected by design (CFG-distilled, no negative branch).
 - VAE patch parallelism requires size 1 or the full DiT group size and supports the
   H3 native `tile` mode only.
-- A U2 x Ring2 hybrid currently fails with an attention-mask length mismatch; use
-  pure Ulysses.
+- Ulysses x Ring hybrid attention supports H3's single-request contiguous suffix
+  padding. Arbitrary attention masks and multi-request packed batches remain
+  unsupported on the Ring path.
 - Online FP8 with DLO AllGather temporarily materializes the complete FP8 model
   in host memory on every rank during startup before retaining only each rank's
   shard. Size startup host memory for that transient peak.
 - TeaCache and Cache-DiT cannot be enabled on the same server.
-- Image+audio Ref2VA accepts exactly one image and one audio reference.
-- Video Ref2VA accepts one or more video files, but not an additional standalone
-  audio reference.
 - Pure Ulysses still replicates the full DiT on every rank, so smaller-memory GPUs
   cannot use `--usp N --tp 1` as a resident capacity path. Use DiT tensor parallelism
   or model-level CPU offload; text-encoder TP alone is not sufficient.
diff --git a/recipes/OpenBMB/MiniCPM-o-4_5.md b/recipes/OpenBMB/MiniCPM-o-4_5.md
index fb0934d4f..01580843f 100644
--- a/recipes/OpenBMB/MiniCPM-o-4_5.md
+++ b/recipes/OpenBMB/MiniCPM-o-4_5.md
@@ -1,6 +1,6 @@
 # MiniCPM-o 4.5
 
-> Online serving and offline inference for omni multimodal chat
+> Online full-duplex and chat-completions serving, and offline inference, for omni multimodal chat
 > (text / image / audio / video → text + 24 kHz speech)
 
 ## Summary
@@ -9,8 +9,12 @@
 - Model: [`openbmb/MiniCPM-o-4_5`](https://huggingface.co/openbmb/MiniCPM-o-4_5)
 - Task: Omni multimodal chat — accepts text / image / audio / video input;
   emits text and 24 kHz mono speech in the same response
-- Mode: Online serving via the OpenAI-compatible `/v1/chat/completions`
-  API (plus Gradio demo), and offline inference via `Omni.generate`
+- Mode: Online full-duplex serving over the OpenAI Realtime protocol
+  (`/v1/realtime?duplex=1`, alias `/v1/duplex`), the OpenAI-compatible
+  `/v1/chat/completions` API (plus Gradio demo) on the same server, and
+  offline turn-based inference via `Omni.generate`. Besides those the server
+  exposes only `/v1/models` and `/health`; the other turn-based HTTP routes
+  are not available on a duplex deployment.
 - Maintainer: [`@tc-mb`](https://github.com/tc-mb) (MiniCPM-V / MiniCPM-o team)
 
 ## When to use this recipe
@@ -18,9 +22,10 @@
 Use this recipe as a known-good starting point for serving
 `openbmb/MiniCPM-o-4_5` on vLLM-Omni. MiniCPM-o 4.5 is the omni member
 of the MiniCPM-o family — it runs a multimodal thinker, a streaming
-MiniCPMTTS codec talker, and a separate batched Code2Wav stage so a single
-`/v1/chat/completions` call can return text and 24 kHz speech in one
-shot. The recommended batching deploy isolates the Thinker on GPU 0 and
+MiniCPMTTS codec talker, and a separate batched Code2Wav stage, so a live
+duplex session streams text and 24 kHz speech while it keeps listening, and a
+single `/v1/chat/completions` call returns both in one shot. The
+recommended batching deploy isolates the Thinker on GPU 0 and
 co-locates Talker and Code2Wav on GPU 1; 1-GPU, 3-GPU, and 8x4090 layouts are
 also provided.
 
@@ -36,8 +41,11 @@ also provided.
     [`vllm_omni/deploy/minicpmo_4_5_3gpu.yaml`](../../vllm_omni/deploy/minicpmo_4_5_3gpu.yaml)
     - 8x RTX 4090 layout:
     [`vllm_omni/deploy/minicpmo_4_5_8x4090.yaml`](../../vllm_omni/deploy/minicpmo_4_5_8x4090.yaml)
-- Online example + Gradio demo:
+- Online examples (Realtime CLI demo, browser client, barge-in client,
+  chat-completions client, curl script, Gradio demo):
   [`examples/online_serving/minicpmo/`](../../examples/online_serving/minicpmo/)
+- Duplex API and Python client docs:
+  [`docs/serving/realtime_duplex_api.md`](../../docs/serving/realtime_duplex_api.md)
 - Offline end-to-end example:
   [`examples/offline_inference/minicpmo/`](../../examples/offline_inference/minicpmo/)
 - Pipeline / talker source:
@@ -179,6 +187,13 @@ as one aggregated chunk, so the table reports Stage 0 metrics.
 
 #### Verification
 
+**Health and model listing**:
+
+```bash
+curl http://localhost:8099/health
+curl http://localhost:8099/v1/models
+```
+
 **Quick smoke test (text-only output)**:
 
 ```bash
@@ -191,8 +206,31 @@ curl http://localhost:8099/v1/chat/completions \
     }'
 ```
 
-**Text + speech in one response** (the headline 4.5 feature). The model
-bridge conditions the Talker from the generated assistant span, so the
+**One duplex turn over the Realtime WebSocket** (text + speech stream back
+while the session keeps listening):
+
+```bash
+python examples/online_serving/minicpmo/realtime_duplex_demo.py \
+    --url ws://localhost:8099/v1/realtime?duplex=1 \
+    --model openbmb/MiniCPM-o-4_5 \
+    --input-wav /path/to/input_16k_mono_pcm16.wav \
+    --ref-audio /path/to/MiniCPM-o-Demo/assets/ref_audio/ref_minicpm_signature.wav \
+    --output-dir /tmp/minicpmo_realtime_duplex_demo
+```
+
+The demo prints transcript deltas as they arrive and saves the streamed
+24 kHz audio to WAV files. The same session shape is available from Python
+through `vllm_omni.clients.duplex.DuplexClient` (over the server) or
+`vllm_omni.clients.inline_duplex.InlineDuplexClient` (in-process, no server;
+`examples/online_serving/barge_in_client.py --inline`).
+
+**Barge-in**: `examples/online_serving/barge_in_client.py` plays a question,
+interrupts the answer with a second WAV and checks that the first response is
+cancelled and the second one is answered.
+
+**Text + speech in one response over `/v1/chat/completions`** (the headline
+4.5 feature, served by the ordinary chat service on the duplex engine). The
+model bridge conditions the Talker from the generated assistant span, so the
 generic serving layer does not inject MiniCPM-specific template defaults.
 `use_tts_template=true` remains supported when explicitly requested:
 
@@ -243,6 +281,12 @@ python examples/online_serving/minicpmo/gradio_demo.py \
 Open `http://<host>:7862` and try a text prompt with the **"Generate
 speech output (TTS)"** checkbox on / off.
 
+**Turn-based generation** is also available offline
+(`examples/offline_inference/minicpmo/`, `Omni.generate`).
+
+The Daily-Omni numbers above were measured on the `/v1/chat/completions`
+route.
+
 #### Notes
 
 - Memory budget: Thinker, Talker, and Code2Wav reserve 0.55, 0.15, and
@@ -326,9 +370,13 @@ vllm serve openbmb/MiniCPM-o-4_5 --omni \
   and defaults to deterministic seed 42. Stage-1 deploy sampling parameters
   control only vLLM's binary continue/stop token.
 
-- **Output audio**: 24 kHz mono WAV inside the OpenAI-style
-  `message.audio.data` (base64). The Gradio demo's WAV player decodes
-  this automatically.
+- **Output audio**: 24 kHz mono. On `/v1/chat/completions` it is base64 WAV
+  inside the OpenAI-style `message.audio.data` (the Gradio demo's WAV player
+  decodes this automatically); on a duplex session it streams as base64
+  `response.audio.delta` events; offline `Omni.generate` returns WAV.
+- **Response choices**: on `/v1/chat/completions` text and audio are separate
+  choices. SDK clients should select the choice whose `message.audio.data` is
+  populated rather than assuming `choices[0]` contains audio.
 
 - **Routing**: MiniCPM-o 4.5 and 2.6 both ship `architectures=
   ["MiniCPMO"]` in HF config; routing is disambiguated by
@@ -340,6 +388,3 @@ vllm serve openbmb/MiniCPM-o-4_5 --omni \
 - **Async chunking**: enabled in all deploy configs. Talker sends
   25-code chunks with three-code left context to Code2Wav through
   `SharedMemoryConnector`; terminal chunks flush held lookahead state.
-- **Response choices**: text and audio are separate choices. SDK clients
-  should select the choice whose `message.audio.data` is populated rather
-  than assuming `choices[0]` contains audio.
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/OpenMOSS/MOSS-TTS-Nano-NPU.md b/recipes/OpenMOSS/MOSS-TTS-Nano-NPU.md
new file mode 100644
index 000000000..5d012fbb4
--- /dev/null
+++ b/recipes/OpenMOSS/MOSS-TTS-Nano-NPU.md
@@ -0,0 +1,128 @@
+# MOSS-TTS-Nano on Ascend NPU
+
+## Summary
+
+- Model: `OpenMOSS-Team/MOSS-TTS-Nano`
+- Task: multilingual text-to-speech with a reference voice
+- Hardware: one Ascend 910B3 64GB NPU
+- Output: 48 kHz mono audio
+- Serving API: OpenAI-compatible `/v1/audio/speech`
+
+MOSS-TTS-Nano combines a small autoregressive language model with
+`OpenMOSS-Team/MOSS-Audio-Tokenizer-Nano`. Both components run on the same
+NPU. The codec is a separate checkpoint and must be available even when the
+main model has already been downloaded.
+
+## Environment
+
+Use an aligned vLLM, vLLM-Ascend, and vLLM-Omni environment. The following
+configuration was validated:
+
+- Image: `quay.nju.edu.cn/ascend/vllm-omni:v0.28.0`
+- Ascend device: 910B3 64GB
+- CANN: 9.1.0
+- vLLM: 0.28.0
+- Execution mode: eager
+
+See the [NPU installation guide](../../docs/getting_started/installation/npu.md)
+for the complete container device and driver mounts.
+
+## Download checkpoints
+
+```bash
+export HF_HOME=/models/huggingface-cache
+
+hf download OpenMOSS-Team/MOSS-TTS-Nano
+
+# This dependency is loaded from its model ID by the MOSS-TTS-Nano config.
+hf download OpenMOSS-Team/MOSS-Audio-Tokenizer-Nano
+```
+
+For an air-gapped server, populate `HF_HOME` with the audio-tokenizer snapshot
+before startup and set `HF_HUB_OFFLINE=1`. Do not omit the audio tokenizer:
+the main model directory does not contain its weights.
+
+## Start the server
+
+Expose one physical NPU and keep the stage's logical device as `0`:
+
+```bash
+export ASCEND_RT_VISIBLE_DEVICES=0
+export HF_HOME=/models/huggingface-cache
+
+vllm serve OpenMOSS-Team/MOSS-TTS-Nano \
+    --omni \
+    --trust-remote-code \
+    --host 0.0.0.0 \
+    --port 8091
+```
+
+`--trust-remote-code` is required because both checkpoints provide custom
+Transformers model implementations. The bundled `moss_tts_nano.yaml` deploy
+configuration enables eager execution; ACL graph capture is not used for this
+model path.
+
+## Voice-cloning request
+
+`ref_audio` accepts an HTTP URL or a base64 data URL. A non-streaming request
+returns a WAV file:
+
+```bash
+curl http://localhost:8091/v1/audio/speech \
+    -H "Content-Type: application/json" \
+    -d '{
+        "model": "OpenMOSS-Team/MOSS-TTS-Nano",
+        "input": "Hello, this is a voice cloning test on Ascend NPU.",
+        "stream": false,
+        "response_format": "wav",
+        "ref_audio": "https://example.com/reference.wav"
+    }' \
+    --output output.wav
+```
+
+Streaming raw PCM uses the same endpoint:
+
+```bash
+curl http://localhost:8091/v1/audio/speech \
+    -H "Content-Type: application/json" \
+    -d '{
+        "model": "OpenMOSS-Team/MOSS-TTS-Nano",
+        "input": "你好，这是一段流式语音合成测试。",
+        "stream": true,
+        "stream_format": "audio",
+        "response_format": "pcm",
+        "ref_audio": "https://example.com/reference.wav"
+    }' \
+    --output output.pcm
+```
+
+Raw PCM output is signed 16-bit little-endian mono at 48 kHz.
+
+## Validation
+
+The Ascend 910B3 validation covered:
+
+- English non-streaming WAV output;
+- Chinese streaming PCM output;
+- repeat generation with the same seed producing byte-identical WAV files;
+- two concurrent non-streaming requests;
+- waveform checks for a non-empty, finite, non-silent signal at 48 kHz.
+
+The first request includes one-time NPU kernel warmup. In the validated setup,
+the first non-streaming request took about 22.7 seconds, a repeated request
+took about 7.5 seconds, and streaming produced its first audio chunk in about
+0.38 seconds. These figures are functional reference measurements, not a
+performance guarantee.
+
+## Current limitations
+
+- The model runs in eager mode; ACL graph mode has not been enabled.
+- Concurrent HTTP requests are accepted but generated serially. Do not raise
+  the stage's `max_num_seqs` above `1`: the remote model and audio tokenizer
+  share RNG and streaming decode state, and interleaved generation can corrupt
+  audio.
+- The remote model's CUDA-only `flash_attention_2` path is replaced with
+  PyTorch SDPA on Ascend.
+- The current non-CUDA model wrapper loads the language model and audio codec
+  in float32. Quantized checkpoints have not been validated.
+- A reference audio clip is required for `voice_clone` mode.
diff --git a/recipes/README.md b/recipes/README.md
index ea4576201..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
@@ -45,13 +47,16 @@ recipes/
 | [`black-forest-labs/FLUX.1-schnell.md`](./black-forest-labs/FLUX.1-schnell.md) | Offline text-to-image generation with CPU offload | 1x NVIDIA GeForce RTX 5090 32GB |
 | [`Boogu/Boogu-Image.md`](./Boogu/Boogu-Image.md) | Text-to-image online serving (Boogu-Image-0.1-Base) | 1x A100/H100 40GB+ |
 | [`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 |
@@ -70,9 +75,10 @@ recipes/
 | [`cosmos3/Cosmos3-Nano.md`](./cosmos3/Cosmos3-Nano.md) | Text-to-image, text-to-video, image-to-video, video-to-video generation, text to video with sound, action policy | 1x H200 141GB / B300 |
 | [`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 serving 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/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 / 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 |
 | [`NVIDIA/NemotronLabs-VoiceChat.md`](./NVIDIA/NemotronLabs-VoiceChat.md) | Offline speech-to-speech voice chat (11B, frame-locked 12.5 Hz, 3-stage thinker/talker/code2wav) | 1x H100 80GB |
 | [`NVIDIA/SANA-WM.md`](./NVIDIA/SANA-WM.md) | First-frame image-to-video serving with camera control | 1x 24GB+ CUDA GPU; ~40GB disk |
@@ -84,6 +90,7 @@ recipes/
 | [`SenseNova/SenseNova-U1.md`](./SenseNova/SenseNova-U1.md) | Unified image generation and understanding | 1x or 2x H200 / 1x AMD MI300X |
 | [`SenseNova/SenseNova-U1.5.md`](./SenseNova/SenseNova-U1.5.md) | Unified image generation and understanding, with an 8-step distilled LoRA | 1x A800 80GB |
 | [`StabilityAI/Stable-Audio-Open.md`](./StabilityAI/Stable-Audio-Open.md) | Offline + online text-to-audio generation (Stable Audio Open) | 1x RTX 4090 24GB / 1x AMD MI300X |
+| [`Tencent/AuK-H100.md`](./Tencent/AuK-H100.md) | Offline instruction-driven TTS, speech editing, enhancement and separation (AuK base and Flash) | 1x H100 80GB |
 | [`Tencent/Covo-Audio-Chat.md`](./Tencent/Covo-Audio-Chat.md) | Online serving for audio chat | 1x A100 80GB |
 | [`Tencent/HunyuanImage-3.0-Instruct.md`](./Tencent/HunyuanImage-3.0-Instruct.md) | DiT-only text-to-image serving and benchmark, including ModelOpt mixed FP8/NVFP4 | 4x H100/H800 80GB / 2x B200 |
 | [`Wan-AI/Wan2.2-T2V.md`](./Wan-AI/Wan2.2-T2V.md) | Text-to-video serving (Wan2.2 14B) with Skip-Softmax sparse attention | 1x datacenter Blackwell (B200/B300) |
diff --git a/recipes/Robbyant/LingBot-World-2.0.md b/recipes/Robbyant/LingBot-World-2.0.md
index c38e24fd2..24a36653d 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.
@@ -48,16 +47,18 @@ python examples/offline_inference/diffusion/lingbot_world_v2.py \
 ```
 
 The current causal-fast checkpoint uses four DMD sampling steps. Raw frame
-counts must be `9 + 12k`, up to 117 frames. Camera files may contain a
-longer bounded source trajectory (the official example contains 269 frames);
-the runtime consumes only the prefix needed by the request.
+counts must be `9 + 12k` for a non-negative integer `k`; for example, 129 frames
+produce eleven AR blocks. Both camera files must contain the same number of
+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.
 
 ## 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
@@ -94,8 +95,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:
@@ -113,11 +114,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",
@@ -132,7 +133,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 \
@@ -140,23 +160,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.
 
@@ -197,8 +215,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/Tencent/AuK-H100.md b/recipes/Tencent/AuK-H100.md
new file mode 100644
index 000000000..5acd01cb0
--- /dev/null
+++ b/recipes/Tencent/AuK-H100.md
@@ -0,0 +1,167 @@
+# AuK speech generation and editing — H100
+
+> Instruction-driven zero-shot TTS, instruct TTS, speech editing, enhancement
+> and separation with Tencent's AuK, served as a two-stage vLLM-Omni pipeline
+> (Qwen2.5-Omni thinker encoder, then a rectified-flow DiT with a BigVGAN-flow
+> VAE) on one H100.
+
+## Summary
+
+- Vendor: Tencent Hunyuan
+- Model: `tencent/AuK` (32-step base) and `tencent/AuK-Flash` (distilled 4-step),
+  both with `Qwen/Qwen2.5-Omni-3B` as the frozen encoder
+- Task: zero-shot TTS, instruct TTS, content and acoustic editing,
+  paralinguistic editing, speech enhancement, speaker and music separation
+- Mode: offline inference (online chat serving is not yet qualified)
+- Hardware: 1x H100 80GB
+- Maintainer: Community
+
+## When to use this recipe
+
+Use this recipe to run AuK through vLLM-Omni for any of its instruction-driven
+tasks with a single shared request shape: an instruction, an optional source or
+reference clip, and a target duration. The task is chosen by the instruction
+text, exactly as in the upstream repository's cookbook.
+
+## Supported model contract
+
+| Task family | Instruction | Audio input | Duration |
+| --- | --- | --- | --- |
+| Zero-shot TTS | "Say the following with the same voice: '...'" | reference clip | `gen_seconds` required |
+| Instruct TTS | `Generate speech based on the following description: "{voice description}". The content to speak is: "{text}".` (upstream template; other orderings can make the model speak the description) | none | `gen_seconds` required |
+| Content / lyric editing | "Replace '...' with '...'" and similar | source clip | defaults to the source length |
+| Acoustic / paralinguistic editing | pitch, speed, volume, emotion, timbre, de-accent, nonverbal, whisper | source clip | defaults to the source length (speed edits scale it) |
+| Enhancement / separation | "Keep pure speech voice, remove noise and reverberation." and similar | source clip | defaults to the source length |
+
+| Property | Value |
+| --- | --- |
+| Input audio | mono or stereo (averaged), any sample rate (resampled to 24 kHz for the VAE and to 16 kHz for the encoder), one clip per request |
+| Output | mono float32 waveform at 24 kHz, `ceil(gen_seconds * 50)` latent frames |
+| Sequence limit | reference plus target latents up to 65536 frames (about 21 minutes) |
+| Sampling knobs | `num_inference_steps` (default 32), `guidance_scale` (default 2.0), `seed`; Flash pins 4 steps, CFG 0 and its own time grid |
+| Request knobs | `gen_seconds`, `sway` (default -1.0), `t_grid`, `vae_sample` via `additional_information["auk"]` |
+| Concurrency | one request per DiT forward; the encoder stage runs with `max_num_seqs: 1`, prefix caching and chunked prefill off |
+| Streaming | none: the ODE runs over the whole target |
+
+## References
+
+- Upstream repository and cookbook: <https://github.com/Tencent-Hunyuan/AuK>
+- Technical report: <https://arxiv.org/abs/2609.08936>
+- Weights: <https://huggingface.co/tencent/AuK>, <https://huggingface.co/tencent/AuK-Flash>,
+  <https://huggingface.co/Qwen/Qwen2.5-Omni-3B>
+- Pipeline topology: `vllm_omni/model_executor/models/auk/pipeline.py`;
+  deploy defaults: `vllm_omni/deploy/auk.yaml`
+- Request helpers: `vllm_omni/model_extras/auk.py`
+- Test: `tests/e2e/offline_inference/test_auk.py`
+
+## Hardware
+
+- Accelerator model and per-device memory: NVIDIA H100 80GB
+- Number of devices: 1 (both stages share the device)
+- Device interconnect: not applicable
+- Host memory: 64 GB is ample; the assembled directory is symlinks only
+- Qualification scope: offline `Omni` inference for the four cookbook tasks
+  below, base and Flash checkpoints, seed-reproducible, four concurrent
+  requests bit-identical to sequential runs
+
+## Software environment
+
+- OS: Linux
+- Python: 3.12
+- Driver / runtime: CUDA 13 driver with the vLLM 0.29.0 wheel (torch 2.13)
+- vLLM version: 0.29.0
+- vLLM-Omni version or commit: branch `auk-support` on top of `aff7d6494`
+
+## Command
+
+Assemble the checkpoint directory once (symlinks by default):
+
+```bash
+hf download tencent/AuK --local-dir ckpts/AuK
+hf download Qwen/Qwen2.5-Omni-3B --local-dir ckpts/Qwen2.5-Omni-3B
+python tools/prepare_auk_checkpoint.py --auk-dir ckpts/AuK --qwen-dir ckpts/Qwen2.5-Omni-3B --out ckpts/auk-omni
+# For AuK-Flash: --auk-dir ckpts/AuK-Flash --out ckpts/auk-omni-flash
+```
+
+Offline inference (any task; the instruction selects it):
+
+```python
+import soundfile as sf
+from vllm.multimodal.media.audio import load_audio
+
+from vllm_omni.entrypoints.omni import Omni
+from vllm_omni.model_extras.auk import auk_prompt, auk_sampling_params
+
+omni = Omni(model="ckpts/auk-omni")  # loads vllm_omni/deploy/auk.yaml
+wav, sr = load_audio("ref.wav", sr=None)
+prompt = auk_prompt(
+    "Say the following with the same voice: 'Ladies and gentlemen, welcome.'",
+    (wav, sr),
+    gen_seconds=4.0,
+)
+out = omni.generate(prompt, auk_sampling_params(nfe=32, cfg=2.0, seed=0))[0]
+sf.write("out.wav", out.multimodal_output["audio"], out.multimodal_output["audio_sample_rate"])
+```
+
+Text-only instruct TTS passes `None` for the audio and must set `gen_seconds`.
+Editing and enhancement requests pass the source clip and may omit
+`gen_seconds` to keep the source length.
+
+## Verification
+
+```bash
+VLLM_OMNI_AUK_MODEL_DIR=ckpts/auk-omni python -m pytest tests/e2e/offline_inference/test_auk.py -q
+```
+
+The parity suites compare the port against the upstream implementation and
+need reference artifacts produced by the upstream package (install it with
+`pip install -e /path/to/AuK` in its own environment; it pins its own torch):
+
+```bash
+python tools/auk_parity_reference.py --auk-repo /path/to/AuK --ckpt-dir ckpts/AuK \
+    --qwen-dir ckpts/Qwen2.5-Omni-3B --out auk-parity
+AUK_CKPT_DIR=ckpts/AuK AUK_REF_WAV=/path/to/AuK/assets/demo-input-audio/zero-shot-tts/ref.wav \
+    python -m pytest tests/diffusion/models/auk/test_auk_transformer_parity.py tests/diffusion/models/auk/test_auk_vae_parity.py -q
+AUK_OMNI_CKPT_DIR=ckpts/auk-omni AUK_PARITY_REF=auk-parity/parity_ref/base \
+    python -m pytest tests/diffusion/models/auk/test_pipeline_auk.py -q
+```
+
+Measured on one H100 against the upstream implementation with the same seeds
+and mean VAE latents (four cookbook cases, base checkpoint): identical
+transcripts, speaker similarity to the upstream output 0.993 to 0.999, log-mel
+L1 0.11 to 0.47 (the upstream VAE-resampling noise floor is 0.39). Flash:
+0.989 to 0.999 and 0.24 to 0.51. Wall per request on the second call: base
+1.0 to 2.0 s for 3.5 to 10.9 s of audio, Flash 0.17 to 0.30 s; engine start
+about 47 s with a warm page cache.
+
+## Notes
+
+- Memory usage: about 25 GB peak on the device for a 12 s generation with
+  both stages resident (deploy defaults: encoder 0.45, diffusion stage 0.35
+  of device memory).
+- Key flags: `enforce_eager` on both stages (the encoder walks the decoder
+  layers itself for the layer fusion). `enable_prefix_caching` must stay off
+  for the encoder: a cache hit skips prompt positions that the fused
+  condition needs. `enable_chunked_prefill` is off by default: forcing it
+  (128-token chunks, so two to three chunks per prompt) reproduces the
+  unchunked condition to bf16 rounding (per-token cosine 0.99999) and leaves
+  request walls unchanged, because the encoder is about 3% of a base request,
+  while concurrent runs stop being bit-identical to sequential ones.
+- Known limitations: the encoder's audio tower runs without `flash_attn` in a
+  plain vLLM install, which shifts the encoder output on audio token positions
+  (per-token cosine 0.96 vs the upstream fp32 fusion; text positions 0.9999)
+  with waveform-level effects at the VAE noise floor; installing `flash-attn`
+  removes the gap. No streaming. Digits are read the way upstream reads them
+  (spell numbers out in the text). Instruct TTS without a reference can leak
+  the description into the speech, as upstream does.
+
+## Supported features
+
+| Feature | Status | Guide |
+| --- | --- | --- |
+| Offline `Omni.generate` | supported (base and Flash) | `docs/getting_started/quickstart.md` |
+| Online `/v1/chat/completions` with audio | not yet qualified | `docs/serving/` |
+| `/v1/audio/speech` | not supported (needs a TTS adapter) | `docs/contributing/model/adding_tts_model.md` |
+| Streaming / async chunk | not supported | `docs/design/feature/async_chunk.md` |
+| Batching across requests | one request per DiT forward | `docs/user_guide/diffusion/` |
+| Tensor / sequence parallelism | not supported | `docs/configuration/composable_parallel.md` |
diff --git a/recipes/Tencent/HunyuanImage-3.0-Instruct.md b/recipes/Tencent/HunyuanImage-3.0-Instruct.md
index 4614df382..eb5ccedf6 100644
--- a/recipes/Tencent/HunyuanImage-3.0-Instruct.md
+++ b/recipes/Tencent/HunyuanImage-3.0-Instruct.md
@@ -8,7 +8,7 @@
 
 - Vendor: Tencent Hunyuan
 - Model: `tencent/HunyuanImage-3.0-Instruct`
-- Task: Text-to-image generation; text-to-text and image-to-text understanding
+- Task: Text-to-image generation, image editing; text-to-text and image-to-text understanding
 - Mode: Offline understanding, online serving, and performance benchmarking
 - Maintainer: Community
 
@@ -31,8 +31,10 @@ FP8/NVFP4 configuration:
 ## References
 
 - Model: <https://huggingface.co/tencent/HunyuanImage-3.0-Instruct>
-- Existing model-specific offline example:
-  [`examples/offline_inference/hunyuan_image3`](../../examples/offline_inference/hunyuan_image3)
+- Shared T2I example:
+  [`examples/offline_inference/text_to_image/text_to_image.py`](../../examples/offline_inference/text_to_image/text_to_image.py)
+- Shared IT2I example:
+  [`examples/offline_inference/image_to_image/image_edit.py`](../../examples/offline_inference/image_to_image/image_edit.py)
 - Shared T2T/I2T example:
   [`examples/offline_inference/x_to_text/x_to_text.py`](../../examples/offline_inference/x_to_text/x_to_text.py)
 - Related PRs:
@@ -66,8 +68,48 @@ python examples/offline_inference/x_to_text/x_to_text.py \
 ```
 
 The AR-only default uses four GPUs. Pass `--deploy-config` to override the
-layout. Image-output tasks remain documented by the existing model-specific
-example and the DiT sections below.
+layout.
+
+### Shared T2I/IT2I offline examples
+
+Text-to-image and image-editing route through the shared task examples, with
+all HunyuanImage-3.0-specific knobs (`bot_task`, `use_system_prompt`,
+`system_prompt`, `negative_prompt`) declared in
+`vllm_omni/model_extras/hunyuan_image3.py` and passed via `--extra-body` /
+`--extra-args`:
+
+```bash
+python examples/offline_inference/text_to_image/text_to_image.py \
+  --model tencent/HunyuanImage-3.0-Instruct \
+  --deploy-config vllm_omni/deploy/hunyuan_image_3_moe.yaml \
+  --trust-remote-code \
+  --prompt "A cute cat sitting on a windowsill watching the sunset" \
+  --height 1024 --width 1024 \
+  --guidance-scale 5.0 --num-inference-steps 50 --seed 42 \
+  --extra-body '{"bot_task": "think", "use_system_prompt": "en_recaption"}' \
+  --output hunyuan_t2i.png
+```
+
+```bash
+python examples/offline_inference/image_to_image/image_edit.py \
+  --model tencent/HunyuanImage-3.0-Instruct \
+  --deploy-config vllm_omni/deploy/hunyuan_image_3_moe.yaml \
+  --trust-remote-code \
+  --image /path/to/image.png \
+  --prompt "Make the petals neon pink" \
+  --guidance-scale 5.0 --num-inference-steps 50 --seed 42 \
+  --extra-args '{"bot_task": "think"}' \
+  --output hunyuan_edit.png
+```
+
+`image_edit.py` accepts up to 3 reference images (repeat `--image`) for
+HunyuanImage-3.0's multi-image fusion. All four shared-script paths (t2i,
+it2i, i2t, t2t) build the AR prefill and stop tokens through the same
+declarative seam (`build_ar_stage_inputs` / `build_x_to_text_prompt`, both
+wrapping `prompt_utils.build_ar_prompt_inputs`), so prompt formatting is
+identical across them. The OpenAI server's `serving_chat.py` does not go
+through this seam yet -- see that function's docstring for the resulting
+`bot_task`-resolution divergence risk when omitted from `extra_body`.
 
 ### 4x H100/H800 80GB
 
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/cosmos3/Cosmos3-Nano.md b/recipes/cosmos3/Cosmos3-Nano.md
index 490f5b1f4..29088e94c 100644
--- a/recipes/cosmos3/Cosmos3-Nano.md
+++ b/recipes/cosmos3/Cosmos3-Nano.md
@@ -32,13 +32,13 @@ mode is selected per request:
   T2V/I2V `/v1/videos/sync` request to also generate synchronized audio, muxed into
   the mp4 as AAC 48 kHz stereo. See the official model card's "Video + Audio" examples.
 - **Action** — pass `extra_params={"action_mode": ...}` to drive Physical-AI tasks:
-  - `forward_dynamics` — given a first frame or video **and** an action trajectory,
+    - `forward_dynamics` — given a first frame or video **and** an action trajectory,
     roll out the resulting video. Synchronous: `POST /v1/videos/sync`.
-  - `policy` — given a first frame or video and a language instruction,
+    - `policy` — given a first frame or video and a language instruction,
     **predict** the action trajectory (and a rollout video). Use the async
     `POST /v1/videos` endpoint and read the predicted action from the top-level
     `action` field.
-  - `inverse_dynamics` — given a video, **recover** the action trajectory. Use
+    - `inverse_dynamics` — given a video, **recover** the action trajectory. Use
     the async `POST /v1/videos` endpoint and read the recovered action from
     the top-level `action` field
     (`{data, shape, dtype, raw_action_dim, domain_id}`).
@@ -50,9 +50,10 @@ mode is selected per request:
   **`nvidia/Cosmos3-Nano-Policy-DROID`** is served the same way
   (`domain_name=droid_lerobot`).
 
-- **DROID OpenPI policy server** — serve `nvidia/Cosmos3-Nano-Policy-DROID` and
-  connect an OpenPI-compatible websocket client to `/v1/realtime/robot/openpi`.
-  This path returns action chunks directly instead of an mp4.
+- **DROID policy server** — serve `nvidia/Cosmos3-Nano-Policy-DROID` and connect
+  RoboLab or another OpenPI-compatible client to
+  `/v1/realtime/robot/openpi`. This endpoint returns action chunks directly
+  instead of an mp4.
 
   Action requests can use `input_reference` or `video_reference` for video input.
   `policy` and `forward_dynamics` can also use an image reference; `inverse_dynamics`
@@ -105,6 +106,25 @@ vllm serve nvidia/Cosmos3-Nano \
   --init-timeout 1800
 ```
 
+For Cosmos3, SeaCache is the recommended default choice when opting into
+diffusion caching. Caching remains opt-in; add `--cache-backend sea_cache` to
+the command above. Its default threshold and maximum cached-step streak are
+tuned for Cosmos3, so no `--cache-config` is required.
+
+Override individual defaults with a JSON cache configuration; for example:
+
+```bash
+vllm serve nvidia/Cosmos3-Nano \
+  --omni \
+  --cache-backend sea_cache \
+  --cache-config '{"sea_threshold":0.2,"sea_max_consecutive_cached":3}'
+```
+
+Lower `sea_threshold` values and smaller `sea_max_consecutive_cached` caps are
+more conservative. Higher values allow more cached steps and may improve
+speed, but can increase quality loss. Setting `sea_max_consecutive_cached` to
+`0` removes the streak cap.
+
 To run **without** guardrails (you are responsible for license compliance),
 add `--no-guardrails` (no token/`cosmos-guardrail` needed). For extra GPUs use
 `--ulysses-degree N` (context parallel) or `--tensor-parallel-size N`;
@@ -115,6 +135,38 @@ shift at the same seed). The pipeline
 auto-resolves from `model_index.json`; pass
 `--model-class-name Cosmos3OmniDiffusersPipeline` to force it explicitly.
 
+For a serialized ModelOpt FP8 or NVFP4 checkpoint, an experimental
+mixed-precision schedule can use native W8A8/W4A4 in middle denoising steps
+and dense W8A16/W4A16 in the first and last steps:
+
+```bash
+vllm serve /path/to/Cosmos3-Nano-modelopt \
+  --omni \
+  --additional-config \
+  '{"cosmos3_mixed_precision":{"first_steps":3,"last_steps":3,"reasoner":"a16"}}'
+```
+
+The nested object's presence supplies an explicit runtime override; use an
+empty object for these defaults. A compatible checkpoint can instead declare
+the versioned `runtime.diffusion_step_policy` in its authoritative
+`transformer/config.json`. The checkpoint policy is used only when no runtime
+override is present. Use
+`--additional-config '{"cosmos3_mixed_precision":{"enabled":false}}'` to
+disable the checkpoint schedule without disabling checkpoint quantization.
+This path currently requires tensor parallel size 1 and does not support HSDP
+or block-scaled FP8. It keeps one live quantized weight representation:
+scheduled FP8 requires serialized tensorwise scales and a canonical backend,
+while scheduled NVFP4 requires a supported CUTLASS-compatible native or
+FlashInfer layout. Its dequantization is a correctness baseline; no speedup is
+implied. Quantized reasoner weights use A16 by default; set
+`"reasoner":"native"` in the nested object to keep W8A8/W4A4.
+The checkpoint's ModelOpt configuration selects FP8 or NVFP4; mixed FP8/NVFP4
+checkpoints are not supported by this schedule. BF16 linears are left unchanged.
+The schedule currently supports one active request per worker. Model-level and
+layer-wise offload are designed to work with this live-weight path but still
+require GPU validation. Distributed layer-wise offload and incompatible native
+weight layouts fail during loading.
+
 #### Verification
 
 Best quality uses the JSON-upsampled prompts from `assets/` (download with
@@ -282,48 +334,79 @@ VIDEO_ID=$(curl -sS -X POST http://localhost:8000/v1/videos \
 curl -sS "http://localhost:8000/v1/videos/$VIDEO_ID" | jq '.action | {shape, dtype, raw_action_dim, domain_id}'
 curl -sS -L "http://localhost:8000/v1/videos/$VIDEO_ID/content" -o cosmos3_inverse_dynamics.mp4
 
-# DROID OpenPI policy server (websocket action serving).
-# Requires cosmos_framework on PYTHONPATH because the pipeline reuses the
-# reference RoboLab action transforms. If your checkpoint config already
-# includes policy_server_config, omit the stage_overrides file and flag.
-cat > cosmos3_droid_openpi_stage_overrides.json <<'JSON'
-{
-  "0": {
-    "model_config": {
-      "policy_server_config": {
-        "image_resolution": [540, 640],
-        "n_external_cameras": 2,
-        "needs_wrist_camera": true,
-        "needs_stereo_camera": false,
-        "needs_session_id": true,
-        "action_space": "joint_position"
-      }
-    }
-  }
-}
-JSON
+# DROID websocket policy server. Use the tested cosmos-framework revision
+# directly from source; installing the package can introduce dependency conflicts.
+export COSMOS_FRAMEWORK_ROOT=/path/to/cosmos-framework
+git -C "$COSMOS_FRAMEWORK_ROOT" checkout c14617c2bc93dacbf69674fb964eec93182933d9
+export PYTHONPATH="$COSMOS_FRAMEWORK_ROOT"
 
+# Validate every cosmos-framework symbol used by the action-policy pipeline
+# before allocating the model.
+python - <<'PY'
+from vllm_omni.diffusion.models.cosmos3.utils import (
+    get_robolab_domain_id,
+    preflight_cosmos3_action_framework_imports,
+)
+
+preflight_cosmos3_action_framework_imports()
+print("cosmos-framework action imports OK; DROID domain:", get_robolab_domain_id("droid_lerobot"))
+PY
+
+# The bundled deploy config (vllm_omni/deploy/cosmos3_policy_droid.yaml)
+# selects the registered cosmos3_policy pipeline and carries the DROID
+# checkpoint's serving defaults: JSON prompt formatting (a property of this
+# checkpoint's training recipe, not a generic server default), the
+# model-specific OpenPI binary handshake metadata (policy_server_config), and
+# guardrails off (policy serving emits robot actions; the guardrail stack is
+# not part of it, so --no-guardrails is implied).
+# Policy checkpoints cannot be auto-detected — they share their HF metadata
+# with the T2I/video Cosmos3 checkpoints — so --deploy-config is required.
+# Per-checkpoint model_config tweaks can be layered on top with
+# --stage-overrides; dict overrides deep-merge with the deploy yaml.
+export VLLM_OMNI_ROOT=/absolute/path/to/vllm-omni
 vllm serve nvidia/Cosmos3-Nano-Policy-DROID \
   --omni \
   --host 0.0.0.0 --port 8000 \
-  --model-class-name Cosmos3OmniDiffusersPipeline \
-  --no-guardrails \
-  --stage-overrides "$(cat cosmos3_droid_openpi_stage_overrides.json)"
+  --deploy-config "$VLLM_OMNI_ROOT/vllm_omni/deploy/cosmos3_policy_droid.yaml" \
+  --robot-openpi-idle-timeout 0
 
-# Point an OpenPI websocket client at:
-#   ws://localhost:8000/v1/realtime/robot/openpi
-# The first server message is policy_server_config. Each infer request sends a
-# msgpack-numpy observation dict and receives a writable float32 action array.
+# From a RoboLab checkout:
+python policies/cosmos3/run.py \
+  --remote-uri ws://localhost:8000/v1/realtime/robot/openpi \
+  --task BananaInBowlTask
+
+# For a server started with "--api-key $POLICY_API_KEY", pass the same value as
+# a Bearer token. --remote-token takes precedence over COSMOS3_API_TOKEN.
+COSMOS3_API_TOKEN="$POLICY_API_KEY" python policies/cosmos3/run.py \
+  --remote-uri wss://policy.example/v1/realtime/robot/openpi \
+  --task BananaInBowlTask
 ```
 
+The endpoint sends `policy_server_config` as its initial binary MsgPack
+message and returns the action array directly. RoboLab accepts that direct
+array as well as proxy responses shaped as `{"action": ...}` or
+`{"actions": ...}`, and turns structured server errors into client exceptions.
+
+RoboLab supplies `session_id=robolab-episode-<episode>-env-<env_id>`, so
+parallel environments have independent policy state even though they share
+one WebSocket. The server tracks interleaved session IDs independently.
+The default receive-idle timeout is 30 seconds; set
+`--robot-openpi-idle-timeout 0` when simulator steps between replans can take
+longer, or set another non-negative timeout in seconds.
+
+If vLLM-Omni is started with `--api-key` or `VLLM_API_KEY`, the standard
+OpenPI route uses the normal API authentication middleware. RoboLab's
+`--remote-token` and `COSMOS3_API_TOKEN` send the required
+`Authorization: Bearer ...` header.
+
 #### Notes
 
-- **Measured latency (1x B300, bf16, guardrails off):**
-  - T2I 1024² — 10 / 25 / 50 steps → ~0.4 / 0.7 / **1.3 s**
-  - T2V 1280×720 @ 35 steps — 25 / 49 / 93 / **189** frames → ~7 / 15 / 33 / **~93 s**
-  - I2V 1280×720, 189 frames @ 35 steps → ~**99 s**
-  - Action 640×480 @ 30 steps — forward-dynamics 61f ~**4 s**, policy 17f ~**1–3 s**.
-  - Guardrails-on overhead: ~8% on T2I, negligible on video.
+- **Measured latency (1x B300, bf16, guardrails off, diffusion cache off):**
+    - T2I 1024² — 10 / 25 / 50 steps → ~0.4 / 0.7 / **1.3 s**
+    - T2V 1280×720 @ 35 steps — 25 / 49 / 93 / **189** frames → ~7 / 15 / 33 / **~93 s**
+    - I2V 1280×720, 189 frames @ 35 steps → ~**99 s**
+    - Action 640×480 @ 30 steps — forward-dynamics 61f ~**4 s**, policy 17f ~**1–3 s**.
+    - Guardrails-on overhead: ~8% on T2I, negligible on video.
 - **Memory:** transformer ~17 GiB (bf16); peak ~46 GiB for 720p video on 1 GPU;
   full repo (transformer + Wan VAE + Qwen3-VL vision encoder + audio tokenizer)
   ~33 GB on disk.
@@ -379,12 +462,12 @@ vllm serve nvidia/Cosmos3-Nano-Policy-DROID \
   `conditioning_fps`, `action_chunk_size`, `raw_action_dim`, `deterministic_seed`,
   and `session_id`.
 - **Known limitations:**
-  - Guardrails-on requires `cosmos-guardrail` **and** access to the gated
+    - Guardrails-on requires `cosmos-guardrail` **and** access to the gated
     `nvidia/Cosmos-1.0-Guardrail` repo (accept license + `HF_TOKEN`); otherwise
     the server fails at pipeline build with a gated-repo / safety-checker error.
-  - A guardrail-blocked prompt currently returns HTTP 500
+    - A guardrail-blocked prompt currently returns HTTP 500
     (`"Guardrail blocked prompt"`).
-  - Action `forward_dynamics`, `policy`, and `inverse_dynamics` are supported
+    - Action `forward_dynamics`, `policy`, and `inverse_dynamics` are supported
     online. Use async `POST /v1/videos` when you need the predicted/recovered
     action payload under the top-level `action` field; sync `/v1/videos/sync`
     returns raw MP4 bytes and does not expose action metadata in the response body.
@@ -515,14 +598,14 @@ so an md5 comparison across two runs also works as a smoke check.
   a ~390 s build of the VAE decode path *for that shape*, so warming 1024² images
   does nothing for 189-frame video. At 720p / 189 frames / 35 steps this is
   **540 s cold vs 161 s warm, with byte-identical output**.
-- **Measured on 1x MI350X (bf16, guardrails off, warm):** T2I 1024² @ 50 steps
+- **Measured on 1x MI350X (bf16, guardrails off, diffusion cache off, warm):** T2I 1024² @ 50 steps
   **~2.7 s**; T2V 1280×720 / 189 frames @ 35 steps **~161 s**, of which ~92% is
   the DiT denoise loop and ~4% VAE decode, so optimization effort belongs in the
   denoise loop. The optional flags act on different terms of the memory bill and
   are therefore complementary rather than redundant:
 
   | Flag | Latency | Peak reserved | Peak allocated | Acts on |
-  |---|---|---|---|---|
+  | --- | --- | --- | --- | --- |
   | *(none)* | 161 s | 120 GiB | 95 GiB | — |
   | `--vae-use-tiling` | 183 s (+13.5%) | **38 GiB** (−68%) | **36 GiB** (−62%) | decode activations |
   | `--enable-layerwise-offload` | 162 s (+0.8%) | 84 GiB (−30%) | 69 GiB (−27%) | weights |
@@ -704,11 +787,11 @@ curl -sS -X POST http://localhost:8000/v1/videos/sync \
 
 #### Notes
 
-- **Measured latency (1x Ascend 910B / 910C, bf16, guardrails off):**
-  - T2I 1024² — 10 steps → ~8 s
-  - T2V 1280×720 @ 20 steps — 49 frames → ~55 s
-  - I2V 1280×720 @ 10 steps — 25 frames → ~25 s
-  - V2V 480×320 @ 10 steps — 17 frames → ~12 s
+- **Measured latency (1x Ascend 910B / 910C, bf16, guardrails off, diffusion cache off):**
+    - T2I 1024² — 10 steps → ~8 s
+    - T2V 1280×720 @ 20 steps — 49 frames → ~55 s
+    - I2V 1280×720 @ 10 steps — 25 frames → ~25 s
+    - V2V 480×320 @ 10 steps — 17 frames → ~12 s
 - **Memory:** transformer ~17 GiB (bf16); peak ~46 GiB for 720p video on 1 NPU;
   full repo (transformer + Wan VAE + Qwen3-VL vision encoder + audio tokenizer)
   ~33 GB on disk.
@@ -721,9 +804,9 @@ curl -sS -X POST http://localhost:8000/v1/videos/sync \
   (for model loading), `--tensor-parallel-size 8` for multi-NPU, and
   `--model-class-name Cosmos3OmniDiffusersPipeline` to force the pipeline class.
 - **Known limitations:**
-  - Transfer V2V with `extra_params` (`edge`/`blur`/`depth`/`seg`/`wsm`) hits a
+    - Transfer V2V with `extra_params` (`edge`/`blur`/`depth`/`seg`/`wsm`) hits a
     resolution-parsing bug; basic V2V without transfer hints works.
-  - FP8 online quantization and layerwise offload are not supported on NPU.
+    - FP8 online quantization and layerwise offload are not supported on NPU.
 
 ### 1x Ascend 910B / 910C (Atlas A2 / A3) — Offline generation
 
diff --git a/recipes/cosmos3/Cosmos3-Super.md b/recipes/cosmos3/Cosmos3-Super.md
index c8bfb6bbd..82ae1f20a 100644
--- a/recipes/cosmos3/Cosmos3-Super.md
+++ b/recipes/cosmos3/Cosmos3-Super.md
@@ -62,6 +62,21 @@ disable. `--enable-layerwise-offload` reduces VRAM on smaller GPUs;
 generation from ~83 GB to ~55 GB per GPU (2-GPU) with BF16-level quality (T2V
 composition can shift at the same seed).
 
+SeaCache is the recommended default choice when opting into diffusion caching,
+which remains opt-in. Add `--cache-backend sea_cache` to either command above;
+its defaults are tuned for Cosmos3.
+
+Override individual defaults with `--cache-config`; for example:
+
+```bash
+--cache-config '{"sea_threshold":0.2,"sea_max_consecutive_cached":3}'
+```
+
+Lower `sea_threshold` values and smaller `sea_max_consecutive_cached` caps are
+more conservative. Higher values allow more cached steps and may improve
+speed, but can increase quality loss. Setting `sea_max_consecutive_cached` to
+`0` removes the streak cap.
+
 #### Verification
 
 Requests are identical to Nano (see [`Cosmos3-Nano.md`](./Cosmos3-Nano.md) for full
@@ -109,12 +124,12 @@ curl -sS -X POST http://localhost:8000/v1/videos/sync -H "Accept: video/mp4" \
 
 #### Notes
 
-- **Measured (2x B300, bf16, guardrails off, official 2-GPU config above):**
-  - T2I 1024², 50 steps → **~6 s**
-  - T2V 1280×720, 189 frames, 35 steps → **~197 s**
-  - I2V 1280×720, 189 frames, 35 steps → **~200 s**
-  - T2V + sound (189 frames, 35 steps) → **~198 s**, output muxes **AAC 48 kHz stereo**
-  - (NVIDIA's reference: 8×H200 @ 50 steps ≈ 55 s/video; 2×H200 @ 35 steps ≈ 3 min/video.)
+- **Measured (2x B300, bf16, guardrails off, diffusion cache off, official 2-GPU config above):**
+    - T2I 1024², 50 steps → **~6 s**
+    - T2V 1280×720, 189 frames, 35 steps → **~197 s**
+    - I2V 1280×720, 189 frames, 35 steps → **~200 s**
+    - T2V + sound (189 frames, 35 steps) → **~198 s**, output muxes **AAC 48 kHz stereo**
+    - (NVIDIA's reference: 8×H200 @ 50 steps ≈ 55 s/video; 2×H200 @ 35 steps ≈ 3 min/video.)
 - **Memory:** ~61.5 GiB per GPU when sharded across 2 GPUs (HSDP shard 2); repo ~135 GB on disk.
 - Same generation defaults, supported sizes, V2V reference-video controls
   (`condition_frame_indexes_vision`, `condition_video_keep`), and
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/mistralai/Voxtral-TTS.md b/recipes/mistralai/Voxtral-TTS.md
index 8868ed3c3..c4eb2d12f 100644
--- a/recipes/mistralai/Voxtral-TTS.md
+++ b/recipes/mistralai/Voxtral-TTS.md
@@ -178,7 +178,7 @@ mistralai/Voxtral-4B-TTS-2603 checkpoint. running the
 voice-cloning e2e test ([`Voice cloning (capability gated upstream)`](../../examples/offline_inference/text_to_speech/README.md#voice-cloning-capability-gated-upstream)
 ) or adding a `ref_audio` request parameter will fail
 because the public checkpoint does not provide the encoder weights needed to
-convert reference audio into conditioning features. The expected failure is: `RuntimeError: encode_waveforms requires encoder weights which are not available in the open-source checkpoint.`
+convert reference audio into conditioning features. The expected failure is a 400 BadRequest `Voice cloning with 'ref_audio' requires the full Voxtral checkpoint with encoder weights. The open-source variant only supports preset voices via the 'voice' parameter.`.
 
 ### 1x NVIDIA RTX A6000 48GB
 
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/benchmark_image_file_response.py b/tests/benchmarks/benchmark_image_file_response.py
new file mode 100644
index 000000000..acd8967a6
--- /dev/null
+++ b/tests/benchmarks/benchmark_image_file_response.py
@@ -0,0 +1,202 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Benchmark newline-split and fixed-size chunking of image file responses.
+
+Both variants stream the exact payload `ImageGenerationResponse.stream_response()`
+produces, so the measurement isolates the response layer: PNG encoding and ZIP
+building are shared by the variants and excluded from the timings.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import base64
+import hashlib
+import io
+import json
+import statistics
+import time
+from collections.abc import AsyncIterator, Callable, Iterable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import cast
+
+import numpy as np
+from PIL import Image
+from starlette.responses import StreamingResponse
+
+from vllm_omni.entrypoints.openai.protocol.images import (
+    _FILE_RESPONSE_CHUNK_SIZE,
+    ImageData,
+    ImageGenerationResponse,
+    _iter_file_chunks,
+)
+
+
+@dataclass(frozen=True)
+class BenchmarkVariant:
+    label: str
+    content: Callable[[bytes], Iterable[bytes] | AsyncIterator[memoryview]]
+
+
+def _positive_int(value: str) -> int:
+    parsed = int(value)
+    if parsed < 1:
+        raise argparse.ArgumentTypeError("value must be at least 1")
+    return parsed
+
+
+def _encode_png(*, width: int, height: int, seed: int) -> bytes:
+    """Encode incompressible noise, so the payload looks like a real photo."""
+    rng = np.random.default_rng(seed)
+    pixels = rng.integers(0, 256, size=(height, width, 3), dtype=np.uint8)
+    buffer = io.BytesIO()
+    Image.fromarray(pixels, mode="RGB").save(buffer, format="png")
+    return buffer.getvalue()
+
+
+async def _drain(response: StreamingResponse) -> tuple[bytes, int]:
+    """Run a response through ASGI, returning its body and non-empty frame count."""
+    body = bytearray()
+    frames = 0
+
+    async def send(message: dict[str, object]) -> None:
+        nonlocal frames
+        if message["type"] == "http.response.body" and message["body"]:
+            frames += 1
+            body.extend(cast(bytes, message["body"]))
+
+    async def receive() -> dict[str, str]:
+        return {"type": "http.disconnect"}
+
+    scope = {"type": "http", "method": "GET", "asgi": {"spec_version": "2.4"}}
+    await response(scope, receive, send)
+    return bytes(body), frames
+
+
+async def _build_payload(*, images: int, width: int, height: int, seed: int) -> bytes:
+    png = _encode_png(width=width, height=height, seed=seed)
+    response = ImageGenerationResponse(
+        created=0,
+        data=[ImageData(b64_json=base64.b64encode(png).decode()) for _ in range(images)],
+        output_format="png",
+        size=f"{width}x{height}",
+    )
+    payload, _ = await _drain(response.stream_response())
+    return payload
+
+
+async def _measure(variant: BenchmarkVariant, payload: bytes) -> dict[str, object]:
+    response = StreamingResponse(variant.content(payload), media_type="application/octet-stream")
+    cpu_start = time.process_time_ns()
+    wall_start = time.perf_counter_ns()
+    body, frames = await _drain(response)
+    wall_ms = (time.perf_counter_ns() - wall_start) / 1_000_000
+    process_cpu_ms = (time.process_time_ns() - cpu_start) / 1_000_000
+    return {
+        "label": variant.label,
+        "wall_ms": wall_ms,
+        "process_cpu_ms": process_cpu_ms,
+        "body_frames": frames,
+        "output_bytes": len(body),
+        "output_sha256": hashlib.sha256(body).hexdigest(),
+    }
+
+
+def _summarize(records: list[dict[str, object]], label: str) -> dict[str, object]:
+    selected = [record for record in records if record["label"] == label]
+    wall_values = [cast(float, record["wall_ms"]) for record in selected]
+    cpu_values = [cast(float, record["process_cpu_ms"]) for record in selected]
+    return {
+        "runs": len(selected),
+        "body_frames": cast(int, selected[0]["body_frames"]),
+        "wall_ms": {
+            "median": statistics.median(wall_values),
+            "min": min(wall_values),
+            "max": max(wall_values),
+        },
+        "process_cpu_ms": {
+            "median": statistics.median(cpu_values),
+            "min": min(cpu_values),
+            "max": max(cpu_values),
+        },
+    }
+
+
+def _parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--images", type=_positive_int, default=1, help="2 or more streams a ZIP archive")
+    parser.add_argument("--width", type=_positive_int, default=1024)
+    parser.add_argument("--height", type=_positive_int, default=1024)
+    parser.add_argument("--warmup", type=int, default=1)
+    parser.add_argument("--rounds", type=_positive_int, default=3)
+    parser.add_argument("--seed", type=int, default=20260912)
+    parser.add_argument("--output-json", type=Path)
+    args = parser.parse_args()
+    if args.warmup < 0:
+        parser.error("--warmup must be non-negative")
+    return args
+
+
+async def _run(args: argparse.Namespace) -> dict[str, object]:
+    payload = await _build_payload(images=args.images, width=args.width, height=args.height, seed=args.seed)
+    baseline = BenchmarkVariant("newline_split", io.BytesIO)
+    candidate = BenchmarkVariant("fixed_size_chunks", _iter_file_chunks)
+
+    for _ in range(args.warmup):
+        for variant in (baseline, candidate):
+            await _measure(variant, payload)
+
+    records: list[dict[str, object]] = []
+    for round_index in range(args.rounds):
+        order = (baseline, candidate) if round_index % 2 == 0 else (candidate, baseline)
+        for variant in order:
+            record = await _measure(variant, payload)
+            record["round"] = round_index + 1
+            records.append(record)
+
+    output_hashes = {str(record["output_sha256"]) for record in records}
+    if len(output_hashes) != 1:
+        raise RuntimeError(f"benchmark variants produced different outputs: {sorted(output_hashes)}")
+
+    baseline_summary = _summarize(records, baseline.label)
+    candidate_summary = _summarize(records, candidate.label)
+    baseline_ms = cast(float, cast(dict[str, object], baseline_summary["wall_ms"])["median"])
+    candidate_ms = cast(float, cast(dict[str, object], candidate_summary["wall_ms"])["median"])
+    return {
+        "config": {
+            "images": args.images,
+            "width": args.width,
+            "height": args.height,
+            "warmup": args.warmup,
+            "rounds": args.rounds,
+            "seed": args.seed,
+            "chunk_size": _FILE_RESPONSE_CHUNK_SIZE,
+            "payload_bytes": len(payload),
+            "payload_newline_bytes": payload.count(b"\n"),
+        },
+        "records": records,
+        "summary": {
+            baseline.label: baseline_summary,
+            candidate.label: candidate_summary,
+            "median_wall_speedup": baseline_ms / candidate_ms,
+            "body_frame_ratio": (
+                cast(int, baseline_summary["body_frames"]) / cast(int, candidate_summary["body_frames"])
+            ),
+            "output_sha256": output_hashes.pop(),
+        },
+    }
+
+
+def main() -> None:
+    args = _parse_args()
+    result = asyncio.run(_run(args))
+    output_json = json.dumps(result, indent=2, sort_keys=True)
+    if args.output_json is not None:
+        args.output_json.write_text(output_json + "\n", encoding="utf-8")
+    print(output_json)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/benchmarks/duplex/test_omni_duplex_eval.py b/tests/benchmarks/duplex/test_omni_duplex_eval.py
index 5f77aacc0..f5d3ebcd8 100644
--- a/tests/benchmarks/duplex/test_omni_duplex_eval.py
+++ b/tests/benchmarks/duplex/test_omni_duplex_eval.py
@@ -64,6 +64,177 @@ def test_hugging_face_subset_names_are_splits(monkeypatch):
     assert sample.task_type == "correction"
 
 
+def test_local_hf_dataset_directory_is_routed_to_hf_loader(tmp_path, monkeypatch):
+    # An existing local Hugging Face dataset layout (directory with a
+    # ``data/*.parquet`` file) must be loaded through ``datasets.load_dataset``
+    # instead of being parsed as a JSON/JSONL manifest.
+    hf_dir = tmp_path / "Omni-DuplexEval"
+    data_dir = hf_dir / "data"
+    data_dir.mkdir(parents=True)
+    (data_dir / "train-00000-of-00001.parquet").write_bytes(b"PAR1")
+    calls = []
+
+    def fake_load_dataset(name, **kwargs):
+        calls.append((name, kwargs))
+        return [{"id": "pr", "split": "PR_correction", "question_text": "Correct this."}]
+
+    monkeypatch.setitem(sys.modules, "datasets", SimpleNamespace(load_dataset=fake_load_dataset))
+    samples = load_samples(hf_dir)
+    assert calls == [(str(hf_dir), {})]
+    assert len(samples) == 1
+    assert samples[0].task_type == "correction"
+
+
+def test_local_parquet_file_is_routed_to_hf_loader(tmp_path, monkeypatch):
+    parquet = tmp_path / "samples.parquet"
+    parquet.write_bytes(b"PAR1")
+    calls = []
+
+    def fake_load_dataset(name, **kwargs):
+        calls.append((name, kwargs))
+        return [{"id": "pr", "split": "PR_correction", "question_text": "Correct this."}]
+
+    monkeypatch.setitem(sys.modules, "datasets", SimpleNamespace(load_dataset=fake_load_dataset))
+    samples = load_samples(str(parquet))
+    assert calls == [("parquet", {"data_files": str(parquet)})]
+    assert len(samples) == 1
+    assert samples[0].family == "pr"
+
+
+def test_hf_collapse_to_train_keeps_row_split_identity(tmp_path, monkeypatch):
+    # datasets.load_dataset collapses a config-less local mirror (a bare data/
+    # directory) into a single generic ``train`` split. Rows that already carry
+    # their own split/subset identity must keep it so family inference is not
+    # poisoned by the generic name (regression for the direct-read path).
+    hf_dir = tmp_path / "Omni-DuplexEval"
+    data_dir = hf_dir / "data"
+    data_dir.mkdir(parents=True)
+    (data_dir / "train-00000-of-00021.parquet").write_bytes(b"PAR1")
+
+    def fake_load_dataset(name, **kwargs):
+        return {
+            "train": [
+                {"id": "pr", "split": "PR_correction", "question_text": "Correct this."},
+                {"id": "pr-subset", "subset": "PR_event_reminder", "question_text": "Remind me."},
+                {"id": "rtd", "split": "RTD_OCR", "question_text": "Read this."},
+            ]
+        }
+
+    monkeypatch.setitem(sys.modules, "datasets", SimpleNamespace(load_dataset=fake_load_dataset))
+    samples = load_samples(hf_dir)
+    by_id = {sample.id: sample for sample in samples}
+    assert by_id["pr"].split == "PR_correction"
+    assert by_id["pr"].family == "pr"
+    assert by_id["pr"].task_type == "correction"
+    assert by_id["pr-subset"].split == "PR_event_reminder"
+    assert by_id["pr-subset"].family == "pr"
+    assert by_id["pr-subset"].task_type == "proactive_reminder"
+    assert by_id["rtd"].split == "RTD_OCR"
+    assert by_id["rtd"].family == "rtd"
+
+
+def test_hf_config_layout_stamps_split_name_when_row_has_none(tmp_path, monkeypatch):
+    # With a proper config-per-split mirror the loader still stamps the Hugging
+    # Face split name onto rows that do not identify themselves (unchanged).
+    hf_dir = tmp_path / "Omni-DuplexEval"
+    data_dir = hf_dir / "data"
+    data_dir.mkdir(parents=True)
+    (data_dir / "RTD_OCR-00000-of-00001.parquet").write_bytes(b"PAR1")
+    (data_dir / "PR_correction-00000-of-00001.parquet").write_bytes(b"PAR1")
+
+    def fake_load_dataset(name, **kwargs):
+        return {
+            "RTD_OCR": [{"id": "rtd", "question_text": "Read this."}],
+            "PR_correction": [{"id": "pr", "question_text": "Correct this."}],
+        }
+
+    monkeypatch.setitem(sys.modules, "datasets", SimpleNamespace(load_dataset=fake_load_dataset))
+    samples = load_samples(hf_dir)
+    by_id = {sample.id: sample for sample in samples}
+    assert by_id["rtd"].split == "RTD_OCR"
+    assert by_id["rtd"].family == "rtd"
+    assert by_id["pr"].split == "PR_correction"
+    assert by_id["pr"].family == "pr"
+    assert by_id["pr"].task_type == "correction"
+
+
+def test_hf_collapse_to_train_without_row_identity_raises_actionable_error(tmp_path, monkeypatch):
+    # A row that carries no split/family/task_type and lands in a generic
+    # collapsed ``train`` split cannot be routed; the loader must raise a clear,
+    # actionable ValueError instead of the bare family_for_split message.
+    hf_dir = tmp_path / "Omni-DuplexEval"
+    data_dir = hf_dir / "data"
+    data_dir.mkdir(parents=True)
+    (data_dir / "train-00000-of-00021.parquet").write_bytes(b"PAR1")
+
+    def fake_load_dataset(name, **kwargs):
+        return {"train": [{"id": "x", "question_text": "What is this?"}]}
+
+    monkeypatch.setitem(sys.modules, "datasets", SimpleNamespace(load_dataset=fake_load_dataset))
+    with pytest.raises(ValueError, match="Hugging Face splits"):
+        load_samples(hf_dir)
+
+
+def test_non_manifest_file_raises_clear_error(tmp_path):
+    # A plain non-JSON file (e.g. a README) must surface a clear ValueError
+    # listing the accepted inputs instead of a raw JSONDecodeError.
+    bad = tmp_path / "README.md"
+    bad.write_text("# readme\nnot a manifest", encoding="utf-8")
+    with pytest.raises(ValueError, match="JSON/JSONL manifest"):
+        load_samples(str(bad))
+
+
+def _write_parquet(path, rows):
+    pyarrow = pytest.importorskip("pyarrow")
+    pyarrow.parquet.write_table(pyarrow.Table.from_pylist(rows), str(path))
+
+
+def test_local_parquet_split_filters_rows_by_identity(tmp_path):
+    # Regression: a single ``.parquet`` file is exposed by ``load_dataset`` as a
+    # generic ``train`` physical split, so ``--split RTD_OCR`` used to raise
+    # ``Unknown split "RTD_OCR"``. The requested split must instead filter the
+    # rows by their preserved identity.
+    pytest.importorskip("datasets")
+    parquet = tmp_path / "samples.parquet"
+    _write_parquet(
+        parquet,
+        [
+            {"id": "rtd", "split": "RTD_OCR", "question_text": "Read this."},
+            {"id": "pr", "split": "PR_correction", "question_text": "Correct this."},
+        ],
+    )
+    assert {sample.id for sample in load_samples(str(parquet))} == {"rtd", "pr"}
+    rtd = load_samples(str(parquet), split="RTD_OCR")
+    assert [sample.id for sample in rtd] == ["rtd"]
+    assert rtd[0].family == "rtd"
+    pr = load_samples(str(parquet), split="PR_correction")
+    assert [sample.id for sample in pr] == ["pr"]
+    assert pr[0].family == "pr"
+    assert pr[0].task_type == "correction"
+
+
+def test_local_directory_named_splits_resolve_without_row_identity(tmp_path):
+    # Regression: a single-configuration mirror whose data files are named after
+    # the benchmark splits must resolve each split for real (no fake loader) and
+    # without any per-row identity.
+    pytest.importorskip("datasets")
+    hf_dir = tmp_path / "Omni-DuplexEval"
+    data_dir = hf_dir / "data"
+    data_dir.mkdir(parents=True)
+    _write_parquet(data_dir / "RTD_OCR-00000-of-00001.parquet", [{"id": "rtd", "question_text": "Read this."}])
+    _write_parquet(
+        data_dir / "PR_correction-00000-of-00001.parquet",
+        [{"id": "pr", "question_text": "Correct this."}],
+    )
+    by_id = {sample.id: sample for sample in load_samples(hf_dir)}
+    assert by_id["rtd"].split == "RTD_OCR"
+    assert by_id["rtd"].family == "rtd"
+    assert by_id["pr"].split == "PR_correction"
+    assert by_id["pr"].family == "pr"
+    assert by_id["pr"].task_type == "correction"
+    assert [sample.id for sample in load_samples(hf_dir, split="RTD_OCR")] == ["rtd"]
+
+
 def test_response_aliases_and_clock_guard():
     assert split_text("One. Two!") == ["One.", "Two!"]
     assert normalize_response_items({"chunks": [{"text": "x", "current_time": 800}]}) == [
@@ -141,3 +312,113 @@ def test_frame_sample_content_passes_frames(tmp_path, monkeypatch):
         judge_video_mode="frame-sample",
     )
     assert score["content"]["frame_count"] == 2
+
+
+def test_local_directory_collapsed_train_with_row_identity_and_split_filter(tmp_path):
+    # Reviewer-pointed gap: a collapsed local mirror (data/train-*.parquet)
+    # whose rows carry their own split identity must correctly filter by
+    # --split RTD_OCR.
+    pytest.importorskip("datasets")
+    hf_dir = tmp_path / "Omni-DuplexEval"
+    data_dir = hf_dir / "data"
+    data_dir.mkdir(parents=True)
+    _write_parquet(
+        data_dir / "train-00000-of-00001.parquet",
+        [
+            {"id": "rtd", "split": "RTD_OCR", "question_text": "Read this."},
+            {"id": "pr", "split": "PR_correction", "question_text": "Correct this."},
+        ],
+    )
+    all_samples = load_samples(hf_dir)
+    assert {s.id for s in all_samples} == {"rtd", "pr"}
+    rtd = load_samples(hf_dir, split="RTD_OCR")
+    assert [s.id for s in rtd] == ["rtd"]
+    assert rtd[0].family == "rtd"
+
+
+def test_local_directory_mistyped_split_raises_clear_error(tmp_path):
+    # A named-shard mirror with --split RTD_TYPO must raise ValueError
+    # listing the observed splits instead of silently returning nothing.
+    pytest.importorskip("datasets")
+    hf_dir = tmp_path / "Omni-DuplexEval"
+    data_dir = hf_dir / "data"
+    data_dir.mkdir(parents=True)
+    _write_parquet(
+        data_dir / "RTD_OCR-00000-of-00001.parquet",
+        [{"id": "rtd", "question_text": "Read this."}],
+    )
+    _write_parquet(
+        data_dir / "PR_correction-00000-of-00001.parquet",
+        [{"id": "pr", "question_text": "Correct this."}],
+    )
+    with pytest.raises(ValueError) as exc_info:
+        load_samples(hf_dir, split="RTD_TYPO")
+    message = str(exc_info.value)
+    assert "matched zero" in message
+    assert "RTD_OCR" in message or "PR_correction" in message
+
+
+def test_manifest_without_split_identity_split_override_still_works(tmp_path):
+    # Manifest rows without split/subset/config identity must keep the
+    # base override behaviour: --split RTD_OCR stamps the split so rows
+    # are kept instead of rejected (regression test for P2).
+    manifest = tmp_path / "samples.json"
+    manifest.write_text(
+        json.dumps([{"id": "a", "video": "clip.mp4"}, {"id": "b", "video": "clip2.mp4"}]),
+        encoding="utf-8",
+    )
+    samples = load_samples(manifest, split="RTD_OCR")
+    assert len(samples) == 2
+    assert all(s.split == "RTD_OCR" for s in samples)
+    assert all(s.family == "rtd" for s in samples)
+
+
+def test_iterable_without_split_identity_split_override_still_works():
+    # Iterable rows without split/subset/config identity must keep the
+    # base override behaviour (regression test for F5/P2).
+    data = [{"id": "a", "video": "clip.mp4"}, {"id": "b", "video": "clip2.mp4"}]
+    samples = load_samples(data, split="RTD_OCR")
+    assert len(samples) == 2
+    assert all(s.split == "RTD_OCR" for s in samples)
+    assert all(s.family == "rtd" for s in samples)
+
+
+def test_audio_feature_decode_false_preserves_bytes_key(tmp_path):
+    # When a parquet file carries an Audio feature column, the loader
+    # must recast it with decode=False so rows contain the ``bytes`` key
+    # instead of ``array``/``sampling_rate``.
+    pytest.importorskip("datasets")
+    pytest.importorskip("pyarrow")
+    import datasets
+
+    audio_bytes = b"\x00\x01\x02"
+    ds = datasets.Dataset.from_dict(
+        {
+            "id": ["a"],
+            "question_text": ["Hello"],
+            "task_type": ["pr_correction"],
+            "audio": [{"bytes": audio_bytes, "path": None}],
+        },
+        features=datasets.Features(
+            {
+                "id": datasets.Value("string"),
+                "question_text": datasets.Value("string"),
+                "task_type": datasets.Value("string"),
+                "audio": datasets.Audio(sampling_rate=16000),
+            }
+        ),
+    )
+    parquet = tmp_path / "audio_sample.parquet"
+    ds.to_parquet(str(parquet))
+
+    samples = load_samples(str(parquet))
+    assert len(samples) == 1
+    raw = samples[0].raw
+    assert raw is not None
+    audio_val = raw.get("audio")
+    assert audio_val is not None
+    # The Audio feature was decoded with decode=False, so the struct
+    # keeps the ``bytes`` key that materialize_media needs.
+    assert isinstance(audio_val, dict) and "bytes" in audio_val
+    assert audio_val["bytes"] == audio_bytes
+    assert "path" in audio_val
diff --git a/tests/benchmarks/duplex/test_omni_duplex_eval_media.py b/tests/benchmarks/duplex/test_omni_duplex_eval_media.py
new file mode 100644
index 000000000..ad2fffc9d
--- /dev/null
+++ b/tests/benchmarks/duplex/test_omni_duplex_eval_media.py
@@ -0,0 +1,341 @@
+# 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 (
+    _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
+    # does not exist on disk), so downstream ffmpeg saw a missing file. Inline
+    # bytes must win and be written to a real file whose content equals bytes.
+    payload = b"\x00\xff\x01RIFFfake-content"
+    resolved = materialize_media({"bytes": payload, "path": "question_audio.wav"}, tmp_path, "s1_question", ".wav")
+    assert resolved.is_file()
+    assert resolved.read_bytes() == payload
+    assert resolved.parent == tmp_path
+    assert resolved.name == "s1_question.wav"
+
+
+def test_dict_extension_comes_from_path_safely(tmp_path):
+    payload = b"flac-ish-bytes"
+    resolved = materialize_media({"bytes": payload, "path": "audio/clip.FLAC"}, tmp_path, "s1", ".wav")
+    assert resolved.name == "s1.flac"
+    assert resolved.read_bytes() == payload
+    # A path with no usable extension falls back to the caller's suffix.
+    resolved = materialize_media({"bytes": payload, "path": "audio/clip"}, tmp_path, "s2", ".wav")
+    assert resolved.name == "s2.wav"
+    assert resolved.read_bytes() == payload
+
+
+def test_materialization_is_idempotent_and_updated(tmp_path):
+    payload = b"abc"
+    first = materialize_media({"bytes": payload, "path": "q.wav"}, tmp_path, "s", ".wav")
+    second = materialize_media({"bytes": payload, "path": "q.wav"}, tmp_path, "s", ".wav")
+    assert first == second
+    assert first.read_bytes() == payload
+    replacement = b"xyz"
+    third = materialize_media({"bytes": replacement, "path": "q.wav"}, tmp_path, "s", ".wav")
+    assert third == first
+    assert third.read_bytes() == replacement
+
+
+def test_str_path_and_path_only_mapping_returned_as_is(tmp_path):
+    existing = tmp_path / "clip.mp4"
+    existing.write_bytes(b"video")
+    assert materialize_media(str(existing), tmp_path, "s", ".mp4") == existing
+    assert materialize_media({"path": str(existing)}, tmp_path, "s", ".mp4") == existing
+
+
+def test_raw_bytes_value_is_written(tmp_path):
+    payload = b"raw-media"
+    resolved = materialize_media(payload, tmp_path, "r", ".bin")
+    assert resolved.name == "r.bin"
+    assert resolved.read_bytes() == payload
+
+
+def test_unresolvable_value_raises_clear_error(tmp_path):
+    with pytest.raises(ValueError, match="cannot materialize"):
+        materialize_media(None, tmp_path, "s", ".wav")
+    with pytest.raises(ValueError, match="cannot materialize"):
+        materialize_media({"path": None}, tmp_path, "s", ".wav")
diff --git a/tests/benchmarks/metrics/test_metrics.py b/tests/benchmarks/metrics/test_metrics.py
index d7dd6c14a..0aae841af 100644
--- a/tests/benchmarks/metrics/test_metrics.py
+++ b/tests/benchmarks/metrics/test_metrics.py
@@ -150,16 +150,16 @@ def test_unmeasured_duplex_latency_does_not_add_zero_samples():
     measured.audio_ttfp = 0.2
     measured.audio_rtf = 0.5
     measured.duplex_session_metrics = {
-        "mean_ttft_ms": 100.0,
-        "mean_ttfp_ms": 200.0,
-        "mean_rtf": 0.5,
+        "ttft_ms": 100.0,
+        "ttfp_ms": 200.0,
+        "rtf": 0.5,
     }
     listen_only = _make_output(100, output_tokens=0)
     listen_only.ttft = listen_only.audio_ttfp = listen_only.audio_rtf = 0.0
     listen_only.duplex_session_metrics = {
-        "mean_ttft_ms": None,
-        "mean_ttfp_ms": None,
-        "mean_rtf": None,
+        "ttft_ms": None,
+        "ttfp_ms": None,
+        "rtf": None,
     }
 
     metrics = _calculate_test_metrics([measured, listen_only], {"ttft": 150.0})
@@ -174,9 +174,9 @@ def test_unmeasured_duplex_latency_does_not_add_zero_samples():
 def test_all_unmeasured_duplex_latency_is_not_reported_as_zero():
     listen_only = _make_output(100, output_tokens=0)
     listen_only.duplex_session_metrics = {
-        "mean_ttft_ms": None,
-        "mean_ttfp_ms": None,
-        "mean_rtf": None,
+        "ttft_ms": None,
+        "ttfp_ms": None,
+        "rtf": None,
     }
 
     metrics = _calculate_test_metrics(
@@ -196,13 +196,13 @@ def test_unmeasured_duplex_tpot_does_not_add_zero_or_misalign_goodput():
     missing_tpot.itl = []
     missing_tpot.text_latency = missing_tpot.ttft = 0.1
     missing_tpot.tpot_measured = False
-    missing_tpot.duplex_session_metrics = {"mean_ttft_ms": 100.0}
+    missing_tpot.duplex_session_metrics = {"ttft_ms": 100.0}
 
     slow_ttft = _make_output(100, output_tokens=5)
     slow_ttft.ttft = 1.0
     slow_ttft.text_latency = 1.4
     slow_ttft.itl = [0.1] * 4
-    slow_ttft.duplex_session_metrics = {"mean_ttft_ms": 1000.0}
+    slow_ttft.duplex_session_metrics = {"ttft_ms": 1000.0}
 
     metrics = _calculate_test_metrics(
         [missing_tpot, slow_ttft],
@@ -219,7 +219,7 @@ def test_all_unmeasured_duplex_token_timing_is_not_reported_as_zero():
     output.itl = []
     output.text_latency = output.ttft
     output.tpot_measured = False
-    output.duplex_session_metrics = {"mean_ttft_ms": 100.0}
+    output.duplex_session_metrics = {"ttft_ms": 100.0}
 
     metrics = _calculate_test_metrics([output], {"tpot": float("inf")})
 
@@ -236,7 +236,7 @@ def test_duplex_response_timings_do_not_build_a_session_token_timeline():
         {"response_id": "r1", "stage0_tokens": {"itls_ms": [100.0, 100.0]}},
         {"response_id": "r2", "stage0_tokens": {"itls_ms": [100.0, 100.0]}},
     ]
-    output.duplex_session_metrics = {"mean_ttft_ms": 100.0}
+    output.duplex_session_metrics = {"ttft_ms": 100.0}
 
     metrics = _calculate_test_metrics([output])
 
@@ -252,7 +252,7 @@ def test_unmeasured_tpot_stays_missing_after_tokenizer_fallback():
     output.itl = []
     output.text_latency = output.ttft
     output.tpot_measured = False
-    output.duplex_session_metrics = {"mean_ttft_ms": 100.0}
+    output.duplex_session_metrics = {"ttft_ms": 100.0}
 
     def tokenizer(text, *, add_special_tokens):
         assert text == output.generated_text
@@ -282,7 +282,7 @@ def test_unmeasured_tpot_stays_missing_after_tokenizer_fallback():
 def test_zero_itl_does_not_create_zero_tpot():
     output = _make_output(100, output_tokens=3)
     output.itl = [0.0, 0.0]
-    output.duplex_session_metrics = {"mean_ttft_ms": 100.0}
+    output.duplex_session_metrics = {"ttft_ms": 100.0}
 
     metrics = _calculate_test_metrics([output], {"tpot": 1.0})
 
@@ -357,9 +357,9 @@ def test_single_token_responses_do_not_report_zero_tpot(capsys):
 def test_duplex_goodput_does_not_pair_measurements_from_different_requests():
     text_only, audio_only = _make_output(100), _make_output(100)
     text_only.ttft, text_only.audio_ttfp = 0.1, 0.0
-    text_only.duplex_session_metrics = {"mean_ttft_ms": 100.0, "mean_ttfp_ms": None, "mean_rtf": None}
+    text_only.duplex_session_metrics = {"ttft_ms": 100.0, "ttfp_ms": None, "rtf": None}
     audio_only.ttft, audio_only.audio_ttfp = 0.0, 0.2
-    audio_only.duplex_session_metrics = {"mean_ttft_ms": None, "mean_ttfp_ms": 200.0, "mean_rtf": None}
+    audio_only.duplex_session_metrics = {"ttft_ms": None, "ttfp_ms": 200.0, "rtf": None}
 
     metrics = _calculate_test_metrics([text_only, audio_only], {"ttft": 500.0, "audio_ttft": 500.0})
 
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/patch/test_patch.py b/tests/benchmarks/patch/test_patch.py
index accb30100..d2552bbff 100644
--- a/tests/benchmarks/patch/test_patch.py
+++ b/tests/benchmarks/patch/test_patch.py
@@ -135,6 +135,7 @@ class MockResponse:
 async def test_seed_tts_realtime_duplex_exports_per_request_metrics(monkeypatch):
     class FakeRealtimeClient:
         last_instance = None
+        instances: list = []
 
         def __init__(self, url):
             assert url == "ws://localhost:8000/v1/realtime?duplex=1"
@@ -143,6 +144,9 @@ async def test_seed_tts_realtime_duplex_exports_per_request_metrics(monkeypatch)
             self.sent = []
             self.response_count = 0
             self.ack_count = 0
+            self.silence_seconds = []
+            self.closed = 0
+            type(self).instances.append(self)
             type(self).last_instance = self
 
         async def __aenter__(self):
@@ -155,10 +159,22 @@ async def test_seed_tts_realtime_duplex_exports_per_request_metrics(monkeypatch)
             assert model == "openbmb/MiniCPM-o-4_5"
             self.configure_kwargs = kwargs
 
+        async def stream_silence(self, *, seconds, chunk_ms=200, until=None):
+            # A model-native session speaks off its seeded context once audio
+            # units arrive; the silence itself carries no content. The probe
+            # stops the silence as soon as the turn settles.
+            self.silence_seconds.append(seconds)
+            self._emit_response()
+            assert until is not None and until()
+            return 1.0
+
         async def send(self, event):
             self.sent.append(event)
             if event["type"] != "response.create":
                 return
+            self._emit_response()
+
+        def _emit_response(self):
             self.response_count += 1
             response_id = f"resp-{self.response_count}"
             now = time.monotonic()
@@ -168,7 +184,7 @@ async def test_seed_tts_realtime_duplex_exports_per_request_metrics(monkeypatch)
             )
             self.events.add(
                 {
-                    "type": "response.audio_transcript.delta",
+                    "type": "response.output_audio_transcript.delta",
                     "response_id": response_id,
                     "delta": f"turn {self.response_count}",
                 },
@@ -176,7 +192,7 @@ async def test_seed_tts_realtime_duplex_exports_per_request_metrics(monkeypatch)
             )
             self.events.add(
                 {
-                    "type": "response.audio.delta",
+                    "type": "response.output_audio.delta",
                     "response_id": response_id,
                     "delta": base64.b64encode(b"\x00\x00" * 2400).decode(),
                     "sample_rate_hz": 24_000,
@@ -210,7 +226,7 @@ async def test_seed_tts_realtime_duplex_exports_per_request_metrics(monkeypatch)
             self.ack_count += 1
 
         async def close_session(self, **_kwargs):
-            return None
+            self.closed += 1
 
     monkeypatch.setattr(
         "vllm_omni.benchmarks.patch.patch._RealtimeTTSProbe",
@@ -239,30 +255,27 @@ async def test_seed_tts_realtime_duplex_exports_per_request_metrics(monkeypatch)
         session=None,
     )
 
-    client = FakeRealtimeClient.last_instance
-    assert client.configure_kwargs["native_duplex"] is False
-    assert client.configure_kwargs["extra_body"] == {
-        "ref_audio": "data:audio/wav;base64,AAAA",
-        "return_stage_metrics": True,
-    }
-    assert client.sent == [
-        event
-        for index in range(4)
-        for event in (
-            {
-                "type": "conversation.item.create",
-                "item": {
-                    "type": "message",
-                    "role": "user",
-                    "content": [{"type": "input_text", "text": f"text {index}"}],
-                },
-            },
-            {"type": "response.create"},
-        )
-    ]
-    assert client.ack_count == 4
+    # One session per utterance: a model-native duplex session takes its text
+    # once, in the session context, so it cannot be re-seeded for a second one.
+    sessions = FakeRealtimeClient.instances
+    assert len(sessions) == 4
+    for index, client in enumerate(sessions):
+        assert "native_duplex" not in client.configure_kwargs
+        assert client.configure_kwargs["extra_body"] == {
+            "ref_audio": "data:audio/wav;base64,AAAA",
+            "return_stage_metrics": True,
+            "duplex_initial_user_text": f"text {index}",
+            "force_listen_count": 0,
+        }
+        # The target text rides the session context, never a conversation item:
+        # a text-only response.create is rejected by a model-native session.
+        assert client.sent == []
+        assert client.silence_seconds and all(seconds > 0 for seconds in client.silence_seconds)
+        assert client.ack_count == 1
+        assert client.closed == 1
+
     assert output.success is True
-    assert output.generated_text == "turn 1 turn 2 turn 3 turn 4"
+    assert output.generated_text == "turn 1 turn 1 turn 1 turn 1"
     assert output.audio_duration == pytest.approx(0.4)
     assert output.ttft > 0
     assert output.audio_ttfp > output.ttft
@@ -281,26 +294,32 @@ async def test_seed_tts_realtime_duplex_exports_per_request_metrics(monkeypatch)
             "session_id": session_id,
             "request_index": index,
             "utterance_id": f"utt-{index}",
-            "response_id": f"resp-{index + 1}",
+            # Response ids are per session, and each utterance now gets its own.
+            "response_id": "resp-1",
             "source": "client_monotonic_receive",
             "measurement_origin": {
-                "ttft": "conversation.item.create client send to first non-empty text delta",
-                "ttfp": "conversation.item.create client send to first audio packet",
+                "ttft": "first silence append client send to first non-empty text delta",
+                "ttfp": "first silence append client send to first audio packet",
                 "rtf": "request-start-to-last-audio receive time divided by emitted audio duration",
+                "tpot": "Stage-0 engine mean time per output token",
             },
             "ttft_ms": pytest.approx(20.0, abs=2.0),
+            "tpot_ms": 10.0,
             "ttfp_ms": pytest.approx(30.0, abs=2.0),
             "rtf": pytest.approx(0.3, abs=0.03),
             "audio_generation_ms": pytest.approx(30.0, abs=2.0),
             "audio_duration_ms": 100.0,
         }
-    assert output.duplex_session_metrics == {
-        "session_id": session_id,
-        "audio_turn_count": 4,
-        "mean_ttft_ms": pytest.approx(20.0, abs=2.0),
-        "mean_ttfp_ms": pytest.approx(30.0, abs=2.0),
-        "mean_rtf": pytest.approx(0.3, abs=0.03),
-    }
+    session = output.duplex_session_metrics
+    assert session["session_id"] == session_id
+    assert session["audio_turn_count"] == 4
+    assert session["ttft_ms"]["count"] == 4
+    assert session["ttft_ms"]["mean"] == pytest.approx(20.0, abs=2.0)
+    assert session["tpot_ms"] == {"count": 4, "mean": 10.0, "p50": 10.0, "p99": 10.0}
+    assert session["ttfp_ms"]["count"] == 4
+    assert session["ttfp_ms"]["mean"] == pytest.approx(30.0, abs=2.0)
+    assert session["rtf"]["count"] == 4
+    assert session["rtf"]["mean"] == pytest.approx(0.3, abs=0.03)
 
 
 def test_stage0_token_timings_use_weighted_tpot_when_itls_are_incomplete():
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_omniinteract.py b/tests/benchmarks/test_omniinteract.py
index f9488b11c..1a6acaca5 100644
--- a/tests/benchmarks/test_omniinteract.py
+++ b/tests/benchmarks/test_omniinteract.py
@@ -65,7 +65,7 @@ def _audio(
     value: int = 1,
 ) -> dict[str, object]:
     event: dict[str, object] = {
-        "type": "response.audio.delta",
+        "type": "response.output_audio.delta",
         "response_id": response_id,
         "format": "pcm16",
         "delta": base64.b64encode(bytes((value, 0)) * samples).decode(),
@@ -76,7 +76,7 @@ def _audio(
 
 
 def _text(response_id: str = "r1", value: str = "hello") -> dict[str, object]:
-    return {"type": "response.audio_transcript.delta", "response_id": response_id, "delta": value}
+    return {"type": "response.output_audio_transcript.delta", "response_id": response_id, "delta": value}
 
 
 def _listen(*, buffering: bool = False) -> dict[str, object]:
@@ -148,6 +148,72 @@ def _successful_output(
     return case, collector, result
 
 
+def test_response_metrics_include_engine_tpot_and_stream_window():
+    first_audio = _audio("r1")
+    first_audio["metadata"] = {
+        "audio_duration_ms": 100,
+        "vllm_omni": {
+            "stage_metrics": {
+                "0": {
+                    "num_tokens_out": 3,
+                    "vllm_tpot_ms": 10.0,
+                    "vllm_itls_ms": [10.0, 10.0],
+                }
+            }
+        },
+    }
+    second_audio = _audio("r2")
+    second_audio["metadata"] = {
+        "audio_duration_ms": 200,
+        "vllm_omni": {
+            "stage_metrics": {
+                "0": {
+                    "num_tokens_out": 2,
+                    "vllm_tpot_ms": 20.0,
+                    "vllm_itls_ms": [20.0],
+                }
+            }
+        },
+    }
+    collector = _collector(
+        (_created("r1"), 10.1),
+        (_text("r1", "first"), 10.2),
+        (first_audio, 10.3),
+        (_done("r1"), 10.4),
+        (_created("r2"), 12.1),
+        (_text("r2", "second"), 12.2),
+        (second_audio, 12.5),
+        (_done("r2"), 12.6),
+    )
+    result = oi.OmniInteractCaseResult("1q1a", "video.mp4", "", session_id="session")
+
+    oi._populate_response_metrics(result, collector, stream_start=10.0)
+
+    assert result.output_tokens == 5
+    assert [metric["tpot_ms"] for metric in result.duplex_request_metrics] == [10.0, 20.0]
+    assert result.duplex_session_metrics == {
+        "session_id": "session",
+        "audio_turn_count": 2,
+        "ttft_ms": {"count": 2, "mean": 100.0, "p50": 100.0, "p99": 100.0},
+        "tpot_ms": {"count": 2, "mean": 15.0, "p50": 10.0, "p99": 20.0},
+        "ttfp_ms": {"count": 2, "mean": 300.0, "p50": 200.0, "p99": 400.0},
+        "rtf": {"count": 2, "mean": 2.0, "p50": 2.0, "p99": 2.0},
+        "stream_ttft_ms": 200.0,
+        "stream_ttfp_ms": 300.0,
+        "stream_rtf": 8.333333,
+        "stream_audio_generation_ms": 2500.0,
+        "stream_audio_duration_ms": 300.0,
+        "stream_measurement_origin": {
+            "ttft": "input stream start to first non-empty text delta",
+            "ttfp": "input stream start to first audio packet",
+            "rtf": (
+                "input stream start-to-last-audio receive time divided by total emitted audio duration; "
+                "includes concurrent realtime input"
+            ),
+        },
+    }
+
+
 def _write_success(
     root: Path,
     case: data.OmniInteractCase,
@@ -401,6 +467,27 @@ def test_tolerated_playback_ack_rejection_is_a_warning_not_a_failure():
         oi._raise_if_session_terminated(collector, 0, warnings=warnings)
 
 
+def test_our_own_close_is_expected_even_though_the_server_stamps_a_reason():
+    """``session.close`` is answered with ``session.closed`` carrying ``client_close``.
+
+    The guard exists to catch a session that ended for a reason we did not ask
+    for. A close we requested is not that, whether or not the server names it.
+    """
+    collector = _collector(({"type": "session.closed", "reason": "client_close"}, 1.0))
+    oi._raise_if_session_terminated(collector, 0, explicit_close_from=0)
+
+    collector = _collector(({"type": "session.closed", "event": {"reason": "client_close"}}, 1.0))
+    oi._raise_if_session_terminated(collector, 0, explicit_close_from=0)
+
+    collector = _collector(({"type": "session.closed", "reason": "disconnect"}, 1.0))
+    with pytest.raises(RuntimeError, match="Unexpected session.closed: disconnect"):
+        oi._raise_if_session_terminated(collector, 0, explicit_close_from=0)
+
+    collector = _collector(({"type": "session.expired", "reason": "timeout"}, 1.0))
+    with pytest.raises(RuntimeError, match="session.expired: timeout"):
+        oi._raise_if_session_terminated(collector, 0, explicit_close_from=0)
+
+
 @pytest.mark.parametrize(
     ("event", "match"),
     [
@@ -427,7 +514,7 @@ def test_artifacts_publish_official_bundle_and_sparse_deferred_state(tmp_path: P
     assert result.success and result.eligible_for_official_eval
     assert summary["scene_type"] == "multi_turn"
     assert context and context.spans
-    assert all("delta" not in event for event in context.events if event["type"] == "response.audio.delta")
+    assert all("delta" not in event for event in context.events if event["type"] == "response.output_audio.delta")
     oi.publish_deferred_case_artifacts(tmp_path / "out", case, result)
     directory = oi._output_dir(tmp_path / "out", case)
     assert all((directory / name).is_file() for name in oi.SUCCESS_ARTIFACTS)
@@ -495,8 +582,8 @@ class _RealtimeClient(oi._RealtimeSession):
 
     instances: list[_RealtimeClient] = []
 
-    def __init__(self, config: oi.OmniInteractBenchmarkConfig, session_id: str, reference_audio: str):
-        super().__init__(config, session_id, reference_audio)
+    def __init__(self, config: oi.OmniInteractBenchmarkConfig, reference_audio: str):
+        super().__init__(config, reference_audio)
         self.acks: list[tuple[str, int]] = []
         self.instances.append(self)
 
@@ -555,7 +642,7 @@ async def test_public_runner_executes_one_prepared_session(tmp_path: Path, monke
     assert "autostart=0" in _RealtimeClient.instances[-1].url
     session_config = _RealtimeClient.instances[-1].session_config
     assert session_config.extra_body["custom"] == "value"
-    assert session_config.extra_body["native_duplex"] is True
+    assert "native_duplex" not in session_config.extra_body
     assert session_config.ref_audio == "data:audio/wav;base64,ref"
     acks = _RealtimeClient.instances[-1].acks
     # Cumulative acks for the one response: an optional 0 ms checkpoint the
@@ -645,7 +732,7 @@ async def test_adapter_requires_and_forwards_exact_prepared_payload(tmp_path: Pa
             transcript="timing metadata missing",
             output_tokens=0,
             duplex_request_metrics=[{"request_metrics": {"ttft_ms": 1.0}}],
-            duplex_session_metrics={"mean_ttft_ms": 10.0},
+            duplex_session_metrics={"ttft_ms": 10.0},
         )
 
     monkeypatch.setattr(benchmark_patch, "run_omniinteract_case", run)
@@ -713,7 +800,7 @@ async def test_adapter_reports_exact_or_weighted_token_timing(
             success=True,
             output_tokens=5,
             duplex_request_metrics=request_metrics,
-            duplex_session_metrics={"mean_ttft_ms": 100.0},
+            duplex_session_metrics={"ttft_ms": 100.0},
         )
 
     monkeypatch.setattr(benchmark_patch, "run_omniinteract_case", run)
diff --git a/tests/benchmarks/test_realtime_tts_probe.py b/tests/benchmarks/test_realtime_tts_probe.py
new file mode 100644
index 000000000..c07a09b62
--- /dev/null
+++ b/tests/benchmarks/test_realtime_tts_probe.py
@@ -0,0 +1,179 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""The Seed-TTS Realtime probe queues for a duplex session slot instead of failing."""
+
+from __future__ import annotations
+
+import pytest
+
+from vllm_omni.benchmarks.patch import patch as bench_patch
+from vllm_omni.clients import duplex as duplex_client
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _AdmissionGate:
+    """Stands in for ``DuplexClient``: refuses admission ``refusals`` times, then admits."""
+
+    instances: list[_AdmissionGate] = []
+    refusals = 0
+    refusal_code = "resource_exhausted"
+
+    def __init__(self, url: str, **kwargs: object) -> None:
+        del url, kwargs
+        self.entered = False
+        type(self).instances.append(self)
+
+    async def __aenter__(self) -> _AdmissionGate:
+        cls = type(self)
+        if cls.refusals > 0:
+            cls.refusals -= 1
+            raise duplex_client.DuplexProtocolError("duplex_session_capacity_exhausted: limit=4", code=cls.refusal_code)
+        self.entered = True
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:
+        del exc_type, exc, tb
+
+    async def events(self):  # the collector's consume loop ends at once
+        return
+        yield  # pragma: no cover
+
+
+@pytest.fixture
+def gate(monkeypatch: pytest.MonkeyPatch) -> type[_AdmissionGate]:
+    _AdmissionGate.instances = []
+    _AdmissionGate.refusals = 0
+    _AdmissionGate.refusal_code = "resource_exhausted"
+    monkeypatch.setattr(duplex_client, "DuplexClient", _AdmissionGate)
+    return _AdmissionGate
+
+
+async def _configure(probe: bench_patch._RealtimeTTSProbe) -> None:
+    try:
+        await probe.configure("test-model", auto_response=True)
+    finally:
+        await probe.__aexit__(None, None, None)
+
+
+@pytest.mark.asyncio
+async def test_configure_waits_for_a_free_session_slot(gate) -> None:
+    """Two refusals, then a slot: the request is served, not counted as failed."""
+    gate.refusals = 2
+    probe = bench_patch._RealtimeTTSProbe("ws://test/v1/realtime?duplex=1")
+    await _configure(probe)
+    assert len(gate.instances) == 3
+    assert gate.instances[-1].entered is True
+    assert probe._client is gate.instances[-1]
+
+
+@pytest.mark.asyncio
+async def test_configure_raises_other_rejections_at_once(gate) -> None:
+    gate.refusals = 1
+    gate.refusal_code = "unsupported_turn_detection"
+    probe = bench_patch._RealtimeTTSProbe("ws://test/v1/realtime?duplex=1")
+    with pytest.raises(duplex_client.DuplexProtocolError):
+        await _configure(probe)
+    assert len(gate.instances) == 1
+
+
+@pytest.mark.asyncio
+async def test_configure_gives_up_when_the_slot_wait_budget_is_spent(gate, monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(bench_patch._RealtimeTTSProbe, "_SESSION_SLOT_WAIT_S", 0.0)
+    gate.refusals = 5
+    probe = bench_patch._RealtimeTTSProbe("ws://test/v1/realtime?duplex=1")
+    with pytest.raises(duplex_client.DuplexProtocolError) as excinfo:
+        await _configure(probe)
+    assert excinfo.value.code == "resource_exhausted"
+    assert len(gate.instances) == 1
+
+
+class _SilenceSink:
+    """Stands in for a configured ``DuplexClient``: records every appended chunk."""
+
+    def __init__(self) -> None:
+        self.config = duplex_client.SessionConfig()
+        self.chunks: list[bytes] = []
+
+    async def append_audio(self, pcm: bytes, *, is_speech: bool | None = None, video_frames=None) -> None:
+        del video_frames
+        assert is_speech is False
+        self.chunks.append(pcm)
+
+
+@pytest.mark.asyncio
+async def test_stream_silence_stops_at_the_turn_end(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Silence is fed until the turn settles, not for the whole cap."""
+    probe = bench_patch._RealtimeTTSProbe("ws://test/v1/realtime?duplex=1")
+    sink = _SilenceSink()
+    probe._client = sink
+
+    async def no_wait(_: float) -> None:
+        return
+
+    monkeypatch.setattr(bench_patch.asyncio, "sleep", no_wait)
+    streamed = await probe.stream_silence(seconds=12.0, chunk_ms=200, until=lambda: len(sink.chunks) >= 3)
+    assert len(sink.chunks) == 3
+    assert streamed == pytest.approx(0.6)
+    assert all(len(chunk) == sink.config.input_audio.byte_count(200) for chunk in sink.chunks)
+
+
+@pytest.mark.asyncio
+async def test_stream_silence_runs_to_the_cap_when_the_turn_never_settles(monkeypatch: pytest.MonkeyPatch) -> None:
+    probe = bench_patch._RealtimeTTSProbe("ws://test/v1/realtime?duplex=1")
+    sink = _SilenceSink()
+    probe._client = sink
+
+    async def no_wait(_: float) -> None:
+        return
+
+    monkeypatch.setattr(bench_patch.asyncio, "sleep", no_wait)
+    streamed = await probe.stream_silence(seconds=1.0, chunk_ms=200, until=lambda: False)
+    assert len(sink.chunks) == 5
+    assert streamed == pytest.approx(1.0)
+
+
+class _TurnEvents:
+    def __init__(self, response_ids: list[str], audio: dict[str, bytes], text: dict[str, str] | None = None) -> None:
+        self.response_ids = response_ids
+        self._audio = audio
+        self._text = text or {}
+
+    def audio_bytes(self, response_id: str) -> bytes:
+        return self._audio.get(response_id, b"")
+
+    def response_text(self, response_id: str) -> str:
+        return self._text.get(response_id, "")
+
+
+def test_turn_response_is_the_first_one_with_audio_even_if_the_model_spoke_again(caplog) -> None:
+    events = _TurnEvents(["r0", "r1", "r2"], {"r1": b"\x01\x00", "r2": b"\x02\x00"})
+    with caplog.at_level("WARNING", logger=bench_patch.logger.name):
+        assert bench_patch._seed_tts_turn_response_id(events, 0, 0) == "r1"
+    assert "spoke again" in caplog.text
+
+
+def test_turn_response_ignores_responses_from_before_the_turn() -> None:
+    events = _TurnEvents(["r0", "r1"], {"r0": b"\x01\x00", "r1": b"\x02\x00"})
+    assert bench_patch._seed_tts_turn_response_id(events, 1, 0) == "r1"
+
+
+def test_turn_without_audio_is_an_error() -> None:
+    events = _TurnEvents(["r0"], {})
+    with pytest.raises(RuntimeError, match="no audio response"):
+        bench_patch._seed_tts_turn_response_id(events, 0, 0)
+
+
+def test_stall_report_says_the_model_never_answered() -> None:
+    events = _TurnEvents(["r0"], {"r0": b"\x01\x00"})
+    report = bench_patch._seed_tts_turn_stall_report(events, 1, 3, 30.0)
+    assert "turn 3 never started a response" in report
+    assert "30.0s of silence" in report
+
+
+def test_stall_report_lists_a_response_that_never_finished() -> None:
+    events = _TurnEvents(["r1"], {"r1": b"\x01\x00\x02\x00"}, {"r1": "hello"})
+    report = bench_patch._seed_tts_turn_stall_report(events, 0, 0, 4.2)
+    assert "started 1 response(s) after 4.2s of silence" in report
+    assert "r1 (4 audio bytes, text 'hello')" in report
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_bootstrap.py b/tests/buildkite/test_amd_bootstrap.py
index 593ba8b26..ac0c8dba4 100644
--- a/tests/buildkite/test_amd_bootstrap.py
+++ b/tests/buildkite/test_amd_bootstrap.py
@@ -136,7 +136,7 @@ def test_label_lookup_selects_tiers(tmp_path, labels, expected_levels):
     ] == expected_levels
 
 
-@pytest.mark.parametrize("debug_test_yaml", ["ready,ready", "nightly", ", ,", " \t"])
+@pytest.mark.parametrize("debug_test_yaml", ["ready,ready", "nightly,nightly", ", ,", " \t"])
 def test_invalid_debug_override_fails_without_label_lookup(tmp_path, debug_test_yaml):
     result = _run_bootstrap(tmp_path, debug_test_yaml=debug_test_yaml, curl_status=22)
 
diff --git a/tests/buildkite/test_amd_pipeline.py b/tests/buildkite/test_amd_pipeline.py
index 1e74b50a1..fac4f8c29 100644
--- a/tests/buildkite/test_amd_pipeline.py
+++ b/tests/buildkite/test_amd_pipeline.py
@@ -10,10 +10,13 @@ import yaml
 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) -> dict:
-    pipeline = yaml.safe_load(AMD_MERGE_PIPELINE.read_text(encoding="utf-8"))
+def _find_step(label: str, pipeline_path: Path = AMD_MERGE_PIPELINE) -> dict:
+    pipeline = yaml.safe_load(pipeline_path.read_text(encoding="utf-8"))
 
     def walk(steps: list[dict]) -> dict | None:
         for step in steps:
@@ -40,3 +43,37 @@ def test_qwen3_tts_base_preserves_advanced_model_arguments() -> None:
     run_level_index = argv.index("--run-level")
     assert argv[marker_index + 1] == "advanced_model and cuda"
     assert argv[run_level_index + 1] == "advanced_model"
+
+
+def test_qwen3_accuracy_defers_artifact_path_expansion() -> None:
+    step = _find_step("Qwen3-Omni Accuracy", AMD_NIGHTLY_PIPELINE)
+    staging_command = next(command for command in step["commands"] if "artifact_dir=" in command)
+
+    # Dynamic pipelines are interpolated once during upload. Double dollars
+    # preserve these variables for the GPU job's runtime shell.
+    assert '"$$PWD"' in staging_command
+    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_amd_ready_r2_01.py b/tests/buildkite/test_amd_ready_r2_01.py
new file mode 100644
index 000000000..9d5147982
--- /dev/null
+++ b/tests/buildkite/test_amd_ready_r2_01.py
@@ -0,0 +1,72 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from pathlib import Path
+from shlex import split
+
+import pytest
+import yaml
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+AMD_READY_PIPELINE = Path(".buildkite/amd/test-amd-ready.yml")
+R2_01_LABEL = "ROCm · Engine & Model Executor GPU Coverage (R2-01)"
+SINGLE_GPU_MARKERS = (
+    "core_model and cuda and not (cards_2 or cards_3 or cards_4 or cards_5 or cards_6 or cards_7 or cards_8)"
+)
+EXCLUDED_TEST = "test_code2wav_streaming_batch_matches_ragged_flow_numerics"
+
+
+def _find_step(label: str) -> dict:
+    pipeline = yaml.safe_load(AMD_READY_PIPELINE.read_text(encoding="utf-8"))
+
+    def walk(steps: list[dict]) -> dict | None:
+        for step in steps:
+            if step.get("label") == label:
+                return step
+            if nested := walk(step.get("steps", [])):
+                return nested
+        return None
+
+    step = walk(pipeline.get("steps", []))
+    assert step is not None, f"missing AMD pipeline step: {label}"
+    return step
+
+
+def _assert_single_gpu_selection(command: str) -> None:
+    argv = split(command)
+    assert "tests/engine/" in argv
+    assert "tests/model_executor/" in argv
+    assert "tests/worker/test_batched_omni_output.py" not in argv
+    assert argv[argv.index("-m") + 1] == SINGLE_GPU_MARKERS
+    assert argv[argv.index("-k") + 1] == f"not {EXCLUDED_TEST}"
+    assert argv[argv.index("--run-level") + 1] == "core_model"
+
+
+def test_r2_01_is_nonblocking_single_gpu_coverage() -> None:
+    step = _find_step(R2_01_LABEL)
+
+    assert step["agent_pool"] == "mi300_1"
+    assert step["grade"] == "NonBlocking"
+    assert step["timeout_in_minutes"] == 20
+    assert step["mirror_hardwares"] == ["amdproduction"]
+    assert step["artifact_paths"] == ["artifacts/rocm-r2-01/**/*"]
+
+
+def test_r2_01_runs_once_fails_closed_and_publishes_results() -> None:
+    commands = _find_step(R2_01_LABEL)["commands"]
+    pytest_commands = [command for command in commands if command.lstrip().startswith("pytest ")]
+    assert len(pytest_commands) == 1
+    run_command = pytest_commands[0]
+    artifact_dir = "$$BUILDKITE_BUILD_CHECKOUT_PATH/artifacts/rocm-r2-01"
+
+    _assert_single_gpu_selection(run_command)
+    assert "--collect-only" not in "\n".join(commands)
+    assert "VLLM_CI_ALLOW_NO_TESTS" not in "\n".join(commands)
+    assert any(artifact_dir in command for command in commands)
+    assert "-v" in split(run_command)
+    assert "-ra" in split(run_command)
+    assert "--durations=0" in split(run_command)
+    assert "--junitxml=$$R2_01_ARTIFACT_DIR/pytest.xml" in split(run_command)
+    assert "$$R2_01_ARTIFACT_DIR/pytest.log" in run_command
+    assert any("$$R2_01_ARTIFACT_DIR/pytest-summary.txt" in command for command in commands)
diff --git a/tests/buildkite/test_amd_suite_selection.py b/tests/buildkite/test_amd_suite_selection.py
index b1b25aa26..dc447f208 100644
--- a/tests/buildkite/test_amd_suite_selection.py
+++ b/tests/buildkite/test_amd_suite_selection.py
@@ -24,10 +24,12 @@ SPEC.loader.exec_module(SELECTOR)
         ("feature", ("ready",), ("ready",)),
         ("feature", ("merge-test",), ("merge",)),
         ("feature", ("merge-test", "ready"), ("ready", "merge")),
+        ("feature", ("nightly-test",), ("nightly",)),
+        ("feature", ("ready", "merge-test", "nightly-test"), ("ready", "merge", "nightly")),
         ("feature", ("amd-test",), ("ready",)),
         ("feature", ("amd-test", "merge-test"), ("merge",)),
         ("feature", ("amd-test", "ready", "merge-test"), ("ready", "merge")),
-        ("feature", ("nightly-test",), ("ready",)),
+        ("feature", ("amd-test", "nightly-test"), ("nightly",)),
         ("feature", ("not-ready", "merge-test-extra"), ("ready",)),
     ],
 )
@@ -39,8 +41,17 @@ def test_debug_override_takes_precedence_and_normalizes_input():
     assert SELECTOR.select_amd_test_suites(
         branch="main",
         labels=("ready",),
-        debug_test_yaml=" MERGE, ready,",
-    ) == ("merge", "ready")
+        debug_test_yaml=" NIGHTLY, merge, ready,",
+        nightly=False,
+    ) == ("nightly", "merge", "ready")
+
+
+def test_scheduled_main_selects_only_nightly():
+    assert SELECTOR.select_amd_test_suites(
+        branch="main",
+        labels=(),
+        nightly=True,
+    ) == ("nightly",)
 
 
 def test_empty_debug_override_uses_normal_selection():
@@ -51,7 +62,7 @@ def test_empty_debug_override_uses_normal_selection():
     ) == ("merge",)
 
 
-@pytest.mark.parametrize("value", ["ready,ready", "nightly", ", ,", " \t"])
+@pytest.mark.parametrize("value", ["ready,ready", "nightly,nightly", "weekly", ", ,", " \t"])
 def test_invalid_debug_override(value):
     with pytest.raises(ValueError):
         SELECTOR.select_amd_test_suites(
diff --git a/tests/buildkite/test_rocm_dockerfile.py b/tests/buildkite/test_rocm_dockerfile.py
new file mode 100644
index 000000000..8101b2157
--- /dev/null
+++ b/tests/buildkite/test_rocm_dockerfile.py
@@ -0,0 +1,126 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from pathlib import Path
+
+import pytest
+
+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:
+    prefix = f"ARG {name}="
+    matches = [
+        line.removeprefix(prefix) for line in path.read_text(encoding="utf-8").splitlines() if line.startswith(prefix)
+    ]
+    assert len(matches) == 1, f"expected one {name} declaration in {path}, found {len(matches)}"
+    return matches[0]
+
+
+def _line_index(lines: list[str], prefix: str) -> int:
+    matches = [index for index, line in enumerate(lines) if line.startswith(prefix)]
+    assert len(matches) == 1, f"expected one line starting with {prefix!r}, found {len(matches)}"
+    return matches[0]
+
+
+def test_rocm_base_tracks_ci_vllm_release() -> None:
+    ci_release = _docker_arg(CI_DOCKERFILE, "VLLM_BASE_TAG")
+    rocm_base = _docker_arg(ROCM_DOCKERFILE, "BASE_IMAGE")
+
+    image_ref, separator, image_tag = rocm_base.rpartition(":")
+    assert separator, f"expected a tagged ROCm base image, got {rocm_base}"
+    assert image_ref.rsplit("/", 1)[-1] == "vllm-openai-rocm", image_ref
+    assert image_tag == ci_release
+
+
+def test_rocm_defaults_to_prebuilt_base_image() -> None:
+    assert _docker_arg(ROCM_DOCKERFILE, "USE_NIGHTLY_BUILD") == "0"
+
+
+def test_amd_build_uses_registry_cache() -> None:
+    template = AMD_TEMPLATE.read_text(encoding="utf-8")
+    script_command = '"bash .buildkite/amd/scripts/build-ci-image.sh"'
+    script = AMD_BUILD_SCRIPT.read_text(encoding="utf-8")
+
+    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_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:
+    ci_release = _docker_arg(CI_DOCKERFILE, "VLLM_BASE_TAG")
+    rocm_source_ref = _docker_arg(ROCM_DOCKERFILE, "VLLM_VERSION_OR_COMMIT_HASH")
+
+    assert rocm_source_ref == ci_release
+
+
+def test_rocm_dockerfile_contains_vllm_api_canary() -> None:
+    dockerfile = ROCM_DOCKERFILE.read_text(encoding="utf-8")
+    lines = dockerfile.splitlines()
+    nightly_start = _line_index(lines, 'RUN if [ "${USE_NIGHTLY_BUILD}" = "1" ]; then')
+    canary = (
+        'RUN python3 -c "import vllm; '
+        "from vllm.v1.kv_cache_interface import compute_layout_strides; "
+        "from vllm.v1.kv_cache_layout import KVCacheLayout;"
+    )
+    canary_index = _line_index(lines, canary)
+
+    assert any(line.strip() == "fi" for line in lines[nightly_start + 1 : canary_index]), (
+        "vLLM API canary must follow the optional nightly source reinstall block"
+    )
diff --git a/tests/buildkite/test_skip_ci.py b/tests/buildkite/test_skip_ci.py
index 4c90b3ff7..1a04ecab8 100644
--- a/tests/buildkite/test_skip_ci.py
+++ b/tests/buildkite/test_skip_ci.py
@@ -144,6 +144,14 @@ def test_npu_nightly_only_skips_all_l23() -> None:
     assert not decision.is_run("npu", "l3")
 
 
+def test_amd_nightly_only_skips_all_l23() -> None:
+    decision = _decision([".buildkite/amd/test-amd-nightly.yml"])
+    assert _is_yaml_gated(decision)
+    assert _all_l23_skipped(decision)
+    assert not decision.is_run("amd", "l2")
+    assert not decision.is_run("amd", "l3")
+
+
 def test_nightly_and_weekly_skips_all_l23() -> None:
     decision = _decision(
         [
diff --git a/tests/buildkite/test_upload_pipeline.py b/tests/buildkite/test_upload_pipeline.py
index 7492a4b82..b39dba2cd 100644
--- a/tests/buildkite/test_upload_pipeline.py
+++ b/tests/buildkite/test_upload_pipeline.py
@@ -13,16 +13,21 @@ sys.path.insert(0, str(Path(__file__).resolve().parents[2] / ".buildkite" / "com
 from skip_ci import resolve_ci_decision  # noqa: E402
 from upload_pipeline import (  # noqa: E402
     CUDA_HF_TOKEN_EXPORT,
+    NIGHTLY_LABEL_IF,
+    _changed_files_for_source_filter,
     _expand_mirror_hardwares,
     _get_mirror_hw_selector,
     _load_bootstrap_steps,
+    _load_source_file_dependencies,
     _render_bootstrap_pipeline,
     _render_test_pipeline,
+    _resolve_source_file_dependencies,
 )
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
 CUDA_BOOTSTRAP_STEPS = Path(".buildkite/cuda/bootstrap-upload-steps.yml")
+NIGHTLY_YAML = Path(".buildkite/cuda/test-nightly.yml")
 BOOTSTRAP_STEPS_TEMPLATE = """steps:
   - key: image-build
   - key: upload-ready-pipeline
@@ -101,6 +106,26 @@ def test_npu_docs_only_does_not_upload_ready_on_nightly() -> None:
     assert 'build.env("NIGHTLY") == "1"' in by_key["upload-nightly-pipeline"]["if"]
 
 
+def test_nightly_label_if_is_only_nightly_test() -> None:
+    assert 'labels includes "nightly-test"' in NIGHTLY_LABEL_IF
+    forbidden = (
+        'includes "omni-test"',
+        'includes "tts-test"',
+        'includes "diffusion-x2iat-test"',
+        'includes "diffusion-x2v-test"',
+    )
+    for needle in forbidden:
+        assert needle not in NIGHTLY_LABEL_IF
+    for path in (
+        Path(".buildkite/cuda/test-nightly.yml"),
+        Path(".buildkite/npu/test-npu-nightly.yml"),
+        Path(".buildkite/common/scripts/upload_pipeline.py"),
+    ):
+        text = path.read_text(encoding="utf-8")
+        for needle in forbidden:
+            assert needle not in text, f"{path} still references {needle}"
+
+
 def test_yaml_gated_l45_only_does_not_unconditionally_build_image() -> None:
     rendered = _render([".buildkite/cuda/test-nightly.yml"])
     assert "if: true" not in rendered
@@ -344,6 +369,52 @@ def test_cpu_step_without_mirror_hardwares_is_unchanged() -> None:
     assert _expand_mirror_hardwares(step) is step
 
 
+def _leaf_steps(steps: list) -> list[dict]:
+    leaves: list[dict] = []
+    for step in steps:
+        if not isinstance(step, dict):
+            continue
+        nested = step.get("steps")
+        if nested is not None:
+            leaves.extend(_leaf_steps(nested))
+        else:
+            leaves.append(step)
+    return leaves
+
+
+def test_nightly_yaml_infers_h100_l4_and_b200(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Nightly inferred jobs share card counts across H100/L4 and B200 mirrors."""
+    src = yaml.safe_load(NIGHTLY_YAML.read_text(encoding="utf-8"))
+    pytest_leaves = [step for step in _leaf_steps(src["steps"]) if "pytest" in str(step.get("commands"))]
+    inferred_leaves = [step for step in pytest_leaves if "mirror_hardwares" not in step]
+    pinned_leaves = [step for step in pytest_leaves if "mirror_hardwares" in step]
+    assert inferred_leaves
+
+    monkeypatch.setattr("upload_pipeline._get_mirror_hw_selector", lambda: "")
+    default_by_label = {
+        step["label"]: step for step in _leaf_steps(_render_test_pipeline(src, changed_files=None)["steps"])
+    }
+
+    monkeypatch.setattr("upload_pipeline._get_mirror_hw_selector", lambda: "b200")
+    b200_src = yaml.safe_load(NIGHTLY_YAML.read_text(encoding="utf-8"))
+    b200_by_label = {
+        step["label"]: step for step in _leaf_steps(_render_test_pipeline(b200_src, changed_files=None)["steps"])
+    }
+
+    pytest_labels = {step["label"] for step in inferred_leaves}
+    pinned_labels = {step["label"] for step in pinned_leaves}
+    assert pinned_labels <= set(default_by_label)
+    assert pinned_labels.isdisjoint(b200_by_label)
+    assert pytest_labels <= set(default_by_label)
+    assert pytest_labels <= set(b200_by_label)
+    for label in pytest_labels:
+        default_step = default_by_label[label]
+        b200_step = b200_by_label[label]
+        assert default_step["agents"]["queue"] in {"mithril-h100-pool", "l4-k8s"}
+        assert b200_step["agents"]["queue"] == "b200-k8s"
+        assert _gpu_limit(default_step) == _gpu_limit(b200_step)
+
+
 @pytest.mark.parametrize(("raw", "expected"), [("", ""), ("  ", ""), ("b200", "b200"), ("B200", "b200")])
 def test_mirror_hw_selector_empty_or_b200(monkeypatch: pytest.MonkeyPatch, raw: str, expected: str) -> None:
     monkeypatch.setenv("MIRROR_HW", raw)
@@ -366,8 +437,17 @@ def test_mirror_hw_typo_fails_closed(monkeypatch: pytest.MonkeyPatch) -> None:
         )
 
 
-def _surviving_labels(doc: dict, changed_files: list[str]) -> set[str]:
-    rendered = _render_test_pipeline(doc, changed_files=changed_files)
+def _surviving_labels(
+    doc: dict,
+    changed_files: list[str],
+    *,
+    pipeline_path: Path | None = None,
+) -> set[str]:
+    rendered = _render_test_pipeline(
+        doc,
+        changed_files=changed_files,
+        pipeline_path=pipeline_path,
+    )
     labels: set[str] = set()
 
     def walk(steps: list | None) -> None:
@@ -382,6 +462,17 @@ def _surviving_labels(doc: dict, changed_files: list[str]) -> set[str]:
     return labels
 
 
+def _iter_steps(doc: dict):
+    def walk(steps: list | None):
+        for step in steps or []:
+            if not isinstance(step, dict):
+                continue
+            yield step
+            yield from walk(step.get("steps"))
+
+    yield from walk(doc.get("steps"))
+
+
 # Synthetic coverage-style job: shared inputs that change what the split measures.
 _COVERAGE_SHARED_INPUTS_DOC = {
     "steps": [
@@ -426,3 +517,291 @@ def test_coverage_shared_inputs_ignored_for_unrelated_change() -> None:
     )
     assert "Coverage Pilot" not in labels
     assert "Unrelated Model Test" not in labels
+
+
+def _pipeline_dep_keys(path: Path) -> set[str]:
+    doc = yaml.safe_load(path.read_text(encoding="utf-8"))
+    keys: set[str] = set()
+
+    def walk(steps: list | None) -> None:
+        for step in steps or []:
+            if not isinstance(step, dict):
+                continue
+            deps = step.get("source_file_dependencies")
+            if isinstance(deps, str) and "/" not in deps:
+                keys.add(deps)
+            elif isinstance(deps, list) and deps and all("/" not in item for item in deps):
+                keys.update(deps)
+            walk(step.get("steps"))
+
+    walk((doc or {}).get("steps"))
+    return keys
+
+
+def test_pipeline_source_file_dependency_keys_are_registered() -> None:
+    _load_source_file_dependencies.cache_clear()
+    registry = _load_source_file_dependencies()
+    used = (
+        _pipeline_dep_keys(Path(".buildkite/cuda/test-ready.yml"))
+        | _pipeline_dep_keys(Path(".buildkite/cuda/test-merge.yml"))
+        | _pipeline_dep_keys(Path(".buildkite/cuda/test-nightly.yml"))
+        | _pipeline_dep_keys(Path(".buildkite/cuda/test-weekly.yml"))
+        | _pipeline_dep_keys(Path(".buildkite/npu/test-npu-nightly.yml"))
+    )
+    missing = used - set(registry)
+    assert not missing, f"unregistered source_file_dependencies keys: {sorted(missing)}"
+
+
+def test_source_file_dependencies_key_expands_from_registry() -> None:
+    doc = {
+        "steps": [
+            {
+                "label": "Diffusion · Qwen Image Test",
+                "source_file_dependencies": "diffusion_qwen_image_function",
+                "commands": ["pytest"],
+            },
+        ],
+    }
+    assert "Diffusion · Qwen Image Test" in _surviving_labels(
+        doc,
+        ["vllm_omni/diffusion/models/qwen_image/transformer.py"],
+    )
+    assert "Diffusion · Qwen Image Test" not in _surviving_labels(doc, ["vllm_omni/unrelated.py"])
+
+
+def test_registry_lists_pytest_targets() -> None:
+    _load_source_file_dependencies.cache_clear()
+    resolved = _resolve_source_file_dependencies(
+        {
+            "label": "Diffusion · Wan22 Test",
+            "source_file_dependencies": "diffusion_wan22_function",
+            "commands": [
+                "pytest -s -v tests/e2e/offline_inference/test_wan22_t2v.py "
+                "tests/e2e/online_serving/test_wan22_t2v.py -m 'advanced_model'",
+            ],
+        },
+    )
+    assert resolved is not None
+    assert "tests/e2e/offline_inference/test_wan22_t2v.py" in resolved
+    assert "tests/e2e/online_serving/test_wan22_t2v.py" in resolved
+    assert "vllm_omni/diffusion/models/wan2_2/" in resolved
+
+
+def test_coverage_key_lists_offline_online_scripts() -> None:
+    resolved = _resolve_source_file_dependencies(
+        {
+            "label": "TTS · Qwen3-TTS Base Test",
+            "source_file_dependencies": "tts_qwen3_tts_cov",
+            "commands": [
+                ".buildkite/common/scripts/run_cov_split.sh \\\n"
+                "  --offline tests/e2e/offline_inference/test_qwen3_tts_base.py \\\n"
+                "  --online tests/e2e/online_serving/test_qwen3_tts_base.py",
+            ],
+        },
+    )
+    assert resolved is not None
+    assert "tests/e2e/offline_inference/test_qwen3_tts_base.py" in resolved
+    assert "tests/e2e/online_serving/test_qwen3_tts_base.py" in resolved
+    assert ".buildkite/common/scripts/run_cov_split.sh" in resolved
+    assert "pyproject.toml" in resolved
+
+
+def test_source_file_dependencies_list_of_keys_concatenates() -> None:
+    resolved = _resolve_source_file_dependencies(
+        {
+            "label": "composed",
+            "source_file_dependencies": ["omni_qwen3_omni_function", "tts_qwen3_tts_function"],
+        },
+    )
+    assert resolved is not None
+    assert "vllm_omni/model_executor/models/qwen3_omni/" in resolved
+    assert "vllm_omni/model_executor/models/qwen3_tts/" in resolved
+    assert resolved.count("vllm_omni/model_executor/models/common/snake_activation.py") == 1
+
+
+def test_unknown_source_file_dependencies_key() -> None:
+    with pytest.raises(ValueError, match="unknown source_file_dependencies"):
+        _render_test_pipeline(
+            {"steps": [{"label": "bad", "source_file_dependencies": "not_a_real_key"}]},
+            changed_files=None,
+        )
+
+
+def test_source_file_dependencies_rejects_mixed_keys_and_paths() -> None:
+    with pytest.raises(ValueError, match="mixes registry keys and path prefixes"):
+        _resolve_source_file_dependencies(
+            {
+                "label": "bad",
+                "source_file_dependencies": ["omni_qwen3_omni_function", "tests/e2e/online_serving/test_qwen3_omni.py"],
+            },
+        )
+
+
+# Synthetic pipeline: selection depends only on listed deps, not on live job names.
+_SOURCE_FILTER_DOC = {
+    "steps": [
+        {
+            "group": "E2E Tests",
+            "if": 'build.env("NON_CRITICAL") == "1"',
+            "steps": [
+                {
+                    "label": "Dedicated E2E",
+                    "commands": ["pytest -sv tests/e2e/online_serving/test_magi2.py"],
+                },
+            ],
+        },
+        {
+            "label": "Omni Sweep",
+            "source_file_dependencies": ["tests/e2e/online_serving/test_qwen3_omni.py"],
+            "commands": ["pytest -sv tests/e2e/ -m omni"],
+        },
+        {
+            "label": "Z-Image Function",
+            "source_file_dependencies": [
+                "tests/e2e/online_serving/test_zimage_expansion.py",
+                "vllm_omni/diffusion/models/z_image/",
+            ],
+            "mirror_hardwares": "l4_4",
+            "commands": ["pytest -sv tests/e2e/online_serving/test_zimage_expansion.py"],
+        },
+        {
+            "label": "Tiny Model",
+            "source_file_dependencies": ["tests/e2e/online_serving/test_tiny.py"],
+            "commands": ["pytest -sv tests/e2e/ -m tiny"],
+        },
+        {
+            "label": "Wan Function",
+            "source_file_dependencies": [
+                "tests/e2e/offline_inference/test_wan22_t2v.py",
+                "tests/e2e/online_serving/test_wan22_t2v.py",
+                "vllm_omni/diffusion/models/wan2_2/",
+            ],
+            "commands": ["pytest -sv tests/e2e/offline_inference/test_wan22_t2v.py"],
+        },
+        {
+            "label": "Wan Perf",
+            "source_file_dependencies": ["vllm_omni/diffusion/models/wan2_2/"],
+            "commands": ["pytest -sv tests/dfx/perf/scripts/run_benchmark.py"],
+        },
+        {
+            "label": "Doc Test",
+            "source_file_dependencies": [
+                "tests/examples/offline_inference/test_text_to_image.py",
+                "tests/examples/online_serving/test_text_to_image.py",
+                "vllm_omni/diffusion/models/qwen_image/",
+                "vllm_omni/diffusion/models/z_image/",
+            ],
+            "commands": ["pytest -sv tests/examples/*/test_text_to_image.py"],
+        },
+    ],
+}
+
+
+def test_source_filter_ignores_unrelated_e2e_file() -> None:
+    """A sweep command is not a dependency; only listed paths select a keyed job."""
+    labels = _surviving_labels(_SOURCE_FILTER_DOC, ["tests/e2e/online_serving/test_magi2.py"])
+    assert labels == {"Dedicated E2E"}
+
+
+def test_source_filter_selects_job_by_listed_script_not_sibling() -> None:
+    labels = _surviving_labels(_SOURCE_FILTER_DOC, ["tests/e2e/online_serving/test_zimage_expansion.py"])
+    assert labels == {"Dedicated E2E", "Z-Image Function"}
+
+
+def test_source_filter_selects_every_job_sharing_a_path() -> None:
+    labels = _surviving_labels(_SOURCE_FILTER_DOC, ["vllm_omni/diffusion/models/wan2_2/transformer.py"])
+    assert labels == {"Dedicated E2E", "Wan Function", "Wan Perf"}
+
+
+def test_source_filter_selects_composed_doc_job_by_example_or_model() -> None:
+    for changed in (
+        "tests/examples/online_serving/test_text_to_image.py",
+        "vllm_omni/diffusion/models/z_image/transformer.py",
+        "vllm_omni/diffusion/models/qwen_image/foo.py",
+    ):
+        labels = _surviving_labels(_SOURCE_FILTER_DOC, [changed])
+        assert "Doc Test" in labels, changed
+        assert "Tiny Model" not in labels
+        assert "Omni Sweep" not in labels
+    assert "Doc Test" not in _surviving_labels(_SOURCE_FILTER_DOC, ["tests/e2e/online_serving/test_magi2.py"])
+
+
+def test_source_filter_strips_deps_and_expands_hardware(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr("upload_pipeline._get_mirror_hw_selector", lambda: "")
+    rendered = _render_test_pipeline(
+        _SOURCE_FILTER_DOC,
+        changed_files=["tests/e2e/online_serving/test_zimage_expansion.py"],
+    )
+    dumped = yaml.safe_dump(rendered)
+    assert "source_file_dependencies" not in dumped
+    assert "mirror_hardwares" not in dumped
+    z_image = next(step for step in _iter_steps(rendered) if step.get("label") == "Z-Image Function")
+    assert z_image["agents"]["queue"] == "l4-k8s"
+
+
+def test_source_filter_respects_force_all_and_uses_diff_on_main(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    class _Ctx:
+        changed_files = ["vllm_omni/unrelated.py"]
+
+    # Post-merge main L3 must still filter by the commit diff.
+    monkeypatch.setenv("BUILDKITE_BRANCH", "main")
+    assert _changed_files_for_source_filter(_Ctx(), force_all=False, e2e_only=False) == [
+        "vllm_omni/unrelated.py",
+    ]
+
+    monkeypatch.setenv("BUILDKITE_BRANCH", "feat/source-filter")
+    assert _changed_files_for_source_filter(_Ctx(), force_all=False, e2e_only=False) == [
+        "vllm_omni/unrelated.py",
+    ]
+    assert _changed_files_for_source_filter(_Ctx(), force_all=True, e2e_only=False) is None
+    assert _changed_files_for_source_filter(_Ctx(), force_all=False, e2e_only=True) is None
+
+
+def test_source_filter_fallback_is_fallback_when_no_job_key_matches(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Fallback only when no listed prefix matched; a matching prefix still wins."""
+    monkeypatch.setattr("upload_pipeline._get_mirror_hw_selector", lambda: "")
+    monkeypatch.setenv("BUILDKITE_BRANCH", "feat/nightly-yaml")
+    pipeline_yaml = Path(".buildkite/npu/test-npu-nightly.yml")
+    shared_paths = _load_source_file_dependencies()["source_filter_fallback"]
+
+    # Synthetic steps only — do not pin live Buildkite job labels.
+    doc = {
+        "steps": [
+            {"key": "ungated", "commands": ["true"]},
+            {
+                "key": "gated_a",
+                "source_file_dependencies": ["pkg/model_a/"],
+                "commands": ["true"],
+            },
+            {
+                "key": "gated_b",
+                "source_file_dependencies": ["pkg/model_b/"],
+                "commands": ["true"],
+            },
+        ],
+    }
+
+    def surviving_keys(changed_files: list[str]) -> set[str]:
+        rendered = _render_test_pipeline(
+            doc,
+            changed_files=changed_files,
+            pipeline_path=pipeline_yaml,
+        )
+        return {step["key"] for step in _iter_steps(rendered) if isinstance(step.get("key"), str)}
+
+    # Only pipeline YAML / fallback paths → no listed prefix match → keep every step.
+    for changed in [pipeline_yaml.as_posix(), *shared_paths]:
+        assert surviving_keys([changed]) == {"ungated", "gated_a", "gated_b"}, changed
+
+    # A different pipeline YAML is not a fallback for this upload.
+    assert surviving_keys([".buildkite/cuda/test-nightly.yml"]) == {"ungated"}
+
+    # A matching source prefix wins over fallback files in the same diff.
+    assert surviving_keys(["pkg/model_a/transformer.py", *shared_paths[:1]]) == {
+        "ungated",
+        "gated_a",
+    }
diff --git a/tests/clients/test_duplex_client.py b/tests/clients/test_duplex_client.py
index 1be3eb943..75ef06e3f 100644
--- a/tests/clients/test_duplex_client.py
+++ b/tests/clients/test_duplex_client.py
@@ -1,6 +1,12 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-"""Unit tests for the public duplex client (fake transport, no server)."""
+"""Unit tests for the public duplex clients (fake transports, no server).
+
+``DuplexClient`` runs over a fake websocket; ``InlineDuplexClient`` over a
+fake ``DuplexOmni`` whose handle records typed commands and replays typed
+events. The demux / handshake tests that only need "feed a server event" are
+parameterized over both clients.
+"""
 
 from __future__ import annotations
 
@@ -8,6 +14,8 @@ import asyncio
 import base64
 import json
 import wave
+from collections.abc import Callable
+from typing import Any
 from urllib.parse import parse_qs, urlsplit
 
 import pytest
@@ -16,8 +24,11 @@ from vllm_omni.clients.duplex import (
     AudioFormat,
     ConnectionResumed,
     DuplexClient,
+    DuplexClientBase,
+    DuplexConnectionError,
     DuplexProtocolError,
     DuplexSessionClosedError,
+    ErrorEvent,
     EventCollector,
     ReconnectPolicy,
     SessionConfig,
@@ -31,17 +42,26 @@ from vllm_omni.clients.duplex import (
     summarize_session_request_metrics,
     write_pcm16_wav,
 )
+from vllm_omni.clients.inline_duplex import InlineDuplexClient
+from vllm_omni.engine.duplex import commands as duplex_commands
+from vllm_omni.engine.duplex import events as duplex_events
+from vllm_omni.engine.duplex.messages import DuplexSessionError
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
+SESSION_ID = "duplex-0123456789abcdef"
+# session.created is not journaled by the server, so it carries no server_event_seq.
 SESSION_CREATED = {
     "type": "session.created",
-    "session": {"session_id": "sess-1"},
-    "incarnation": 0,
+    "session": {"id": SESSION_ID, "model": "test-model"},
+    "attachment_generation": 1,
     "resume_token": "tok-1",
-    "server_event_seq": 1,
 }
-SESSION_CLOSED = {"type": "session.closed", "session_id": "sess-1", "server_event_seq": 99}
+SESSION_CLOSED = {"type": "session.closed", "session_id": SESSION_ID, "reason": "client_close", "server_event_seq": 99}
+
+
+# ---------------------------------------------------------------------------
+# Fake websocket transport
 
 
 class FakeSocket:
@@ -88,14 +108,139 @@ def make_client(*sockets: FakeSocket, **kwargs) -> tuple[DuplexClient, list[str]
     return client, calls
 
 
+# ---------------------------------------------------------------------------
+# Fake DuplexOmni for the inline client
+
+
+class _WireEvent:
+    """A typed-event stand-in that renders a fixed wire payload."""
+
+    def __init__(self, raw: dict[str, object]) -> None:
+        self.raw = raw
+
+    @property
+    def is_terminal(self) -> bool:
+        return self.raw.get("type") in {"session.closed", "session.expired"}
+
+    def to_realtime(self) -> dict[str, object]:
+        return dict(self.raw)
+
+
+class FakeInlineHandle:
+    def __init__(self, session_id: str) -> None:
+        self.session_id = session_id
+        self.closed = False
+        self.close_calls = 0
+        self.commands: list[duplex_commands.DuplexCommand] = []
+        self.consumer_active = False
+        self._outbox: asyncio.Queue = asyncio.Queue()
+
+    def deliver(self, event: Any) -> None:
+        self._outbox.put_nowait(event)
+
+    def feed(self, raw: dict[str, object]) -> None:
+        self.deliver(_WireEvent(raw))
+
+    async def submit(self, command: duplex_commands.DuplexCommand) -> None:
+        if self.closed:
+            raise DuplexSessionError("closed", code="session_closed", session_id=self.session_id)
+        self.commands.append(command)
+
+    async def events(self):
+        self.consumer_active = True
+        try:
+            while True:
+                event = await self._outbox.get()
+                yield event
+                if event.is_terminal:
+                    return
+        finally:
+            self.consumer_active = False
+
+    async def close(self, *, reason: str = "client_close", timeout: float | None = None) -> None:
+        self.close_calls += 1
+        if self.closed:
+            return
+        self.closed = True
+        self.deliver(duplex_events.SessionClosed(session_id=self.session_id, reason=reason))
+
+
+class FakeInlineOmni:
+    def __init__(self) -> None:
+        self.opened: list[dict[str, object]] = []
+        self.handles: list[FakeInlineHandle] = []
+
+    async def open_session(self, config: dict[str, object]) -> FakeInlineHandle:
+        self.opened.append(dict(config))
+        handle = FakeInlineHandle(SESSION_ID)
+        self.handles.append(handle)
+        handle.deliver(
+            duplex_events.SessionCreated(
+                session_id=SESSION_ID,
+                session={"id": SESSION_ID, "model": config.get("model")},
+            )
+        )
+        return handle
+
+
+def make_inline_client(**kwargs) -> tuple[InlineDuplexClient, FakeInlineOmni]:
+    omni = FakeInlineOmni()
+    kwargs.setdefault("handshake_timeout_s", 5.0)
+    return InlineDuplexClient(omni, model="test-model", **kwargs), omni
+
+
+# ---------------------------------------------------------------------------
+# One rig over both clients: ``feed`` a server event, drive ``client``
+
+
+class Rig:
+    def __init__(self, client: DuplexClientBase, feed: Callable[[dict[str, object]], None]) -> None:
+        self.client = client
+        self.feed = feed
+
+
+def _websocket_rig(*, handshake: dict[str, object] | None = SESSION_CREATED) -> Rig:
+    sock = FakeSocket()
+    if handshake is not None:
+        sock.feed(handshake)
+    client, _ = make_client(sock)
+    return Rig(client, sock.feed)
+
+
+def _inline_rig(*, handshake: dict[str, object] | None = SESSION_CREATED) -> Rig:
+    client, omni = make_inline_client()
+    original_open = omni.open_session
+
+    async def open_session(config: dict[str, object]) -> FakeInlineHandle:
+        handle = await original_open(config)
+        if handshake is not SESSION_CREATED:
+            # Replace the default session.created with the requested first event.
+            handle._outbox = asyncio.Queue()
+            if handshake is not None:
+                handle.feed(handshake)
+        return handle
+
+    omni.open_session = open_session  # type: ignore[method-assign]
+
+    def feed(raw: dict[str, object]) -> None:
+        omni.handles[-1].feed(raw)
+
+    return Rig(client, feed)
+
+
+@pytest.fixture(params=["websocket", "inline"])
+def make_rig(request: pytest.FixtureRequest) -> Callable[..., Rig]:
+    return _websocket_rig if request.param == "websocket" else _inline_rig
+
+
 # ---------------------------------------------------------------------------
 # SessionConfig
 
 
 def test_session_config_payload_defaults():
-    payload = SessionConfig().to_session_payload(model="m", session_id="s")
+    payload = SessionConfig().to_session_payload(model="m")
     assert payload["model"] == "m"
-    assert payload["session_id"] == "s"
+    assert "session_id" not in payload
     assert payload["modalities"] == ["audio", "text"]
     assert payload["input_audio_format"] == "pcm16"
     assert payload["output_audio_format"] == "pcm16"
@@ -137,19 +282,59 @@ def test_audio_format_math():
 
 
 # ---------------------------------------------------------------------------
-# Handshake and lifecycle
+# Handshake and lifecycle (both clients)
 
 
-async def test_handshake_adopts_session_and_acks():
+@pytest.mark.asyncio
+async def test_handshake_adopts_server_allocated_session_id(make_rig):
+    rig = make_rig()
+    async with rig.client as client:
+        assert client.session_id == SESSION_ID
+        assert client.session_info == {"id": SESSION_ID, "model": "test-model"}
+        rig.feed(SESSION_CLOSED)
+
+
+@pytest.mark.asyncio
+async def test_handshake_error_raises_protocol_error(make_rig):
+    rig = make_rig(handshake={"type": "error", "error": {"code": "unsupported_audio_format", "message": "bad"}})
+    with pytest.raises(DuplexProtocolError) as excinfo:
+        async with rig.client:
+            pass
+    assert excinfo.value.code == "unsupported_audio_format"
+
+
+@pytest.mark.asyncio
+async def test_session_expired_raises_from_event_stream(make_rig):
+    rig = make_rig()
+    async with rig.client as client:
+        rig.feed(
+            {"type": "session.expired", "session_id": SESSION_ID, "reason": "lease_expired", "server_event_seq": 2}
+        )
+        with pytest.raises(DuplexSessionClosedError) as excinfo:
+            async for _ in client.events():
+                pass
+        assert "lease_expired" in excinfo.value.reason
+
+
+# ---------------------------------------------------------------------------
+# Websocket transport specifics
+
+
+@pytest.mark.asyncio
+async def test_websocket_handshake_sends_session_update_and_acks_sequenced_events():
     sock = FakeSocket()
     sock.feed(SESSION_CREATED)
     client, calls = make_client(sock)
     async with client:
-        assert client.session_id == "sess-1"
+        assert client.session_id == SESSION_ID
         assert client.resume_token == "tok-1"
         assert calls == ["ws://test-host:8099/v1/realtime?duplex=1&model=test-model&autostart=0"]
         assert sock.sent[0]["type"] == "session.update"
         assert sock.sent[0]["session"]["model"] == "test-model"
+        assert "session_id" not in sock.sent[0]["session"]
+        # session.created is unjournaled (no seq): nothing to ack yet.
+        assert _acks(sock) == []
+        sock.feed({"type": "response.listen", "server_event_seq": 1})
         await _drain(lambda: {"type": "session.event_ack", "server_event_seq": 1} in _acks(sock))
         close_task = asyncio.create_task(client.close())
         await _drain(lambda: "session.close" in sock.sent_types())
@@ -158,28 +343,7 @@ async def test_handshake_adopts_session_and_acks():
     assert "session.close" in sock.sent_types()
 
 
-async def test_handshake_error_raises_protocol_error():
-    sock = FakeSocket()
-    sock.feed({"type": "error", "error": {"code": "unsupported_audio_format", "message": "bad"}})
-    client, _ = make_client(sock)
-    with pytest.raises(DuplexProtocolError) as excinfo:
-        async with client:
-            pass
-    assert excinfo.value.code == "unsupported_audio_format"
-
-
-async def test_session_expired_raises_from_event_stream():
-    sock = FakeSocket()
-    sock.feed(SESSION_CREATED)
-    client, _ = make_client(sock)
-    async with client:
-        sock.feed({"type": "session.expired", "reason": "lease_expired", "server_event_seq": 2})
-        with pytest.raises(DuplexSessionClosedError) as excinfo:
-            async for _ in client.events():
-                pass
-        assert "lease_expired" in excinfo.value.reason
-
-
+@pytest.mark.asyncio
 async def test_resync_required_drops_resume_credential():
     sock = FakeSocket()
     sock.feed(SESSION_CREATED)
@@ -187,7 +351,7 @@ async def test_resync_required_drops_resume_credential():
     async with client:
         assert client.resume_token == "tok-1"
         stream = client.events()
-        sock.feed({"type": "session.resync_required", "session_id": "sess-1", "server_event_seq": 2})
+        sock.feed({"type": "session.resync_required", "session_id": SESSION_ID, "server_event_seq": 2})
         async for event in stream:
             if event.type == "session.resync_required":
                 break
@@ -202,9 +366,10 @@ async def test_resync_required_drops_resume_credential():
 
 
 # ---------------------------------------------------------------------------
-# Input events
+# Input events (websocket wire shape)
 
 
+@pytest.mark.asyncio
 async def test_append_audio_tracks_cumulative_end_ms():
     sock = FakeSocket()
     sock.feed(SESSION_CREATED)
@@ -224,6 +389,7 @@ async def test_append_audio_tracks_cumulative_end_ms():
         sock.feed(SESSION_CLOSED)
 
 
+@pytest.mark.asyncio
 async def test_append_audio_strips_video_frame_data_url_prefix():
     sock = FakeSocket()
     sock.feed(SESSION_CREATED)
@@ -238,6 +404,7 @@ async def test_append_audio_strips_video_frame_data_url_prefix():
         sock.feed(SESSION_CLOSED)
 
 
+@pytest.mark.asyncio
 async def test_stream_pcm_chunking():
     sock = FakeSocket()
     sock.feed(SESSION_CREATED)
@@ -249,6 +416,7 @@ async def test_stream_pcm_chunking():
         sock.feed(SESSION_CLOSED)
 
 
+@pytest.mark.asyncio
 async def test_interruption_primitives_send_documented_events():
     sock = FakeSocket()
     sock.feed(SESSION_CREATED)
@@ -262,39 +430,38 @@ async def test_interruption_primitives_send_documented_events():
 
 
 # ---------------------------------------------------------------------------
-# Response demultiplexing
+# Response demultiplexing (both clients)
 
 
 def _b64(data: bytes) -> str:
     return base64.b64encode(data).decode("ascii")
 
 
-async def test_response_handle_flow():
-    sock = FakeSocket()
-    sock.feed(SESSION_CREATED)
+@pytest.mark.asyncio
+async def test_response_handle_flow(make_rig):
+    rig = make_rig()
     chunk = b"\x00\x01" * 2400  # 100 ms of pcm16 @ 24 kHz
-    client, _ = make_client(sock)
-    async with client:
-        sock.feed({"type": "response.created", "response": {"id": "resp-1"}, "server_event_seq": 2})
-        sock.feed({"type": "response.speak", "response_id": "resp-1", "server_event_seq": 3})
-        sock.feed(
+    async with rig.client as client:
+        rig.feed({"type": "response.created", "response": {"id": "resp-1"}, "server_event_seq": 2})
+        rig.feed({"type": "response.speak", "response_id": "resp-1", "server_event_seq": 3})
+        rig.feed(
             {
-                "type": "response.audio.delta",
+                "type": "response.output_audio.delta",
                 "response_id": "resp-1",
                 "delta": _b64(chunk),
                 "sample_rate_hz": 24_000,
                 "server_event_seq": 4,
             }
         )
-        sock.feed(
+        rig.feed(
             {
-                "type": "response.audio_transcript.delta",
+                "type": "response.output_audio_transcript.delta",
                 "response_id": "resp-1",
                 "delta": "hi there",
                 "server_event_seq": 5,
             }
         )
-        sock.feed({"type": "response.done", "response_id": "resp-1", "server_event_seq": 6})
+        rig.feed({"type": "response.done", "response_id": "resp-1", "server_event_seq": 6})
 
         async for response in client.responses():
             chunks = [piece async for piece in response.audio()]
@@ -304,49 +471,46 @@ async def test_response_handle_flow():
             assert response.played_ms == pytest.approx(100.0)
             assert response.finished
             break
-        sock.feed(SESSION_CLOSED)
+        rig.feed(SESSION_CLOSED)
 
 
-async def test_listen_decision_yields_finished_silent_handle():
-    sock = FakeSocket()
-    sock.feed(SESSION_CREATED)
-    client, _ = make_client(sock)
-    async with client:
-        sock.feed({"type": "response.listen", "server_event_seq": 2})
+@pytest.mark.asyncio
+async def test_listen_decision_yields_finished_silent_handle(make_rig):
+    rig = make_rig()
+    async with rig.client as client:
+        rig.feed({"type": "response.listen", "server_event_seq": 2})
         async for response in client.responses():
             assert response.decision == "listen"
             assert response.finished
             assert [piece async for piece in response.audio()] == []
             break
-        sock.feed(SESSION_CLOSED)
+        rig.feed(SESSION_CLOSED)
 
 
-async def test_listen_terminates_active_response():
-    sock = FakeSocket()
-    sock.feed(SESSION_CREATED)
-    client, _ = make_client(sock)
-    async with client:
-        sock.feed({"type": "response.created", "response": {"id": "resp-1"}, "server_event_seq": 2})
-        sock.feed({"type": "response.listen", "response_id": "resp-1", "server_event_seq": 3})
+@pytest.mark.asyncio
+async def test_listen_terminates_active_response(make_rig):
+    rig = make_rig()
+    async with rig.client as client:
+        rig.feed({"type": "response.created", "response": {"id": "resp-1"}, "server_event_seq": 2})
+        rig.feed({"type": "response.listen", "response_id": "resp-1", "server_event_seq": 3})
         async for response in client.responses():
             await response.wait(timeout_s=5.0)
             assert response.decision == "listen"
             break
-        sock.feed(SESSION_CLOSED)
+        rig.feed(SESSION_CLOSED)
 
 
-async def test_id_less_listen_never_closes_an_in_flight_response():
+@pytest.mark.asyncio
+async def test_id_less_listen_never_closes_an_in_flight_response(make_rig):
     # An id-less listen is a standalone decision beat (e.g. a silence-skip
     # while a response streams); it must surface as its own finished handle
     # and leave the in-flight response to its real terminal.
-    sock = FakeSocket()
-    sock.feed(SESSION_CREATED)
-    client, _ = make_client(sock)
-    async with client:
-        sock.feed({"type": "response.created", "response": {"id": "resp-1"}, "server_event_seq": 2})
-        sock.feed({"type": "response.speak", "response_id": "resp-1", "server_event_seq": 3})
-        sock.feed({"type": "response.listen", "server_event_seq": 4})
-        sock.feed({"type": "response.done", "response_id": "resp-1", "server_event_seq": 5})
+    rig = make_rig()
+    async with rig.client as client:
+        rig.feed({"type": "response.created", "response": {"id": "resp-1"}, "server_event_seq": 2})
+        rig.feed({"type": "response.speak", "response_id": "resp-1", "server_event_seq": 3})
+        rig.feed({"type": "response.listen", "server_event_seq": 4})
+        rig.feed({"type": "response.done", "response_id": "resp-1", "server_event_seq": 5})
         seen: list[tuple[str | None, str | None, bool]] = []
         async for response in client.responses():
             await response.wait(timeout_s=5.0)
@@ -355,46 +519,44 @@ async def test_id_less_listen_never_closes_an_in_flight_response():
                 break
         assert ("resp-1", "speak", True) in seen
         assert (None, "listen", True) in seen
-        sock.feed(SESSION_CLOSED)
+        rig.feed(SESSION_CLOSED)
 
 
-async def test_terminal_listen_keeps_spoken_decision():
+@pytest.mark.asyncio
+async def test_terminal_listen_keeps_spoken_decision(make_rig):
     # A terminal listen after the response spoke is the model yielding the
     # turn; the handle must stay decision="speak" with its audio intact.
-    sock = FakeSocket()
-    sock.feed(SESSION_CREATED)
+    rig = make_rig()
     chunk = b"\x00\x01" * 2400
-    client, _ = make_client(sock)
-    async with client:
-        sock.feed({"type": "response.created", "response": {"id": "resp-1"}, "server_event_seq": 2})
-        sock.feed({"type": "response.speak", "response_id": "resp-1", "server_event_seq": 3})
-        sock.feed(
+    async with rig.client as client:
+        rig.feed({"type": "response.created", "response": {"id": "resp-1"}, "server_event_seq": 2})
+        rig.feed({"type": "response.speak", "response_id": "resp-1", "server_event_seq": 3})
+        rig.feed(
             {
-                "type": "response.audio.delta",
+                "type": "response.output_audio.delta",
                 "response_id": "resp-1",
                 "delta": _b64(chunk),
                 "sample_rate_hz": 24_000,
                 "server_event_seq": 4,
             }
         )
-        sock.feed({"type": "response.listen", "response_id": "resp-1", "server_event_seq": 5})
+        rig.feed({"type": "response.listen", "response_id": "resp-1", "server_event_seq": 5})
         async for response in client.responses():
             chunks = [piece async for piece in response.audio()]
             assert chunks == [chunk]
             assert response.decision == "speak"
             assert response.finished
             break
-        sock.feed(SESSION_CLOSED)
+        rig.feed(SESSION_CLOSED)
 
 
-async def test_error_event_surfaces_on_response_path():
+@pytest.mark.asyncio
+async def test_error_event_surfaces_on_response_path(make_rig):
     # A rejected send produces no response; a consumer waiting in responses()
     # must see the rejection instead of waiting forever.
-    sock = FakeSocket()
-    sock.feed(SESSION_CREATED)
-    client, _ = make_client(sock)
-    async with client:
-        sock.feed(
+    rig = make_rig()
+    async with rig.client as client:
+        rig.feed(
             {
                 "type": "error",
                 "error": {"code": "input_audio_buffer_empty", "message": "empty commit"},
@@ -405,9 +567,37 @@ async def test_error_event_surfaces_on_response_path():
             async for _ in client.responses():
                 pass
         assert excinfo.value.code == "input_audio_buffer_empty"
+        rig.feed(SESSION_CLOSED)
+
+
+@pytest.mark.asyncio
+async def test_close_after_error_reports_the_server_reason_to_a_sender():
+    # A client streaming input sits in send(), not in responses(), so the
+    # error text has to survive into the close marker or the session looks
+    # like it ended for no reason.
+    sock = FakeSocket()
+    sock.feed(SESSION_CREATED)
+    client, _ = make_client(sock)
+    async with client:
+        sock.feed(
+            {
+                "type": "error",
+                "error": {
+                    "code": "runtime_data_plane_stream_failed",
+                    "message": "context_length_exceeded: streaming session prompt would grow to 41207 tokens",
+                },
+                "server_event_seq": 2,
+            }
+        )
         sock.feed(SESSION_CLOSED)
+        await _drain(lambda: client._closed.is_set())
+        with pytest.raises(DuplexSessionClosedError) as excinfo:
+            await client.send({"type": "input_audio_buffer.append", "audio": ""})
+    assert "runtime_data_plane_stream_failed" in str(excinfo.value)
+    assert "context_length_exceeded" in str(excinfo.value)
 
 
+@pytest.mark.asyncio
 async def test_slow_audio_consumer_drops_oldest_instead_of_stalling():
     from vllm_omni.clients.duplex import AudioDelta, ResponseHandle
 
@@ -418,31 +608,31 @@ async def test_slow_audio_consumer_drops_oldest_instead_of_stalling():
     )
     for payload in (b"c1", b"c2", b"c3"):
         # _feed must never block the reader, even against a full queue.
-        handle._feed(AudioDelta({"type": "response.audio.delta", "delta": _b64(payload)}))
+        handle._feed(AudioDelta({"type": "response.output_audio.delta", "delta": _b64(payload)}))
     handle._finish(None)
     chunks = [chunk async for chunk in handle.audio()]
     assert chunks == [b"c3"]  # oldest chunks were dropped, the sentinel landed
 
 
 # ---------------------------------------------------------------------------
-# Resume
+# Resume (websocket only)
 
 
+@pytest.mark.asyncio
 async def test_resume_after_transport_drop():
     first = FakeSocket()
     first.feed(SESSION_CREATED)
     second = FakeSocket()
     # Mirror the real resume activation payload
     # (entrypoints/duplex/serving.py, activation_payload_factory): it carries
-    # no nested "session" object, only the identity fields.
+    # the identity fields plus the (empty) public session object.
     second.feed(
         {
             "type": "session.resumed",
-            "session_id": "sess-1",
-            "incarnation": 0,
-            "attachment_generation": 1,
+            "session_id": SESSION_ID,
+            "session": {},
+            "attachment_generation": 2,
             "resume_token": "tok-2",
-            "server_event_seq": 5,
         }
     )
     client, calls = make_client(
@@ -453,34 +643,39 @@ async def test_resume_after_transport_drop():
     async with client:
         stream = client.events()
 
-        async def take_two():
+        async def collect_until_resumed():
             seen = []
             async for event in stream:
                 seen.append(event)
-                if len(seen) == 2:
+                if isinstance(event, SessionResumed):
                     return seen
 
-        consumer = asyncio.create_task(take_two())
+        consumer = asyncio.create_task(collect_until_resumed())
         await asyncio.sleep(0)  # let the consumer subscribe before the drop
         await asyncio.sleep(0)
+        first.feed({"type": "response.listen", "server_event_seq": 7})
+        await _drain(lambda: {"type": "session.event_ack", "server_event_seq": 7} in _acks(first))
         first.feed(RuntimeError("transport dropped"))
         seen = await asyncio.wait_for(consumer, timeout=5.0)
-        assert isinstance(seen[0], ConnectionResumed)
-        assert isinstance(seen[1], SessionResumed)
+        assert [type(event) for event in seen[-2:]] == [ConnectionResumed, SessionResumed]
         assert client.resume_token == "tok-2"
+        # The superseded transport is closed, not leaked.
+        assert first.closed
         # The activation payload has no session object; the info captured at
         # the original handshake must survive the resume.
-        assert client.session_info == {"session_id": "sess-1"}
+        assert client.session_info == {"id": SESSION_ID, "model": "test-model"}
         assert len(calls) == 2
         resume = second.sent[0]
-        assert resume["type"] == "session.resume"
-        assert resume["session_id"] == "sess-1"
-        assert resume["incarnation"] == 0
-        assert resume["resume_token"] == "tok-1"
-        assert resume["last_received_server_event_seq"] == 1
+        assert resume == {
+            "type": "session.resume",
+            "session_id": SESSION_ID,
+            "resume_token": "tok-1",
+            "last_received_server_event_seq": 7,
+        }
         second.feed(SESSION_CLOSED)
 
 
+@pytest.mark.asyncio
 async def test_no_reconnect_policy_surfaces_closed():
     sock = FakeSocket()
     sock.feed(SESSION_CREATED)
@@ -493,6 +688,7 @@ async def test_no_reconnect_policy_surfaces_closed():
                 pass
 
 
+@pytest.mark.asyncio
 async def test_heartbeat_survives_transient_send_failure():
     sock = FakeSocket()
     sock.feed(SESSION_CREATED)
@@ -514,6 +710,7 @@ async def test_heartbeat_survives_transient_send_failure():
         sock.feed(SESSION_CLOSED)
 
 
+@pytest.mark.asyncio
 async def test_aexit_sends_session_close_on_error_path():
     sock = FakeSocket()
     sock.feed(SESSION_CREATED)
@@ -534,6 +731,7 @@ def test_target_url_forces_autostart_off():
     assert query["autostart"] == ["0"]
 
 
+@pytest.mark.asyncio
 async def test_fatal_resume_error_gives_up():
     first = FakeSocket()
     first.feed(SESSION_CREATED)
@@ -553,6 +751,121 @@ async def test_fatal_resume_error_gives_up():
         assert len(calls) == 2  # no retry after a fatal resume error
 
 
+# ---------------------------------------------------------------------------
+# Inline client over a fake DuplexOmni
+
+
+@pytest.mark.asyncio
+async def test_inline_handshake_opens_session_with_payload_and_adopts_id():
+    client, omni = make_inline_client(config=SessionConfig(ref_audio="data:audio/wav;base64,AAA="))
+    async with client:
+        assert omni.opened == [client.config.to_session_payload(model="test-model")]
+        assert omni.opened[0]["ref_audio"] == "data:audio/wav;base64,AAA="
+        assert client.session_id == SESSION_ID
+        handle = omni.handles[0]
+        # The session was opened with the full session object already; the
+        # base handshake's session.update must not be re-submitted as a patch
+        # (a ref_audio patch would be rejected by the runner).
+        assert handle.commands == []
+        await client.send({"type": "session.update", "session": {"instructions": "later"}})
+        assert [type(command) for command in handle.commands] == [duplex_commands.UpdateSession]
+        assert handle.commands[0].patch == {"instructions": "later"}
+
+
+@pytest.mark.asyncio
+async def test_inline_client_submits_typed_commands_in_order():
+    client, omni = make_inline_client()
+    async with client:
+        handle = omni.handles[0]
+        pcm = b"\x01\x00" * 1600
+        await client.append_audio(pcm, is_speech=True)
+        await client.commit(create_response=True)
+        await client.cancel_response("resp-1")
+        await client.ack_playback(120.9, response_id="resp-1")
+        assert [type(command) for command in handle.commands] == [
+            duplex_commands.AppendAudio,
+            duplex_commands.Commit,
+            duplex_commands.CancelResponse,
+            duplex_commands.AckPlayback,
+        ]
+        append, commit, cancel, ack = handle.commands
+        assert append.is_speech is True
+        assert append.audio_end_ms == 100
+        assert append.event_id
+        assert commit.final is True and commit.create_response is True
+        assert cancel.response_id == "resp-1"
+        assert ack.played_ms == 120 and ack.response_id == "resp-1"
+
+
+@pytest.mark.asyncio
+async def test_inline_session_close_maps_to_handle_close():
+    client, omni = make_inline_client()
+    async with client:
+        pass
+    handle = omni.handles[0]
+    assert handle.closed
+    assert handle.close_calls >= 1
+    assert not any(isinstance(command, duplex_commands.CloseSession) for command in handle.commands)
+    # The typed session.closed reached the client as the expected end.
+    with pytest.raises(DuplexSessionClosedError):
+        await client.send({"type": "session.heartbeat"})
+
+
+@pytest.mark.asyncio
+async def test_inline_client_forwards_heartbeats_and_drops_event_acks():
+    client, omni = make_inline_client()
+    async with client:
+        handle = omni.handles[0]
+        await client.send({"type": "session.heartbeat"})
+        await client.send({"type": "session.event_ack", "server_event_seq": 3})
+        # A heartbeat is a lease touch the engine must see; the ack is a journal concern.
+        assert [type(command).__name__ for command in handle.commands] == ["Heartbeat"]
+
+
+@pytest.mark.asyncio
+async def test_inline_malformed_payload_surfaces_as_error_event():
+    client, omni = make_inline_client()
+    async with client:
+        handle = omni.handles[0]
+        # Subscribe before sending: the translation error is dispatched inline.
+        first_event = asyncio.create_task(client.wait_for("error", timeout_s=5.0))
+        await asyncio.sleep(0)
+        event_id = await client.send({"type": "playback.ack"})  # played_ms missing
+        event = await first_event
+        assert isinstance(event, ErrorEvent)
+        assert event.code == "bad_event"
+        assert event.related_event_id == event_id
+        assert handle.commands == []
+        with pytest.raises(DuplexProtocolError) as excinfo:
+            async for _ in client.responses():
+                pass
+        assert excinfo.value.code == "bad_event"
+
+
+@pytest.mark.asyncio
+async def test_inline_teardown_cancels_pump_and_closes_handle():
+    client, omni = make_inline_client()
+    async with client:
+        handle = omni.handles[0]
+        await _drain(lambda: handle.consumer_active)
+        pump = client._pump_task
+        assert pump is not None and not pump.done()
+    assert pump.done()
+    assert not handle.consumer_active
+    assert handle.closed
+
+
+@pytest.mark.asyncio
+async def test_inline_send_after_handle_closed_raises_connection_error():
+    client, omni = make_inline_client()
+    async with client:
+        handle = omni.handles[0]
+        handle.closed = True  # the engine ended the session without an event yet
+        with pytest.raises(DuplexConnectionError, match="not open"):
+            await client.send({"type": "input_audio_buffer.clear"})
+        handle.closed = False
+
+
 # ---------------------------------------------------------------------------
 # Collector
 
@@ -561,7 +874,7 @@ def test_event_collector_accumulates_audio():
     collector = EventCollector()
     collector.add({"type": "response.created", "response": {"id": "r1"}}, received_at_s=1.0)
     collector.add(
-        {"type": "response.audio.delta", "response_id": "r1", "delta": _b64(b"ab"), "sample_rate_hz": 16_000},
+        {"type": "response.output_audio.delta", "response_id": "r1", "delta": _b64(b"ab"), "sample_rate_hz": 16_000},
         received_at_s=1.1,
     )
     collector.add(
@@ -600,8 +913,7 @@ def test_build_realtime_url_with_model_extra_query():
     url = build_realtime_url(
         "ws://localhost:8099/v1/realtime?custom=1",
         "openbmb/MiniCPM-o-4_5",
-        session_id="session-a",
-        extra_query={"native_duplex": "1"},
+        extra_query={"probe": "1"},
     )
 
     query = parse_qs(urlsplit(url).query)
@@ -609,8 +921,7 @@ def test_build_realtime_url_with_model_extra_query():
         "custom": ["1"],
         "duplex": ["1"],
         "model": ["openbmb/MiniCPM-o-4_5"],
-        "native_duplex": ["1"],
-        "session_id": ["session-a"],
+        "probe": ["1"],
     }
 
 
@@ -619,12 +930,11 @@ def test_build_realtime_url_resume_only_when_autostart_disabled():
         "ws://localhost:8099/v1/realtime?duplex=1",
         "openbmb/MiniCPM-o-4_5",
         autostart=False,
-        extra_query={"native_duplex": "1"},
     )
 
     query = parse_qs(urlsplit(url).query)
     assert query["autostart"] == ["0"]
-    assert query["native_duplex"] == ["1"]
+    assert "session_id" not in query
 
 
 def test_event_collector_partitions_audio_by_response():
@@ -632,7 +942,7 @@ def test_event_collector_partitions_audio_by_response():
     collector.add({"type": "response.created", "response": {"id": "resp-a"}})
     collector.add(
         {
-            "type": "response.audio.delta",
+            "type": "response.output_audio.delta",
             "response_id": "resp-a",
             "delta": base64.b64encode(b"audio-a").decode("ascii"),
             "sample_rate_hz": 16_000,
@@ -643,7 +953,7 @@ def test_event_collector_partitions_audio_by_response():
     assert collector.audio_bytes("resp-a") == b"audio-a"
     assert collector.output_sample_rate_hz == 16_000
     assert collector.first_received_at("response.created") is not None
-    assert collector.last_received_at("response.audio.delta") is not None
+    assert collector.last_received_at("response.output_audio.delta") is not None
 
 
 def test_event_collector_reports_engine_token_and_audio_intervals():
@@ -664,7 +974,7 @@ def test_event_collector_reports_engine_token_and_audio_intervals():
     for received_at_s, cumulative_audio_ms in ((10.2, 80), (10.25, 160), (10.36, 240)):
         collector.add(
             {
-                "type": "response.audio.delta",
+                "type": "response.output_audio.delta",
                 "response_id": "resp-a",
                 "delta": base64.b64encode(b"audio").decode("ascii"),
                 "sample_rate_hz": 16_000,
@@ -676,11 +986,11 @@ def test_event_collector_reports_engine_token_and_audio_intervals():
             received_at_s=received_at_s,
         )
     collector.add(
-        {"type": "response.audio_transcript.delta", "response_id": "resp-a", "delta": ""},
+        {"type": "response.output_audio_transcript.delta", "response_id": "resp-a", "delta": ""},
         received_at_s=10.1,
     )
     collector.add(
-        {"type": "response.audio_transcript.delta", "response_id": "resp-a", "delta": "hello"},
+        {"type": "response.output_audio_transcript.delta", "response_id": "resp-a", "delta": "hello"},
         received_at_s=10.15,
     )
     collector.add(
@@ -736,11 +1046,162 @@ def test_event_collector_reports_engine_token_and_audio_intervals():
         "measurement_origin": {
             "ttft": "input_audio_buffer.commit client send to first non-empty text delta",
             "ttfp": "input_audio_buffer.commit client send to first audio packet",
+            "tpot": "Stage-0 engine mean time per output token",
         },
         "ttft_ms": 250.0,
         "ttfp_ms": 300.0,
         "audio_generation_ms": 460.0,
         "audio_duration_ms": 240.0,
+        "tpot_ms": 15.0,
+    }
+
+
+def test_session_summary_omits_unmeasured_zero_tpot():
+    summary = summarize_session_request_metrics(
+        [
+            {"ttft_ms": 100.0, "tpot_ms": 0.0},
+            {"ttft_ms": 200.0, "tpot_ms": None},
+        ],
+        session_id="session",
+    )
+
+    assert summary["ttft_ms"] == {
+        "count": 2,
+        "mean": 150.0,
+        "p50": 100.0,
+        "p99": 200.0,
+    }
+    assert "tpot_ms" not in summary
+
+
+def test_event_collector_reports_global_metrics_across_responses():
+    collector = EventCollector()
+    for response_id, created_at_s, text_at_s, audio_times, durations in (
+        ("resp-a", 10.1, 10.2, (10.3, 10.4), (100, 200)),
+        ("resp-b", 12.1, 12.2, (12.3, 12.5), (150, 300)),
+    ):
+        collector.add(
+            {"type": "response.created", "response": {"id": response_id}},
+            received_at_s=created_at_s,
+        )
+        collector.add(
+            {
+                "type": "response.output_audio_transcript.delta",
+                "response_id": response_id,
+                "delta": response_id,
+            },
+            received_at_s=text_at_s,
+        )
+        for received_at_s, duration_ms in zip(audio_times, durations, strict=True):
+            collector.add(
+                {
+                    "type": "response.output_audio.delta",
+                    "response_id": response_id,
+                    "delta": base64.b64encode(b"audio").decode("ascii"),
+                    "sample_rate_hz": 16_000,
+                    "metadata": {"audio_duration_ms": duration_ms},
+                },
+                received_at_s=received_at_s,
+            )
+
+    metrics = collector.global_timing_summary(
+        after_s=10.0,
+        window_started_at_s=10.0,
+        response_ids=["resp-a", "resp-b"],
+        measurement_origin={
+            "ttft": "input stream start to first non-empty text delta",
+            "ttfp": "input stream start to first audio packet",
+            "rtf": "input stream start-to-last-audio receive time divided by total emitted audio duration",
+        },
+    )
+
+    assert metrics == {
+        "source": "client_monotonic_receive",
+        "response_ids": ["resp-a", "resp-b"],
+        "measurement_origin": {
+            "ttft": "input stream start to first non-empty text delta",
+            "ttfp": "input stream start to first audio packet",
+            "rtf": "input stream start-to-last-audio receive time divided by total emitted audio duration",
+        },
+        "ttft_ms": 200.0,
+        "ttfp_ms": 300.0,
+        "audio_generation_ms": 2500.0,
+        "audio_duration_ms": 500.0,
+    }
+
+
+def test_event_collector_prefers_server_request_start_for_ttf():
+    collector = EventCollector()
+    collector.add(
+        {
+            "type": "response.created",
+            "response": {
+                "id": "resp-a",
+                "metadata": {
+                    "duplex_event": {
+                        "response_request_metrics": {
+                            "source": "server_monotonic_request_start",
+                            "measurement_origin": {
+                                "ttft": "native request start to first text output",
+                                "ttfp": "native request start to first audio output",
+                            },
+                            "ttft_ms": 125.0,
+                            "ttfp_ms": 175.0,
+                        }
+                    }
+                },
+            },
+        },
+        received_at_s=10.0,
+    )
+    stage_metrics = {
+        "0": {
+            "num_tokens_out": 4,
+            "vllm_ttft_ms": 120.0,
+            "vllm_tpot_ms": 15.0,
+            "vllm_itl_ms": 14.0,
+            "vllm_itls_ms": [10.0, 14.0, 18.0],
+        }
+    }
+    for received_at_s, cumulative_audio_ms in ((10.2, 80), (10.25, 160), (10.36, 240)):
+        collector.add(
+            {
+                "type": "response.output_audio.delta",
+                "response_id": "resp-a",
+                "delta": base64.b64encode(b"audio").decode("ascii"),
+                "sample_rate_hz": 16_000,
+                "metadata": {
+                    "audio_duration_ms": cumulative_audio_ms,
+                    "vllm_omni": {"stage_metrics": stage_metrics},
+                },
+            },
+            received_at_s=received_at_s,
+        )
+    collector.add(
+        {"type": "response.output_audio_transcript.delta", "response_id": "resp-a", "delta": "hello"},
+        received_at_s=10.15,
+    )
+
+    timing = collector.timing_summary(
+        after_s=10.0,
+        input_committed_at_s=9.9,
+        response_id="resp-a",
+    )
+
+    assert timing["request_metrics"] == {
+        "source": "server_request_start_and_client_receive",
+        "measurement_origin": {
+            "ttft": "native request start to first text output",
+            "ttfp": "native request start to first audio output",
+            "tpot": "Stage-0 engine mean time per output token",
+        },
+        "ttft_ms": 125.0,
+        "ttfp_ms": 175.0,
+        "audio_generation_ms": 460.0,
+        "audio_duration_ms": 240.0,
+        "response_created_to_first_text_ms": 150.0,
+        "response_created_to_first_audio_ms": 200.0,
+        "tpot_ms": 15.0,
     }
 
 
@@ -752,7 +1213,7 @@ def test_response_timing_ignores_unowned_session_level_metrics():
     )
     collector.add(
         {
-            "type": "response.audio.delta",
+            "type": "response.output_audio.delta",
             "response_id": "resp-a",
             "delta": base64.b64encode(b"audio").decode("ascii"),
             "metadata": {
@@ -806,9 +1267,9 @@ def test_summarize_session_request_metrics_averages_audio_turns():
     assert summary == {
         "session_id": "sess-1",
         "audio_turn_count": 2,
-        "mean_ttft_ms": 200.0,
-        "mean_ttfp_ms": 300.0,
-        "mean_rtf": 0.6,
+        "ttft_ms": {"count": 2, "mean": 200.0, "p50": 100.0, "p99": 300.0},
+        "ttfp_ms": {"count": 2, "mean": 300.0, "p50": 200.0, "p99": 400.0},
+        "rtf": {"count": 2, "mean": 0.6, "p50": 0.5, "p99": 0.7},
     }
 
 
@@ -838,6 +1299,7 @@ def test_duplex_unit_boundary_and_residual_math():
     assert chunk_period_ms([{"type": "session.created", "session": {}}]) == 1000
 
 
+@pytest.mark.asyncio
 async def test_stream_pcm_sends_each_units_composite_beside_its_base_frame():
     sock = FakeSocket()
     sock.feed(SESSION_CREATED)
@@ -860,16 +1322,16 @@ async def test_stream_pcm_sends_each_units_composite_beside_its_base_frame():
         sock.feed(SESSION_CLOSED)
 
 
-def test_build_realtime_url_native_duplex_flag_and_http_scheme():
-    url = build_realtime_url("http://localhost:8099/v1/realtime", None, native_duplex=None)
+def test_build_realtime_url_rewrites_http_scheme_and_rejects_others():
+    url = build_realtime_url("http://localhost:8099/v1/realtime", None)
     parts = urlsplit(url)
     assert parts.scheme == "ws"
     assert parse_qs(parts.query) == {"duplex": ["1"]}
 
-    url = build_realtime_url("https://host/v1/realtime", "m", native_duplex=False)
+    url = build_realtime_url("https://host/v1/realtime", "m", autostart=True)
     parts = urlsplit(url)
     assert parts.scheme == "wss"
-    assert parse_qs(parts.query)["native_duplex"] == ["0"]
+    assert parse_qs(parts.query) == {"duplex": ["1"], "model": ["m"], "autostart": ["1"]}
 
     with pytest.raises(ValueError):
         build_realtime_url("ftp://host/v1/realtime", "m")
@@ -887,7 +1349,7 @@ def test_reference_audio_data_url(tmp_path):
 def test_event_collector_response_text_joins_deltas_per_response():
     collector = EventCollector()
     collector.add({"type": "response.created", "response_id": "r1"})
-    collector.add({"type": "response.audio_transcript.delta", "response_id": "r1", "delta": "he"})
+    collector.add({"type": "response.output_audio_transcript.delta", "response_id": "r1", "delta": "he"})
     collector.add({"type": "response.output_text.delta", "response_id": "r2", "delta": "other"})
     collector.add({"type": "response.text.delta", "response_id": "r1", "delta": "llo"})
     assert collector.response_text("r1") == "hello"
diff --git a/tests/clients/test_model_session_configs.py b/tests/clients/test_model_session_configs.py
index 00741d3c6..080fea879 100644
--- a/tests/clients/test_model_session_configs.py
+++ b/tests/clients/test_model_session_configs.py
@@ -18,13 +18,13 @@ from vllm_omni.clients.personaplex import (
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
 
-def test_minicpmo45_session_config_matches_native_duplex_deployment():
+def test_minicpmo45_session_config_matches_duplex_deployment():
     config = create_minicpmo45_session_config(ref_audio="data:audio/wav;base64,AAA=", temperature=0.0)
     payload = config.to_session_payload(model="openbmb/MiniCPM-o-4_5")
     assert payload["ref_audio"] == "data:audio/wav;base64,AAA="
     assert payload["overlap_policy"] == "listen_only"
     assert payload["playback_commit_policy"] == "ack_only"
-    assert payload["extra_body"]["native_duplex"] is True
+    assert "native_duplex" not in payload["extra_body"]
     assert payload["extra_body"]["auto_response"] is True
     assert payload["temperature"] == 0.0
 
@@ -41,8 +41,9 @@ def test_personaplex_session_config_matches_deployment():
 @pytest.mark.parametrize(
     "duplex_package",
     [
+        # PersonaPlex and Nemotron VoiceChat rejoin this list with the follow-up
+        # PRs that port them to the duplex plugin framework.
         "vllm_omni.model_executor.models.minicpmo_4_5.duplex",
-        "vllm_omni.model_executor.models.personaplex.duplex",
     ],
 )
 def test_model_duplex_packages_stay_clear_of_client_library(duplex_package: str):
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 51c7d549e..fdba7e90a 100644
--- a/tests/config/test_config_factory.py
+++ b/tests/config/test_config_factory.py
@@ -197,6 +197,25 @@ class TestStageConfig:
         omega_config = config.to_omegaconf()
         assert omega_config.engine_args.max_num_seqs == 32
 
+    def test_to_omegaconf_dict_override_deep_merges_yaml_dict(self):
+        """A partial dict CLI override (e.g. --no-guardrails riding on
+        model_config) must layer onto the YAML dict, not clobber siblings."""
+        config = StageConfig(
+            stage_id=0,
+            model_stage="diffusion",
+            stage_type=StageType.DIFFUSION,
+            yaml_engine_args={
+                "model_config": {
+                    "guardrails": True,
+                    "policy_server_config": {"action_space": "joint_position"},
+                }
+            },
+            runtime_overrides={"model_config": {"guardrails": False}},
+        )
+        omega_config = config.to_omegaconf()
+        assert omega_config.engine_args.model_config.guardrails is False
+        assert omega_config.engine_args.model_config.policy_server_config.action_space == "joint_position"
+
     def test_to_omegaconf_diffusion_parallel_overrides_replace_nested_values(self):
         config = StageConfig(
             stage_id=1,
@@ -623,6 +642,58 @@ class TestPipelineDiscovery:
         assert p.hf_architectures == ("SomeCollidingArch",)
 
 
+class TestCosmos3PolicyPipeline:
+    """Cosmos3 policy serving resolves via deploy yaml selection (π0 precedent)."""
+
+    def test_registered_without_capturing_base_cosmos3_checkpoints(self):
+        assert "cosmos3_policy" in OMNI_PIPELINES
+        # T2I/video Cosmos3 checkpoints report model_type=cosmos3_omni and the
+        # same model_index.json _class_name as policy checkpoints; they must
+        # keep resolving through the single-stage diffusion fallback, so the
+        # policy pipeline must not be reachable by auto-detection.
+        assert "cosmos3_omni" not in OMNI_PIPELINES
+        pipeline = OMNI_PIPELINES["cosmos3_policy"]
+        assert pipeline.hf_architectures == ()
+        assert pipeline.diffusers_class_name is None
+
+    def test_droid_deploy_yaml_carries_policy_server_config(self):
+        deploy = load_deploy_config(get_deploy_config_path("cosmos3_policy_droid.yaml"))
+        assert deploy.pipeline == "cosmos3_policy"
+
+        stages = merge_pipeline_deploy(OMNI_PIPELINES["cosmos3_policy"], deploy)
+        assert len(stages) == 1
+        stage = stages[0].to_omegaconf()
+
+        assert stage.stage_type == "diffusion"
+        assert stage.final_output_type == "action"
+        assert stage.engine_args.model_class_name == "Cosmos3OmniDiffusersPipeline"
+        # OpenPI websocket handshake metadata must reach the serving layer via
+        # engine_args.model_config (ServingRealtimeRobotOpenPI reads it there).
+        psc = stage.engine_args.model_config.policy_server_config
+        assert list(psc.image_resolution) == [540, 640]
+        assert psc.n_external_cameras == 2
+        assert psc.needs_wrist_camera is True
+        assert psc.needs_stereo_camera is False
+        assert psc.needs_session_id is True
+        assert psc.action_space == "joint_position"
+        # The DROID checkpoint's training recipe expects JSON-formatted prompts.
+        assert stage.default_sampling_params.extra_args.format_prompt_as_json is True
+
+    def test_no_guardrails_cli_flag_keeps_policy_server_config(self):
+        """--no-guardrails becomes a partial model_config CLI override; it must
+        deep-merge with the deploy yaml's model_config, not clobber the
+        policy_server_config the OpenPI handshake depends on."""
+        deploy = load_deploy_config(get_deploy_config_path("cosmos3_policy_droid.yaml"))
+        stages, _ = StageConfigFactory._create_legacy_from_registry(
+            OMNI_PIPELINES["cosmos3_policy"],
+            {"model_config": {"guardrails": False}},
+            user_deploy_config=deploy,
+        )
+        stage = stages[0].to_omegaconf()
+        assert stage.engine_args.model_config.guardrails is False
+        assert stage.engine_args.model_config.policy_server_config.action_space == "joint_position"
+
+
 class TestStagePipelineConfig:
     def test_frozen(self):
         s = StagePipelineConfig(stage_id=0, model_stage="a")
@@ -1257,10 +1328,18 @@ class TestDeployConfigLoading:
         stages = merge_pipeline_deploy(pipeline, deploy)
 
         assert deploy.session_mode == "duplex"
-        assert deploy.active_stream_window == max_sessions
+        # ``0`` disables the limiter: the configured session/stage capacity is
+        # what bounds the pipeline. Any positive window serializes concurrent
+        # audio first-packet generation (measured: TTFP -23% at 0 vs 4 on
+        # L20X, 128 requests / concurrency 8).
+        assert deploy.active_stream_window == 0
         assert deploy.duplex_session.max_sessions == max_sessions
         assert [stage.session_mode for stage in stages] == ["duplex", "duplex", "duplex"]
         assert [stage.to_omegaconf().session_mode for stage in stages] == ["duplex", "duplex", "duplex"]
+        assert stages[0].yaml_extras["default_sampling_params"]["stop_token_ids"] == [
+            151704,
+            151645,
+        ]
 
     def test_load_minicpmo_default_deploy_config(self):
         deploy_path = Path(get_deploy_config_path("minicpmo_4_5.yaml"))
@@ -1350,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"),
@@ -1483,7 +1565,10 @@ stages:
         monkeypatch.setattr(stage_init_utils, "resolve_worker_cls", lambda _engine_args: None)
 
         deploy = load_deploy_config(get_deploy_config_path("minimax_h3_disaggregated.yaml"))
-        assert deploy.stages[1].engine_extras["model_loaded"] == {"text_encoder": False}
+        assert deploy.stages[1].engine_extras["model_loaded"] == {
+            "text_encoder": False,
+            "vae_encoder": False,
+        }
         stages = merge_pipeline_deploy(OMNI_PIPELINES["minimax_h3_disaggregated"], deploy)
         resolved = [stage_init_utils.build_engine_args_dict(stage.to_omegaconf(), str(model_root)) for stage in stages]
 
@@ -1508,12 +1593,20 @@ stages:
         deploy = load_deploy_config(Path(get_deploy_config_path("minimax_h3_disaggregated.yaml")))
         stages = merge_pipeline_deploy(pipeline, deploy)
 
-        assert stages[0].yaml_engine_args["model_arch"] == "MiniMaxH3TextEncoder"
+        assert stages[0].yaml_engine_args["model_arch"] == "MiniMaxH3Encoder"
         assert stages[1].yaml_engine_args["model_arch"] == "MiniMaxH3Pipeline"
         assert stages[0].yaml_runtime["num_replicas"] == 1
         assert stages[1].yaml_runtime["num_replicas"] == 1
-        assert stages[1].yaml_engine_args["model_loaded"] == {"text_encoder": False}
+        assert stages[1].yaml_engine_args["model_loaded"] == {
+            "text_encoder": False,
+            "vae_encoder": False,
+        }
         assert stages[0].yaml_engine_args["max_num_seqs"] == 1
+        assert stages[0].yaml_engine_args["hf_overrides"]["minimax_h3_encoder_components"] == {
+            "text_encoder": {"parallel_mode": "tp"},
+            "video_vae": {"parallel_mode": "patch"},
+            "audio_vae": {"parallel_mode": "leader"},
+        }
         assert stages[0].yaml_engine_args["model_path_resolver"].endswith(".resolve_minimax_h3_model_root")
         assert stages[1].yaml_engine_args["model_path_resolver"].endswith(".resolve_minimax_h3_diffusion_model_path")
         parallel = stages[1].yaml_engine_args["parallel_config"]
@@ -1525,6 +1618,9 @@ stages:
 
         turbo = load_deploy_config(Path(get_deploy_config_path("minimax_h3_disaggregated_turbo.yaml")))
         turbo_stages = merge_pipeline_deploy(pipeline, turbo)
+        assert turbo_stages[0].yaml_engine_args["model_arch"] == stages[0].yaml_engine_args["model_arch"]
+        assert turbo_stages[1].yaml_engine_args["model_loaded"] == stages[1].yaml_engine_args["model_loaded"]
+        assert turbo_stages[0].yaml_engine_args["hf_overrides"] == stages[0].yaml_engine_args["hf_overrides"]
         turbo_sampling = turbo_stages[1].yaml_extras["default_sampling_params"]
         assert turbo_sampling["num_inference_steps"] == 5
         assert turbo_sampling["extra_args"] == {"flow_shift": 6.0, "audio_flow_shift": 3.0}
@@ -2512,6 +2608,35 @@ class TestPlatformOverrides:
         assert rocm.stages[0].enforce_eager is None
         assert rocm.stages[1].enforce_eager is True
 
+    @pytest.mark.parametrize("deploy_name", ["qwen3_tts.yaml", "qwen3_tts_high_concurrency.yaml"])
+    @pytest.mark.parametrize("platform", ["cuda", "npu", "rocm"])
+    def test_qwen3_tts_default_code2wav_dtype_is_bf16(self, deploy_name, platform):
+        deploy = load_deploy_config(Path(get_deploy_config_path(deploy_name)))
+        deploy = _apply_platform_overrides(deploy, platform=platform)
+        stages = merge_pipeline_deploy(resolve_pipeline_config("qwen3_tts"), deploy)
+
+        assert stages[1].yaml_engine_args["dtype"] == "bfloat16"
+
+    @pytest.mark.parametrize("deploy_name", ["qwen3_tts.yaml", "qwen3_tts_high_concurrency.yaml"])
+    @pytest.mark.parametrize("platform", ["cuda", "npu"])
+    @pytest.mark.parametrize("dtype", ["float32", "bfloat16", "float16"])
+    def test_qwen3_tts_propagates_explicit_code2wav_dtype(self, deploy_name, platform, dtype):
+        deploy = load_deploy_config(Path(get_deploy_config_path(deploy_name)))
+        deploy.stages[1].engine_extras["dtype"] = dtype
+        deploy = _apply_platform_overrides(deploy, platform=platform)
+        stages = merge_pipeline_deploy(resolve_pipeline_config("qwen3_tts"), deploy)
+
+        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"))
 
@@ -2575,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():
@@ -3141,7 +3323,7 @@ class TestSentinelDefaultPrecedence:
 
 
 class TestSamplingConstraintsPrecedence:
-    """Test that pipeline sampling_constraints override deploy defaults."""
+    """Test scalar constraint precedence and additive required stop tokens."""
 
     def test_constraints_win(self):
         deploy_path = Path(get_deploy_config_path("qwen3_omni_moe.yaml"))
@@ -3161,6 +3343,47 @@ class TestSamplingConstraintsPrecedence:
         # Pipeline says stop_token_ids=[2150] for talker
         assert stages[1].yaml_extras["default_sampling_params"]["stop_token_ids"] == [2150]
 
+    def test_required_stop_tokens_extend_yaml_defaults(self, tmp_path):
+        pipeline = PipelineConfig(
+            model_type="required_stop_tokens",
+            stages=(
+                StagePipelineConfig(
+                    stage_id=0,
+                    model_stage="thinker",
+                    final_output=True,
+                    sampling_constraints={
+                        "detokenize": True,
+                        "stop_token_ids": [151704, 151645],
+                    },
+                ),
+            ),
+        )
+        deploy_path = tmp_path / "required-stop-tokens.yaml"
+        deploy_path.write_text(
+            """
+stages:
+  - stage_id: 0
+    default_sampling_params:
+      max_tokens: 7
+      stop_token_ids: [100, 151704]
+""",
+            encoding="utf-8",
+        )
+
+        legacy_stage = merge_pipeline_deploy(pipeline, load_deploy_config(deploy_path))[0]
+        structured_stage = VllmOmniConfig.from_pipeline_config(
+            pipeline,
+            deploy_config_path=str(deploy_path),
+        ).stage_by_id(0)
+        expected = {
+            "max_tokens": 7,
+            "detokenize": True,
+            "stop_token_ids": [100, 151704, 151645],
+        }
+
+        assert legacy_stage.yaml_extras["default_sampling_params"] == expected
+        assert structured_stage.model_config.default_sampling_params == expected
+
 
 class TestPipelineConfigResolvers:
     @pytest.mark.parametrize("resolver", [obj for obj in OMNI_PIPELINES.values() if callable(obj)])
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 7603945a0..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: 24,
+        EnvironmentVariableCategory.PUBLIC_OMNI: 29,
         EnvironmentVariableCategory.INHERITED_VLLM: 20,
         EnvironmentVariableCategory.PLATFORM_EXTERNAL: 27,
-        EnvironmentVariableCategory.MODEL_SPECIFIC: 61,
-        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: 37,
-        ModelEnvironmentVariableDisposition.REQUEST_SCOPE: 6,
+        ModelEnvironmentVariableDisposition.PROMOTE: 31,
+        ModelEnvironmentVariableDisposition.REQUEST_SCOPE: 5,
         ModelEnvironmentVariableDisposition.EXTERNAL: 0,
-        ModelEnvironmentVariableDisposition.INTERNALIZE: 13,
-        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 40229f521..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",
     [
@@ -271,6 +368,44 @@ def test_from_pipeline_config_rejects_unowned_deploy_engine_extras(engine_extras
         VllmOmniConfig.from_pipeline_config(pipeline, user_deploy_config=deploy)
 
 
+_MODEL_CLI_FLAGS = {
+    "served_model_name": "omni",
+    "allowed_local_media_path": "/data",
+    "allowed_media_domains": ["example.com"],
+    "max_logprobs": 7,
+    "logprobs_mode": "processed_logprobs",
+    "mm_processor_kwargs": {"max_slice_nums": 1},
+    "mm_processor_cache_type": "shm",
+    "hf_token": "hf_test",
+    "hf_config_path": "/models/config",
+    "generation_config": "vllm",
+    "override_generation_config": {"temperature": 0.5},
+    "enable_prompt_embeds": True,
+}
+
+
+@pytest.mark.parametrize("model_type", ["minicpmo_4_5", "qwen3_tts"])
+@pytest.mark.parametrize(("field", "value"), list(_MODEL_CLI_FLAGS.items()), ids=list(_MODEL_CLI_FLAGS))
+def test_from_pipeline_config_owns_model_cli_fields(model_type, field, value):
+    config = _from_pipeline_key(model_type, cli_overrides={field: value})
+
+    for stage in config.stage_configs:
+        assert getattr(stage.model_config, field) == value
+
+
+def test_model_cli_fields_reach_typed_engine_args(monkeypatch):
+    from vllm_omni.engine import stage_init_utils
+    from vllm_omni.engine.stage_init_utils import build_engine_args_dict_from_omni_stage_config
+
+    # Worker discovery requires hardware support; this test covers config transport.
+    monkeypatch.setattr(stage_init_utils, "resolve_worker_cls", lambda engine_args: None)
+    config = _from_pipeline_key("minicpmo_4_5", cli_overrides=dict(_MODEL_CLI_FLAGS))
+
+    engine_args = build_engine_args_dict_from_omni_stage_config(config.stage_by_id(0), model="test-model")
+
+    assert {field: engine_args.get(field) for field in _MODEL_CLI_FLAGS} == _MODEL_CLI_FLAGS
+
+
 @pytest.mark.parametrize("stage_id", [0, 2], ids=["ar", "generation"])
 def test_llm_additional_config_roundtrip_and_isolation(stage_id, monkeypatch):
     from vllm_omni.engine import stage_init_utils
@@ -386,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",
@@ -394,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(
@@ -604,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")
@@ -616,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",
@@ -699,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",
@@ -710,10 +955,12 @@ 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",
         "enable_multithread_weight_load",
+        "enable_broadcast_weight_load",
         "num_weight_load_threads",
         "disable_autocast",
         # Per-stage checkpoint resolution for repos whose stages live in
@@ -722,6 +969,18 @@ def test_sub_config_fields_match_structured_scopes():
         "model_subdir",
         "tokenizer_subdir",
         "requires_full_payload_input",
+        "served_model_name",
+        "allowed_local_media_path",
+        "allowed_media_domains",
+        "max_logprobs",
+        "logprobs_mode",
+        "mm_processor_kwargs",
+        "mm_processor_cache_type",
+        "hf_token",
+        "hf_config_path",
+        "generation_config",
+        "override_generation_config",
+        "enable_prompt_embeds",
     }
     vllm_load_fields = {f.name for f in fields(VllmLoadConfig)}
     assert issubclass(OmniStageLoadConfig, VllmLoadConfig)
@@ -746,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",
@@ -838,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
 
@@ -1301,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
@@ -1349,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
 
@@ -1414,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"
@@ -1429,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"
 
 
@@ -1542,6 +1777,59 @@ def test_diffusion_quantization_mapping_reaches_terminal_config(monkeypatch):
     assert cfg.quantization_config.get_name() == "int8"
 
 
+def test_video_output_transport_mapping_is_normalized() -> None:
+    from vllm_omni.diffusion.data import VideoOutputTransportConfig
+
+    cfg = omni_config_module._DiffusionConfigProjection(
+        video_output_transport={"enable_device_postprocess": True},
+    )
+
+    assert isinstance(cfg.video_output_transport, VideoOutputTransportConfig)
+    assert cfg.video_output_transport.enable_device_postprocess is True
+
+
+def test_omni_diffusion_config_normalizes_video_output_transport_mapping() -> None:
+    from vllm_omni.diffusion.data import OmniDiffusionConfig, VideoOutputTransportConfig
+
+    cfg = OmniDiffusionConfig(
+        model=None,
+        video_output_transport={"enable_device_postprocess": True},
+    )
+
+    assert isinstance(cfg.video_output_transport, VideoOutputTransportConfig)
+    assert cfg.video_output_transport.enable_device_postprocess is True
+
+
+def test_video_output_transport_rejects_non_boolean_flag() -> None:
+    from vllm_omni.diffusion.data import VideoOutputTransportConfig
+
+    with pytest.raises(TypeError, match="enable_device_postprocess must be a bool"):
+        VideoOutputTransportConfig(enable_device_postprocess="true")  # type: ignore[arg-type]
+
+
+def test_video_output_transport_survives_stage_override_filtering() -> None:
+    from vllm_omni.config.stage_config import build_stage_runtime_overrides, deploy_runtime_override_keys
+
+    transport = {"enable_device_postprocess": True}
+    overrides = build_stage_runtime_overrides(0, {"video_output_transport": transport})
+
+    assert "video_output_transport" in deploy_runtime_override_keys()
+    assert overrides["video_output_transport"] == transport
+
+
+def test_video_output_transport_reaches_default_diffusion_stage() -> None:
+    transport = {"enable_device_postprocess": True}
+    stages = StageConfigFactory.create_default_diffusion(
+        {
+            "model": "unused",
+            "model_class_name": "UnknownPipeline",
+            "video_output_transport": transport,
+        }
+    )
+
+    assert stages[0]["engine_args"]["video_output_transport"] == transport
+
+
 def test_compact_offload_config_reaches_terminal_config(monkeypatch):
     from vllm_omni.diffusion.data import OmniDiffusionConfig
     from vllm_omni.diffusion.offloader.config import OffloadStrategy, resolve_offload_strategy
@@ -1599,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 604904dd0..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,10 +149,21 @@ 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))
     scheduler._cleanup_kv_tracking = MethodType(OmniARScheduler._cleanup_kv_tracking, scheduler)
+    scheduler._emit_streaming_context_overflow_outputs = MethodType(
+        OmniARScheduler._emit_streaming_context_overflow_outputs, scheduler
+    )
     scheduler.make_spec_decoding_stats = lambda *args, **kwargs: None
     scheduler.make_stats = lambda *args, **kwargs: None
     return scheduler
@@ -164,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
@@ -216,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 bca7d095c..83c7038f2 100644
--- a/tests/core/sched/test_omni_ar_scheduler_streaming.py
+++ b/tests/core/sched/test_omni_ar_scheduler_streaming.py
@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 
+from collections import defaultdict
 from types import SimpleNamespace
 from unittest.mock import MagicMock
 
@@ -16,7 +17,10 @@ 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
 from vllm.v1.request import Request, RequestStatus, StreamingUpdate
 from vllm_omni.core.sched.omni_ar_scheduler import OmniARAsyncScheduler, OmniARScheduler
 from vllm_omni.distributed.omni_connectors.transfer_adapter.chunk_transfer_adapter import (
@@ -958,3 +962,347 @@ def test_chunk_segment_cleanup_keeps_explicit_update_stage_parked(
     assert session.request_id not in sched.chunk_transfer_adapter.segment_finished_requests
     sched.skipped_waiting.remove_requests.assert_not_called()
     sched._enqueue_waiting_request.assert_not_called()
+
+
+def _make_live_session_scheduler(*, max_model_len: int) -> OmniARScheduler:
+    """A scheduler whose finish path is real: the queues, ``finish_requests``,
+    ``_free_request`` and the finished-request bookkeeping that wakes an idle
+    engine all run. Only block freeing and the encoder cache are mocked."""
+    sched = _make_admission_scheduler(max_model_len=max_model_len)
+    del sched._free_request  # the admission helper mocks it; run the real one
+    sched._omits_kv_transfer_cache = {}
+    sched.connector = None
+    sched.perf_metrics = None
+    sched.recompute_kv_load_failures = False
+    sched.finished_req_ids = set()
+    sched.finished_req_ids_dict = defaultdict(set)
+    sched.transfer_triggered_requests = set()
+    sched.active_kv_transfers = set()
+    sched.waiting_for_transfer_free = set()
+    sched.pending_stop_after_extraction = set()
+    sched.requests_needing_kv_transfer = {}
+    sched._kv_wait_start_ts = {}
+    sched.kv_cache_manager = SimpleNamespace(take_events=lambda: None, estimate_cached_tokens=lambda _request: 0)
+    return sched
+
+
+def _run_idle_step(sched: OmniARScheduler):
+    """One ``update_from_output`` with nothing scheduled: the step an idle
+    engine runs once ``has_finished_requests()`` reports a freed session."""
+    scheduler_output = SimpleNamespace(
+        num_scheduled_tokens={},
+        scheduled_spec_decode_tokens={},
+        num_invalid_spec_tokens=0,
+    )
+    model_runner_output = SimpleNamespace(
+        sampled_token_ids=[],
+        logprobs=None,
+        prompt_logprobs_dict={},
+        pooler_output=None,
+        num_nans_in_logits=None,
+        kv_connector_output=None,
+        cudagraph_stats=None,
+        req_id_to_index={},
+        routed_experts=None,
+    )
+    return OmniARScheduler.update_from_output(sched, scheduler_output, model_runner_output)
+
+
+def _park_session(sched: OmniARScheduler, session: Request) -> None:
+    """Put a session where a 1 fps video stream leaves it between appends:
+    prompt partly computed, waiting for streaming input, in admission."""
+    sched.requests[session.request_id] = session
+    session.append_output_token_ids([7, 8, 9])
+    session.num_computed_tokens = 6
+    session.num_output_placeholders = 0
+    session.status = RequestStatus.WAITING_FOR_STREAMING_REQ
+    sched.skipped_waiting.add_request(session)
+    sched.num_waiting_for_streaming_input = 1
+
+
+def test_stage0_streaming_update_that_overflows_max_model_len_finishes_the_session() -> None:
+    """A native duplex session grows its prompt on every append; once the
+    extension cannot fit the model the worker crashes copying the prompt.
+    The scheduler must drop the update and fail only this session, at once,
+    through the real finish path: a parked session does not make the engine
+    schedule, so what wakes the engine is the freed request showing up in
+    ``has_finished_requests()``, and the step that follows must carry one
+    explicit ERROR rather than the synthesized ABORT."""
+    sched = _make_live_session_scheduler(max_model_len=8)
+    session = _make_request()
+    _park_session(sched, session)
+
+    sched._update_request_as_session(session, _make_update([10, 20, 30]))
+
+    assert session.prompt_token_ids == [1, 2, 3]
+    assert session.num_prompt_tokens == 3
+    assert session.status == RequestStatus.FINISHED_ERROR
+    assert session.request_id not in sched.requests
+    assert len(sched.waiting) == 0
+    assert len(sched.skipped_waiting) == 0
+    assert sched.num_waiting_for_streaming_input == 0
+    sched._free_request_blocks.assert_called_once_with(session)
+    assert sched.finished_req_ids == {session.request_id}
+    assert sched.has_finished_requests()
+    client_index, reason = sched._streaming_context_overflow[session.request_id]
+    assert client_index == session.client_index
+    assert reason.startswith("context_length_exceeded: ")
+    assert "9 tokens" in reason and "max_model_len 8" in reason
+
+    engine_core_outputs = _run_idle_step(sched)
+
+    (output,) = engine_core_outputs[session.client_index].outputs
+    assert output.request_id == session.request_id
+    assert output.finish_reason == FinishReason.ERROR
+    assert output.stop_reason == reason
+    assert output.new_token_ids == []
+    assert engine_core_outputs[session.client_index].finished_requests == {session.request_id}
+    assert sched._streaming_context_overflow == {}
+    # Nothing is left to report once the error went out.
+    assert _run_idle_step(sched) == {}
+
+
+def test_stage0_streaming_update_that_fills_max_model_len_exactly_finishes_the_session() -> None:
+    """An exactly full prompt leaves no room for the token every duplex step
+    samples: upstream's running budget drops to -1, which ``schedule()`` does
+    not catch, so the exact fill is an overflow too."""
+    sched = _make_scheduler(stage_id=0)
+    sched.max_model_len = 8
+    sched.finish_requests = MagicMock()
+    session = _make_request()
+    session.status = RequestStatus.WAITING_FOR_STREAMING_REQ
+    session.append_output_token_ids([7, 8, 9])
+    session.num_computed_tokens = 6
+    session.num_output_placeholders = 0
+
+    sched._update_request_as_session(session, _make_update([10, 20]))
+
+    assert session.prompt_token_ids == [1, 2, 3]
+    assert session.num_prompt_tokens == 3
+    sched.finish_requests.assert_called_once_with((session.request_id,), RequestStatus.FINISHED_ERROR)
+    _, reason = sched._streaming_context_overflow[session.request_id]
+    assert "8 tokens" in reason and "max_model_len 8" in reason
+
+
+def test_stage0_streaming_update_that_leaves_room_to_sample_is_applied() -> None:
+    sched = _make_scheduler(stage_id=0)
+    sched.max_model_len = 9
+    sched.finish_requests = MagicMock()
+    session = _make_request()
+    session.status = RequestStatus.WAITING_FOR_STREAMING_REQ
+    session.append_output_token_ids([7, 8, 9])
+    session.num_computed_tokens = 6
+    session.num_output_placeholders = 0
+
+    sched._update_request_as_session(session, _make_update([10, 20]))
+
+    assert session.prompt_token_ids == [1, 2, 3, 7, 8, 9, 10, 20]
+    assert session.num_prompt_tokens == 8
+    assert session.status == RequestStatus.WAITING
+    sched.finish_requests.assert_not_called()
+    assert not getattr(sched, "_streaming_context_overflow", {})
+
+
+def test_stage0_streaming_update_keeps_room_for_every_token_sampled_per_step() -> None:
+    """With speculative decoding a step samples more than one token, and the
+    prompt must leave room for all of them."""
+    sched = _make_scheduler(stage_id=0)
+    sched.max_model_len = 9
+    sched.num_sampled_tokens_per_step = 2
+    sched.finish_requests = MagicMock()
+    session = _make_request()
+    session.status = RequestStatus.WAITING_FOR_STREAMING_REQ
+    session.append_output_token_ids([7, 8, 9])
+    session.num_computed_tokens = 6
+    session.num_output_placeholders = 0
+
+    sched._update_request_as_session(session, _make_update([10, 20]))
+
+    assert session.prompt_token_ids == [1, 2, 3]
+    sched.finish_requests.assert_called_once_with((session.request_id,), RequestStatus.FINISHED_ERROR)
+    assert "8 tokens" in sched._streaming_context_overflow[session.request_id][1]
+
+
+def test_stage0_streaming_update_overflow_counts_an_uncomputed_prompt() -> None:
+    """A preempted session keeps its prompt even though num_computed_tokens
+    fell behind it; the projection must use the longer of the two."""
+    sched = _make_scheduler(stage_id=0)
+    sched.max_model_len = 4
+    sched.finish_requests = MagicMock()
+    session = _make_request()
+    session.status = RequestStatus.WAITING_FOR_STREAMING_REQ
+    session.num_computed_tokens = 0
+
+    sched._update_request_as_session(session, _make_update([10, 20]))
+
+    assert session.prompt_token_ids == [1, 2, 3]
+    sched.finish_requests.assert_called_once()
+    assert "5 tokens" in sched._streaming_context_overflow[session.request_id][1]
+
+
+def _make_admission_scheduler(*, max_model_len: int) -> OmniARScheduler:
+    """A scheduler with real admission queues, so nothing about the terminal
+    handling below is mocked away except block freeing."""
+    sched = _make_scheduler(stage_id=0)
+    sched.max_model_len = max_model_len
+    sched.policy = SchedulingPolicy.FCFS
+    sched.waiting = create_request_queue(sched.policy)
+    sched.skipped_waiting = create_request_queue(sched.policy)
+    sched.running = []
+    sched.requests = {}
+    sched._free_request = MagicMock()  # needs a KV manager; not what this covers
+    return sched
+
+
+def _make_queued_stop(session: Request, update: StreamingUpdate) -> None:
+    """Put the request in the state upstream hands to _handle_stopped_request:
+    an append that arrived during generation is queued, and the stop status is
+    still on the request."""
+    from collections import deque
+
+    session.resumable = True
+    session.streaming_queue = deque([update])
+    session.status = RequestStatus.FINISHED_STOPPED
+
+
+def test_queued_streaming_update_that_overflows_does_not_return_to_admission() -> None:
+    sched = _make_admission_scheduler(max_model_len=4)
+    session = _make_request()
+    sched.requests[session.request_id] = session
+    session.num_computed_tokens = 3
+    _make_queued_stop(session, _make_update([10, 20]))
+
+    finished = sched._handle_stopped_request(session)
+
+    assert finished is True
+    assert len(sched.waiting) == 0
+    assert len(sched.skipped_waiting) == 0
+    assert session.status == RequestStatus.FINISHED_ERROR
+    assert session.resumable is False
+    assert "context_length_exceeded: " in sched._streaming_context_overflow[session.request_id][1]
+    # update_from_output frees every request reported as finished; freeing here
+    # as well deleted it from self.requests twice (KeyError in _free_blocks).
+    sched._free_request.assert_not_called()
+
+
+def test_queued_streaming_update_that_fits_still_resumes_the_session() -> None:
+    sched = _make_admission_scheduler(max_model_len=64)
+    session = _make_request()
+    sched.requests[session.request_id] = session
+    session.num_computed_tokens = 3
+    _make_queued_stop(session, _make_update([10, 20]))
+
+    finished = sched._handle_stopped_request(session)
+
+    assert finished is False
+    assert len(sched.waiting) == 1
+    assert session.status == RequestStatus.WAITING
+    assert not getattr(sched, "_streaming_context_overflow", {})
+    sched._free_request.assert_not_called()
+
+
+def test_queued_stop_with_a_recorded_overflow_still_leaves_admission() -> None:
+    """The overflow may already be on record when the stop is handled (an
+    earlier update of the same session). Upstream still re-enqueues the
+    request, so the override must take it back out either way instead of
+    leaving a FINISHED_ERROR request for admission to trip over."""
+    sched = _make_admission_scheduler(max_model_len=64)
+    session = _make_request()
+    sched.requests[session.request_id] = session
+    session.num_computed_tokens = 3
+    sched._streaming_context_overflow = {session.request_id: (session.client_index, "context_length_exceeded: earlier")}
+    _make_queued_stop(session, _make_update([10, 20]))  # this update itself fits
+
+    finished = sched._handle_stopped_request(session)
+
+    assert finished is True
+    assert len(sched.waiting) == 0
+    assert len(sched.skipped_waiting) == 0
+    assert session.status == RequestStatus.FINISHED_ERROR
+    assert session.resumable is False
+    sched._free_request.assert_not_called()
+
+
+def test_parked_stop_with_a_recorded_overflow_keeps_the_streaming_counter_balanced() -> None:
+    """Same as above with nothing queued: upstream parks the request as
+    waiting for streaming input and counts it; the dequeue must uncount it."""
+    from collections import deque
+
+    sched = _make_admission_scheduler(max_model_len=64)
+    session = _make_request()
+    sched.requests[session.request_id] = session
+    session.num_computed_tokens = 3
+    sched._streaming_context_overflow = {session.request_id: (session.client_index, "context_length_exceeded: earlier")}
+    session.resumable = True
+    session.streaming_queue = deque()
+    session.status = RequestStatus.FINISHED_STOPPED
+
+    finished = sched._handle_stopped_request(session)
+
+    assert finished is True
+    assert len(sched.skipped_waiting) == 0
+    assert sched.num_waiting_for_streaming_input == 0
+    assert session.status == RequestStatus.FINISHED_ERROR
+    sched._free_request.assert_not_called()
+
+
+def test_context_overflow_emits_an_error_output_with_the_reason() -> None:
+    sched = _make_scheduler(stage_id=0)
+    sched._streaming_context_overflow = {"req-a": (2, "context_length_exceeded: too long")}
+    outputs: dict[int, list] = {}
+
+    sched._emit_streaming_context_overflow_outputs(outputs)
+
+    (output,) = outputs[2]
+    assert output.request_id == "req-a"
+    assert output.finish_reason == FinishReason.ERROR
+    assert output.stop_reason == "context_length_exceeded: too long"
+    assert output.new_token_ids == []
+    assert sched._streaming_context_overflow == {}
+
+    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 ae1b3924e..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,8 +58,10 @@ 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,
     )
 
 
@@ -82,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):
@@ -95,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):
@@ -270,6 +314,19 @@ class TestWaitingForInputTransition(unittest.TestCase):
         self.assertEqual(len(coord.pending_input_registrations), 1)
         self.assertEqual(coord.pending_input_registrations[0].request_id, "r1")
 
+    def test_pending_input_registration_carries_payload_sender_info(self):
+        coord = OmniSchedulingCoordinator(stage_id=1)
+        req = _make_request("r1", status=RequestStatus.WAITING_FOR_INPUT)
+        req.payload_sender_info = {"host": "10.0.0.1", "zmq_port": 50051}
+        waiting = MockQueue([req])
+
+        coord.process_pending_full_payload_inputs(waiting, set())
+
+        self.assertEqual(
+            coord.pending_input_registrations[0].payload_sender_info,
+            {"host": "10.0.0.1", "zmq_port": 50051},
+        )
+
     def test_idle_cycles_retain_received_marker_before_request_appears(self):
         coord = OmniSchedulingCoordinator(stage_id=1)
         coord._full_payload_input_received.add("late")
@@ -368,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_cosmos3_vllm_omni.json b/tests/dfx/perf/tests/test_cosmos3_vllm_omni.json
index bcd649de1..5e2b9d3dc 100644
--- a/tests/dfx/perf/tests/test_cosmos3_vllm_omni.json
+++ b/tests/dfx/perf/tests/test_cosmos3_vllm_omni.json
@@ -5,7 +5,7 @@
       {
         "hardware_marks": {
           "res": {
-            "cuda": "H100"
+            "cuda": ["H100", "B200"]
           },
           "num_cards": 2
         }
@@ -63,7 +63,7 @@
       {
         "hardware_marks": {
           "res": {
-            "cuda": "H100"
+            "cuda": ["H100", "B200"]
           },
           "num_cards": 2
         }
@@ -132,7 +132,7 @@
       {
         "hardware_marks": {
           "res": {
-            "cuda": "H100"
+            "cuda": ["H100", "B200"]
           },
           "num_cards": 2
         }
@@ -200,7 +200,7 @@
       {
         "hardware_marks": {
           "res": {
-            "cuda": "H100"
+            "cuda": ["H100", "B200"]
           },
           "num_cards": 2
         }
diff --git a/tests/dfx/perf/tests/test_hunyuanvideo15_i2v_vllm_omni.json b/tests/dfx/perf/tests/test_hunyuanvideo15_i2v_vllm_omni.json
index 8186edf2c..25d91c44f 100644
--- a/tests/dfx/perf/tests/test_hunyuanvideo15_i2v_vllm_omni.json
+++ b/tests/dfx/perf/tests/test_hunyuanvideo15_i2v_vllm_omni.json
@@ -5,7 +5,7 @@
       {
         "hardware_marks": {
           "res": {
-            "cuda": "H100"
+            "cuda": ["H100", "B200"]
           },
           "num_cards": 1
         }
@@ -55,7 +55,7 @@
       {
         "hardware_marks": {
           "res": {
-            "cuda": "H100"
+            "cuda": ["H100", "B200"]
           },
           "num_cards": 2
         }
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 3771c1c81..6a3433dbe 100644
--- a/tests/dfx/perf/tests/test_hunyuanvideo15_t2v_vllm_omni.json
+++ b/tests/dfx/perf/tests/test_hunyuanvideo15_t2v_vllm_omni.json
@@ -5,7 +5,7 @@
       {
         "hardware_marks": {
           "res": {
-            "cuda": "H100"
+            "cuda": ["H100", "B200"]
           },
           "num_cards": 1
         }
@@ -54,7 +54,8 @@
       {
         "hardware_marks": {
           "res": {
-            "cuda": "H100"
+            "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 cac1880c5..7d7ca08ad 100644
--- a/tests/dfx/perf/tests/test_minicpmo_4_5.json
+++ b/tests/dfx/perf/tests/test_minicpmo_4_5.json
@@ -5,7 +5,7 @@
       {
         "hardware_marks": {
           "res": {
-            "cuda": "H100",
+            "cuda": ["H100", "B200"],
             "npu": "A3"
           },
           "num_cards": 1
diff --git a/tests/dfx/perf/tests/test_minicpmo_4_5_duplex_seed_tts.json b/tests/dfx/perf/tests/test_minicpmo_4_5_duplex_seed_tts.json
index 801743134..a145459ed 100644
--- a/tests/dfx/perf/tests/test_minicpmo_4_5_duplex_seed_tts.json
+++ b/tests/dfx/perf/tests/test_minicpmo_4_5_duplex_seed_tts.json
@@ -5,7 +5,7 @@
       {
         "hardware_marks": {
           "res": {
-            "cuda": "H100",
+            "cuda": ["H100", "B200"],
             "npu": "A3"
           },
           "num_cards": 1
@@ -43,43 +43,7 @@
         "extra_body": {
           "save_duplex_request_metrics": true
         },
-        "percentile-metrics": "ttft,tpot,itl,e2el,audio_ttfp,audio_rtf,audio_duration",
-        "baseline": {
-          "H100": {
-            "request_throughput": [
-              0.3038
-            ],
-            "mean_ttft_ms": [
-              139.997
-            ],
-            "mean_e2el_ms": [
-              3269.8807
-            ],
-            "mean_audio_ttfp_ms": [
-              456.073
-            ],
-            "mean_audio_rtf": [
-              0.2254
-            ]
-          },
-          "A3": {
-            "request_throughput": [
-              0.1594
-            ],
-            "mean_ttft_ms": [
-              274.164
-            ],
-            "mean_e2el_ms": [
-              6250.7696
-            ],
-            "mean_audio_ttfp_ms": [
-              994.422
-            ],
-            "mean_audio_rtf": [
-              0.46163
-            ]
-          }
-        }
+        "percentile-metrics": "ttft,tpot,itl,e2el,audio_ttfp,audio_rtf,audio_duration"
       }
     ]
   }
diff --git a/tests/dfx/perf/tests/test_minimax_h3_vllm_omni.json b/tests/dfx/perf/tests/test_minimax_h3_vllm_omni.json
index e16b40e91..7dfbe6f3d 100644
--- a/tests/dfx/perf/tests/test_minimax_h3_vllm_omni.json
+++ b/tests/dfx/perf/tests/test_minimax_h3_vllm_omni.json
@@ -5,7 +5,7 @@
       {
         "hardware_marks": {
           "res": {
-            "cuda": "H100"
+            "cuda": ["H100", "B200"]
           },
           "num_cards": 4
         }
@@ -76,7 +76,7 @@
       {
         "hardware_marks": {
           "res": {
-            "cuda": "H100"
+            "cuda": ["H100", "B200"]
           },
           "num_cards": 4
         }
@@ -148,7 +148,7 @@
       {
         "hardware_marks": {
           "res": {
-            "cuda": "H100"
+            "cuda": ["H100", "B200"]
           },
           "num_cards": 4
         }
@@ -219,7 +219,7 @@
       {
         "hardware_marks": {
           "res": {
-            "cuda": "H100"
+            "cuda": ["H100", "B200"]
           },
           "num_cards": 4
         }
diff --git a/tests/dfx/perf/tests/test_qwen3_omni_async_chunk.json b/tests/dfx/perf/tests/test_qwen3_omni_async_chunk.json
index 6b0247aaf..1292a79e5 100644
--- a/tests/dfx/perf/tests/test_qwen3_omni_async_chunk.json
+++ b/tests/dfx/perf/tests/test_qwen3_omni_async_chunk.json
@@ -5,7 +5,7 @@
       {
         "hardware_marks": {
           "res": {
-            "cuda": "H100",
+            "cuda": ["H100", "B200"],
             "npu": "A3"
           },
           "num_cards": 2
@@ -242,7 +242,7 @@
       {
         "hardware_marks": {
           "res": {
-            "cuda": "H100"
+            "cuda": ["H100", "B200"]
           },
           "num_cards": 2
         }
diff --git a/tests/dfx/perf/tests/test_qwen3_omni_no_async_chunk.json b/tests/dfx/perf/tests/test_qwen3_omni_no_async_chunk.json
index d73629666..186bac452 100644
--- a/tests/dfx/perf/tests/test_qwen3_omni_no_async_chunk.json
+++ b/tests/dfx/perf/tests/test_qwen3_omni_no_async_chunk.json
@@ -5,7 +5,7 @@
       {
         "hardware_marks": {
           "res": {
-            "cuda": "H100",
+            "cuda": ["H100", "B200"],
             "npu": "A3"
           },
           "num_cards": 2
diff --git a/tests/dfx/perf/tests/test_qwen_image_vllm_omni.json b/tests/dfx/perf/tests/test_qwen_image_vllm_omni.json
index 4f64d6ec1..61cb334eb 100644
--- a/tests/dfx/perf/tests/test_qwen_image_vllm_omni.json
+++ b/tests/dfx/perf/tests/test_qwen_image_vllm_omni.json
@@ -5,7 +5,7 @@
       {
         "hardware_marks": {
           "res": {
-            "cuda": "H100"
+            "cuda": ["H100", "B200"]
           },
           "num_cards": 1
         }
@@ -66,7 +66,7 @@
       {
         "hardware_marks": {
           "res": {
-            "cuda": "H100"
+            "cuda": ["H100", "B200"]
           },
           "num_cards": 1
         }
@@ -150,7 +150,7 @@
       {
         "hardware_marks": {
           "res": {
-            "cuda": "H100"
+            "cuda": ["H100", "B200"]
           },
           "num_cards": 4
         }
@@ -197,7 +197,7 @@
       {
         "hardware_marks": {
           "res": {
-            "cuda": "H100"
+            "cuda": ["H100", "B200"]
           },
           "num_cards": 4
         }
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/dfx/perf/tests/test_tts.json b/tests/dfx/perf/tests/test_tts.json
index 592f61ca2..c627c01e8 100644
--- a/tests/dfx/perf/tests/test_tts.json
+++ b/tests/dfx/perf/tests/test_tts.json
@@ -5,7 +5,7 @@
       {
         "hardware_marks": {
           "res": {
-            "cuda": "H100",
+            "cuda": ["H100", "B200"],
             "npu": "A3"
           },
           "num_cards": 2
@@ -121,7 +121,7 @@
       {
         "hardware_marks": {
           "res": {
-            "cuda": "H100"
+            "cuda": ["H100", "B200"]
           },
           "num_cards": 2
         }
@@ -285,7 +285,7 @@
       {
         "hardware_marks": {
           "res": {
-            "cuda": "H100"
+            "cuda": ["H100", "B200"]
           },
           "num_cards": 2
         }
@@ -416,7 +416,7 @@
       {
         "hardware_marks": {
           "res": {
-            "cuda": "H100"
+            "cuda": ["H100", "B200"]
           },
           "num_cards": 1
         }
diff --git a/tests/dfx/perf/tests/test_wan22_i2v_vllm_omni.json b/tests/dfx/perf/tests/test_wan22_i2v_vllm_omni.json
index 234bbf1db..3244d1c41 100644
--- a/tests/dfx/perf/tests/test_wan22_i2v_vllm_omni.json
+++ b/tests/dfx/perf/tests/test_wan22_i2v_vllm_omni.json
@@ -5,7 +5,7 @@
       {
         "hardware_marks": {
           "res": {
-            "cuda": "H100"
+            "cuda": ["H100", "B200"]
           },
           "num_cards": 1
         }
@@ -57,7 +57,7 @@
       {
         "hardware_marks": {
           "res": {
-            "cuda": "H100",
+            "cuda": ["H100", "B200"],
             "npu": "A3"
           },
           "num_cards": 2
diff --git a/tests/dfx/reliability/invalid_param_test/test_invalid_audio_speech.py b/tests/dfx/reliability/invalid_param_test/test_invalid_audio_speech.py
index 9861b609e..98b4184d9 100644
--- a/tests/dfx/reliability/invalid_param_test/test_invalid_audio_speech.py
+++ b/tests/dfx/reliability/invalid_param_test/test_invalid_audio_speech.py
@@ -157,14 +157,8 @@ def test_speech_missing_required_fields(omni_server: OmniServer, online_client:
                 "ref_audio": None,
                 "ref_text": None,
             },
-            # NOTE: This is delegating down the TTS adapter, so the message is both specific
-            # to the Qwen3TTS adapter and dependent on whether or not the model has any speakers
-            # (as opposed to having valida speakers, but getting an invalid speaker). it would
-            # be more ideal to validate that this is landing on `.validate()` on the adapter
-            # and ensuring that the returned message matches what we would get from calling the
-            # adapter validate directly.
-            ("no speakers configured",),
-            id="customvoice_invalid_voice",
+            ("Base checkpoint does not support task_type='CustomVoice'",),
+            id="base_checkpoint_customvoice_task_mismatch",
         ),
         pytest.param(
             {"task_type": "InvalidEnum"}, ("task_type", "literal_error", "CustomVoice"), id="task_type_invalid"
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/ar_diffusion/test_streaming_decode.py b/tests/diffusion/ar_diffusion/test_streaming_decode.py
new file mode 100644
index 000000000..52889bfbd
--- /dev/null
+++ b/tests/diffusion/ar_diffusion/test_streaming_decode.py
@@ -0,0 +1,361 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Streaming VAE decode against the real Wan autoencoder, on CPU.
+
+The autoencoder is built from a config rather than a checkpoint -- weights are
+random, only shapes and the temporal cache protocol matter -- so these run
+without a device or a download.
+
+The load-bearing test is equivalence: decoding a session chunk by chunk must
+produce exactly what decoding the whole clip produces. Everything else about
+streaming is worthless if that does not hold.
+"""
+
+from __future__ import annotations
+
+from contextlib import contextmanager
+
+import pytest
+import torch
+
+from vllm_omni.experimental.ar_diffusion.streaming_decode import (
+    StreamingDecodeState,
+    SupportsStreamingDecode,
+    WanStreamingDecoder,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+# Small enough to decode on CPU in a test, same architecture as the shipped
+# checkpoint: base_dim 96 / dim_mult [1,2,4,4] would be far too slow, so the
+# widths are scaled down while the causal structure is unchanged.
+VAE_CONFIG = {
+    "base_dim": 8,
+    "z_dim": 4,
+    "dim_mult": [1, 2],
+    "num_res_blocks": 1,
+    "temperal_downsample": [True],
+    "attn_scales": [],
+    "dropout": 0.0,
+}
+LATENT_H = LATENT_W = 4
+
+
+@pytest.fixture(scope="module")
+def vae():
+    diffusers = pytest.importorskip("diffusers")
+    torch.manual_seed(0)
+    model = diffusers.AutoencoderKLWan(**VAE_CONFIG).eval()
+    for parameter in model.parameters():
+        parameter.requires_grad_(False)
+    return model
+
+
+@pytest.fixture(scope="module")
+def decoder(vae):
+    return WanStreamingDecoder(vae)
+
+
+def _latent(num_frames: int, *, seed: int = 0) -> torch.Tensor:
+    generator = torch.Generator().manual_seed(seed)
+    return torch.randn(1, VAE_CONFIG["z_dim"], num_frames, LATENT_H, LATENT_W, generator=generator)
+
+
+@torch.no_grad()
+def _decode_whole(vae, latent: torch.Tensor) -> torch.Tensor:
+    """The non-streaming reference: one call, cache cleared at both ends."""
+    return vae._decode(latent, return_dict=False)[0]
+
+
+# --------------------------------------------------------------------------
+# Equivalence: the property that makes streaming worth doing at all
+# --------------------------------------------------------------------------
+
+
+def _stream(decoder, latent: torch.Tensor, chunk_sizes, *, session_id: str = "s") -> torch.Tensor:
+    state = decoder.new_decode_state(session_id)
+    pieces, offset = [], 0
+    for size in chunk_sizes:
+        pieces.append(decoder.decode_chunk(latent[:, :, offset : offset + size], state))
+        offset += size
+    return torch.cat(pieces, dim=2)
+
+
+@torch.no_grad()
+@pytest.mark.parametrize("chunk_sizes", [(3, 3, 3), (1, 1, 1, 1, 1), (2, 4, 3)])
+def test_chunking_is_neutral(vae, decoder, chunk_sizes) -> None:
+    """Splitting a session into chunks must change nothing about its output.
+
+    This is the property streaming actually introduces, so it is the one
+    asserted exactly. The control is the same session decoded in a single
+    call through the same code path -- not ``_decode`` -- because ``_decode``
+    differs in a way that has nothing to do with chunking; see
+    ``test_distance_from_the_one_shot_path_is_a_post_quant_conv_artifact``.
+    """
+    total = sum(chunk_sizes)
+    latent = _latent(total)
+    reference = _stream(decoder, latent, (total,), session_id="ref")
+    streamed = _stream(decoder, latent, chunk_sizes)
+
+    assert streamed.shape == reference.shape
+    torch.testing.assert_close(streamed, reference, rtol=0, atol=0)
+
+
+@torch.no_grad()
+def test_distance_from_the_one_shot_path_is_a_post_quant_conv_artifact(vae, decoder) -> None:
+    """Explain, and bound, the gap against diffusers' ``_decode``.
+
+    ``_decode`` applies ``post_quant_conv`` to the whole latent at once; the
+    tiled path in this repo, and this decoder, apply it per frame. It is a
+    1x1x1 convolution, so the two are mathematically identical -- but they can
+    select different kernels, and on bf16 CUDA that difference is real and is
+    amplified by the causal convolutions downstream.
+
+    Asserting equality with ``_decode`` would therefore pin a kernel-selection
+    coincidence rather than a property of streaming. Assert instead that the
+    gap is entirely explained by where ``post_quant_conv`` runs.
+    """
+    latent = _latent(6)
+    per_frame_pq = torch.cat([vae.post_quant_conv(latent[:, :, k : k + 1]) for k in range(latent.shape[2])], dim=2)
+    whole_pq = vae.post_quant_conv(latent)
+
+    streamed = _stream(decoder, latent, (3, 3))
+    one_shot = _decode_whole(vae, latent)
+
+    # Same inputs to the decoder => same output, whatever the backend does.
+    if torch.equal(whole_pq, per_frame_pq):
+        torch.testing.assert_close(streamed, one_shot, rtol=0, atol=0)
+    else:  # pragma: no cover - backend dependent
+        pytest.skip("backend batches post_quant_conv differently; the gap is that, not chunking")
+
+
+@torch.no_grad()
+def test_a_restarted_stream_does_not_match_a_continued_one(decoder) -> None:
+    """Negative control: the equivalence test above must be discriminating.
+
+    Clearing state between chunks -- what the non-streaming path does on every
+    call -- has to change the pixels, otherwise the temporal cache carries
+    nothing and the assertion above holds for a write-only cache too.
+
+    Restarting also changes the frame count, because a fresh state expands its
+    opening latent frame to one raw frame. Comparing totals would therefore
+    pass on the frame count alone and never look at a pixel, so this compares
+    the tail both runs agree on: the frames from the chunk's later latents,
+    which are the full temporal factor wide on either side.
+    """
+    latent = _latent(6)
+    state = decoder.new_decode_state("continued")
+    decoder.decode_chunk(latent[:, :, :3], state)
+    continued = decoder.decode_chunk(latent[:, :, 3:], state)
+    restarted = decoder.decode_chunk(latent[:, :, 3:], decoder.new_decode_state("restarted"))
+
+    tail = min(continued.shape[2], restarted.shape[2]) - 1
+    assert tail > 0, "the comparison needs at least one fully expanded frame on both sides"
+    continued_tail, restarted_tail = continued[:, :, -tail:], restarted[:, :, -tail:]
+    assert continued_tail.shape == restarted_tail.shape, "the tails must be comparable for this to mean anything"
+    assert not torch.equal(continued_tail, restarted_tail), (
+        "restarting the decoder produced the same pixels as continuing it, so the carried cache is not being read"
+    )
+
+
+# --------------------------------------------------------------------------
+# Cross-session isolation: the failure that timing metrics cannot see
+# --------------------------------------------------------------------------
+
+
+@torch.no_grad()
+@pytest.mark.parametrize("seed_a, seed_b", [(1, 2), (11, 12)])
+def test_interleaved_sessions_keep_independent_temporal_context(vae, decoder, seed_a: int, seed_b: int) -> None:
+    """Two sessions ticking alternately must each match their solo decode.
+
+    A session that reads another's temporal cache produces a perfectly
+    plausible but wrong video, and every latency metric stays green, so this
+    has to be asserted against a recorded solo run rather than inferred. The
+    control is a solo stream rather than ``_decode``, so it differs from the
+    run under test only in the interleaving.
+    """
+    latent_a = _latent(6, seed=seed_a)
+    latent_b = _latent(6, seed=seed_b)
+    solo_a = _stream(decoder, latent_a, (6,), session_id="solo-a")
+    solo_b = _stream(decoder, latent_b, (6,), session_id="solo-b")
+    assert not torch.equal(solo_a, solo_b), "negative control: the two sessions must differ"
+
+    state_a = decoder.new_decode_state("a")
+    state_b = decoder.new_decode_state("b")
+    out_a, out_b = [], []
+    for start in (0, 3):
+        window = slice(start, start + 3)
+        out_a.append(decoder.decode_chunk(latent_a[:, :, window], state_a))
+        out_b.append(decoder.decode_chunk(latent_b[:, :, window], state_b))
+
+    torch.testing.assert_close(torch.cat(out_a, dim=2), solo_a, rtol=0, atol=0)
+    torch.testing.assert_close(torch.cat(out_b, dim=2), solo_b, rtol=0, atol=0)
+
+
+@torch.no_grad()
+def test_the_module_cache_is_untouched_so_sessions_can_share_one_decoder(vae, decoder) -> None:
+    vae.clear_cache()
+    before = [entry for entry in vae._feat_map]
+    decoder.decode_chunk(_latent(3), decoder.new_decode_state("s"))
+    assert vae._feat_map == before, "streaming decode must not write the module-owned cache"
+
+
+# --------------------------------------------------------------------------
+# Causal geometry and boundedness
+# --------------------------------------------------------------------------
+
+
+@torch.no_grad()
+def test_opening_chunk_is_shorter_and_later_chunks_are_full_length(vae, decoder) -> None:
+    """(n - 1) * factor + 1 for the opening chunk, n * factor after it."""
+    factor = 2 ** sum(VAE_CONFIG["temperal_downsample"])
+    state = decoder.new_decode_state("s")
+    first = decoder.decode_chunk(_latent(3), state)
+    second = decoder.decode_chunk(_latent(3, seed=5), state)
+
+    assert first.shape[2] == (3 - 1) * factor + 1
+    assert second.shape[2] == 3 * factor
+    assert state.chunks_decoded == 2
+    assert state.frames_decoded == 6
+
+
+@torch.no_grad()
+def test_resident_state_does_not_grow_with_session_length(vae, decoder) -> None:
+    """Each causal convolution retains at most CACHE_T temporal slices."""
+    state = decoder.new_decode_state("s")
+    decoder.decode_chunk(_latent(3), state)
+    baseline = state.nbytes()
+    assert baseline > 0
+
+    for step in range(8):
+        decoder.decode_chunk(_latent(3, seed=step + 10), state)
+        assert state.nbytes() == baseline
+
+    assert sum(state.nbytes_by_device().values()) == baseline
+
+
+@torch.no_grad()
+def test_release_returns_the_session_to_its_pre_stream_state(vae, decoder) -> None:
+    state = decoder.new_decode_state("s")
+    decoder.decode_chunk(_latent(3), state)
+    assert state.started and state.nbytes() > 0
+
+    decoder.release(state)
+    assert state.nbytes() == 0
+    assert not state.started
+    assert state.chunks_decoded == 0
+
+    # A released session restarts rather than resumes, so its first chunk is
+    # short again -- the same semantics reset() has for AR KV.
+    factor = 2 ** sum(VAE_CONFIG["temperal_downsample"])
+    assert decoder.decode_chunk(_latent(3), state).shape[2] == (3 - 1) * factor + 1
+
+
+# --------------------------------------------------------------------------
+# Contract
+# --------------------------------------------------------------------------
+
+
+def test_the_vaes_execution_context_is_entered_for_every_frame(vae) -> None:
+    """Decode must run inside the autoencoder's own execution context.
+
+    Every public compute entry point on ``OmniAutoencoderKLWan`` enters
+    ``_execution_context()``, which is where autocast is established for
+    fp16/bf16 parameters -- and on NPU the only place it is established at all.
+    Driving ``post_quant_conv`` and ``decoder`` directly bypasses it unless this
+    decoder enters it itself, which would compute streamed chunks under a
+    different numeric context from the whole-clip decode they are compared to.
+    """
+    entered: list[str] = []
+
+    class _ContextualVAE:
+        """The parts of the contract this decoder uses, plus the hook."""
+
+        config = vae.config
+        dtype = torch.float32
+
+        def __init__(self) -> None:
+            self.decoder = vae.decoder
+            self.post_quant_conv = vae.post_quant_conv
+            self._cached_conv_counts = vae._cached_conv_counts
+
+        @contextmanager
+        def _execution_context(self):
+            entered.append("enter")
+            try:
+                yield
+            finally:
+                entered.append("exit")
+
+    decoder = WanStreamingDecoder(_ContextualVAE())
+    with torch.no_grad():
+        decoder.decode_chunk(_latent(3), decoder.new_decode_state("s"))
+
+    # One context for the call, not one per frame, and it closes.
+    assert entered == ["enter", "exit"]
+
+
+def test_a_plain_diffusers_autoencoder_needs_no_execution_context(decoder) -> None:
+    """The hook is optional: a VAE without one still decodes."""
+    with torch.no_grad():
+        out = decoder.decode_chunk(_latent(1), decoder.new_decode_state("s"))
+    assert out.shape[2] == 1
+
+
+def test_wan_decoder_satisfies_the_protocol(decoder) -> None:
+    assert isinstance(decoder, SupportsStreamingDecode)
+
+
+def test_state_from_another_decoder_is_rejected(decoder) -> None:
+    foreign = StreamingDecodeState(session_id="s", feat_map=[None])
+    with pytest.raises(ValueError, match="does not belong to this decoder"):
+        decoder.decode_chunk(_latent(1), foreign)
+
+
+def test_a_non_wan_module_is_rejected() -> None:
+    with pytest.raises(TypeError, match="Wan-family autoencoder"):
+        WanStreamingDecoder(object())
+
+
+def test_empty_and_malformed_latents_are_rejected(decoder) -> None:
+    state = decoder.new_decode_state("s")
+    with pytest.raises(ValueError, match=r"\[B, C, T, H, W\]"):
+        decoder.decode_chunk(torch.zeros(1, 4, 4, 4), state)
+    with pytest.raises(ValueError, match="at least one frame"):
+        decoder.decode_chunk(torch.zeros(1, 4, 0, LATENT_H, LATENT_W), state)
+
+
+def test_a_batch_is_refused_rather_than_threaded_through_one_cache(decoder) -> None:
+    """One state is one session, so a batch has no correct interpretation here.
+
+    ``AutoencoderKLWan.decode`` handles a batch by decoding each sample with
+    its own cleared cache (``use_slicing``). This decoder carries exactly one
+    temporal context, so a batch would mix samples into it and still return
+    correctly shaped pixels.
+    """
+    state = decoder.new_decode_state("s")
+    batched = torch.zeros(2, VAE_CONFIG["z_dim"], 3, LATENT_H, LATENT_W)
+    with pytest.raises(ValueError, match="one sample per session state"):
+        decoder.decode_chunk(batched, state)
+    assert state.frames_decoded == 0, "a refused call must not advance the session"
+
+
+def test_session_id_must_be_meaningful(decoder) -> None:
+    with pytest.raises(ValueError, match="session_id"):
+        decoder.new_decode_state("  ")
+
+
+def test_declared_state_bytes_scales_with_area_and_dtype(vae) -> None:
+    # A local decoder, not the module-scoped fixture: the measured constant
+    # belongs to this test, and leaking it would change what a reordered run
+    # of the default-None case sees. Passing it here is also the constructor
+    # argument's intended use.
+    # Measured for the shipped checkpoint: 37832 KiB of fp32 cache at 64x64.
+    decoder = WanStreamingDecoder(vae, bytes_per_pixel_fp32=37832 * 1024 / (64 * 64))
+    fp32 = decoder.declared_state_bytes(height=480, width=832, dtype=torch.float32)
+    bf16 = decoder.declared_state_bytes(height=480, width=832, dtype=torch.bfloat16)
+    half_area = decoder.declared_state_bytes(height=240, width=832, dtype=torch.float32)
+    assert bf16 == fp32 // 2
+    assert half_area == fp32 // 2
+    assert fp32 / 2**20 == pytest.approx(3602.0, abs=5.0)
diff --git a/tests/diffusion/attention/test_attention_config.py b/tests/diffusion/attention/test_attention_config.py
index 656161589..4a053b1bf 100644
--- a/tests/diffusion/attention/test_attention_config.py
+++ b/tests/diffusion/attention/test_attention_config.py
@@ -10,6 +10,7 @@ Tests cover:
 - AttentionMetadata.extra field
 """
 
+from dataclasses import replace
 from types import SimpleNamespace
 from unittest.mock import Mock
 
@@ -17,7 +18,12 @@ import pytest
 import torch
 
 import vllm_omni.diffusion.attention.layer as layer_mod
-from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata
+import vllm_omni.diffusion.attention.selector as selector_mod
+from vllm_omni.diffusion.attention.backends.abstract import (
+    AttentionMetadata,
+    PackedPaddingMetadata,
+    QueryRange,
+)
 from vllm_omni.diffusion.attention.backends.flash_attn import FlashAttentionBackend
 from vllm_omni.diffusion.attention.layer import Attention
 from vllm_omni.diffusion.config import (
@@ -477,6 +483,7 @@ class TestAttentionInitUsesCurrentDiffusionConfig:
     @pytest.mark.parametrize("mindiesd_available", [False, True])
     def test_paged_npu_memory_profile_uses_sdpa_only_without_mindiesd(self, monkeypatch, mindiesd_available):
         attention = Attention.__new__(Attention)
+        attention.allow_fp32_fallback = False
         attention._scheduler_paged_kv = True
         attention.paged_kv_cache_role = "primary"
         attention.backend_pref = "FLASH_ATTN"
@@ -519,6 +526,7 @@ class TestAttentionInitUsesCurrentDiffusionConfig:
     @pytest.mark.parametrize("fa4_available", [False, True])
     def test_paged_cuda_memory_profile_uses_sdpa_without_dense_fa4(self, monkeypatch, fa4_available):
         attention = Attention.__new__(Attention)
+        attention.allow_fp32_fallback = False
         attention._scheduler_paged_kv = True
         attention.paged_kv_cache_role = "primary"
         attention.backend_pref = "FLASH_ATTN"
@@ -561,6 +569,7 @@ class TestAttentionInitUsesCurrentDiffusionConfig:
 
     def test_dense_flash_import_error_is_not_reclassified(self, monkeypatch):
         attention = Attention.__new__(Attention)
+        attention.allow_fp32_fallback = False
         attention._scheduler_paged_kv = False
         attention.paged_kv_cache_role = "primary"
         attention.backend_pref = "FLASH_ATTN"
@@ -900,6 +909,7 @@ class TestAttentionInitUsesCurrentDiffusionConfig:
             return sentinel
 
         fake_attention = SimpleNamespace(
+            allow_fp32_fallback=False,
             attention=SimpleNamespace(
                 forward=_selected_forward,
             ),
@@ -938,6 +948,164 @@ class TestAttentionInitUsesCurrentDiffusionConfig:
             Attention._run_ring_attention(fake_attention, query, query, query, metadata)
 
 
+class TestOptInFloat32Fallback:
+    @staticmethod
+    def _make_attention(monkeypatch, *, backend=None, allow=True, kv_cache_dtype=None):
+        events, state = [], {}
+        context = object()
+
+        class _SelectedImpl:
+            def __init__(self, **kwargs):
+                self.kwargs = kwargs
+
+            @staticmethod
+            def supports_kv_cache_dtype(*args):
+                return True
+
+            def forward(self, query, key, value, metadata):
+                events.append("selected")
+                state["kernel_call"] = (query, key, value, metadata)
+                state["kernel_output"] = query + 4
+                return state["kernel_output"]
+
+        class _FallbackImpl(_SelectedImpl):
+            def forward(self, query, key, value, metadata):
+                output = super().forward(query, key, value, metadata)
+                events[-1] = "fallback"
+                return output
+
+        class _FlashBackend(FlashAttentionBackend):
+            @staticmethod
+            def get_impl_cls():
+                return _SelectedImpl
+
+        class _SDPABackend(layer_mod.SDPABackend):
+            @staticmethod
+            def get_impl_cls():
+                return _SelectedImpl
+
+        class _Strategy:
+            def pre_attention(self, query, key, value, metadata):
+                events.append("pre")
+                state["prepared"] = (
+                    query + 1,
+                    key + 2,
+                    value + 3,
+                    replace(metadata) if metadata is not None else None,
+                )
+                return (*state["prepared"], context)
+
+            def post_attention(self, output, ctx):
+                events.append("post")
+                assert output is state["kernel_output"]
+                assert ctx is context
+                return output + 7
+
+        # Keep real role/config resolution and construction; replace hardware
+        # lookup and kernels. These are CPU dispatch tests, not SP collectives.
+        monkeypatch.setattr(
+            selector_mod,
+            "_cached_get_backend_cls",
+            lambda name, *args, **kwargs: _SDPABackend if name == "TORCH_SDPA" else _FlashBackend,
+        )
+        monkeypatch.setattr(layer_mod.SDPABackend, "get_impl_cls", staticmethod(lambda: _FallbackImpl))
+        monkeypatch.setattr(layer_mod, "build_parallel_attention_strategy", lambda **kwargs: _Strategy())
+        monkeypatch.setattr(layer_mod, "is_forward_context_available", lambda: False)
+        config = OmniDiffusionConfig(
+            diffusion_attention_config={"default": backend} if backend else {},
+            diffusion_kv_cache_dtype=kv_cache_dtype,
+        )
+        with set_current_diffusion_config(config):
+            attention = Attention(
+                num_heads=4,
+                num_kv_heads=2,
+                head_size=8,
+                causal=False,
+                softmax_scale=0.25,
+                **({"allow_fp32_fallback": True} if allow else {}),
+            )
+        return attention, events, state
+
+    @pytest.mark.parametrize(
+        "backend,allow,dtype,is_cuda,expected",
+        [
+            pytest.param(None, True, torch.float32, True, "fallback", id="auto-fp32"),
+            pytest.param(None, False, torch.float32, True, "selected", id="default-opt-out"),
+            pytest.param("FLASH_ATTN", True, torch.float32, True, "selected", id="explicit-flash"),
+            pytest.param("TORCH_SDPA", True, torch.float32, True, "selected", id="explicit-sdpa"),
+            pytest.param(None, True, torch.bfloat16, True, "selected", id="bf16"),
+            pytest.param(None, True, torch.float32, False, "selected", id="cpu-fp32"),
+        ],
+    )
+    def test_public_forward_preserves_strategy_and_backend_choice(
+        self, monkeypatch, backend, allow, dtype, is_cuda, expected
+    ):
+        attention, events, state = self._make_attention(monkeypatch, backend=backend, allow=allow)
+        # Only the dispatch predicate is simulated; every tensor stays on CPU.
+        monkeypatch.setattr(torch.Tensor, "is_cuda", property(lambda self: is_cuda))
+        query = torch.ones(1, 2, 4, 8, dtype=dtype)
+        key = torch.full((1, 2, 2, 8), 2, dtype=dtype)
+        value = torch.full_like(key, 3)
+        metadata = AttentionMetadata(attn_mask=torch.tensor([[True, False]]))
+
+        output = attention(query, key, value, metadata)
+
+        assert events == ["pre", expected, "post"]
+        assert all(got is prepared for got, prepared in zip(state["kernel_call"], state["prepared"]))
+        assert state["kernel_call"][3] is not metadata
+        assert state["kernel_call"][3].attn_mask is metadata.attn_mask
+        torch.testing.assert_close(output, query + 12)
+        assert attention.backend_explicit is (backend is not None)
+        impl = attention.sdpa_fallback if expected == "fallback" else attention.attention
+        assert impl.kwargs["num_kv_heads"] == 2
+        assert impl.kwargs["softmax_scale"] == 0.25
+
+    def test_explicit_backend_failure_is_not_retried_with_sdpa(self, monkeypatch):
+        attention, events, _ = self._make_attention(monkeypatch, backend="FLASH_ATTN")
+        monkeypatch.setattr(torch.Tensor, "is_cuda", property(lambda self: True))
+        selected = Mock(side_effect=RuntimeError("selected backend rejects this dtype"))
+        monkeypatch.setattr(attention.attention, "forward", selected)
+        query = torch.ones(1, 2, 4, 8)
+
+        with pytest.raises(RuntimeError, match="selected backend rejects this dtype"):
+            attention(query, query, query)
+
+        selected.assert_called_once()
+        assert events == ["pre"]
+
+    @pytest.mark.parametrize("contract", ["packed", "packed-padding", "piecewise", "quantized-kv"])
+    def test_backend_metadata_is_not_silently_sent_to_dense_sdpa(self, monkeypatch, contract):
+        quant_dtype = "fp8" if contract == "quantized-kv" else None
+        attention, events, state = self._make_attention(monkeypatch, kv_cache_dtype=quant_dtype)
+        monkeypatch.setattr(torch.Tensor, "is_cuda", property(lambda self: True))
+        lengths = torch.tensor([0, 1, 2], dtype=torch.int32)
+        metadata = AttentionMetadata()
+        if contract == "packed":
+            metadata.extra = {
+                "cu_seqlens_q": lengths,
+                "cu_seqlens_k": lengths,
+                "max_seqlen_q": 1,
+                "max_seqlen_k": 1,
+            }
+        elif contract == "packed-padding":
+            metadata.packed_padding = PackedPaddingMetadata(1, 1, lengths[:2], lengths[:2])
+        elif contract == "piecewise":
+            metadata.full_attn_spans = [[(0, 1)]]
+            metadata.query_ranges = (QueryRange(0, 2, 0),)
+        query = torch.ones(1, 2, 4, 8)
+
+        attention(query, query, query, metadata)
+
+        assert events == ["pre", "selected", "post"]
+        forwarded = state["kernel_call"][3]
+        if quant_dtype:
+            # Quantization is injected by the public forward from config.
+            assert forwarded.extra == {"kv_cache_dtype": "fp8"}
+            assert metadata.extra == {}
+        else:
+            assert forwarded is state["prepared"][3]
+
+
 class TestDiffusionKvCacheQuantization:
     @staticmethod
     def _install_attention_init_stubs(monkeypatch, *, supports_kv_cache_dtype=True):
diff --git a/tests/diffusion/attention/test_block_sparse_ops.py b/tests/diffusion/attention/test_block_sparse_ops.py
new file mode 100644
index 000000000..845f09b46
--- /dev/null
+++ b/tests/diffusion/attention/test_block_sparse_ops.py
@@ -0,0 +1,126 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import sys
+import types
+
+import pytest
+import torch
+from torch._subclasses.fake_tensor import FakeTensorMode
+
+from vllm_omni.diffusion.attention.ops.block_sparse import (
+    build_prefix_dense_block_map,
+    fastvideo_block_sparse_attn_bshd,
+    mean_pool_tiles,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+
+@pytest.mark.parametrize("prefix_blocks,topk", [(0, 1), (2, 0), (2, 1), (2, 3), (2, 5)])
+def test_block_map_keeps_prefix_dense_and_selects_non_prefix_keys(prefix_blocks, topk):
+    sparse_blocks = 3
+    blocks = prefix_blocks + sparse_blocks
+    scores = torch.arange(2 * blocks * blocks, dtype=torch.float32).reshape(1, 2, blocks, blocks)
+    block_map = build_prefix_dense_block_map(scores, prefix_blocks, sparse_blocks, topk)
+    expected = torch.zeros_like(scores, dtype=torch.bool)
+    # Scores increase with key index, so top-k always selects the last keys.
+    for query_block in range(blocks):
+        for key_block in range(blocks):
+            if (
+                query_block < prefix_blocks
+                or key_block < prefix_blocks
+                or key_block >= blocks - min(topk, sparse_blocks)
+            ):
+                expected[..., query_block, key_block] = True
+    assert torch.equal(block_map, expected)
+
+
+@pytest.mark.parametrize("block_size", [4, 32, 64])
+@pytest.mark.parametrize("dtype", [torch.float32, torch.bfloat16])
+def test_pooling_uses_valid_tile_sizes_and_fp32_accumulation(block_size, dtype):
+    sizes = torch.tensor([block_size, block_size - 1, 0], dtype=torch.int32)
+    tiles = torch.arange(2 * 3 * block_size * 2 * 3).reshape(2, 3, block_size, 2, 3).to(dtype)
+    tiles[:, 1, -1] = 0
+    tiles[:, 2] = 0
+    expected = torch.stack(
+        [tiles[:, 0].float().mean(dim=1), tiles[:, 1, :-1].float().mean(dim=1), torch.zeros(2, 2, 3)], dim=2
+    )
+    result = mean_pool_tiles(tiles.flatten(1, 2), sizes, block_size)
+    assert result.dtype == torch.float32
+    torch.testing.assert_close(result, expected, rtol=0, atol=0)
+
+
+def test_provider_wrapper_restores_transport_rows_and_bshd_layout(monkeypatch):
+    monkeypatch.delenv("FASTVIDEO_VSA_SM100A", raising=False)
+    calls = []
+
+    def block_sparse_attn(q, k, v, block_map, sizes):
+        calls.append((q.shape, block_map.shape, sizes.tolist()))
+        assert q.is_contiguous() and k.is_contiguous() and v.is_contiguous()
+        assert sizes.dtype == torch.int32
+        return q + k + v, None
+
+    module = types.ModuleType("fastvideo_kernel.block_sparse_attn")
+    setattr(module, "block_sparse_attn", block_sparse_attn)
+    monkeypatch.setitem(sys.modules, "fastvideo_kernel", types.ModuleType("fastvideo_kernel"))
+    monkeypatch.setitem(sys.modules, "fastvideo_kernel.block_sparse_attn", module)
+    query = torch.randn(1, 4 * 64, 2, 8)
+    block_map = torch.ones(1, 2, 4, 4, dtype=torch.bool)
+    sizes = torch.tensor([64, 17, 64, 0])
+    output = fastvideo_block_sparse_attn_bshd(query, query, query, block_map, sizes, 3)
+    expected = torch.zeros_like(query)
+    expected[:, : 3 * 64] = query[:, : 3 * 64] * 3
+    torch.testing.assert_close(output, expected)
+    assert calls == [(torch.Size([1, 2, 3 * 64, 8]), torch.Size([1, 2, 3, 3]), [64, 17, 64])]
+
+
+def test_custom_op_fake_preserves_metadata_without_loading_provider(monkeypatch):
+    monkeypatch.setitem(sys.modules, "fastvideo_kernel", None)
+    with FakeTensorMode():
+        query = torch.empty(1, 4 * 64, 2, 8, dtype=torch.bfloat16)
+        block_map = torch.empty(1, 2, 4, 4, dtype=torch.bool)
+        sizes = torch.empty(4, dtype=torch.int32)
+        output = fastvideo_block_sparse_attn_bshd(query, query, query, block_map, sizes, 3)
+        assert output.shape == query.shape
+        assert output.dtype == query.dtype
+        assert output.device == query.device
+
+
+@pytest.mark.parametrize("error_type", [ImportError, RuntimeError, torch.AcceleratorError])
+def test_native_provider_failure_only_recovers_without_accelerator_fault(monkeypatch, mocker, error_type):
+    monkeypatch.setenv("FASTVIDEO_VSA_SM100A", "1")
+    error = error_type("native provider failure")
+    native = mocker.Mock()
+    native.is_supported.return_value = True
+    native.block_sparse_attn_sm100a.side_effect = error
+    provider = types.ModuleType("fastvideo_kernel")
+    setattr(provider, "block_sparse_attn_sm100a", native)
+    index = types.ModuleType("fastvideo_kernel.triton_kernels.index")
+    setattr(
+        index,
+        "map_to_index",
+        mocker.Mock(return_value=(torch.zeros(1, dtype=torch.int32), torch.ones(1, dtype=torch.int32))),
+    )
+    triton = types.ModuleType("fastvideo_kernel.block_sparse_attn")
+    fallback = mocker.Mock(side_effect=lambda q, *args: (q.clone(), None))
+    setattr(triton, "block_sparse_attn", fallback)
+    monkeypatch.setitem(sys.modules, "fastvideo_kernel", provider)
+    monkeypatch.setitem(
+        sys.modules, "fastvideo_kernel.triton_kernels", types.ModuleType("fastvideo_kernel.triton_kernels")
+    )
+    monkeypatch.setitem(sys.modules, "fastvideo_kernel.triton_kernels.index", index)
+    monkeypatch.setitem(sys.modules, "fastvideo_kernel.block_sparse_attn", triton)
+    query = torch.arange(128 * 2 * 8, dtype=torch.float32).reshape(1, 128, 2, 8)
+    block_map = torch.ones(1, 2, 2, 2, dtype=torch.bool)
+    sizes = torch.tensor([64, 64], dtype=torch.int32)
+
+    if error_type is torch.AcceleratorError:
+        with pytest.raises(torch.AcceleratorError, match="native provider failure") as raised:
+            fastvideo_block_sparse_attn_bshd(query, query, query, block_map, sizes, 2)
+        assert raised.value is error
+        fallback.assert_not_called()
+    else:
+        output = fastvideo_block_sparse_attn_bshd(query, query, query, block_map, sizes, 2)
+        torch.testing.assert_close(output, query, rtol=0, atol=0)
+        fallback.assert_called_once()
diff --git a/tests/diffusion/attention/test_fastvideo_vsa.py b/tests/diffusion/attention/test_fastvideo_vsa.py
index 1bd7192ad..e5c854d8d 100644
--- a/tests/diffusion/attention/test_fastvideo_vsa.py
+++ b/tests/diffusion/attention/test_fastvideo_vsa.py
@@ -1,7 +1,6 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
-import math
 import sys
 import types
 from typing import Any
@@ -12,14 +11,10 @@ import torch
 from vllm_omni.diffusion.attention.backends.abstract import (
     AttentionMetadata,
     PackedPaddingMetadata,
-    VideoTokenLayout,
-    VideoTokenSpan,
 )
 from vllm_omni.diffusion.attention.backends.fastvideo_vsa import (
     FastVideoVSABackend,
     FastVideoVSAImpl,
-    _build_h3_block_map,
-    _get_h3_tile_metadata,
 )
 from vllm_omni.diffusion.attention.backends.registry import (
     DiffusionAttentionBackendEnum,
@@ -218,144 +213,8 @@ def test_fastvideo_vsa_allows_topk_equal_to_num_blocks():
     assert too_many._fallback_reason(query, query, query, metadata) == "topk 3 > num_blocks 2"
 
 
-def _h3_metadata(prefix_segments, video_shape, *, gate=None, packed_padding=None):
-    extra: dict[str, Any] = {
-        "vsa_h3_prefix_segments": prefix_segments,
-    }
-    if gate is not None:
-        extra["gate_compress"] = gate
-    return AttentionMetadata(
-        packed_padding=packed_padding,
-        video_layout=VideoTokenLayout(
-            used_len=sum(prefix_segments) + math.prod(video_shape),
-            video_spans=(VideoTokenSpan(start=sum(prefix_segments), latent_grid=video_shape, role="target"),),
-        ),
-        extra=extra,
-    )
-
-
-def _fake_block_sparse_kernel(monkeypatch, calls):
-    """Stand in for fastvideo_kernel.block_sparse_attn with a mask-obeying SDPA."""
-
-    def block_sparse_attn(q, k, v, block_map, variable_block_sizes):
-        calls["block_map"] = block_map.clone()
-        calls["variable_block_sizes"] = variable_block_sizes.tolist()
-        calls["q_shape"] = tuple(q.shape)
-        blocks = block_map.shape[-1]
-        assert blocks * 64 == q.shape[2]
-        # Expand the per-block map to a per-token mask so the stand-in honours
-        # the sparsity contract the real kernel implements, and drop the rows
-        # each partial block pads with, which the real kernel skips through
-        # variable_block_sizes.
-        token_mask = block_map.repeat_interleave(64, dim=-1).repeat_interleave(64, dim=-2)
-        within = torch.arange(64, device=q.device)[None, :] < variable_block_sizes[:, None]
-        token_mask = token_mask & within.reshape(1, 1, 1, -1)
-        out = torch.nn.functional.scaled_dot_product_attention(q.float(), k.float(), v.float(), attn_mask=token_mask)
-        return out.to(q.dtype), None
-
-    module = types.ModuleType("fastvideo_kernel.block_sparse_attn")
-    setattr(module, "block_sparse_attn", block_sparse_attn)
-    monkeypatch.setitem(sys.modules, "fastvideo_kernel", types.ModuleType("fastvideo_kernel"))
-    monkeypatch.setitem(sys.modules, "fastvideo_kernel.block_sparse_attn", module)
-
-
-def _h3_impl(**backend_kwargs):
-    kwargs = {"topk": 1, "min_seq_len": 1, "disable_when_sp_active": False}
-    kwargs.update(backend_kwargs)
-    return FastVideoVSAImpl(num_heads=2, head_size=8, softmax_scale=8**-0.5, backend_kwargs=kwargs)
-
-
-def test_h3_forward_tiles_untiles_and_restores_the_original_row_order(monkeypatch):
-    calls: dict[str, Any] = {}
-    _fake_block_sparse_kernel(monkeypatch, calls)
-    impl = _h3_impl(topk=64)
-    prefix_segments, video_shape = (5, 70), (2, 4, 4)
-    seq_len = sum(prefix_segments) + 2 * 4 * 4
-    torch.manual_seed(0)
-    query = torch.randn(1, seq_len, 2, 8, dtype=torch.bfloat16)
-
-    output = impl.forward_cuda(query, query, query, _h3_metadata(prefix_segments, video_shape))
-
-    assert output.shape == query.shape
-    # topk covers every video block, so the block map is dense and the tiled
-    # kernel must reproduce plain attention over the same rows.
-    reference = torch.nn.functional.scaled_dot_product_attention(
-        *(x.float().transpose(1, 2) for x in (query, query, query))
-    ).transpose(1, 2)
-    torch.testing.assert_close(output.float(), reference, atol=2e-2, rtol=2e-2)
-    # 5 + 70 splits into segment-pure 5 | 64 | 6, then one (2, 4, 4) video tile.
-    assert calls["variable_block_sizes"] == [5, 64, 6, 32]
-
-
-def test_h3_forward_keeps_prefix_dense_and_selects_top_k_video_tiles(monkeypatch):
-    calls: dict[str, Any] = {}
-    _fake_block_sparse_kernel(monkeypatch, calls)
-    impl = _h3_impl(topk=1)
-    prefix_segments, video_shape = (5,), (8, 4, 4)
-    seq_len = 5 + 8 * 4 * 4
-    torch.manual_seed(0)
-    query = torch.randn(1, seq_len, 2, 8, dtype=torch.bfloat16)
-
-    impl.forward_cuda(query, query, query, _h3_metadata(prefix_segments, video_shape))
-
-    # 1 prefix block + 2 video blocks. The odd count is padded to an even one
-    # for the paired-CTA kernel contract, and the Triton route slices that
-    # transport-only partner off again before launching.
-    block_map = calls["block_map"]
-    assert block_map.shape[-1] == 3
-    assert calls["variable_block_sizes"] == [5, 64, 64]
-    assert block_map[:, :, :1, :].all(), "prefix queries stay dense"
-    assert block_map[..., :1].all(), "prefix keys are exempt from selection"
-    assert (block_map[:, :, 1:, 1:].sum(dim=-1) == 1).all(), "one video tile per video query"
-
-    # The same odd geometry must still untile back onto the original rows.
-    dense = _h3_impl(topk=64).forward_cuda(query, query, query, _h3_metadata(prefix_segments, video_shape))
-    reference = torch.nn.functional.scaled_dot_product_attention(
-        *(x.float().transpose(1, 2) for x in (query, query, query))
-    ).transpose(1, 2)
-    torch.testing.assert_close(dense.float(), reference, atol=2e-2, rtol=2e-2)
-
-
-def test_h3_forward_applies_the_learned_compression_gate(monkeypatch):
-    _fake_block_sparse_kernel(monkeypatch, {})
-    impl = _h3_impl(topk=64)
-    prefix_segments, video_shape = (5,), (2, 4, 4)
-    seq_len = 5 + 2 * 4 * 4
-    torch.manual_seed(0)
-    query = torch.randn(1, seq_len, 2, 8, dtype=torch.bfloat16)
-
-    without_gate = impl.forward_cuda(query, query, query, _h3_metadata(prefix_segments, video_shape))
-    zero_gate = torch.zeros_like(query)
-    with_zero_gate = impl.forward_cuda(query, query, query, _h3_metadata(prefix_segments, video_shape, gate=zero_gate))
-    live_gate = torch.full_like(query, 0.5)
-    with_live_gate = impl.forward_cuda(query, query, query, _h3_metadata(prefix_segments, video_shape, gate=live_gate))
-
-    torch.testing.assert_close(with_zero_gate.float(), without_gate.float())
-    assert not torch.allclose(with_live_gate.float(), without_gate.float())
-
-
-def test_h3_forward_restores_rows_the_packed_padding_excludes(monkeypatch):
-    _fake_block_sparse_kernel(monkeypatch, {})
-    impl = _h3_impl(topk=64)
-    prefix_segments, video_shape = (5,), (2, 4, 4)
-    valid = 5 + 2 * 4 * 4
-    torch.manual_seed(0)
-    query = torch.randn(1, valid + 24, 2, 8, dtype=torch.bfloat16)
-    padding = PackedPaddingMetadata(
-        q_length=valid,
-        kv_length=valid,
-        cu_seqlens_q=torch.tensor([0, valid], dtype=torch.int32),
-        cu_seqlens_k=torch.tensor([0, valid], dtype=torch.int32),
-    )
-
-    output = impl.forward_cuda(query, query, query, _h3_metadata(prefix_segments, video_shape, packed_padding=padding))
-
-    assert output.shape == query.shape
-    assert torch.count_nonzero(output[:, valid:]) == 0
-
-
 def test_sdpa_fallback_never_attends_the_structural_padding(monkeypatch):
-    # The backend advertises supports_packed_mask_free, so MiniMax-H3 skips
+    # The backend advertises supports_packed_mask_free, so a model may skip
     # building the padding mask. Every fallback out of the VSA path must honour
     # that contract itself; SDPA reads attn_mask and nothing else.
     impl = FastVideoVSAImpl(
@@ -374,6 +233,8 @@ def test_sdpa_fallback_never_attends_the_structural_padding(monkeypatch):
         cu_seqlens_k=torch.tensor([0, valid], dtype=torch.int32),
     )
 
+    monkeypatch.setattr(impl.sdpa_fallback, "forward", impl.sdpa_fallback.forward_cuda)
+
     baseline = impl.forward_cuda(query, query, query, AttentionMetadata(packed_padding=padding, extra={}))
     perturbed_input = query.clone()
     perturbed_input[:, valid:] += 100.0
@@ -384,22 +245,3 @@ def test_sdpa_fallback_never_attends_the_structural_padding(monkeypatch):
     assert baseline.shape == query.shape
     torch.testing.assert_close(baseline[:, :valid], perturbed[:, :valid])
     assert torch.count_nonzero(baseline[:, valid:]) == 0
-
-
-def test_h3_geometry_keeps_prefix_segments_pure_and_tiles_video_3d():
-    partition, sizes, non_pad, untile, prefix_blocks, video_blocks = _get_h3_tile_metadata(
-        (5, 70, 9), (5, 6, 6), torch.device("cpu")
-    )
-    assert sizes[:4].tolist() == [5, 64, 6, 9]
-    assert prefix_blocks == 4
-    assert video_blocks == 8
-    assert int(sizes.sum()) == 5 + 70 + 9 + 5 * 6 * 6
-    assert partition.numel() == non_pad.numel() == untile.numel() == int(sizes.sum())
-
-
-def test_h3_block_map_makes_prefix_queries_dense_and_prefix_keys_exempt():
-    scores = torch.arange(1 * 2 * 5 * 5, dtype=torch.float32).reshape(1, 2, 5, 5)
-    block_map = _build_h3_block_map(scores, num_prefix_blocks=2, num_video_blocks=3, topk=1)
-    assert block_map[:, :, :2].all()
-    assert block_map[..., :2].all()
-    assert (block_map[:, :, 2:, 2:].sum(dim=-1) == 1).all()
diff --git a/tests/diffusion/attention/test_flash_attn.py b/tests/diffusion/attention/test_flash_attn.py
index be78ad690..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)
@@ -503,11 +514,12 @@ def test_packed_varlen_metadata_must_be_complete(monkeypatch):
 #   - boundary resolution in ``_resolve_packed_seq_npu`` (pure Python, no device
 #     sync, no MindIE-SD import);
 #   - env dispatch in ``forward_fa_npu`` (which op a packed forward takes);
+#   - native torch_npu dispatch for right-down causal attention;
 #   - the laser input pre-scaling math in ``_forward_prefix_kv_slice_npu``.
 #
-# They run on CPU without a real NPU by injecting a fake ``mindiesd`` module
-# into ``sys.modules`` (same pattern as ``test_paged_attention`` /
-# ``benchmarks/conftest``). No production code is exercised for real kernels.
+# They run on CPU without a real NPU by injecting fake ``mindiesd`` and
+# ``torch_npu`` modules into ``sys.modules`` (same pattern as
+# ``test_paged_attention`` / ``benchmarks/conftest``). No real kernel runs.
 
 
 def _npu_impl(causal: bool = False) -> FlashAttentionImpl:
@@ -529,9 +541,19 @@ def _fake_mindiesd(monkeypatch, *, attention_forward=None, attention_forward_var
     return fake
 
 
+def _fake_torch_npu(monkeypatch, *, npu_fusion_attention=None):
+    """Install the minimal torch_npu surface used by causal NPU attention."""
+    fake = SimpleNamespace(
+        npu_fusion_attention=npu_fusion_attention or Mock(return_value=(torch.zeros(1), None, None, None, 0, 0, 0)),
+    )
+    monkeypatch.setitem(sys.modules, "torch_npu", fake)
+    return fake
+
+
 # --- 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)
@@ -541,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)
@@ -564,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."""
@@ -620,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)
@@ -632,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)
@@ -645,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).
 
@@ -665,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."""
@@ -685,9 +713,115 @@ def test_npu_varlen_opt_in_unset_takes_mask_path(monkeypatch):
     assert out is fake_forward.return_value
 
 
-# --- Test group C: laser input pre-scaling in _forward_prefix_kv_slice_npu --
+# --- Test group C: native NPU causal attention dispatch ----------------------
 
 
+@pytest.mark.parametrize(
+    ("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,
+    key_length,
+    expected_inner_precise,
+):
+    expected_out = torch.randn(1, query_length, 2, 4)
+    fusion_attention = Mock(return_value=(expected_out, None, None, None, 0, 0, 0))
+    fake_torch_npu = _fake_torch_npu(monkeypatch, npu_fusion_attention=fusion_attention)
+    impl = FlashAttentionImpl(num_heads=8, head_size=4, softmax_scale=0.5, causal=True)
+    query = torch.randn(1, query_length, 2, 4)
+    key = torch.randn(1, key_length, 2, 4)
+
+    out = impl.forward_fa_npu(query, key, key)
+
+    fake_torch_npu.npu_fusion_attention.assert_called_once()
+    args, kwargs = fake_torch_npu.npu_fusion_attention.call_args
+    assert torch.equal(args[0], query)
+    assert torch.equal(args[1], key)
+    assert torch.equal(args[2], key)
+    assert all(tensor.is_contiguous() for tensor in args[:3])
+    assert kwargs["head_num"] == query.shape[2]
+    assert kwargs["input_layout"] == "BSND"
+    assert kwargs["scale"] == 0.5
+    assert kwargs["keep_prob"] == 1.0
+    assert kwargs["sparse_mode"] == 3
+    assert kwargs["inner_precise"] == expected_inner_precise
+
+    block_mask = kwargs["atten_mask"]
+    assert block_mask.shape == (2048, 2048)
+    assert block_mask.dtype == torch.bool
+    assert block_mask.is_contiguous()
+    expected_corner = torch.tensor(
+        [
+            [False, True, True, True],
+            [False, False, True, True],
+            [False, False, False, True],
+            [False, False, False, False],
+        ]
+    )
+    assert torch.equal(block_mask[:4, :4], expected_corner)
+    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))
+    fake_torch_npu = _fake_torch_npu(monkeypatch, npu_fusion_attention=fusion_attention)
+    impl = FlashAttentionImpl(num_heads=2, head_size=4, softmax_scale=0.5, causal=True)
+    query = torch.randn(1, 4, 2, 4)
+    key_keep_mask = torch.tensor([[True, False, True, True]])
+
+    out = impl.forward_fa_npu(
+        query,
+        query,
+        query,
+        AttentionMetadata(attn_mask=key_keep_mask),
+    )
+
+    fake_torch_npu.npu_fusion_attention.assert_called_once()
+    kwargs = fake_torch_npu.npu_fusion_attention.call_args.kwargs
+    assert kwargs["sparse_mode"] == 1
+    assert kwargs["inner_precise"] == 2
+    expected_block_mask = torch.tensor(
+        [
+            [
+                [
+                    [False, True, True, True],
+                    [False, True, True, True],
+                    [False, True, False, True],
+                    [False, True, False, False],
+                ]
+            ]
+        ]
+    )
+    assert torch.equal(kwargs["atten_mask"], expected_block_mask)
+    assert kwargs["atten_mask"].is_contiguous()
+    assert out is expected_out
+
+
+@pytest.mark.cpu
+def test_npu_noncausal_without_explicit_mask_stays_unmasked(monkeypatch):
+    captured: dict = {}
+
+    def fake_attention_forward(query, key, value, **kwargs):
+        captured.update(kwargs)
+        return torch.zeros_like(query)
+
+    _fake_mindiesd(monkeypatch, attention_forward=fake_attention_forward)
+    query = torch.randn(1, 4, 2, 4)
+
+    _npu_impl(causal=False).forward_fa_npu(query, query, query)
+
+    assert captured["attn_mask"] is None
+
+
+# --- 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 = {}
@@ -726,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_flash_attn_npu.py b/tests/diffusion/attention/test_flash_attn_npu.py
new file mode 100644
index 000000000..c971e251b
--- /dev/null
+++ b/tests/diffusion/attention/test_flash_attn_npu.py
@@ -0,0 +1,118 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import pytest
+import torch
+
+from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata
+from vllm_omni.diffusion.attention.backends.flash_attn import FlashAttentionImpl
+from vllm_omni.platforms import current_omni_platform
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.npu]
+
+
+def _bottom_right_causal_reference(
+    query: torch.Tensor,
+    key: torch.Tensor,
+    value: torch.Tensor,
+    scale: float,
+    key_keep_mask: torch.Tensor | None = None,
+) -> torch.Tensor:
+    scores = torch.einsum("bqhd,bkhd->bhqk", query.float(), key.float()) * scale
+    query_positions = torch.arange(query.shape[1]).unsqueeze(1)
+    key_positions = torch.arange(key.shape[1]).unsqueeze(0)
+    keep_mask = key_positions <= query_positions + (key.shape[1] - query.shape[1])
+    if key_keep_mask is not None:
+        assert query.shape[0] == 1
+        keep_mask = keep_mask & key_keep_mask[0].bool().unsqueeze(0)
+    valid_rows = keep_mask.any(dim=-1)
+
+    output = torch.zeros(
+        query.shape[0],
+        query.shape[1],
+        query.shape[2],
+        value.shape[-1],
+        dtype=torch.float32,
+    )
+    valid_scores = scores[:, :, valid_rows].masked_fill(~keep_mask[valid_rows], float("-inf"))
+    probabilities = torch.softmax(valid_scores, dim=-1)
+    output[:, valid_rows] = torch.einsum("bhqk,bkhd->bqhd", probabilities, value.float())
+    return output
+
+
+@pytest.mark.skipif(not current_omni_platform.is_npu(), reason="Native causal attention requires Ascend NPU")
+def test_npu_bottom_right_causal_fully_masked_rows_are_zero():
+    torch.manual_seed(0)
+    batch_size, query_length, key_length = 1, 4, 2
+    num_heads, head_size = 2, 64
+    scale = head_size**-0.5
+
+    query_cpu = torch.randn(batch_size, query_length, num_heads, head_size).to(torch.bfloat16)
+    key_cpu = torch.randn(batch_size, key_length, num_heads, head_size).to(torch.bfloat16)
+    value_cpu = torch.randn(batch_size, key_length, num_heads, head_size).to(torch.bfloat16)
+    expected = _bottom_right_causal_reference(query_cpu, key_cpu, value_cpu, scale)
+
+    device = torch.device(current_omni_platform.device_type)
+    query = query_cpu.to(device)
+    key = key_cpu.to(device)
+    value = value_cpu.to(device)
+    impl = FlashAttentionImpl(
+        num_heads=num_heads,
+        head_size=head_size,
+        softmax_scale=scale,
+        causal=True,
+    )
+
+    output = impl.forward_fa_npu(query, key, value)
+    output_cpu = output.float().cpu()
+
+    assert torch.isfinite(output_cpu).all()
+    assert torch.equal(output_cpu[:, : query_length - key_length], torch.zeros_like(output_cpu[:, :2]))
+    torch.testing.assert_close(
+        output_cpu[:, query_length - key_length :],
+        expected[:, query_length - key_length :],
+        rtol=2e-2,
+        atol=2e-2,
+    )
+
+
+@pytest.mark.skipif(not current_omni_platform.is_npu(), reason="Native causal attention requires Ascend NPU")
+def test_npu_bottom_right_causal_composes_explicit_keep_mask():
+    torch.manual_seed(1)
+    batch_size, sequence_length = 1, 4
+    num_heads, head_size = 2, 64
+    scale = head_size**-0.5
+    key_keep_mask_cpu = torch.tensor([[True, False, True, True]])
+
+    query_cpu = torch.randn(batch_size, sequence_length, num_heads, head_size).to(torch.bfloat16)
+    key_cpu = torch.randn(batch_size, sequence_length, num_heads, head_size).to(torch.bfloat16)
+    value_cpu = torch.randn(batch_size, sequence_length, num_heads, head_size).to(torch.bfloat16)
+    expected = _bottom_right_causal_reference(
+        query_cpu,
+        key_cpu,
+        value_cpu,
+        scale,
+        key_keep_mask_cpu,
+    )
+
+    device = torch.device(current_omni_platform.device_type)
+    query = query_cpu.to(device)
+    key = key_cpu.to(device)
+    value = value_cpu.to(device)
+    impl = FlashAttentionImpl(
+        num_heads=num_heads,
+        head_size=head_size,
+        softmax_scale=scale,
+        causal=True,
+    )
+
+    output = impl.forward_fa_npu(
+        query,
+        key,
+        value,
+        AttentionMetadata(attn_mask=key_keep_mask_cpu.to(device)),
+    )
+    output_cpu = output.float().cpu()
+
+    assert torch.isfinite(output_cpu).all()
+    torch.testing.assert_close(output_cpu, expected, rtol=2e-2, atol=2e-2)
diff --git a/tests/diffusion/attention/test_impl_overrides.py b/tests/diffusion/attention/test_impl_overrides.py
new file mode 100644
index 000000000..f7755de5c
--- /dev/null
+++ b/tests/diffusion/attention/test_impl_overrides.py
@@ -0,0 +1,136 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import pytest
+
+from vllm_omni.diffusion.attention import layer
+from vllm_omni.diffusion.attention.backends.fastvideo_vsa import FastVideoVSABackend, FastVideoVSAImpl
+from vllm_omni.diffusion.attention.backends.sdpa import SDPABackend
+from vllm_omni.diffusion.attention.parallel.base import NoParallelAttention
+from vllm_omni.diffusion.data import AttentionSpec
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+
+class _SpecializedImpl(FastVideoVSAImpl):
+    pass
+
+
+@pytest.fixture
+def local_attention(monkeypatch):
+    monkeypatch.setattr(layer, "get_current_diffusion_config_or_none", lambda: None)
+    monkeypatch.setattr(layer, "build_parallel_attention_strategy", lambda **kwargs: NoParallelAttention())
+
+
+@pytest.mark.parametrize("explicit", [False, True])
+@pytest.mark.parametrize("override", [False, True])
+def test_specialization_preserves_selected_backend_and_options(mocker, local_attention, explicit, override):
+    spec = AttentionSpec(backend="FASTVIDEO_VSA", fastvideo_vsa_topk=7) if explicit else None
+    select = mocker.patch.object(layer, "get_attn_backend_for_role", return_value=(FastVideoVSABackend, spec))
+    attention = layer.Attention(
+        num_heads=2,
+        head_size=8,
+        softmax_scale=8**-0.5,
+        causal=False,
+        role="video.self",
+        role_category="self",
+        qkv_layout="BSND",
+        impl_overrides={"FASTVIDEO_VSA": _SpecializedImpl} if override else None,
+    )
+
+    assert attention.attn_backend is FastVideoVSABackend
+    assert type(attention.attention) is (_SpecializedImpl if override else FastVideoVSAImpl)
+    assert attention.attention.topk == (7 if explicit else 64)
+    assert attention.attention.qkv_layout == "BSND"
+    assert attention.backend_pref == "FASTVIDEO_VSA"
+    assert attention.backend_explicit is explicit
+    assert attention.attn_spec is spec
+    assert isinstance(attention.parallel_strategy, NoParallelAttention)
+    select.assert_called_once_with(
+        role="video.self", head_size=8, attention_config=None, role_category="self", allow_trtllm_default=False
+    )
+
+
+def test_unselected_specialization_does_not_replace_dense_backend(mocker, local_attention):
+    mocker.patch.object(layer, "get_attn_backend_for_role", return_value=(SDPABackend, None))
+    attention = layer.Attention(
+        num_heads=2,
+        head_size=8,
+        softmax_scale=8**-0.5,
+        causal=False,
+        impl_overrides={"FASTVIDEO_VSA": _SpecializedImpl},
+    )
+    assert attention.attn_backend is SDPABackend
+    assert type(attention.attention) is SDPABackend.get_impl_cls()
+
+
+def test_specialization_does_not_bypass_selection_errors(mocker, local_attention):
+    mocker.patch.object(layer, "get_attn_backend_for_role", side_effect=ImportError("optional kernel unavailable"))
+    with pytest.raises(ImportError, match="optional kernel unavailable"):
+        layer.Attention(
+            num_heads=2,
+            head_size=8,
+            softmax_scale=8**-0.5,
+            causal=False,
+            impl_overrides={"FASTVIDEO_VSA": _SpecializedImpl},
+        )
+
+
+def test_specialization_must_extend_selected_implementation(mocker, local_attention):
+    mocker.patch.object(layer, "get_attn_backend_for_role", return_value=(FastVideoVSABackend, None))
+    with pytest.raises(TypeError, match="must subclass the selected implementation"):
+        layer.Attention(
+            num_heads=2,
+            head_size=8,
+            softmax_scale=8**-0.5,
+            causal=False,
+            impl_overrides={"FASTVIDEO_VSA": SDPABackend.get_impl_cls()},
+        )
+
+
+def test_platform_backend_capabilities_survive_model_specialization(mocker, local_attention):
+    from vllm_omni.diffusion.models.minimax_h3.attention.fastvideo_h3 import MiniMaxH3VSAImpl
+
+    class PlatformBackend(FastVideoVSABackend):
+        @classmethod
+        def supports_packed_mask_free(cls):
+            return False
+
+        @staticmethod
+        def get_supported_head_sizes():
+            return [128]
+
+    # A registry/platform may refine capabilities without changing the
+    # implementation. The model must not replace those capability decisions.
+    mocker.patch.object(layer, "get_attn_backend_for_role", return_value=(PlatformBackend, None))
+    attention = layer.Attention(
+        num_heads=2,
+        head_size=128,
+        softmax_scale=128**-0.5,
+        causal=False,
+        impl_overrides={"FASTVIDEO_VSA": MiniMaxH3VSAImpl},
+    )
+    assert attention.attn_backend is PlatformBackend
+    assert not attention.attn_backend.supports_packed_mask_free()
+    assert attention.attn_backend.get_supported_head_sizes() == [128]
+    assert type(attention.attention) is MiniMaxH3VSAImpl
+
+
+def test_incompatible_platform_implementation_is_not_discarded(mocker, local_attention):
+    class PlatformImpl(FastVideoVSAImpl):
+        pass
+
+    class PlatformBackend(FastVideoVSABackend):
+        @staticmethod
+        def get_impl_cls():
+            return PlatformImpl
+
+    mocker.patch.object(layer, "get_attn_backend_for_role", return_value=(PlatformBackend, None))
+    with pytest.raises(TypeError, match="selected implementation .*PlatformImpl"):
+        layer.Attention(
+            num_heads=2,
+            head_size=8,
+            softmax_scale=8**-0.5,
+            causal=False,
+            impl_overrides={"FASTVIDEO_VSA": _SpecializedImpl},
+        )
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/attention/test_ring_padding.py b/tests/diffusion/attention/test_ring_padding.py
new file mode 100644
index 000000000..8994e3fc1
--- /dev/null
+++ b/tests/diffusion/attention/test_ring_padding.py
@@ -0,0 +1,221 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from dataclasses import dataclass
+from typing import Any
+
+import pytest
+import torch
+
+from vllm_omni.diffusion.attention.backends import ring_flash_attn, ring_pytorch_attn
+from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata
+from vllm_omni.diffusion.attention.backends.ring.ring_selector import AttnType
+from vllm_omni.diffusion.attention.backends.ring.ring_utils import ring_kv_block_valid_length
+from vllm_omni.diffusion.attention.parallel import ring as ring_parallel
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+
+class _SingleRankComm:
+    rank = 0
+    world_size = 1
+
+
+@dataclass(frozen=True)
+class _FakeSequenceParallelGroup:
+    ring_group: object
+
+
+def _fake_attention_result(q, _k, _v, **_kwargs):
+    return torch.zeros_like(q), torch.zeros(q.shape[0], q.shape[2], q.shape[1])
+
+
+@pytest.mark.parametrize(("block_rank", "expected"), [(0, 4), (1, 1), (2, 0)])
+def test_global_prefix_is_partitioned_across_ring_blocks(block_rank, expected):
+    assert ring_kv_block_valid_length(5, 4, block_rank, 3) == expected
+
+
+def test_absent_prefix_length_keeps_the_full_ring_block():
+    assert ring_kv_block_valid_length(None, 4, 2, 3) == 4
+
+
+def test_pytorch_ring_trims_padding_from_each_kv_block(monkeypatch):
+    captured: dict[str, Any] = {}
+
+    def fake_attention(q, k, v, **kwargs):
+        captured.update(k=k, v=v, **kwargs)
+        return _fake_attention_result(q, k, v, **kwargs)
+
+    monkeypatch.setattr(ring_pytorch_attn, "RingComm", lambda _group: _SingleRankComm())
+    monkeypatch.setattr(ring_pytorch_attn, "pytorch_attn_forward", fake_attention)
+    qkv = torch.randn(1, 4, 2, 8)
+
+    output = ring_pytorch_attn.ring_pytorch_attn_func(
+        qkv,
+        qkv,
+        qkv,
+        group=object(),
+        valid_kv_length=3,
+    )
+
+    assert output.shape == qkv.shape
+    assert captured["k"].shape[1] == 3
+    assert captured["v"].shape[1] == 3
+
+
+def test_pytorch_ring_trims_circulated_blocks_by_source_rank(monkeypatch):
+    observed_lengths = []
+    # Each ring step sends K and V separately.
+    blocks = [torch.randn(1, 4, 2, 8) for _ in range(4)]
+
+    class FakeRingComm:
+        rank = 2
+        world_size = 3
+
+        def __init__(self, _group):
+            self._next_block = 0
+
+        def send_recv(self, _tensor):
+            block = blocks[self._next_block]
+            self._next_block += 1
+            return block
+
+        def commit(self):
+            pass
+
+        def wait(self):
+            pass
+
+    def fake_attention(q, k, v, **kwargs):
+        observed_lengths.append(k.shape[1])
+        return _fake_attention_result(q, k, v, **kwargs)
+
+    monkeypatch.setattr(ring_pytorch_attn, "RingComm", FakeRingComm)
+    monkeypatch.setattr(ring_pytorch_attn, "pytorch_attn_forward", fake_attention)
+    qkv = torch.randn(1, 4, 2, 8)
+
+    ring_pytorch_attn.ring_pytorch_attn_func(
+        qkv,
+        qkv,
+        qkv,
+        group=object(),
+        valid_kv_length=5,
+    )
+
+    # Rank 2 starts with global block 2, then receives blocks 1 and 0.
+    # The first block is empty and therefore does not launch attention.
+    assert observed_lengths == [1, 4]
+
+
+def test_flash_ring_trims_padding_from_each_kv_block(monkeypatch):
+    captured: dict[str, Any] = {}
+
+    def fake_attention(q, k, v, **kwargs):
+        captured.update(k=k, v=v, **kwargs)
+        return _fake_attention_result(q, k, v, **kwargs)
+
+    monkeypatch.setattr(ring_flash_attn, "RingComm", lambda _group: _SingleRankComm())
+    monkeypatch.setattr(ring_flash_attn, "select_flash_attn_impl", lambda *_args, **_kwargs: fake_attention)
+    qkv = torch.randn(1, 4, 2, 8)
+
+    output, _ = ring_flash_attn.ring_flash_attn_forward(
+        object(),
+        qkv,
+        qkv,
+        qkv,
+        softmax_scale=0.25,
+        causal=False,
+        attn_type=AttnType.FA,
+        valid_kv_length=3,
+    )
+
+    assert output.shape == qkv.shape
+    assert captured["k"].shape[1] == 3
+    assert captured["v"].shape[1] == 3
+
+
+def test_ring_dispatch_forwards_global_valid_kv_length(monkeypatch):
+    captured: dict[str, Any] = {}
+
+    def fake_ring_attention(*_args, **kwargs):
+        captured.update(kwargs)
+        return "output"
+
+    monkeypatch.setattr(ring_pytorch_attn, "ring_pytorch_attn_func", fake_ring_attention)
+    strategy = ring_parallel.RingParallelAttention(
+        _FakeSequenceParallelGroup(ring_group=object()),
+        attn_backend_pref="sdpa",
+    )
+    metadata = AttentionMetadata(extra={"valid_kv_length": 3})
+    query = torch.randn(1, 4, 2, 8)
+
+    assert strategy.run_attention(query, query, query, metadata) == "output"
+    assert captured["valid_kv_length"] == 3
+
+
+def test_pytorch_ring_rejects_causal_with_a_valid_prefix(monkeypatch):
+    """Trimming a K/V block under causal=True would silently shift the diagonal.
+
+    The query block keeps the full padded length while the circulated K/V block
+    is trimmed, and a causal mask over a rectangular tile is bottom-right
+    aligned, so the combination must be refused rather than computed.
+    """
+    monkeypatch.setattr(ring_pytorch_attn, "RingComm", lambda _group: _SingleRankComm())
+    monkeypatch.setattr(ring_pytorch_attn, "pytorch_attn_forward", _fake_attention_result)
+    qkv = torch.randn(1, 4, 2, 8)
+
+    with pytest.raises(ValueError, match="valid_kv_length is not supported with causal=True"):
+        ring_pytorch_attn.ring_pytorch_attn_func(
+            qkv,
+            qkv,
+            qkv,
+            causal=True,
+            group=object(),
+            valid_kv_length=3,
+        )
+
+
+def test_flash_ring_rejects_causal_with_a_valid_prefix(monkeypatch):
+    """Same refusal on the Flash-Attention ring path."""
+    monkeypatch.setattr(ring_flash_attn, "RingComm", lambda _group: _SingleRankComm())
+    monkeypatch.setattr(
+        ring_flash_attn,
+        "select_flash_attn_impl",
+        lambda *_args, **_kwargs: _fake_attention_result,
+    )
+    qkv = torch.randn(1, 4, 2, 8)
+
+    with pytest.raises(ValueError, match="valid_kv_length is not supported with causal=True"):
+        ring_flash_attn.ring_flash_attn_forward(
+            object(),
+            qkv,
+            qkv,
+            qkv,
+            softmax_scale=0.25,
+            causal=True,
+            attn_type=AttnType.FA,
+            valid_kv_length=3,
+        )
+
+
+def test_ring_paths_still_accept_causal_without_a_valid_prefix(monkeypatch):
+    """The guard is scoped to the padded case: plain causal Ring is unchanged."""
+    monkeypatch.setattr(ring_flash_attn, "RingComm", lambda _group: _SingleRankComm())
+    monkeypatch.setattr(
+        ring_flash_attn,
+        "select_flash_attn_impl",
+        lambda *_args, **_kwargs: _fake_attention_result,
+    )
+    qkv = torch.randn(1, 4, 2, 8)
+
+    output, _ = ring_flash_attn.ring_flash_attn_forward(
+        object(),
+        qkv,
+        qkv,
+        qkv,
+        softmax_scale=0.25,
+        causal=True,
+        attn_type=AttnType.FA,
+    )
+
+    assert output.shape == qkv.shape
diff --git a/tests/diffusion/cache/test_seacache.py b/tests/diffusion/cache/test_seacache.py
new file mode 100644
index 000000000..ea11537d1
--- /dev/null
+++ b/tests/diffusion/cache/test_seacache.py
@@ -0,0 +1,635 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from __future__ import annotations
+
+import datetime
+from contextlib import nullcontext
+from types import SimpleNamespace
+
+import pytest
+import torch
+
+from tests.helpers.runtime import get_distributed_init_method
+from vllm_omni.diffusion.cache.seacache import (
+    SeaCacheBackend,
+    SeaCacheConfig,
+    SeaCacheRootHook,
+    apply_sea_cache_hook,
+)
+from vllm_omni.diffusion.cache.seacache.sea_filter import (
+    apply_sea_filter,
+    extrapolate_residual,
+    indicator_distance,
+)
+from vllm_omni.diffusion.cache.selector import get_cache_backend
+from vllm_omni.diffusion.cache.teacache.extractors import EXTRACTOR_REGISTRY, CacheContext, get_extractor
+from vllm_omni.diffusion.data import DiffusionCacheConfig
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class TinyCosmos3Transformer(torch.nn.Module):
+    """Small model that exposes a cache-neutral execution boundary."""
+
+    def _run_gen_layers(self, hidden_gen: torch.Tensor) -> torch.Tensor:
+        return hidden_gen * 2
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        timestep: torch.Tensor,
+        text_ids: torch.Tensor | None = None,
+        text_mask: torch.Tensor | None = None,
+        video_shape: tuple[int, int, int] | None = None,
+        noisy_frame_mask: torch.Tensor | None = None,
+        control_latents: list[torch.Tensor] | torch.Tensor | None = None,
+        **kwargs,
+    ) -> torch.Tensor:
+        del timestep, text_ids, text_mask, video_shape, noisy_frame_mask
+        if kwargs:
+            raise TypeError(f"Unexpected tiny transformer kwargs: {sorted(kwargs)}")
+        controls = (
+            []
+            if control_latents is None
+            else [control_latents]
+            if isinstance(control_latents, torch.Tensor)
+            else list(control_latents)
+        )
+        inputs = [*controls, hidden_states]
+        gen_input = torch.cat(
+            [value.movedim(1, -1).flatten(1, 3) for value in inputs],
+            dim=1,
+        )
+        return self._run_gen_layers(gen_input)
+
+
+def _extract_tiny_cosmos3_context(
+    module: TinyCosmos3Transformer,
+    hidden_states: torch.Tensor,
+    timestep: torch.Tensor,
+    text_ids: torch.Tensor | None = None,
+    text_mask: torch.Tensor | None = None,
+    video_shape: tuple[int, int, int] | None = None,
+    noisy_frame_mask: torch.Tensor | None = None,
+    control_latents: list[torch.Tensor] | torch.Tensor | None = None,
+    **kwargs,
+) -> CacheContext:
+    del timestep, text_ids, text_mask, video_shape
+    if kwargs:
+        raise TypeError(f"Unexpected tiny transformer kwargs: {sorted(kwargs)}")
+    controls = (
+        []
+        if control_latents is None
+        else [control_latents]
+        if isinstance(control_latents, torch.Tensor)
+        else list(control_latents)
+    )
+    vision_items = [*controls, hidden_states]
+    gen_input = torch.cat(
+        [value.movedim(1, -1).flatten(1, 3) for value in vision_items],
+        dim=1,
+    )
+    return CacheContext(
+        modulated_input=gen_input,
+        hidden_states=gen_input,
+        encoder_hidden_states=None,
+        temb=torch.zeros_like(gen_input[:, 0]),
+        run_transformer_blocks=lambda: (module._run_gen_layers(gen_input),),
+        postprocess=lambda output: output,
+        extra_states={
+            "sea_cache_latents": vision_items,
+            "sea_cache_noisy_frame_mask": noisy_frame_mask,
+        },
+    )
+
+
+class Cosmos3OmniDiffusersPipeline:
+    def __init__(self) -> None:
+        self.transformer = TinyCosmos3Transformer()
+        self._current_step_index: int | None = None
+        self._current_sigma: float | None = None
+        self._num_timesteps: int | None = None
+
+    @property
+    def current_step_index(self) -> int | None:
+        return self._current_step_index
+
+    @property
+    def current_sigma(self) -> float | None:
+        return self._current_sigma
+
+    @property
+    def num_timesteps(self) -> int | None:
+        return self._num_timesteps
+
+
+def _latent(value: float) -> torch.Tensor:
+    return torch.full((1, 2, 2, 2, 2), value)
+
+
+def _run_step(
+    transformer: TinyCosmos3Transformer,
+    timestep: int,
+    value: float,
+    *,
+    hook: SeaCacheRootHook | None = None,
+    context: str = "cond",
+    control: float | None = None,
+    noisy_frame_mask: torch.Tensor | None = None,
+) -> torch.Tensor:
+    controls = None if control is None else [_latent(control)]
+    cache_context = hook.cache_context(context) if hook is not None else nullcontext()
+    with torch.inference_mode(), cache_context:
+        return transformer(
+            hidden_states=_latent(value),
+            timestep=torch.tensor([timestep]),
+            noisy_frame_mask=noisy_frame_mask,
+            control_latents=controls,
+        )
+
+
+def _apply_test_hook(
+    transformer: TinyCosmos3Transformer,
+    metadata: SimpleNamespace,
+    config: SeaCacheConfig | None = None,
+) -> SeaCacheRootHook:
+    return apply_sea_cache_hook(
+        transformer,
+        config or SeaCacheConfig(threshold=100.0),
+        current_step_callback=lambda: metadata.step,
+        current_sigma_callback=lambda: metadata.sigma,
+        num_inference_steps_callback=lambda: metadata.num_steps,
+        extractor_fn=_extract_tiny_cosmos3_context,
+    )
+
+
+def test_config_validation() -> None:
+    assert SeaCacheConfig().threshold == 0.25
+    with pytest.raises(ValueError, match="residual_order"):
+        SeaCacheConfig(residual_order=-1)
+    with pytest.raises(ValueError, match="max_consecutive_cached"):
+        SeaCacheConfig(max_consecutive_cached=-1)
+
+
+def test_sea_filter_matches_reference_equation() -> None:
+    hidden = torch.randn(3, 4, 5, 2, dtype=torch.float32)
+    sigma = 0.4
+    power_exp = 3.0
+
+    spectrum = torch.fft.fftn(hidden, dim=(0, 1, 2))
+    gain = None
+    for axis in (0, 1, 2):
+        frequencies = torch.fft.fftfreq(hidden.shape[axis], dtype=torch.float32)
+        clean_power = 1.0 / (frequencies.abs().pow(power_exp) + 1e-16)
+        axis_gain = (1.0 - sigma) * clean_power / ((1.0 - sigma) ** 2 * clean_power + sigma**2 + 1e-16)
+        shape = [1] * hidden.ndim
+        shape[axis] = hidden.shape[axis]
+        gain = axis_gain.reshape(shape) if gain is None else gain * axis_gain.reshape(shape)
+    assert gain is not None
+    gain = gain / gain.mean()
+    expected = torch.fft.ifftn(spectrum * gain, dim=(0, 1, 2)).real
+
+    torch.testing.assert_close(
+        apply_sea_filter(hidden, sigma=sigma, power_exp=power_exp),
+        expected,
+    )
+
+
+def test_indicator_distance_and_linear_extrapolation() -> None:
+    previous = [torch.ones(2, 2)]
+    current = [torch.full((2, 2), 1.5)]
+    assert indicator_distance(current, previous) == pytest.approx(0.5)
+    assert indicator_distance([torch.ones(3)], previous) == float("inf")
+
+    history = [
+        (0, torch.full((2, 2), 2.0)),
+        (2, torch.full((2, 2), 6.0)),
+    ]
+    torch.testing.assert_close(
+        extrapolate_residual(history, step=3, order=1),
+        torch.full((2, 2), 8.0),
+    )
+    torch.testing.assert_close(
+        extrapolate_residual(history, step=3, order=0),
+        torch.full((2, 2), 6.0),
+    )
+    quadratic_history = [
+        (0, torch.zeros(2, 2)),
+        (1, torch.ones(2, 2)),
+        (2, torch.full((2, 2), 4.0)),
+    ]
+    torch.testing.assert_close(
+        extrapolate_residual(quadratic_history, step=3, order=2),
+        torch.full((2, 2), 9.0),
+    )
+
+
+def test_hook_skips_middle_steps_and_forces_endpoints() -> None:
+    transformer = TinyCosmos3Transformer()
+    metadata = SimpleNamespace(step=0, sigma=1.0, num_steps=4)
+    hook = _apply_test_hook(
+        transformer,
+        metadata,
+        SeaCacheConfig(threshold=100.0, max_consecutive_cached=2),
+    )
+    hook.refresh(transformer)
+
+    for step, timestep in enumerate((1000, 750, 500, 250)):
+        metadata.step = step
+        metadata.sigma = timestep / 1000
+        _run_step(transformer, timestep, 1.0 - step * 0.01, hook=hook)
+
+    assert hook.full_count == 2
+    assert hook.skip_count == 2
+    assert [step for step, _ in hook.state_manager._states["cond"].history] == [0, 3]
+
+
+def test_parameter_sharded_hook_skips_when_all_shard_ranks_agree(monkeypatch: pytest.MonkeyPatch) -> None:
+    from vllm_omni.diffusion.distributed import parallel_state
+
+    transformer = TinyCosmos3Transformer()
+    metadata = SimpleNamespace(step=0, sigma=1.0, num_steps=3)
+    hook = _apply_test_hook(transformer, metadata)
+    hook._parameter_sharded = True
+    fs_group = object()
+    reduced_groups: list[object] = []
+
+    monkeypatch.setattr(torch.distributed, "is_available", lambda: True)
+    monkeypatch.setattr(torch.distributed, "is_initialized", lambda: True)
+    monkeypatch.setattr(
+        parallel_state,
+        "get_fs_group",
+        lambda: SimpleNamespace(world_size=2, device_group=fs_group),
+    )
+    monkeypatch.setattr(parallel_state, "get_sequence_parallel_world_size", lambda: 1)
+
+    def all_reduce(decision, *, op, group):
+        assert op == torch.distributed.ReduceOp.MAX
+        reduced_groups.append(group)
+
+    monkeypatch.setattr(torch.distributed, "all_reduce", all_reduce)
+
+    _run_step(transformer, 1000, 1.0, hook=hook)
+    metadata.step = 1
+    metadata.sigma = 0.5
+    _run_step(transformer, 500, 0.99, hook=hook)
+
+    assert hook.full_count == 1
+    assert hook.skip_count == 1
+    assert reduced_groups == [fs_group, fs_group]
+
+
+def test_parameter_sharded_peer_forces_full_compute(monkeypatch: pytest.MonkeyPatch) -> None:
+    from vllm_omni.diffusion.distributed import parallel_state
+
+    transformer = TinyCosmos3Transformer()
+    metadata = SimpleNamespace(step=0, sigma=1.0, num_steps=3)
+    hook = _apply_test_hook(transformer, metadata)
+    hook._parameter_sharded = True
+
+    monkeypatch.setattr(torch.distributed, "is_available", lambda: True)
+    monkeypatch.setattr(torch.distributed, "is_initialized", lambda: True)
+    monkeypatch.setattr(
+        parallel_state,
+        "get_fs_group",
+        lambda: SimpleNamespace(world_size=2, device_group=object()),
+    )
+    monkeypatch.setattr(parallel_state, "get_sequence_parallel_world_size", lambda: 1)
+    reduce_count = 0
+
+    def all_reduce(decision, *, op, group):
+        nonlocal reduce_count
+        del op, group
+        reduce_count += 1
+        if reduce_count == 2:
+            decision.fill_(1)
+
+    monkeypatch.setattr(torch.distributed, "all_reduce", all_reduce)
+
+    _run_step(transformer, 1000, 1.0, hook=hook)
+    metadata.step = 1
+    metadata.sigma = 0.5
+    _run_step(transformer, 500, 0.99, hook=hook)
+
+    assert hook.full_count == 2
+    assert hook.skip_count == 0
+    assert hook.state_manager._states["cond"].accumulated_distance == 0.0
+
+
+def _uneven_cfg_sharded_worker(
+    rank: int,
+    init_method: str,
+    result_queue: torch.multiprocessing.Queue,
+) -> None:
+    from vllm_omni.diffusion.distributed import parallel_state
+
+    torch.distributed.init_process_group(
+        "gloo",
+        init_method=init_method,
+        rank=rank,
+        world_size=4,
+        timeout=datetime.timedelta(seconds=10),
+    )
+    try:
+        fs_groups = [
+            (ranks, torch.distributed.new_group(ranks, timeout=datetime.timedelta(seconds=10)))
+            for ranks in ([0, 1], [2, 3])
+        ]
+        sp_groups = [
+            (ranks, torch.distributed.new_group(ranks, timeout=datetime.timedelta(seconds=10)))
+            for ranks in ([0, 1], [2, 3])
+        ]
+        cfg_groups = [
+            (ranks, torch.distributed.new_group(ranks, timeout=datetime.timedelta(seconds=10)))
+            for ranks in ([0, 2], [1, 3])
+        ]
+        fs_group = next(group for ranks, group in fs_groups if rank in ranks)
+        sp_group = next(group for ranks, group in sp_groups if rank in ranks)
+        cfg_group = next(group for ranks, group in cfg_groups if rank in ranks)
+        parallel_state._FS = SimpleNamespace(world_size=2, device_group=fs_group)
+        parallel_state._SP = SimpleNamespace(world_size=2, device_group=sp_group)
+
+        hook = SeaCacheRootHook(SeaCacheConfig())
+        hook._parameter_sharded = True
+        hook._synchronize_compute(False, torch.device("cpu"))
+        if rank in (0, 1):
+            hook._synchronize_compute(False, torch.device("cpu"))
+
+        gathered = [torch.zeros(1) for _ in range(2)]
+        torch.distributed.all_gather(
+            gathered,
+            torch.tensor([rank], dtype=torch.float32),
+            group=cfg_group,
+        )
+        result_queue.put((rank, [int(value.item()) for value in gathered]))
+    finally:
+        parallel_state._FS = None
+        parallel_state._SP = None
+        torch.distributed.destroy_process_group()
+
+
+def test_parameter_sharded_hook_handles_uneven_cfg_branch_dispatch() -> None:
+    mp_context = torch.multiprocessing.get_context("spawn")
+    manager = mp_context.Manager()
+    result_queue = manager.Queue()
+    torch.multiprocessing.spawn(
+        _uneven_cfg_sharded_worker,
+        args=(get_distributed_init_method("seacache_uneven_cfg_"), result_queue),
+        nprocs=4,
+    )
+
+    results = sorted(result_queue.get(timeout=2) for _ in range(4))
+    assert results == [
+        (0, [0, 2]),
+        (1, [1, 3]),
+        (2, [0, 2]),
+        (3, [1, 3]),
+    ]
+
+
+def _hybrid_sp_worker(
+    rank: int,
+    init_method: str,
+    result_queue: torch.multiprocessing.Queue,
+) -> None:
+    from vllm_omni.diffusion.distributed import parallel_state
+
+    torch.distributed.init_process_group(
+        "gloo",
+        init_method=init_method,
+        rank=rank,
+        world_size=4,
+        timeout=datetime.timedelta(seconds=10),
+    )
+    try:
+        fs_groups = [
+            (ranks, torch.distributed.new_group(ranks, timeout=datetime.timedelta(seconds=10)))
+            for ranks in ([0, 1], [2, 3])
+        ]
+        ulysses_groups = [
+            (ranks, torch.distributed.new_group(ranks, timeout=datetime.timedelta(seconds=10)))
+            for ranks in ([0, 1], [2, 3])
+        ]
+        ring_groups = [
+            (ranks, torch.distributed.new_group(ranks, timeout=datetime.timedelta(seconds=10)))
+            for ranks in ([0, 2], [1, 3])
+        ]
+        sp_group = torch.distributed.new_group(
+            [0, 1, 2, 3],
+            timeout=datetime.timedelta(seconds=10),
+        )
+        fs_group = next(group for ranks, group in fs_groups if rank in ranks)
+        ulysses_group = next(group for ranks, group in ulysses_groups if rank in ranks)
+        ring_group = next(group for ranks, group in ring_groups if rank in ranks)
+        parallel_state._FS = SimpleNamespace(world_size=2, device_group=fs_group)
+        parallel_state._SP = SimpleNamespace(
+            world_size=4,
+            device_group=sp_group,
+            ulysses_world_size=2,
+            ulysses_group=ulysses_group,
+            ring_world_size=2,
+            ring_group=ring_group,
+        )
+
+        compute = rank == 3
+        non_sharded_hook = SeaCacheRootHook(SeaCacheConfig())
+        non_sharded_result = non_sharded_hook._synchronize_compute(compute, torch.device("cpu"))
+
+        sharded_hook = SeaCacheRootHook(SeaCacheConfig())
+        sharded_hook._parameter_sharded = True
+        sharded_result = sharded_hook._synchronize_compute(compute, torch.device("cpu"))
+        result_queue.put((rank, non_sharded_result, sharded_result))
+    finally:
+        parallel_state._FS = None
+        parallel_state._SP = None
+        torch.distributed.destroy_process_group()
+
+
+def test_hook_synchronizes_full_hybrid_sequence_parallel_group() -> None:
+    mp_context = torch.multiprocessing.get_context("spawn")
+    manager = mp_context.Manager()
+    result_queue = manager.Queue()
+    torch.multiprocessing.spawn(
+        _hybrid_sp_worker,
+        args=(get_distributed_init_method("seacache_hybrid_sp_"), result_queue),
+        nprocs=4,
+    )
+
+    results = sorted(result_queue.get(timeout=2) for _ in range(4))
+    assert results == [
+        (0, True, True),
+        (1, True, True),
+        (2, True, True),
+        (3, True, True),
+    ]
+
+
+def test_parameter_sharded_hook_fails_open_without_distributed_state(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    hook = SeaCacheRootHook(SeaCacheConfig())
+    hook._parameter_sharded = True
+    monkeypatch.setattr(torch.distributed, "is_available", lambda: True)
+    monkeypatch.setattr(torch.distributed, "is_initialized", lambda: False)
+
+    assert hook._synchronize_compute(False, torch.device("cpu")) is True
+
+
+def test_hook_keeps_three_transfer_branches_separate() -> None:
+    transformer = TinyCosmos3Transformer()
+    metadata = SimpleNamespace(step=0, sigma=1.0, num_steps=3)
+    hook = _apply_test_hook(transformer, metadata)
+    hook.refresh(transformer)
+
+    contexts = ("cond", "cond_no_control", "uncond")
+    for step, (timestep, value) in enumerate(((1000, 1.0), (500, 0.9))):
+        metadata.step = step
+        metadata.sigma = timestep / 1000
+        _run_step(transformer, timestep, value, hook=hook, context=contexts[0], control=0.5)
+        _run_step(transformer, timestep, value, hook=hook, context=contexts[1])
+        _run_step(transformer, timestep, value, hook=hook, context=contexts[2], control=0.5)
+
+    assert set(hook.state_manager._states) == set(contexts)
+    assert hook.full_count == 3
+    assert hook.skip_count == 3
+    assert len(hook.state_manager._states["cond"].previous_indicator) == 2
+    assert len(hook.state_manager._states["cond_no_control"].previous_indicator) == 1
+
+
+def test_hook_fails_open_without_noisy_vision() -> None:
+    transformer = TinyCosmos3Transformer()
+    metadata = SimpleNamespace(step=0, sigma=1.0, num_steps=3)
+    hook = _apply_test_hook(transformer, metadata)
+    hook.refresh(transformer)
+    all_clean = torch.zeros(1, 1, 2, 1, 1)
+
+    _run_step(transformer, 1000, 1.0, hook=hook, noisy_frame_mask=all_clean)
+    metadata.step = 1
+    metadata.sigma = 0.5
+    _run_step(transformer, 500, 0.9, hook=hook, noisy_frame_mask=all_clean)
+
+    assert hook.full_count == 0
+    assert hook.skip_count == 0
+
+
+def test_conditioning_only_model_failure_runs_forward_once(monkeypatch: pytest.MonkeyPatch) -> None:
+    transformer = TinyCosmos3Transformer()
+    metadata = SimpleNamespace(step=0, sigma=1.0, num_steps=3)
+    hook = _apply_test_hook(transformer, metadata)
+    hook.refresh(transformer)
+    forward_calls = 0
+
+    def fail_forward(hidden_gen: torch.Tensor) -> torch.Tensor:
+        nonlocal forward_calls
+        forward_calls += 1
+        raise RuntimeError("model forward failed")
+
+    monkeypatch.setattr(transformer, "_run_gen_layers", fail_forward)
+    all_clean = torch.zeros(1, 1, 2, 1, 1)
+
+    with pytest.raises(RuntimeError, match="model forward failed"):
+        _run_step(transformer, 1000, 1.0, hook=hook, noisy_frame_mask=all_clean)
+
+    assert forward_calls == 1
+
+
+def test_hook_fails_open_without_explicit_context() -> None:
+    transformer = TinyCosmos3Transformer()
+    metadata = SimpleNamespace(step=0, sigma=1.0, num_steps=2)
+    hook = _apply_test_hook(transformer, metadata)
+    hook.refresh(transformer)
+
+    _run_step(transformer, 1000, 1.0)
+
+    assert hook.full_count == 0
+    assert hook.skip_count == 0
+    assert hook.state_manager._states == {}
+
+
+def test_hook_uses_exact_sigma_callback(monkeypatch: pytest.MonkeyPatch) -> None:
+    from vllm_omni.diffusion.cache.seacache import hook as hook_module
+
+    transformer = TinyCosmos3Transformer()
+    metadata = SimpleNamespace(step=0, sigma=0.37, num_steps=2)
+    observed_sigmas: list[float] = []
+    original_filter = hook_module.apply_sea_filter
+
+    def recording_filter(hidden_states: torch.Tensor, sigma: float, power_exp: float) -> torch.Tensor:
+        observed_sigmas.append(sigma)
+        return original_filter(hidden_states, sigma, power_exp)
+
+    monkeypatch.setattr(hook_module, "apply_sea_filter", recording_filter)
+    hook = _apply_test_hook(transformer, metadata)
+    hook.refresh(transformer)
+    _run_step(transformer, timestep=999, value=1.0, hook=hook)
+
+    assert observed_sigmas
+    assert all(sigma == pytest.approx(0.37) for sigma in observed_sigmas)
+
+
+def test_backend_selector_and_refresh(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setitem(EXTRACTOR_REGISTRY, "TinyCosmos3Transformer", _extract_tiny_cosmos3_context)
+
+    class FSDPTinyCosmos3Transformer(TinyCosmos3Transformer):
+        pass
+
+    assert get_extractor(FSDPTinyCosmos3Transformer) is _extract_tiny_cosmos3_context
+    backend = get_cache_backend(
+        "sea_cache",
+        {
+            "sea_threshold": 0.4,
+            "sea_residual_order": 0,
+        },
+    )
+    assert isinstance(backend, SeaCacheBackend)
+    assert backend.config.sea_threshold == 0.4
+
+    pipeline = Cosmos3OmniDiffusersPipeline()
+    backend.enable(pipeline)
+    hook = pipeline.transformer._hook_registry.get_hook(SeaCacheRootHook._HOOK_NAME)
+    assert isinstance(hook, SeaCacheRootHook)
+    assert callable(getattr(pipeline, "_cache_context_factory", None))
+    for name in ("_seacache_skip", "_seacache_record", "_seacache_residual", "_seacache_last_residual"):
+        assert not hasattr(pipeline.transformer, name)
+    pipeline._current_step_index = 0
+    pipeline._current_sigma = 1.0
+    pipeline._num_timesteps = 7
+    _run_step(pipeline.transformer, 1000, 1.0, hook=hook)
+    assert hook.full_count == 1
+
+    backend.refresh(pipeline, num_inference_steps=7)
+    assert hook.full_count == 0
+    assert hook.skip_count == 0
+    assert hook.state_manager._states == {}
+
+
+def test_backend_uses_resolved_pipeline_metadata_not_refresh_argument(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setitem(EXTRACTOR_REGISTRY, "TinyCosmos3Transformer", _extract_tiny_cosmos3_context)
+    pipeline = Cosmos3OmniDiffusersPipeline()
+    backend = SeaCacheBackend(DiffusionCacheConfig())
+    backend.enable(pipeline)
+    hook = pipeline.transformer._hook_registry.get_hook(SeaCacheRootHook._HOOK_NAME)
+    assert isinstance(hook, SeaCacheRootHook)
+    backend.refresh(pipeline, num_inference_steps=35)
+    pipeline._num_timesteps = 50
+    pipeline._current_step_index = 0
+    pipeline._current_sigma = 1.0
+    _run_step(pipeline.transformer, 1000, 1.0, hook=hook)
+    assert hook.full_count == 1
+    assert hook.num_inference_steps_callback is not None
+    assert hook.num_inference_steps_callback() == 50
+
+    pipeline._current_step_index = 1
+    pipeline._current_sigma = 0.98
+    _run_step(pipeline.transformer, 980, 0.99, hook=hook)
+    assert hook.full_count == 1
+    assert hook.skip_count == 1
+
+
+def test_shared_config_defaults() -> None:
+    config = DiffusionCacheConfig()
+    assert config.sea_threshold == 0.25
+    assert config.sea_residual_order == 1
+    assert config.sea_max_consecutive_cached == 2
+    assert config.sea_power_exp == 3.0
diff --git a/tests/diffusion/cache/test_teacache_extractors.py b/tests/diffusion/cache/test_teacache_extractors.py
index d821541d0..55b92b820 100644
--- a/tests/diffusion/cache/test_teacache_extractors.py
+++ b/tests/diffusion/cache/test_teacache_extractors.py
@@ -68,12 +68,12 @@ class BaseExtractorTest(ABC):
         pass
 
     @abstractmethod
-    def get_module(self):
+    def get_module(self, module, /):
         """Return model module instance."""
         pass
 
     @abstractmethod
-    def get_sample_inputs(self):
+    def get_sample_inputs(self, sample_inputs, /):
         """Return sample inputs for model."""
         pass
 
@@ -737,10 +737,10 @@ class TestMiniMaxH3Extractor(BaseExtractorTest):
         monkeypatch,
     ):
         """Strict SP must not mix local TeaCache state with gathered block rows."""
-        from vllm_omni.diffusion.attention.ops import minimax_h3_modulation
         from vllm_omni.diffusion.cache.teacache.config import TeaCacheConfig
         from vllm_omni.diffusion.cache.teacache.hook import TeaCacheHook
         from vllm_omni.diffusion.distributed import parallel_state
+        from vllm_omni.diffusion.layers import indexed_modulation
 
         seq_len = sample_inputs["x"].shape[1]
         local_len = seq_len // 2
@@ -844,13 +844,13 @@ class TestMiniMaxH3Extractor(BaseExtractorTest):
         )
         monkeypatch.setattr(parallel_state, "get_sp_group", lambda: sp_group)
 
-        original_indexed_scale_shift = minimax_h3_modulation.indexed_scale_shift_
+        original_indexed_scale_shift = indexed_modulation.indexed_scale_shift_
 
         def capture_indexed_scale_shift(hidden, shift, scale, indices):
             captured_modulation_indices.append(indices.clone())
             return original_indexed_scale_shift(hidden, shift, scale, indices)
 
-        monkeypatch.setattr(minimax_h3_modulation, "indexed_scale_shift_", capture_indexed_scale_shift)
+        monkeypatch.setattr(indexed_modulation, "indexed_scale_shift_", capture_indexed_scale_shift)
 
         local_img_pos = torch.tensor([0, 1])
         local_audio_pos = torch.tensor([2, 3])
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_cfg_parallel.py b/tests/diffusion/distributed/test_cfg_parallel.py
index 2ade13549..20679cf76 100644
--- a/tests/diffusion/distributed/test_cfg_parallel.py
+++ b/tests/diffusion/distributed/test_cfg_parallel.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 CFG (Classifier-Free Guidance) parallel functionality.
 
 CPU tests mock the CFG process group and validate mixin logic without GPUs.
@@ -32,8 +32,8 @@ from vllm_omni.diffusion.distributed.parallel_state import (
 )
 from vllm_omni.platforms import current_omni_platform
 
-_L4_TWO_GPU = hardware_marks(res={"cuda": "L4"}, num_cards=2)
-_L4_THREE_GPU = hardware_marks(res={"cuda": "L4"}, num_cards=3)
+_L4_TWO_GPU = hardware_marks(res={"cuda": ["L4", "B200"]}, num_cards=2)
+_L4_THREE_GPU = hardware_marks(res={"cuda": ["L4", "B200"]}, num_cards=3)
 
 
 def _set_random_seeds(seed: int) -> None:
@@ -1009,7 +1009,7 @@ def _run_multi_branch_gpu_parity(
 @pytest.mark.full_model
 @pytest.mark.diffusion
 @pytest.mark.parallel
-@hardware_test(res={"cuda": "L4"}, num_cards=2)
+@hardware_test(res={"cuda": ["L4", "B200"]}, num_cards=2)
 @pytest.mark.parametrize("batch_size", [2])
 @pytest.mark.parametrize("cfg_normalize", [False, True])
 @pytest.mark.parametrize("extra_kwargs", [None, {"step_i": 1}])
diff --git a/tests/diffusion/distributed/test_comm.py b/tests/diffusion/distributed/test_comm.py
index 647389048..21cb18821 100644
--- a/tests/diffusion/distributed/test_comm.py
+++ b/tests/diffusion/distributed/test_comm.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 SeqAllToAll4D, SeqAllToAll5D, and RingComm communication primitives.
 
 CPU tests use gloo on CPU tensors (no GPU). Nightly parity tests run the same
@@ -24,8 +24,8 @@ from vllm_omni.diffusion.distributed.parallel_state import (
 )
 from vllm_omni.platforms import current_omni_platform
 
-_L4_TWO_GPU = hardware_marks(res={"cuda": "L4"}, num_cards=2)
-_L4_FOUR_GPU = hardware_marks(res={"cuda": "L4"}, num_cards=4)
+_L4_TWO_GPU = hardware_marks(res={"cuda": ["L4", "B200"]}, num_cards=2)
+_L4_FOUR_GPU = hardware_marks(res={"cuda": ["L4", "B200"]}, num_cards=4)
 
 DeviceKind = Literal["cpu", "cuda"]
 
@@ -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_expert_parallel.py b/tests/diffusion/distributed/test_expert_parallel.py
index 8e9be1367..053fed9d1 100644
--- a/tests/diffusion/distributed/test_expert_parallel.py
+++ b/tests/diffusion/distributed/test_expert_parallel.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
 
 """
 System test for Expert Parallel (EP).
diff --git a/tests/diffusion/distributed/test_flux2_vae_patch_parallel.py b/tests/diffusion/distributed/test_flux2_vae_patch_parallel.py
index 8de3a42f8..204406ec1 100644
--- a/tests/diffusion/distributed/test_flux2_vae_patch_parallel.py
+++ b/tests/diffusion/distributed/test_flux2_vae_patch_parallel.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
 
 """FLUX.2-dev VAE patch-parallel correctness tests.
 
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_pipeline_parallel.py b/tests/diffusion/distributed/test_pipeline_parallel.py
index cccf116c3..08c3cc775 100644
--- a/tests/diffusion/distributed/test_pipeline_parallel.py
+++ b/tests/diffusion/distributed/test_pipeline_parallel.py
@@ -31,9 +31,9 @@ from vllm_omni.diffusion.distributed.parallel_state import (
 from vllm_omni.diffusion.distributed.pipeline_parallel import AsyncLatents, PipelineParallelMixin
 from vllm_omni.platforms import current_omni_platform
 
-_L4_TWO_GPU = hardware_marks(res={"cuda": "L4"}, num_cards=2)
-_L4_THREE_GPU = hardware_marks(res={"cuda": "L4"}, num_cards=3)
-_L4_FOUR_GPU = hardware_marks(res={"cuda": "L4"}, num_cards=4)
+_L4_TWO_GPU = hardware_marks(res={"cuda": ["L4", "B200"]}, num_cards=2)
+_L4_THREE_GPU = hardware_marks(res={"cuda": ["L4", "B200"]}, num_cards=3)
+_L4_FOUR_GPU = hardware_marks(res={"cuda": ["L4", "B200"]}, num_cards=4)
 
 DeviceKind = Literal["cpu", "cuda"]
 _UNIT_MARKS = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
diff --git a/tests/diffusion/distributed/test_sana_video_sp_numeric.py b/tests/diffusion/distributed/test_sana_video_sp_numeric.py
index b18cafe4c..872dcbcbb 100644
--- a/tests/diffusion/distributed/test_sana_video_sp_numeric.py
+++ b/tests/diffusion/distributed/test_sana_video_sp_numeric.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
 """Real multi-process numeric equivalence gate for SANA-Video sequence parallel.
 
 Runs the native transformer directly (no pipeline, no topology validation) with
@@ -273,7 +273,7 @@ def _baseline_worker(
 @pytest.mark.full_model
 @pytest.mark.diffusion
 @pytest.mark.parallel
-@hardware_test(res={"cuda": "L4"}, num_cards=2)
+@hardware_test(res={"cuda": ["L4", "B200"]}, num_cards=2)
 @pytest.mark.parametrize("task", ["t2v", "i2v"])
 @pytest.mark.parametrize("num_frames", [21, 5])
 def test_sp2_matches_sp1_fp32(task: str, num_frames: int) -> None:
@@ -290,7 +290,7 @@ def test_sp2_matches_sp1_fp32(task: str, num_frames: int) -> None:
 @pytest.mark.full_model
 @pytest.mark.diffusion
 @pytest.mark.parallel
-@hardware_test(res={"cuda": "L4"}, num_cards=4)
+@hardware_test(res={"cuda": ["L4", "B200"]}, num_cards=4)
 @pytest.mark.parametrize("task", ["t2v", "i2v"])
 @pytest.mark.parametrize("num_frames", [21, 5])
 def test_sp4_matches_sp1_fp32(task: str, num_frames: int) -> None:
@@ -307,7 +307,7 @@ def test_sp4_matches_sp1_fp32(task: str, num_frames: int) -> None:
 @pytest.mark.full_model
 @pytest.mark.diffusion
 @pytest.mark.parallel
-@hardware_test(res={"cuda": "L4"}, num_cards=4)
+@hardware_test(res={"cuda": ["L4", "B200"]}, num_cards=4)
 def test_sp2_cfg2_matches_sp1_fp32() -> None:
     """Four processes: CFG branches with distinct inputs each run their own SP
     group; catches CFG/SP group crossover and deadlocks."""
@@ -324,7 +324,7 @@ def test_sp2_cfg2_matches_sp1_fp32() -> None:
 @pytest.mark.full_model
 @pytest.mark.diffusion
 @pytest.mark.parallel
-@hardware_test(res={"cuda": "L4"}, num_cards=4)
+@hardware_test(res={"cuda": ["L4", "B200"]}, num_cards=4)
 def test_tp2_sp2_matches_sp1_fp32() -> None:
     """Four processes: TP shards heads and channels while SP shards frames; the
     combined mesh must still reproduce the serial output."""
@@ -342,7 +342,7 @@ def test_tp2_sp2_matches_sp1_fp32() -> None:
 @pytest.mark.full_model
 @pytest.mark.diffusion
 @pytest.mark.parallel
-@hardware_test(res={"cuda": "L4"}, num_cards=2)
+@hardware_test(res={"cuda": ["L4", "B200"]}, num_cards=2)
 def test_sp2_bf16_drift_informational() -> None:
     """Records the bf16 reduction-reorder drift magnitude; the load-bearing
     numeric gate is the fp32 suite above."""
diff --git a/tests/diffusion/distributed/test_sequence_parallel.py b/tests/diffusion/distributed/test_sequence_parallel.py
index f083e1d26..ba68669e9 100644
--- a/tests/diffusion/distributed/test_sequence_parallel.py
+++ b/tests/diffusion/distributed/test_sequence_parallel.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
 
 """
 System test for Sequence Parallel (SP) backends: Ulysses and Ring attention.
diff --git a/tests/diffusion/distributed/test_vae_decode_parallelism.py b/tests/diffusion/distributed/test_vae_decode_parallelism.py
index 28ded4639..acd916806 100644
--- a/tests/diffusion/distributed/test_vae_decode_parallelism.py
+++ b/tests/diffusion/distributed/test_vae_decode_parallelism.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
 
 """VAE patch-parallel decode parity tests for diffusion models.
 
@@ -145,7 +145,7 @@ def _run_generate(
 @pytest.mark.full_model
 @pytest.mark.diffusion
 @pytest.mark.parallel
-@hardware_test(res={"cuda": "H100"}, num_cards={"cuda": 4})
+@hardware_test(res={"cuda": ["H100", "B200"]}, num_cards={"cuda": 4})
 @pytest.mark.parametrize("model_case", MODEL_CASES)
 def test_vae_patch_parallel_tp2(model_case: dict[str, Any], tmp_path: Path):
     if current_omni_platform.is_npu():
diff --git a/tests/diffusion/distributed/test_wan_spatial_shard.py b/tests/diffusion/distributed/test_wan_spatial_shard.py
index beb5ac2db..23c29c938 100644
--- a/tests/diffusion/distributed/test_wan_spatial_shard.py
+++ b/tests/diffusion/distributed/test_wan_spatial_shard.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 import os
 from types import SimpleNamespace
 
@@ -353,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):
@@ -538,7 +629,7 @@ def _spatial_shard_decode_worker(rank: int, split_dim: str, return_dict, master_
 @pytest.mark.full_model
 @pytest.mark.diffusion
 @pytest.mark.parallel
-@hardware_test(res={"cuda": "H100"}, num_cards=_SPATIAL_SHARD_WORLD_SIZE)
+@hardware_test(res={"cuda": ["H100", "B200"]}, num_cards=_SPATIAL_SHARD_WORLD_SIZE)
 @pytest.mark.parametrize("split_dim", ["height", "width"])
 def test_spatial_shard_decode_matches_reference(split_dim: str):
     manager = mp.get_context("spawn").Manager()
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 40888556a..4f1ad82b4 100644
--- a/tests/diffusion/layers/test_fused_qk_norm_rope.py
+++ b/tests/diffusion/layers/test_fused_qk_norm_rope.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 pytest
 import torch
@@ -80,3 +80,113 @@ def test_fused_qk_norm_rope_matches_bf16_reference(seq_len):
 
     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)
+
+
+# ---------------------------------------------------------------------------
+# General geometry (any even head_dim, here Boogu-Image's 120) in both
+# pairing modes, against the module's own eager reference at the same
+# tolerance as the MiniMax-H3 test above.
+# ---------------------------------------------------------------------------
+
+_BOOGU_HEAD_DIM = 120
+
+
+def _boogu_inputs(strided: bool):
+    torch.manual_seed(11)
+    if strided:
+        # Slices of a wider head axis: the op must honour q/k strides
+        # (merged-QKV projections hand the op such views).
+        q = torch.randn(4139, 35, _BOOGU_HEAD_DIM, device="cuda", dtype=torch.bfloat16)[:, :28]
+        k = torch.randn(4139, 35, _BOOGU_HEAD_DIM, device="cuda", dtype=torch.bfloat16)[:, :7]
+    else:
+        q = torch.randn(4139, 28, _BOOGU_HEAD_DIM, device="cuda", dtype=torch.bfloat16)
+        k = torch.randn(4139, 7, _BOOGU_HEAD_DIM, device="cuda", dtype=torch.bfloat16)
+    q_weight = torch.randn(_BOOGU_HEAD_DIM, device="cuda", dtype=torch.bfloat16)
+    k_weight = torch.randn(_BOOGU_HEAD_DIM, device="cuda", dtype=torch.bfloat16)
+    freqs = torch.randn(4139, _BOOGU_HEAD_DIM // 2, device="cuda", dtype=torch.float32)
+    rope_table = torch.cat((torch.cos(freqs), torch.sin(freqs)), dim=-1)
+    return q, k, q_weight, k_weight, rope_table
+
+
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA required")
+@pytest.mark.skipif(not HAS_TRITON, reason="Triton required")
+@pytest.mark.parametrize("strided", [False, True])
+def test_fused_qk_norm_rope_interleaved(strided):
+    from vllm_omni.diffusion.layers.fused_qk_norm_rope import (
+        _eager_qk_norm_rope,
+        _launch_fused_qk_norm_rope,
+        fused_qk_norm_rope,
+    )
+
+    q, k, q_weight, k_weight, rope_table = _boogu_inputs(strided)
+    expected = _eager_qk_norm_rope(q, k, q_weight, k_weight, rope_table, _EPS, _BOOGU_HEAD_DIM, _BOOGU_HEAD_DIM, True)
+    # Check the public op AND the launcher directly: the latter cannot fall
+    # back to eager, so a silent dispatch regression cannot go green here.
+    for actual in (
+        fused_qk_norm_rope(q, k, q_weight, k_weight, rope_table, _EPS, interleaved=True),
+        _launch_fused_qk_norm_rope(q, k, q_weight, k_weight, rope_table, _EPS, interleaved=True),
+    ):
+        torch.testing.assert_close(actual[0], expected[0], atol=0.0625, rtol=0.02)
+        torch.testing.assert_close(actual[1], expected[1], atol=0.0625, rtol=0.02)
+
+
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA required")
+@pytest.mark.skipif(not HAS_TRITON, reason="Triton required")
+def test_fused_qk_norm_rope_half_split_general_dim():
+    """head_dim=120 off the MiniMax-H3 128 pin, half-split pairing.
+
+    Exercises the generalised combined kernel's half-split mode via the
+    launcher. It is not routed in production (half-split traffic keeps the
+    untouched pre-existing per-tensor kernel and its 128/96 contract, so the
+    public op falls back to eager at this geometry), pending the
+    maintainers' call.
+    """
+    from vllm_omni.diffusion.layers.fused_qk_norm_rope import (
+        _eager_qk_norm_rope,
+        _launch_fused_qk_norm_rope,
+    )
+
+    q, k, q_weight, k_weight, rope_table = _boogu_inputs(strided=False)
+    expected = _eager_qk_norm_rope(q, k, q_weight, k_weight, rope_table, _EPS, _BOOGU_HEAD_DIM, _BOOGU_HEAD_DIM)
+    actual = _launch_fused_qk_norm_rope(q, k, q_weight, k_weight, rope_table, _EPS, interleaved=False)
+    torch.testing.assert_close(actual[0], expected[0], atol=0.0625, rtol=0.02)
+    torch.testing.assert_close(actual[1], expected[1], atol=0.0625, rtol=0.02)
+
+
+def test_fused_qk_norm_rope_min_tokens_resolution(monkeypatch):
+    """The op-level token-gate override: unset or blank -> caller's default; a
+    non-negative integer string overrides it (``0`` = always fuse); anything
+    else is rejected naming the variable."""
+    from vllm_omni.diffusion.layers.fused_qk_norm_rope import fused_qk_norm_rope_min_tokens
+
+    env = "VLLM_OMNI_FUSED_QK_NORM_ROPE_MIN_TOKENS"
+    monkeypatch.delenv(env, raising=False)
+    assert fused_qk_norm_rope_min_tokens(2048) == 2048
+    for blank in ("", "  "):
+        monkeypatch.setenv(env, blank)
+        assert fused_qk_norm_rope_min_tokens(2048) == 2048
+    monkeypatch.setenv(env, "0")
+    assert fused_qk_norm_rope_min_tokens(2048) == 0
+    monkeypatch.setenv(env, "4096")
+    assert fused_qk_norm_rope_min_tokens(2048) == 4096
+    for bad in ("-1", "abc"):
+        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/layers/test_qwen_select01_modulation.py b/tests/diffusion/layers/test_qwen_select01_modulation.py
new file mode 100644
index 000000000..050da4717
--- /dev/null
+++ b/tests/diffusion/layers/test_qwen_select01_modulation.py
@@ -0,0 +1,299 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from __future__ import annotations
+
+import pytest
+import torch
+import torch.nn.functional as F
+
+from vllm_omni.diffusion.layers import qwen_select01_modulation
+from vllm_omni.diffusion.layers.qwen_select01_modulation import (
+    can_use_qwen_select01_triton,
+    fused_layernorm_select01,
+    fused_residual_layernorm_select01,
+    select01_modulation_native,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion]
+
+
+@pytest.mark.cpu
+@pytest.mark.parametrize(
+    ("platform_is_cuda", "tensor_is_cuda", "has_triton", "expected"),
+    [
+        (True, True, True, True),
+        (False, True, True, False),
+        (True, False, True, False),
+        (True, True, False, False),
+    ],
+)
+def test_qwen_select01_triton_requires_cuda_platform(
+    monkeypatch,
+    platform_is_cuda: bool,
+    tensor_is_cuda: bool,
+    has_triton: bool,
+    expected: bool,
+):
+    class FakePlatform:
+        @staticmethod
+        def is_cuda() -> bool:
+            return platform_is_cuda
+
+    class FakeTensor:
+        is_cuda = tensor_is_cuda
+
+    monkeypatch.setattr(qwen_select01_modulation, "current_platform", FakePlatform())
+    monkeypatch.setattr(qwen_select01_modulation, "HAS_TRITON", has_triton)
+
+    assert can_use_qwen_select01_triton(FakeTensor()) is expected
+
+
+def _make_inputs(
+    batch_size: int,
+    seq_len: int,
+    hidden_size: int,
+    dtype: torch.dtype,
+    device: torch.device,
+) -> tuple[torch.Tensor, ...]:
+    generator = torch.Generator(device=device)
+    generator.manual_seed(202817)
+    x = torch.randn(batch_size, seq_len, hidden_size, dtype=dtype, device=device, generator=generator)
+    residual = torch.randn(batch_size, seq_len, hidden_size, dtype=dtype, device=device, generator=generator)
+    residual_gate = torch.randn(batch_size, 1, hidden_size, dtype=dtype, device=device, generator=generator)
+    mod_params = torch.randn(batch_size * 2, hidden_size * 3, dtype=dtype, device=device, generator=generator)
+    index = torch.randint(0, 2, (batch_size, seq_len), dtype=torch.int64, device=device, generator=generator)
+    return x, residual, residual_gate, mod_params, index
+
+
+def _reference_layernorm_select01(
+    x: torch.Tensor,
+    mod_params: torch.Tensor,
+    index: torch.Tensor,
+    eps: float,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    scale, shift, gate = select01_modulation_native(mod_params, index)
+    out = F.layer_norm(x.float(), (x.shape[-1],), eps=eps).to(x.dtype)
+    return out * (1 + scale) + shift, gate
+
+
+def _reference_residual_layernorm_select01(
+    x: torch.Tensor,
+    residual: torch.Tensor,
+    residual_gate: torch.Tensor,
+    mod_params: torch.Tensor,
+    index: torch.Tensor,
+    eps: float,
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    scale, shift, gate = select01_modulation_native(mod_params, index)
+    residual_out = residual + residual_gate * x
+    out = F.layer_norm(residual_out.float(), (residual_out.shape[-1],), eps=eps).to(residual_out.dtype)
+    return out * (1 + scale) + shift, residual_out, gate
+
+
+@pytest.mark.cpu
+@pytest.mark.parametrize("dtype", [torch.float32, torch.bfloat16])
+@pytest.mark.parametrize("broadcast_index", [False, True])
+def test_qwen_select01_native_fallback_matches_reference(dtype: torch.dtype, broadcast_index: bool):
+    device = torch.device("cpu")
+    x, residual, residual_gate, mod_params, index = _make_inputs(2, 17, 64, dtype, device)
+    if broadcast_index:
+        index = index[:1]
+    eps = 1e-6
+
+    actual_norm, actual_gate = fused_layernorm_select01(x, mod_params, index, eps)
+    ref_norm, ref_gate = _reference_layernorm_select01(x, mod_params, index, eps)
+    torch.testing.assert_close(actual_norm, ref_norm, atol=1e-5, rtol=1e-5)
+    torch.testing.assert_close(actual_gate, ref_gate, atol=0, rtol=0)
+
+    actual_norm, actual_residual, actual_gate = fused_residual_layernorm_select01(
+        x,
+        residual,
+        residual_gate,
+        mod_params,
+        index,
+        eps,
+    )
+    ref_norm, ref_residual, ref_gate = _reference_residual_layernorm_select01(
+        x,
+        residual,
+        residual_gate,
+        mod_params,
+        index,
+        eps,
+    )
+    torch.testing.assert_close(actual_norm, ref_norm, atol=1e-5, rtol=1e-5)
+    torch.testing.assert_close(actual_residual, ref_residual, atol=1e-5, rtol=1e-5)
+    torch.testing.assert_close(actual_gate, ref_gate, atol=0, rtol=0)
+
+
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA required")
+@pytest.mark.parametrize(
+    ("dtype", "atol", "rtol"),
+    [
+        (torch.float32, 1e-5, 1e-5),
+        (torch.bfloat16, 5e-2, 5e-2),
+    ],
+)
+@pytest.mark.parametrize("seq_len", [1, 7, 128, 1024])
+def test_qwen_select01_triton_matches_reference(dtype: torch.dtype, atol: float, rtol: float, seq_len: int):
+    device = torch.device("cuda:0")
+    x, residual, residual_gate, mod_params, index = _make_inputs(2, seq_len, 256, dtype, device)
+    eps = 1e-6
+
+    actual_norm, actual_gate = fused_layernorm_select01(x, mod_params, index, eps)
+    ref_norm, ref_gate = _reference_layernorm_select01(x, mod_params, index, eps)
+    torch.testing.assert_close(actual_norm, ref_norm, atol=atol, rtol=rtol)
+    torch.testing.assert_close(actual_gate, ref_gate, atol=0, rtol=0)
+
+    actual_norm, actual_residual, actual_gate = fused_residual_layernorm_select01(
+        x,
+        residual,
+        residual_gate.expand_as(residual),
+        mod_params,
+        index,
+        eps,
+    )
+    ref_norm, ref_residual, ref_gate = _reference_residual_layernorm_select01(
+        x,
+        residual,
+        residual_gate.expand_as(residual),
+        mod_params,
+        index,
+        eps,
+    )
+    torch.testing.assert_close(actual_norm, ref_norm, atol=atol, rtol=rtol)
+    torch.testing.assert_close(actual_residual, ref_residual, atol=atol, rtol=rtol)
+    torch.testing.assert_close(actual_gate, ref_gate, atol=0, rtol=0)
+
+
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA required")
+@pytest.mark.parametrize(
+    ("dtype", "atol", "rtol"),
+    [
+        (torch.float32, 1e-5, 1e-5),
+        (torch.bfloat16, 5e-2, 5e-2),
+    ],
+)
+def test_qwen_select01_triton_matches_reference_for_structured_multi_batch_index(
+    dtype: torch.dtype,
+    atol: float,
+    rtol: float,
+):
+    device = torch.device("cuda:0")
+    x, residual, residual_gate, mod_params, _ = _make_inputs(3, 16, 256, dtype, device)
+    index = torch.tensor(
+        [
+            [0] * 16,
+            [1] * 16,
+            [0, 1] * 8,
+        ],
+        dtype=torch.int64,
+        device=device,
+    )
+    eps = 1e-6
+
+    actual_norm, actual_gate = fused_layernorm_select01(x, mod_params, index, eps)
+    ref_norm, ref_gate = _reference_layernorm_select01(x, mod_params, index, eps)
+    torch.testing.assert_close(actual_norm, ref_norm, atol=atol, rtol=rtol)
+    torch.testing.assert_close(actual_gate, ref_gate, atol=0, rtol=0)
+
+    actual_norm, actual_residual, actual_gate = fused_residual_layernorm_select01(
+        x,
+        residual,
+        residual_gate.expand_as(residual),
+        mod_params,
+        index,
+        eps,
+    )
+    ref_norm, ref_residual, ref_gate = _reference_residual_layernorm_select01(
+        x,
+        residual,
+        residual_gate.expand_as(residual),
+        mod_params,
+        index,
+        eps,
+    )
+    torch.testing.assert_close(actual_norm, ref_norm, atol=atol, rtol=rtol)
+    torch.testing.assert_close(actual_residual, ref_residual, atol=atol, rtol=rtol)
+    torch.testing.assert_close(actual_gate, ref_gate, atol=0, rtol=0)
+
+
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA required")
+@pytest.mark.parametrize(
+    ("dtype", "atol", "rtol"),
+    [
+        (torch.float32, 1e-5, 1e-5),
+        (torch.bfloat16, 5e-2, 5e-2),
+    ],
+)
+def test_qwen_select01_triton_broadcasts_single_index_batch(dtype: torch.dtype, atol: float, rtol: float):
+    device = torch.device("cuda:0")
+    x, residual, residual_gate, mod_params, index = _make_inputs(2, 17, 256, dtype, device)
+    index = index[:1]
+    eps = 1e-6
+
+    actual_norm, actual_gate = fused_layernorm_select01(x, mod_params, index, eps)
+    ref_norm, ref_gate = _reference_layernorm_select01(x, mod_params, index, eps)
+    torch.testing.assert_close(actual_norm, ref_norm, atol=atol, rtol=rtol)
+    torch.testing.assert_close(actual_gate, ref_gate, atol=0, rtol=0)
+
+    actual_norm, actual_residual, actual_gate = fused_residual_layernorm_select01(
+        x,
+        residual,
+        residual_gate.expand_as(residual),
+        mod_params,
+        index,
+        eps,
+    )
+    ref_norm, ref_residual, ref_gate = _reference_residual_layernorm_select01(
+        x,
+        residual,
+        residual_gate.expand_as(residual),
+        mod_params,
+        index,
+        eps,
+    )
+    torch.testing.assert_close(actual_norm, ref_norm, atol=atol, rtol=rtol)
+    torch.testing.assert_close(actual_residual, ref_residual, atol=atol, rtol=rtol)
+    torch.testing.assert_close(actual_gate, ref_gate, atol=0, rtol=0)
+
+
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA required")
+def test_qwen_select01_cuda_falls_back_without_triton(monkeypatch):
+    device = torch.device("cuda:0")
+    x, residual, residual_gate, mod_params, index = _make_inputs(2, 7, 256, torch.bfloat16, device)
+    residual_gate = residual_gate.expand_as(residual)
+    eps = 1e-6
+
+    def fail_if_launched(*args, **kwargs):
+        pytest.fail("Triton launcher must not run when HAS_TRITON is false")
+
+    monkeypatch.setattr(qwen_select01_modulation, "HAS_TRITON", False)
+    monkeypatch.setattr(qwen_select01_modulation, "_launch_layernorm_select01", fail_if_launched)
+    monkeypatch.setattr(qwen_select01_modulation, "_launch_residual_layernorm_select01", fail_if_launched)
+
+    actual_norm, actual_gate = fused_layernorm_select01(x, mod_params, index, eps)
+    ref_norm, ref_gate = _reference_layernorm_select01(x, mod_params, index, eps)
+    torch.testing.assert_close(actual_norm, ref_norm, atol=0, rtol=0)
+    torch.testing.assert_close(actual_gate, ref_gate, atol=0, rtol=0)
+
+    actual_norm, actual_residual, actual_gate = fused_residual_layernorm_select01(
+        x,
+        residual,
+        residual_gate,
+        mod_params,
+        index,
+        eps,
+    )
+    ref_norm, ref_residual, ref_gate = _reference_residual_layernorm_select01(
+        x,
+        residual,
+        residual_gate,
+        mod_params,
+        index,
+        eps,
+    )
+    torch.testing.assert_close(actual_norm, ref_norm, atol=0, rtol=0)
+    torch.testing.assert_close(actual_residual, ref_residual, atol=0, rtol=0)
+    torch.testing.assert_close(actual_gate, ref_gate, atol=0, rtol=0)
diff --git a/tests/diffusion/lora/test_loader.py b/tests/diffusion/lora/test_loader.py
index deb5ec80d..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
@@ -509,3 +510,93 @@ def test_lora_loader_mixin_lora_is_fused_property(mocker: MockerFixture):
     assert pipeline2.lora_is_fused is False
     pipeline2.lora_is_fused = True
     assert pipeline2.lora_is_fused is True
+
+
+def test_prepare_lora_delta_with_compute_device():
+    base_key = "blocks.0.attn.to_q"
+    state_dict = {
+        f"{base_key}.lora_A.weight": torch.ones(RANK, HEAD_DIM),
+        f"{base_key}.lora_B.weight": torch.ones(HEAD_DIM, RANK),
+    }
+    delta, used_keys = _prepare_lora_delta(state_dict, base_key, compute_device=torch.device("cpu"))
+    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/lora/test_lora_manager.py b/tests/diffusion/lora/test_lora_manager.py
index 0814bf15f..b2a0505f3 100644
--- a/tests/diffusion/lora/test_lora_manager.py
+++ b/tests/diffusion/lora/test_lora_manager.py
@@ -411,6 +411,50 @@ def test_lora_manager_rolls_back_all_layers_when_activation_fails():
     assert len(first.set_calls) == first_calls_after_success + 2
 
 
+def test_lora_manager_rejects_adapter_that_binds_no_layer():
+    """An adapter whose target modules match nothing must fail, not silently no-op."""
+    manager = DiffusionLoRAManager(
+        pipeline=torch.nn.Module(),
+        device=torch.device("cpu"),
+        dtype=torch.bfloat16,
+        max_cached_adapters=1,
+    )
+    layer = _DummyLoRALayer(n_slices=1, output_slices=(2,))
+    manager._lora_modules = {"transformer.blocks.0.attn.to_q": layer}
+
+    # Adapter-side name the engine does not expose, e.g. a diffusers-style
+    # checkpoint against a differently named engine layout.
+    mismatched = LoRALayerWeights(
+        module_name="unet.down_blocks.0.attn.to_q",
+        rank=2,
+        lora_alpha=2,
+        lora_a=torch.ones((2, 2)),
+        lora_b=torch.ones((2, 2)),
+    )
+    manager._registered_adapters = {
+        3: type(
+            "LM",
+            (),
+            {
+                "id": 3,
+                "loras": {"unet.down_blocks.0.attn.to_q": mismatched},
+                "get_lora": lambda self, key: self.loras.get(key),
+            },
+        )()
+    }
+
+    with pytest.raises(ValueError, match="applies to no layer") as excinfo:
+        manager._activate_adapter(3, scale=1.0)
+
+    # The message must name what was received so the mismatch is diagnosable.
+    assert "unet.down_blocks.0.attn.to_q" in str(excinfo.value)
+
+    # Nothing was bound and the adapter must not be left marked active.
+    assert manager._active_adapter_id is None
+    assert layer.set_calls == []
+    assert layer.reset_calls >= 1
+
+
 def _dummy_lora_request(adapter_id: int) -> LoRARequest:
     return LoRARequest(
         lora_name=f"adapter_{adapter_id}",
@@ -685,8 +729,10 @@ def test_lora_manager_discovers_bagel_component(monkeypatch):
         lambda root, name, sub: fake_replace_submodule(root, name, sub, replace_calls),
     )
 
-    # Pipeline with a 'bagel' component (no 'transformer')
+    # Pipeline with a 'bagel' component (no 'transformer') declared via
+    # _lora_components, matching how BagelPipeline opts in.
     pipeline = torch.nn.Module()
+    pipeline._lora_components = ["bagel"]
     pipeline.bagel = torch.nn.Module()
     pipeline.bagel.language_model = torch.nn.Module()
     pipeline.bagel.language_model.qkv_proj = _FakeLinearBase()
diff --git a/tests/diffusion/model_loader/test_diffusers_loader.py b/tests/diffusion/model_loader/test_diffusers_loader.py
index 565949ff6..8a2ee0900 100644
--- a/tests/diffusion/model_loader/test_diffusers_loader.py
+++ b/tests/diffusion/model_loader/test_diffusers_loader.py
@@ -6,9 +6,11 @@ Tests for the DiffusersPipelineLoader.
 """
 
 import json
+import os
+import tempfile
 from pathlib import Path
 from types import SimpleNamespace
-from unittest.mock import MagicMock
+from unittest.mock import MagicMock, patch
 
 import pytest
 import torch
@@ -260,17 +262,16 @@ def test_hwr_cold_publication_and_warm_restore_skip_ordinary_dit_loading(
     assert len(tuple((store_root / "source-digests-v1" / "entries").glob("*.json"))) == 1
 
 
-def test_maybe_fuse_distilled_lora_skips_when_hwr_warm_snapshot_present():
+def test_maybe_fuse_distilled_lora_skips_when_lora_path_unset():
     cfg = SimpleNamespace(
         lora_backend="distill",
-        lora_path="/path/to/lora.safetensors",
+        lora_path=None,
         lora_scale=1.0,
         dtype=torch.bfloat16,
         quantization_config=None,
         parallel_config=SimpleNamespace(use_hsdp=False),
     )
     loader = DiffusersPipelineLoader(LoadConfig(), cfg)
-    loader._hwr_state = {"warm_snapshot": {"transformer.weight": (1234, "hash")}}
 
     model = nn.Module()
     model.load_lora_weights = MagicMock()
@@ -278,7 +279,7 @@ def test_maybe_fuse_distilled_lora_skips_when_hwr_warm_snapshot_present():
     loader._maybe_fuse_distilled_lora(model)
 
     model.load_lora_weights.assert_not_called()
-    assert getattr(model, "lora_is_fused", False) is True
+    assert getattr(model, "lora_is_fused", False) is False
 
 
 def test_maybe_fuse_distilled_lora_fuses_when_not_warm_snapshot():
@@ -1053,6 +1054,34 @@ def test_dlo_plan_fallback_runs_ordinary_loader(monkeypatch):
     assert loader.take_host_weight_plan() is None
 
 
+def test_dlo_mmap_plan_with_distilled_lora_falls_back_to_ordinary_loader(monkeypatch):
+    od_config = SimpleNamespace(
+        dtype=torch.float32,
+        parallel_config=SimpleNamespace(use_hsdp=False, tensor_parallel_size=1),
+        quantization_config=None,
+        enable_distributed_layerwise_offload=True,
+        dlo_use_allgather=False,
+        lora_backend=LoRABackend.DISTILL,
+        lora_path="/fake/lora.safetensors",
+        model="unused",
+    )
+    loader = DiffusersPipelineLoader(LoadConfig(), od_config)
+    model = nn.Module()
+    model.transformer = nn.Linear(2, 2, bias=False)
+    model.load_lora_weights = MagicMock()
+    calls: list[str] = []
+
+    loader._init_from_load_format = lambda *_args, **_kwargs: model  # type: ignore[method-assign]
+    loader.load_weights = lambda _model: calls.append("load")  # type: ignore[method-assign]
+    loader._process_weights_after_loading = lambda *_args: calls.append("process")  # type: ignore[method-assign]
+    loader._apply_skip_softmax_calibration = lambda _model: None  # type: ignore[method-assign]
+
+    assert loader.load_model(load_device="cpu") is model
+    assert calls == ["load", "process"]
+    assert model.load_lora_weights.call_count == 1
+    assert loader.take_host_weight_plan() is None
+
+
 def test_dlo_allgather_online_fp8_uses_ordinary_loader(monkeypatch):
     from vllm.model_executor.layers.quantization.online.fp8 import (
         Fp8PerTensorOnlineLinearMethod,
@@ -1212,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
@@ -1487,3 +1679,413 @@ def test_load_model(prefetch_helios_model, mock_tp_group):
     )
     model = loader.load_model(load_device="cpu")
     assert isinstance(model, HeliosPipeline)
+
+
+def test_hsdp_broadcast_weight_load_rank0(mocker):
+    """Ensure that on rank 0 with enable_broadcast_weight_load=True, weights are loaded, fused, and broadcast."""
+    import vllm_omni.diffusion.model_loader.diffusers_loader as loader_mod
+    from vllm_omni.diffusion.offloader.module_collector import PipelineModules
+
+    mocker.patch("torch.distributed.is_initialized", return_value=True)
+    mocker.patch("torch.distributed.get_world_size", return_value=4)
+    mocker.patch("torch.distributed.get_rank", return_value=0)
+
+    od_config = SimpleNamespace(
+        dtype=torch.float32,
+        parallel_config=SimpleNamespace(
+            use_hsdp=True,
+            hsdp_replicate_size=1,
+            hsdp_shard_size=4,
+        ),
+        enable_broadcast_weight_load=True,
+        lora_backend=LoRABackend.DISTILL,
+        lora_path="/fake/lora.safetensors",
+        quantization_config=None,
+    )
+    loader = DiffusersPipelineLoader(LoadConfig(), od_config)
+
+    model = nn.Module()
+    model.transformer = nn.Linear(2, 2, bias=False)
+    events: list[str] = []
+
+    loader._init_from_load_format = mocker.Mock(return_value=model)  # type: ignore[method-assign]
+    loader.load_weights = mocker.Mock(side_effect=lambda _model: events.append("load"))  # type: ignore[method-assign]
+    loader._maybe_fuse_distilled_lora = mocker.Mock(  # type: ignore[method-assign]
+        side_effect=lambda _model: events.append("fuse")
+    )
+    loader._broadcast_model_weights = mocker.Mock(  # type: ignore[method-assign]
+        side_effect=lambda _model, **_kwargs: events.append("broadcast")
+    )
+    loader._process_weights_after_loading = mocker.Mock(  # type: ignore[method-assign]
+        side_effect=lambda _model, _device: events.append("process")
+    )
+    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.object(
+        loader_mod,
+        "apply_hsdp_to_model",
+        side_effect=lambda *_args, **_kwargs: events.append("shard"),
+    )
+
+    loader._load_model_with_hsdp(torch.device("cpu"))
+
+    assert events == ["load", "fuse", "broadcast", "process", "shard"]
+
+
+def test_hsdp_broadcast_weight_load_rank_nonzero(mocker):
+    """Ensure that on rank > 0 with enable_broadcast_weight_load=True, loading is skipped and broadcast is received."""
+    import vllm_omni.diffusion.model_loader.diffusers_loader as loader_mod
+    from vllm_omni.diffusion.offloader.module_collector import PipelineModules
+
+    mocker.patch("torch.distributed.is_initialized", return_value=True)
+    mocker.patch("torch.distributed.get_world_size", return_value=4)
+    mocker.patch("torch.distributed.get_rank", return_value=1)
+
+    od_config = SimpleNamespace(
+        dtype=torch.float32,
+        parallel_config=SimpleNamespace(
+            use_hsdp=True,
+            hsdp_replicate_size=1,
+            hsdp_shard_size=4,
+        ),
+        enable_broadcast_weight_load=True,
+        lora_backend=LoRABackend.DISTILL,
+        lora_path="/fake/lora.safetensors",
+        quantization_config=None,
+    )
+    loader = DiffusersPipelineLoader(LoadConfig(), od_config)
+
+    model = nn.Module()
+    model.transformer = nn.Linear(2, 2, bias=False)
+    model.load_lora_weights = mocker.Mock()  # type: ignore[assignment]
+    events: list[str] = []
+
+    loader._init_from_load_format = mocker.Mock(return_value=model)  # type: ignore[method-assign]
+    loader.load_weights = mocker.Mock(side_effect=lambda _model: events.append("load"))  # type: ignore[method-assign]
+    loader._maybe_fuse_distilled_lora = mocker.Mock(  # type: ignore[method-assign]
+        side_effect=lambda _model: events.append("fuse")
+    )
+    loader._broadcast_model_weights = mocker.Mock(  # type: ignore[method-assign]
+        side_effect=lambda _model, **_kwargs: events.append("broadcast")
+    )
+    loader._process_weights_after_loading = mocker.Mock(  # type: ignore[method-assign]
+        side_effect=lambda _model, _device: events.append("process")
+    )
+    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.object(
+        loader_mod,
+        "apply_hsdp_to_model",
+        side_effect=lambda *_args, **_kwargs: events.append("shard"),
+    )
+
+    loader._load_model_with_hsdp(torch.device("cpu"))
+
+    # Rank 1 should NOT call load_weights or _maybe_fuse_distilled_lora from disk
+    assert "load" not in events
+    assert "fuse" not in events
+    assert events == ["broadcast", "process", "shard"]
+    assert getattr(model, "lora_is_fused", False) is True
+
+
+def test_broadcast_model_weights_invokes_dist_broadcast(mocker):
+    broadcast_calls = []
+    mocker.patch("torch.distributed.is_initialized", return_value=True)
+    mocker.patch("torch.distributed.get_world_size", return_value=2)
+    mocker.patch("torch.distributed.get_rank", return_value=0)
+    mocker.patch("torch.distributed.get_backend", return_value="gloo")
+    mocker.patch("torch.distributed.broadcast", side_effect=lambda tensor, src: broadcast_calls.append((tensor, src)))
+    mocker.patch("torch.distributed.barrier")
+
+    model = nn.Module()
+    model.linear = nn.Linear(2, 2)
+    model.register_buffer("buf", torch.tensor([1.0, 2.0]))
+    model.register_buffer("int_buf", torch.tensor([1, 2, 3], dtype=torch.long))
+
+    od_config = SimpleNamespace(
+        dtype=torch.float32,
+        parallel_config=SimpleNamespace(use_hsdp=True),
+        enable_broadcast_weight_load=True,
+        quantization_config=None,
+    )
+    loader = DiffusersPipelineLoader(LoadConfig(), od_config)
+    loader._broadcast_model_weights(model, target_device=torch.device("cpu"), src_rank=0)
+
+    # float32 tensors (linear.weight, linear.bias, buf) are coalesced into 1 bucket,
+    # and int64 tensor (int_buf) is in a separate bucket -> 2 coalesced broadcast calls
+    assert len(broadcast_calls) == 2
+    assert all(src == 0 for _, src in broadcast_calls)
+
+
+def test_broadcast_model_weights_receiver_copies_data(mocker):
+    """Ensure receiver rank copies broadcasted flat tensor data into its model parameters/buffers."""
+    mocker.patch("torch.distributed.is_initialized", return_value=True)
+    mocker.patch("torch.distributed.get_world_size", return_value=2)
+    mocker.patch("torch.distributed.get_rank", return_value=1)
+    mocker.patch("torch.distributed.get_backend", return_value="gloo")
+    mocker.patch("torch.distributed.barrier")
+
+    # Simulate broadcast by filling the flat tensor with source values
+    def mock_broadcast(tensor, src):
+        if tensor.dtype == torch.float32:
+            tensor.fill_(3.14)
+        elif tensor.dtype == torch.long:
+            tensor.fill_(42)
+
+    mocker.patch("torch.distributed.broadcast", side_effect=mock_broadcast)
+
+    model = nn.Module()
+    model.linear = nn.Linear(2, 2)
+    model.register_buffer("buf", torch.zeros(2))
+    model.register_buffer("int_buf", torch.zeros(3, dtype=torch.long))
+
+    od_config = SimpleNamespace(
+        dtype=torch.float32,
+        parallel_config=SimpleNamespace(use_hsdp=True),
+        enable_broadcast_weight_load=True,
+        quantization_config=None,
+    )
+    loader = DiffusersPipelineLoader(LoadConfig(), od_config)
+    loader._broadcast_model_weights(model, target_device=torch.device("cpu"), src_rank=0)
+
+    assert torch.allclose(model.linear.weight, torch.tensor(3.14))
+    assert torch.allclose(model.linear.bias, torch.tensor(3.14))
+    assert torch.allclose(model.buf, torch.tensor(3.14))
+    assert torch.equal(model.int_buf, torch.tensor([42, 42, 42], dtype=torch.long))
+
+
+def test_broadcast_model_weights_mixed_cpu_and_accelerator_devices(mocker):
+    """Ensure that when some pipeline modules are on CPU (transformer) and others on accelerator (VAE/encoder),
+    broadcasting normalizes tensors to CPU before concatenation and succeeds without device mismatch.
+    """
+    dev = torch.device("cuda:0") if torch.cuda.is_available() else torch.device("cpu")
+    mocker.patch("torch.distributed.is_initialized", return_value=True)
+    mocker.patch("torch.distributed.get_world_size", return_value=2)
+    mocker.patch("torch.distributed.get_rank", return_value=0)
+    mocker.patch("torch.distributed.get_backend", return_value="nccl" if dev.type == "cuda" else "gloo")
+    mocker.patch("torch.distributed.broadcast")
+    mocker.patch("torch.distributed.barrier")
+
+    model = nn.Module()
+    # Transformer parameters on CPU
+    model.transformer = nn.Linear(4, 4)
+    # VAE / Encoder parameters on accelerator
+    model.vae = nn.Linear(4, 4).to(dev)
+    model.text_encoder = nn.Linear(4, 4).to(dev)
+
+    od_config = SimpleNamespace(
+        dtype=torch.float32,
+        parallel_config=SimpleNamespace(use_hsdp=True),
+        enable_broadcast_weight_load=True,
+        quantization_config=None,
+    )
+    loader = DiffusersPipelineLoader(LoadConfig(), od_config)
+    # Should not raise RuntimeError: Tensors must have same device
+    loader._broadcast_model_weights(model, target_device=dev, src_rank=0)
+
+
+def test_broadcast_model_weights_mixed_devices_receiver(mocker):
+    """Ensure receiver rank with mixed CPU/accelerator tensors correctly receives broadcast data."""
+    dev = torch.device("cuda:0") if torch.cuda.is_available() else torch.device("cpu")
+    mocker.patch("torch.distributed.is_initialized", return_value=True)
+    mocker.patch("torch.distributed.get_world_size", return_value=2)
+    mocker.patch("torch.distributed.get_rank", return_value=1)
+    mocker.patch("torch.distributed.get_backend", return_value="nccl" if dev.type == "cuda" else "gloo")
+    mocker.patch("torch.distributed.barrier")
+
+    def mock_broadcast(tensor, src):
+        tensor.fill_(7.0)
+
+    mocker.patch("torch.distributed.broadcast", side_effect=mock_broadcast)
+
+    model = nn.Module()
+    model.transformer = nn.Linear(2, 2)  # CPU
+    model.vae = nn.Linear(2, 2).to(dev)  # Accelerator
+
+    od_config = SimpleNamespace(
+        dtype=torch.float32,
+        parallel_config=SimpleNamespace(use_hsdp=True),
+        enable_broadcast_weight_load=True,
+        quantization_config=None,
+    )
+    loader = DiffusersPipelineLoader(LoadConfig(), od_config)
+    loader._broadcast_model_weights(model, target_device=dev, src_rank=0)
+
+    assert torch.allclose(model.transformer.weight, torch.tensor(7.0))
+    assert torch.allclose(model.vae.weight, torch.tensor(7.0, device=dev))
+
+
+@pytest.mark.parametrize("rank", [0, 1])
+def test_hsdp_broadcast_weight_load_falls_back_when_online_quantization_enabled(mocker, rank):
+    """Ensure that when online quantization is enabled, HSDP weight loading falls back to
+    ordinary per-rank loading on all ranks rather than rank-0 broadcast.
+    """
+    import vllm_omni.diffusion.model_loader.diffusers_loader as loader_mod
+    from vllm_omni.diffusion.offloader.module_collector import PipelineModules
+
+    mocker.patch("torch.distributed.is_initialized", return_value=True)
+    mocker.patch("torch.distributed.get_world_size", return_value=4)
+    mocker.patch("torch.distributed.get_rank", return_value=rank)
+
+    mock_quant_config = SimpleNamespace(
+        is_checkpoint_quantized=False,
+    )
+    od_config = SimpleNamespace(
+        dtype=torch.float32,
+        parallel_config=SimpleNamespace(
+            use_hsdp=True,
+            hsdp_replicate_size=1,
+            hsdp_shard_size=4,
+        ),
+        enable_broadcast_weight_load=True,
+        lora_backend=None,
+        lora_path=None,
+        quantization_config=mock_quant_config,
+    )
+    loader = DiffusersPipelineLoader(LoadConfig(), od_config)
+
+    model = nn.Module()
+    model.transformer = nn.Linear(2, 2, bias=False)
+    events: list[str] = []
+
+    loader._init_from_load_format = mocker.Mock(return_value=model)  # type: ignore[method-assign]
+    loader.load_weights = mocker.Mock(side_effect=lambda _model: events.append("load"))  # type: ignore[method-assign]
+    loader._broadcast_model_weights = mocker.Mock(  # type: ignore[method-assign]
+        side_effect=lambda _model, **_kwargs: events.append("broadcast")
+    )
+    loader._process_weights_after_loading = mocker.Mock(  # type: ignore[method-assign]
+        side_effect=lambda _model, _device: events.append("process")
+    )
+    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.object(
+        loader_mod,
+        "apply_hsdp_to_model",
+        side_effect=lambda *_args, **_kwargs: events.append("shard"),
+    )
+
+    loader._load_model_with_hsdp(torch.device("cpu"))
+
+    # Both rank 0 and non-zero ranks MUST execute ordinary load_weights, not broadcast
+    assert "load" in events
+    assert "broadcast" not in events
+    assert events == ["load", "process", "shard"]
+
+
+def _mp_worker_online_quant(rank: int, world_size: int, rendezvous: str, temp_dir: str) -> None:
+    torch.set_num_threads(1)
+    import torch.distributed as dist
+
+    from vllm_omni.diffusion.offloader.module_collector import PipelineModules
+
+    dist.init_process_group("gloo", init_method=rendezvous, rank=rank, world_size=world_size)
+    try:
+
+        class _MockOnlineQuantModel(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.transformer = nn.Linear(4, 4)
+                self.load_called = False
+
+            def load_weights(self, weights):
+                self.load_called = True
+                return {"transformer.weight", "transformer.bias"}
+
+        mock_quant_config = SimpleNamespace(is_checkpoint_quantized=False)
+        od_config = SimpleNamespace(
+            dtype=torch.float32,
+            parallel_config=SimpleNamespace(
+                use_hsdp=True,
+                hsdp_replicate_size=1,
+                hsdp_shard_size=world_size,
+            ),
+            enable_broadcast_weight_load=True,
+            lora_backend=None,
+            lora_path=None,
+            quantization_config=mock_quant_config,
+        )
+        loader = DiffusersPipelineLoader(LoadConfig(), od_config)
+        model = _MockOnlineQuantModel()
+        loader._init_from_load_format = lambda *args, **kwargs: model  # type: ignore[method-assign]
+        loader._process_weights_after_loading = lambda *args, **kwargs: None  # type: ignore[method-assign]
+
+        with (
+            patch.object(
+                loader_module.ModuleDiscovery,
+                "discover",
+                return_value=PipelineModules(
+                    dits=[model.transformer],
+                    dit_names=["transformer"],
+                    vaes=[],
+                    encoders=[],
+                    encoder_names=[],
+                    resident_modules=[],
+                    resident_names=[],
+                ),
+            ),
+            patch.object(loader_module, "apply_hsdp_to_model", return_value=None),
+        ):
+            loader._load_model_with_hsdp(torch.device("cpu"))
+
+        if model.load_called:
+            with open(os.path.join(temp_dir, f"rank_{rank}_success.flag"), "w") as f:
+                f.write("ok")
+    finally:
+        dist.destroy_process_group()
+
+
+@pytest.mark.skipif(
+    not torch.distributed.is_available() or not torch.distributed.is_gloo_available(),
+    reason="requires torch.distributed gloo",
+)
+def test_hsdp_broadcast_weight_load_online_quant_multiprocess():
+    """Multi-process regression test verifying that with online quantization and broadcast enabled,
+    all ranks fall back to independent load_weights in parallel processes without hanging.
+    """
+    import torch.multiprocessing as mp
+
+    with tempfile.TemporaryDirectory() as temp_dir:
+        rendezvous = f"file://{os.path.join(temp_dir, 'gloo-rendezvous')}"
+        world_size = 2
+        with patch.dict(os.environ, {"CUDA_VISIBLE_DEVICES": ""}):
+            mp.spawn(
+                _mp_worker_online_quant,
+                args=(world_size, rendezvous, temp_dir),
+                nprocs=world_size,
+                join=True,
+            )
+        assert os.path.exists(os.path.join(temp_dir, "rank_0_success.flag"))
+        assert os.path.exists(os.path.join(temp_dir, "rank_1_success.flag"))
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/auk/test_auk_transformer_parity.py b/tests/diffusion/models/auk/test_auk_transformer_parity.py
new file mode 100644
index 000000000..937369d05
--- /dev/null
+++ b/tests/diffusion/models/auk/test_auk_transformer_parity.py
@@ -0,0 +1,439 @@
+#!/usr/bin/env python
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""AuK transformer parity: the correctness oracle for the in-tree port.
+
+Checks that :class:`AuKTransformer` reproduces the upstream ``auk`` reference backbone
+on the released ``auk_base`` weights. Both models are built from the same
+state dict and fed the same inputs, under the reference's own inference
+configuration: fp32 weights with ``torch.autocast(bfloat16)``. That
+configuration matters. The reference keeps its rotary frequencies in a buffer,
+so casting its weights to bf16 would round both the frequencies and the
+integer positions and move the numbers for reasons unrelated to the port.
+
+Cases:
+
+* ``single`` - one conditional forward
+* ``cfg`` - the doubled ``cfg_infer`` forward, both branches
+* ``masked`` - batch of 2 with padded targets, references and text
+* ``rope`` - the local rotary implementation against ``x_transformers``, and
+  its survival of a cast to bf16
+* ``sample`` - an 8-step Euler trajectory against the reference backbone
+  driven by a transcription of upstream's ODE loop
+* ``generator`` - the sampler's two noise paths agreeing
+* ``cache`` - the text projection cache and ``clear_cache()``
+* ``mask flag`` - ``attn_mask_enabled=False`` reproducing the reference with
+  its own flag off
+
+This directory deliberately has no ``__init__.py``, unlike its siblings.
+pytest's prepend import mode puts the nearest non-package directory on
+``sys.path``, and an ``auk`` package here would shadow the upstream ``auk``
+distribution this test compares against.
+
+Needs the released checkpoint and a GPU, so it runs locally rather than in
+CI. Point ``AUK_CKPT_DIR`` at a directory holding ``auk_base.safetensors`` and
+``config.yaml``; the test skips when that is unset or when the upstream
+``auk`` package is not importable::
+
+    AUK_CKPT_DIR=/path/to/ckpts/AuK CUDA_VISIBLE_DEVICES=6 \
+        python -m pytest tests/diffusion/models/auk/test_auk_transformer_parity.py -v -s
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import math
+import os
+from pathlib import Path
+
+import pytest
+import torch
+import yaml
+
+from vllm_omni.diffusion.models.auk.auk_transformer import (
+    AuKTransformer,
+    Rotary,
+    _apply_rope,
+    dit_state_dict,
+    sample_latents,
+)
+
+CKPT_DIR = os.environ.get("AUK_CKPT_DIR")
+
+# Tolerances. The port evaluates rotary embeddings in fp32 and skips the
+# reference's redundant uncond text projection, so the two graphs are not
+# bit-identical under autocast; they agree well inside bf16 noise.
+FORWARD_ATOL = 3e-2
+FORWARD_COS = 0.999
+SAMPLE_ATOL = 5e-2
+SAMPLE_COS = 0.999
+ROPE_ATOL = 1e-5
+
+TARGET_FRAMES = 300
+REF_FRAMES = 150
+TEXT_TOKENS = 40
+SHORT_LENS = (220, 90, 25)  # target, reference, text for the padded batch row
+TIME = 0.37
+SAMPLE_STEPS = 8
+SWAY_COEF = -1.0
+SEED = 1234
+DEVICE = "cuda:0"
+AUTOCAST_DTYPE = torch.bfloat16
+
+
+def _skip_reason() -> str | None:
+    if CKPT_DIR is None:
+        return "AUK_CKPT_DIR is not set"
+    if not Path(CKPT_DIR, "auk_base.safetensors").is_file():
+        return f"no auk_base.safetensors under {CKPT_DIR}"
+    try:
+        # Resolving the submodule, not just "auk", also catches the shadow an
+        # __init__.py in this directory would create.
+        upstream = importlib.util.find_spec("auk.model")
+    except ModuleNotFoundError:
+        upstream = None
+    if upstream is None:
+        return "the upstream 'auk' package is not importable or is shadowed by this directory"
+    if not torch.cuda.is_available():
+        return "no CUDA device"
+    return None
+
+
+SKIP_REASON = _skip_reason()
+
+pytestmark = [
+    pytest.mark.local_model,
+    pytest.mark.diffusion,
+    pytest.mark.gpu,
+    pytest.mark.cuda,
+    pytest.mark.skipif(SKIP_REASON is not None, reason=str(SKIP_REASON)),
+]
+
+
+def _arch() -> dict:
+    """Read the backbone geometry out of the checkpoint's config."""
+    config = yaml.safe_load(Path(CKPT_DIR, "config.yaml").read_text())["model"]
+    return {
+        "dim": config["arch"]["dim"],
+        "heads": config["arch"]["heads"],
+        "dim_head": config["arch"].get("dim_head", 64),
+        "ff_mult": config["arch"]["ff_mult"],
+        "text_hidden_dim": config["arch"]["text_hidden_dim"],
+        "num_layers": config["arch"]["num_layers"],
+        "num_single_layers": config["arch"]["num_single_layers"],
+        "latent_dim": config["vae"]["latent_dim"],
+    }
+
+
+def _stats(port: torch.Tensor, ref: torch.Tensor) -> tuple[float, float, float]:
+    """Return max abs diff, cosine similarity and the reference's RMS."""
+    a = port.flatten().float()
+    b = ref.flatten().float()
+    return (
+        (a - b).abs().max().item(),
+        torch.nn.functional.cosine_similarity(a, b, dim=0).item(),
+        b.pow(2).mean().sqrt().item(),
+    )
+
+
+def _assert_close(name: str, port: torch.Tensor, ref: torch.Tensor, atol: float, min_cos: float) -> None:
+    max_abs, cos, rms = _stats(port, ref)
+    print(f"[{name}] max|Δ|={max_abs:.4e} cos={cos:.8f} ref_rms={rms:.4f} rel={max_abs / rms:.3e}")
+    assert max_abs < atol, f"{name}: max|Δ|={max_abs:.4e} >= {atol:.1e} (reference rms {rms:.4f})"
+    assert cos > min_cos, f"{name}: cos={cos:.8f} <= {min_cos}"
+
+
+def _autocast():
+    return torch.autocast("cuda", dtype=AUTOCAST_DTYPE)
+
+
+@pytest.fixture(scope="module")
+def models() -> tuple[torch.nn.Module, AuKTransformer]:
+    """The reference and the port, same weights, fp32 on the accelerator."""
+    from auk.model.flux2_edit import Flux2Edit
+    from safetensors.torch import load_file
+
+    arch = _arch()
+    device = torch.device(DEVICE)
+    state = dit_state_dict(load_file(str(Path(CKPT_DIR, "auk_base.safetensors")), device="cpu"))
+
+    reference = Flux2Edit(dropout=0.0, attn_backend="torch", attn_mask_enabled=True, **arch)
+    reference.load_state_dict(state, strict=True)
+    reference = reference.to(device).eval().requires_grad_(False)
+
+    port = AuKTransformer(**arch)
+    # strict=True is the point of the port: every released tensor lands.
+    port.load_state_dict(state, strict=True)
+    port = port.to(device).eval().requires_grad_(False)
+
+    del state
+    return reference, port
+
+
+@pytest.fixture(scope="module")
+def inputs() -> dict[str, torch.Tensor]:
+    """Fixed random inputs, as a batch of 2 whose second row is padded."""
+    device = torch.device(DEVICE)
+    generator = torch.Generator(device="cpu").manual_seed(SEED)
+    arch = _arch()
+
+    def randn(*shape: int) -> torch.Tensor:
+        return torch.randn(*shape, generator=generator, dtype=torch.float32).to(device)
+
+    def pad_mask(width: int, short: int) -> torch.Tensor:
+        mask = torch.zeros(2, width, dtype=torch.bool, device=device)
+        mask[0, :] = True
+        mask[1, :short] = True
+        return mask
+
+    mask2 = pad_mask(TARGET_FRAMES, SHORT_LENS[0])
+    ref_mask2 = pad_mask(REF_FRAMES, SHORT_LENS[1])
+    c_mask2 = pad_mask(TEXT_TOKENS, SHORT_LENS[2])
+
+    # Padding rows are all-zero in the text encoder's output, so keep the
+    # inputs consistent with the masks.
+    x2 = randn(2, TARGET_FRAMES, arch["latent_dim"]) * mask2.unsqueeze(-1)
+    ref2 = randn(2, REF_FRAMES, arch["latent_dim"]) * ref_mask2.unsqueeze(-1)
+    text2 = randn(2, TEXT_TOKENS, arch["text_hidden_dim"]) * c_mask2.unsqueeze(-1)
+
+    return {
+        "x": x2[:1].contiguous(),
+        "ref": ref2[:1].contiguous(),
+        "text": text2[:1].contiguous(),
+        "c_mask": c_mask2[:1].contiguous(),
+        "x2": x2,
+        "ref2": ref2,
+        "text2": text2,
+        "mask2": mask2,
+        "ref_mask2": ref_mask2,
+        "c_mask2": c_mask2,
+        "time": torch.tensor(TIME, dtype=torch.float32, device=device),
+    }
+
+
+def test_single_forward(models, inputs) -> None:
+    """One conditional forward: reference against port."""
+    reference, port = models
+    kwargs = dict(text=inputs["text"], time=inputs["time"], c_mask=inputs["c_mask"], ref=inputs["ref"])
+    with torch.no_grad(), _autocast():
+        want = reference(x=inputs["x"], **kwargs)
+        got = port(inputs["x"], **kwargs)
+
+    assert got.shape == want.shape == (1, TARGET_FRAMES, port.latent_dim)
+    _assert_close("single", got, want, FORWARD_ATOL, FORWARD_COS)
+
+
+def test_cfg_forward(models, inputs) -> None:
+    """The doubled cfg_infer forward, cond branch first."""
+    reference, port = models
+    kwargs = dict(
+        text=inputs["text"],
+        time=inputs["time"],
+        c_mask=inputs["c_mask"],
+        ref=inputs["ref"],
+        cfg_infer=True,
+    )
+    with torch.no_grad(), _autocast():
+        want = reference(x=inputs["x"], **kwargs)
+        got = port(inputs["x"], **kwargs)
+
+    assert got.shape == want.shape == (2, TARGET_FRAMES, port.latent_dim)
+    _assert_close("cfg-cond", got[:1], want[:1], FORWARD_ATOL, FORWARD_COS)
+    _assert_close("cfg-uncond", got[1:], want[1:], FORWARD_ATOL, FORWARD_COS)
+
+
+def test_masked_batch_forward(models, inputs) -> None:
+    """Batch of 2 with padded targets, references and text.
+
+    Only valid target frames are compared. Padded frames are unconstrained:
+    the reference leaves them to whatever masked attention emits there.
+    """
+    reference, port = models
+    kwargs = dict(
+        text=inputs["text2"],
+        time=inputs["time"],
+        mask=inputs["mask2"],
+        c_mask=inputs["c_mask2"],
+        ref=inputs["ref2"],
+        ref_mask=inputs["ref_mask2"],
+    )
+    with torch.no_grad(), _autocast():
+        want = reference(x=inputs["x2"], **kwargs)
+        got = port(inputs["x2"], **kwargs)
+
+    assert got.shape == want.shape == (2, TARGET_FRAMES, port.latent_dim)
+    valid = inputs["mask2"].unsqueeze(-1).expand_as(got)
+    _assert_close("masked", got[valid], want[valid], FORWARD_ATOL, FORWARD_COS)
+
+
+def _set_mask_flag(reference, port, enabled: bool) -> None:
+    """Flip attn_mask_enabled on both models in place, so no second copy is loaded."""
+    for module in port.modules():
+        if hasattr(module, "attn_mask_enabled"):
+            module.attn_mask_enabled = enabled
+    for blocks in (reference.transformer_blocks, reference.single_transformer_blocks):
+        for block in blocks:
+            block.attn.processor.attn_mask_enabled = enabled
+
+
+def test_mask_flag_disabled(models, inputs) -> None:
+    """``attn_mask_enabled=False`` must track the reference with its own flag off.
+
+    With the flag off both models run attention unmasked and still zero the
+    padded outputs, so the padded batch is compared in full.
+    """
+    reference, port = models
+    kwargs = dict(
+        text=inputs["text2"],
+        time=inputs["time"],
+        mask=inputs["mask2"],
+        c_mask=inputs["c_mask2"],
+        ref=inputs["ref2"],
+        ref_mask=inputs["ref_mask2"],
+    )
+    with torch.no_grad(), _autocast():
+        masked = port(inputs["x2"], **kwargs)
+        _set_mask_flag(reference, port, False)
+        try:
+            want = reference(x=inputs["x2"], **kwargs)
+            got = port(inputs["x2"], **kwargs)
+        finally:
+            _set_mask_flag(reference, port, True)
+
+    _assert_close("mask-flag-off", got, want, FORWARD_ATOL, FORWARD_COS)
+    # Guard against a vacuous pass: the flag has to actually change something.
+    assert (got.float() - masked.float()).abs().max().item() > 1e-3
+
+
+def test_sampler_generator_matches_seed(models, inputs) -> None:
+    """A generator seeded with 0 must draw exactly what ``seed=0`` draws."""
+    _, port = models
+    common = dict(
+        gen_frames=TARGET_FRAMES,
+        nfe=2,
+        cfg_strength=0.0,
+        sway_sampling_coef=SWAY_COEF,
+        text=inputs["text"],
+        c_mask=inputs["c_mask"],
+        ref=inputs["ref"],
+        ref_mask=None,
+    )
+    with torch.no_grad(), _autocast():
+        by_seed = sample_latents(port, seed=0, **common)
+        by_generator = sample_latents(port, generator=torch.Generator(device=DEVICE).manual_seed(0), **common)
+
+    print(f"[generator] max|Δ|={(by_generator.float() - by_seed.float()).abs().max().item():.4e}")
+    torch.testing.assert_close(by_generator, by_seed, rtol=0, atol=0)
+
+
+def test_cache_needs_clearing(models, inputs) -> None:
+    """The cached text projection is reused until ``clear_cache()``.
+
+    ``sample_latents`` clears on the way out, so a pipeline that reuses the
+    module across requests is safe without doing anything. A caller driving
+    ``forward(cache=True)`` itself has to clear when the text changes.
+    """
+    _, port = models
+    other_text = inputs["text"] * 0.5
+    kwargs = dict(time=inputs["time"], c_mask=inputs["c_mask"], ref=inputs["ref"], cfg_infer=True)
+
+    port.clear_cache()
+    with torch.no_grad(), _autocast():
+        want = port(inputs["x"], inputs["text"], **kwargs)
+        port(inputs["x"], other_text, cache=True, **kwargs)
+        stale = port(inputs["x"], inputs["text"], cache=True, **kwargs)
+        port.clear_cache()
+        fresh = port(inputs["x"], inputs["text"], cache=True, **kwargs)
+        port.clear_cache()
+
+    # The cache is real: the second call reused the first call's projection.
+    assert (stale.float() - want.float()).abs().max().item() > 1e-3
+    torch.testing.assert_close(fresh, want, rtol=0, atol=0)
+    assert port.text_cond is None and port.text_uncond is None
+
+
+def test_rope_matches_x_transformers() -> None:
+    """The local rotary implementation against x_transformers, in fp32."""
+    from x_transformers.x_transformers import RotaryEmbedding, apply_rotary_pos_emb
+
+    device = torch.device(DEVICE)
+    dim_head, seq_len = 64, TEXT_TOKENS + REF_FRAMES + TARGET_FRAMES
+    q = torch.randn(2, 24, seq_len, dim_head, dtype=torch.float32, device=device)
+
+    freqs = RotaryEmbedding(dim_head).to(device).forward_from_seq_len(seq_len)[0]
+    want = apply_rotary_pos_emb(q, freqs)
+    got = _apply_rope(q, Rotary(dim_head).to(device)(seq_len))
+
+    max_abs, cos, _ = _stats(got, want)
+    print(f"[rope] max|Δ|={max_abs:.4e} cos={cos:.10f}")
+    assert max_abs < ROPE_ATOL, f"rope: max|Δ|={max_abs:.4e} >= {ROPE_ATOL:.1e}"
+
+
+def test_rope_survives_half_precision_cast() -> None:
+    """Casting the module to bf16 must not round the rotary frequencies.
+
+    The reference stores them in a buffer, so ``.to(bfloat16)`` rounds both the
+    frequencies and the integer positions and silently changes every rotation.
+    The port recomputes them instead.
+    """
+    dim_head, seq_len = 64, TEXT_TOKENS + REF_FRAMES + TARGET_FRAMES
+    exact = Rotary(dim_head)(seq_len)
+    got = Rotary(dim_head).to(torch.bfloat16)(seq_len)
+
+    assert got.dtype == torch.float32
+    torch.testing.assert_close(got, exact, rtol=0, atol=0)
+
+
+def _reference_euler(reference, *, x, text, c_mask, ref, steps, cfg_strength, sway) -> torch.Tensor:
+    """Upstream's ODE loop, transcribed.
+
+    ``CFMEdit.sample`` hands the backbone to ``torchdiffeq.odeint(method=
+    "euler")``, which on a fixed grid is ``y += (t1 - t0) * f(t0, y)``.
+    Constructing a real ``CFMEdit`` would drag in the Qwen-Omni text encoder,
+    so only the backbone here comes from upstream.
+    """
+    t = torch.linspace(0, 1, steps + 1, device=x.device, dtype=torch.float32)
+    if sway is not None:
+        t = t + sway * (torch.cos(math.pi / 2 * t) - 1 + t)
+
+    shared = dict(text=text, c_mask=c_mask, ref=ref, mask=None, ref_mask=None, cache=True)
+    for i in range(steps):
+        if cfg_strength < 1e-5:
+            v = reference(x=x, time=t[i], **shared)
+        else:
+            pred = reference(x=x, time=t[i], cfg_infer=True, **shared)
+            v_cond, v_uncond = torch.chunk(pred, 2, dim=0)
+            v = v_cond + (v_cond - v_uncond) * cfg_strength
+        x = x + (t[i + 1] - t[i]) * v
+    reference.clear_cache()
+    return x
+
+
+@pytest.mark.parametrize("cfg_strength", [0.0, 2.0])
+def test_euler_sample(models, inputs, cfg_strength: float) -> None:
+    """An 8-step Euler trajectory, with and without guidance."""
+    reference, port = models
+    shared = dict(text=inputs["text"], c_mask=inputs["c_mask"], ref=inputs["ref"])
+
+    with torch.no_grad(), _autocast():
+        got = sample_latents(
+            port,
+            gen_frames=TARGET_FRAMES,
+            ref_mask=None,
+            nfe=SAMPLE_STEPS,
+            cfg_strength=cfg_strength,
+            sway_sampling_coef=SWAY_COEF,
+            seed=SEED,
+            **shared,
+        )
+        # Re-seeding reproduces the noise sample_latents drew for itself.
+        torch.manual_seed(SEED)
+        noise = torch.randn(
+            TARGET_FRAMES, port.latent_dim, device=inputs["ref"].device, dtype=inputs["ref"].dtype
+        ).unsqueeze(0)
+        want = _reference_euler(
+            reference, x=noise, steps=SAMPLE_STEPS, cfg_strength=cfg_strength, sway=SWAY_COEF, **shared
+        )
+
+    assert got.shape == want.shape == (1, TARGET_FRAMES, port.latent_dim)
+    _assert_close(f"sample-cfg{cfg_strength:g}", got, want, SAMPLE_ATOL, SAMPLE_COS)
diff --git a/tests/diffusion/models/auk/test_auk_vae_parity.py b/tests/diffusion/models/auk/test_auk_vae_parity.py
new file mode 100644
index 000000000..cafc99614
--- /dev/null
+++ b/tests/diffusion/models/auk/test_auk_vae_parity.py
@@ -0,0 +1,254 @@
+#!/usr/bin/env python
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""AuK VAE parity: the numeric oracle for the vendored BigVGAN-flow codec.
+
+Checks ``AuKVAE`` against the AuK reference implementation on real speech, with
+both models loaded from the same released ``vae.safetensors``:
+
+  * encoder statistics (mean / log-std) agree,
+  * ``encode(sample=False)`` reproduces the reference mean path,
+  * ``encode(sample=True)`` reproduces ``encoding_and_normalization`` for a
+    matching RNG seed,
+  * ``decode`` reproduces ``denormalize`` + ``inference_from_latents``, in fp32
+    and (reported, not gated tightly) under bf16 autocast,
+  * the waveform survives a mean-path round trip.
+
+Runs on GPU in fp32 and needs both the released checkpoint and the reference
+``auk`` package importable, so it is a local_model test rather than CI. Point
+``AUK_CKPT_DIR`` at the directory holding ``vae.safetensors`` and ``AUK_REF_WAV``
+at a speech clip (default ``$AUK_CKPT_DIR/ref.wav``)::
+
+    AUK_CKPT_DIR=... AUK_REF_WAV=... python -m pytest \
+        tests/diffusion/models/auk/test_auk_vae_parity.py -v -s
+
+Unlike its sibling directories this one carries no ``__init__.py`` on purpose: it would put
+``tests/diffusion/models`` on ``sys.path`` ahead of site-packages, and this directory's own name
+would then shadow the reference ``auk`` package the parity check imports.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import os
+from pathlib import Path
+
+import pytest
+import soundfile as sf
+import torch
+import torchaudio.functional as AF
+
+from vllm_omni.diffusion.models.auk.auk_vae import AuKVAE
+
+pytestmark = [pytest.mark.local_model, pytest.mark.diffusion, pytest.mark.gpu, pytest.mark.cuda]
+
+# The released model.vae.model_init_kwargs, shared by both models under test.
+VAE_CONFIG = {
+    "upsample_rates": [5, 4, 3, 2, 2, 2],
+    "upsample_kernel_sizes": [10, 8, 6, 4, 4, 4],
+    "upsample_initial_channel": 1536,
+    "resblock_kernel_sizes": [3, 7, 11],
+    "resblock_dilation_sizes": [[1, 3, 5], [1, 3, 5], [1, 3, 5]],
+    "downsample_rates": [2, 2, 2, 3, 4, 5],
+    "downsample_channels": [12, 24, 48, 96, 192, 384, 768],
+    "snake_logscale": True,
+    "latent_dim": 64,
+    "use_vae": True,
+    "causal": True,
+    "flow_hidden_channels": 256,
+    "act_causal": True,
+}
+
+SAMPLE_RATE = 24000
+HOP_SIZE = 480
+LATENT_DIM = 64
+SEED = 1234
+# Keep the clip short: the parity run shares its GPU with other jobs.
+MAX_SECONDS = 4.0
+TOLERANCE = 1e-5
+DEVICE = "cuda"
+
+_CKPT_DIR = os.environ.get("AUK_CKPT_DIR")
+_VAE_PATH = Path(_CKPT_DIR) / "vae.safetensors" if _CKPT_DIR else None
+_REF_WAV = Path(os.environ.get("AUK_REF_WAV") or (Path(_CKPT_DIR) / "ref.wav" if _CKPT_DIR else "unset"))
+
+
+def _reference_importable() -> bool:
+    """Resolve ``auk.model``, not ``auk``.
+
+    An ``__init__.py`` in this directory would make its own name resolve as ``auk`` and satisfy a
+    top-level probe, leaving the fixtures to fail at setup instead of skipping. The submodule
+    probe fails in that case, which is the honest answer.
+    """
+    try:
+        return importlib.util.find_spec("auk.model") is not None
+    except (ImportError, ValueError):
+        return False
+
+
+def _skip_reason() -> str | None:
+    if not _CKPT_DIR:
+        return "set AUK_CKPT_DIR to the directory holding vae.safetensors"
+    if _VAE_PATH is None or not _VAE_PATH.is_file():
+        return f"no vae.safetensors under {_CKPT_DIR}"
+    if not _REF_WAV.is_file():
+        return f"no reference clip at {_REF_WAV} (set AUK_REF_WAV)"
+    if not _reference_importable():
+        return "cannot import the reference auk.model package (an __init__.py here would shadow it)"
+    if not torch.cuda.is_available():
+        return "parity runs in fp32 on GPU"
+    return None
+
+
+pytestmark.append(pytest.mark.skipif(_skip_reason() is not None, reason=_skip_reason() or ""))
+
+
+def _max_abs(lhs: torch.Tensor, rhs: torch.Tensor) -> float:
+    return (lhs.float() - rhs.float()).abs().max().item()
+
+
+def _snr_db(signal: torch.Tensor, estimate: torch.Tensor) -> float:
+    noise = (signal.float() - estimate.float()).pow(2).sum()
+    return (10.0 * torch.log10(signal.float().pow(2).sum() / noise)).item()
+
+
+@pytest.fixture(scope="module")
+def clip() -> torch.Tensor:
+    """Mono 24 kHz speech, trimmed to a whole number of latent frames."""
+    audio, sample_rate = sf.read(str(_REF_WAV), dtype="float32", always_2d=True)  # (T, C)
+    wav = torch.from_numpy(audio).mean(dim=1, keepdim=True).transpose(0, 1)
+    if sample_rate != SAMPLE_RATE:
+        wav = AF.resample(wav, sample_rate, SAMPLE_RATE)
+    samples = min(int(MAX_SECONDS * SAMPLE_RATE), wav.size(-1)) // HOP_SIZE * HOP_SIZE
+    wav = wav[:, :samples].contiguous().to(DEVICE)
+    print(f"\n[clip] {_REF_WAV.name}: {samples} samples, {samples / SAMPLE_RATE:.2f} s, {samples // HOP_SIZE} frames")
+    return wav
+
+
+@pytest.fixture(scope="module")
+def reference(clip: torch.Tensor) -> dict[str, torch.Tensor]:
+    """Reference tensors from the upstream model, which is then released so one model fits at a time."""
+    from auk.model.vae import load_vae_model
+    from auk.model.vae.bigvgan_flow_vae import BigVGANFlowVAEConfig
+
+    model = load_vae_model(
+        vae_name="BigVGANFlowVAE",
+        vae_cfg=BigVGANFlowVAEConfig.from_dict(VAE_CONFIG),
+        vae_ckpt=str(_VAE_PATH),
+        map_location="cpu",
+    )
+    model = model.to(DEVICE).eval()
+    model.requires_grad_(False)
+
+    with torch.no_grad():
+        mean, log_std = model.audio_encoder(clip.unsqueeze(1)).chunk(2, 1)
+        scale = torch.sqrt(model.global_log_std.float())
+        mean_latents = (mean.transpose(1, 2).float() - model.global_mean.float()) / scale
+        torch.manual_seed(SEED)
+        sampled_latents, _ = model.encoding_and_normalization(clip.unsqueeze(1))
+        decoded = model.inference_from_latents(model.denormalize(mean_latents).permute(0, 2, 1))
+
+    tensors = {
+        "mean": mean.clone(),
+        "log_std": log_std.clone(),
+        "mean_latents": mean_latents.clone(),
+        "sampled_latents": sampled_latents.clone(),
+        "decoded": decoded.squeeze(1).clone(),
+    }
+    del model
+    torch.accelerator.empty_cache()
+    return tensors
+
+
+@pytest.fixture(scope="module")
+def port(reference: dict[str, torch.Tensor]) -> tuple[AuKVAE, list[str], list[str]]:
+    """The vendored module, loaded from the same checkpoint. Depends on ``reference`` for load ordering.
+
+    Placed on the accelerator before loading so weight norm is folded there; see ``load_weights``.
+    """
+    model = AuKVAE.from_config(VAE_CONFIG).to(DEVICE)
+    missing, unexpected = model.load_weights(_VAE_PATH)
+    model = model.eval()
+    model.requires_grad_(False)
+    return model, missing, unexpected
+
+
+def test_checkpoint_covers_every_inference_tensor(port: tuple[AuKVAE, list[str], list[str]]) -> None:
+    model, missing, unexpected = port
+    print(f"[keys] missing={len(missing)} unexpected={len(unexpected)}")
+    print(f"[keys] unexpected prefixes={sorted({key.split('.')[0] for key in unexpected})}")
+    assert missing == []
+    assert unexpected and all(key.startswith("flow.") for key in unexpected)
+    assert (model.hop_size, model.sample_rate, model.latent_dim) == (HOP_SIZE, SAMPLE_RATE, LATENT_DIM)
+
+
+def test_encoder_statistics_match(
+    clip: torch.Tensor, reference: dict[str, torch.Tensor], port: tuple[AuKVAE, list[str], list[str]]
+) -> None:
+    model = port[0]
+    with torch.no_grad():
+        mean, log_std = model.audio_encoder(clip.unsqueeze(1)).chunk(2, 1)
+    mean_diff = _max_abs(mean, reference["mean"])
+    log_std_diff = _max_abs(log_std, reference["log_std"])
+    print(f"[encoder] max|dmean|={mean_diff:.3e} max|dlog_std|={log_std_diff:.3e}")
+    assert mean_diff < TOLERANCE
+    assert log_std_diff < TOLERANCE
+    # Folded and hook-computed weights are bit-identical on one device, so the whole encoder is.
+    assert (mean_diff, log_std_diff) == (0.0, 0.0)
+
+
+def test_encode_mean_path_matches(
+    clip: torch.Tensor, reference: dict[str, torch.Tensor], port: tuple[AuKVAE, list[str], list[str]]
+) -> None:
+    model = port[0]
+    with torch.no_grad():
+        latents = model.encode(clip)
+    assert latents.shape == (1, clip.size(-1) // HOP_SIZE, LATENT_DIM)
+    diff = _max_abs(latents, reference["mean_latents"])
+    print(f"[encode mean] shape={tuple(latents.shape)} max|d|={diff:.3e}")
+    assert diff == 0.0
+
+
+def test_encode_sampled_matches_seeded_reference(
+    clip: torch.Tensor, reference: dict[str, torch.Tensor], port: tuple[AuKVAE, list[str], list[str]]
+) -> None:
+    model = port[0]
+    generator = torch.Generator(device=DEVICE)
+    generator.manual_seed(SEED)
+    with torch.no_grad():
+        latents = model.encode(clip, sample=True, generator=generator)
+    diff = _max_abs(latents, reference["sampled_latents"])
+    spread = _max_abs(latents, reference["mean_latents"])
+    print(f"[encode sample] max|d vs seeded reference|={diff:.3e} max|d vs mean path|={spread:.3e}")
+    assert diff < TOLERANCE
+    assert diff == 0.0  # a fresh device Generator replays the default one after torch.manual_seed
+    assert spread > TOLERANCE  # the draw actually moved the latents
+
+
+def test_decode_matches(reference: dict[str, torch.Tensor], port: tuple[AuKVAE, list[str], list[str]]) -> None:
+    model = port[0]
+    latents = reference["mean_latents"]
+    with torch.no_grad():
+        wav = model.decode(latents)
+    assert wav.shape == (1, latents.size(1) * HOP_SIZE)
+    diff = _max_abs(wav, reference["decoded"])
+    print(f"[decode fp32] shape={tuple(wav.shape)} max|d|={diff:.3e}")
+    assert diff < TOLERANCE
+    assert diff == 0.0
+
+    with torch.no_grad(), torch.autocast(device_type="cuda", dtype=torch.bfloat16):
+        wav_bf16 = model.decode(latents)
+    bf16_diff = _max_abs(wav_bf16, reference["decoded"])
+    print(f"[decode bf16 autocast] max|d| vs fp32 reference={bf16_diff:.3e} snr={_snr_db(wav, wav_bf16):.2f} dB")
+    assert torch.isfinite(wav_bf16).all()
+    assert bf16_diff < 0.5  # sanity only: bf16 is reported, not held to fp32 parity
+
+
+def test_round_trip_snr(clip: torch.Tensor, port: tuple[AuKVAE, list[str], list[str]]) -> None:
+    model = port[0]
+    with torch.no_grad():
+        wav = model.decode(model.encode(clip))
+    assert wav.shape == clip.shape
+    snr = _snr_db(clip, wav)
+    print(f"[round trip] snr={snr:.2f} dB peak={wav.abs().max().item():.4f}")
+    assert snr > 10.0
diff --git a/tests/diffusion/models/auk/test_pipeline_auk.py b/tests/diffusion/models/auk/test_pipeline_auk.py
new file mode 100644
index 000000000..261c5240d
--- /dev/null
+++ b/tests/diffusion/models/auk/test_pipeline_auk.py
@@ -0,0 +1,514 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""AuK stage-1 pipeline: request parsing on CPU, generation parity on a GPU.
+
+The CPU tests stub the transformer, the codec and the ODE so they exercise only
+what the pipeline itself owns: how a request turns into a target length, a
+sampling schedule and a noise generator.
+
+The parity test replays the saved upstream reference for the zero-shot TTS case
+and reports latent, per-frame and waveform distances rather than asserting bit
+equality, because two differences live in the conditioning rather than in the
+port: the saved text condition is an fp32 thinker forward while the reference
+generated under bf16 autocast, and the reference's stochastic VAE draw came from
+the process-global RNG seeded at 1234.
+
+It replays with ``vae_sample=False``. That is the deliberate choice: the
+reference re-seeds the global RNG immediately before drawing the ODE noise, so a
+per-request generator reproduces that noise exactly (verified bit-identical) as
+long as nothing else has drawn from it. Sampling the VAE posterior consumes the
+generator first, which moves the noise and produces a different, equally valid
+realization; comparing latents then measures the noise, not the port. The
+posterior mean costs a reference latent that is 0.045 MSE (0.969 cosine) away
+from the draw the reference used, which is the smaller of the two errors.
+Generate the reference artifacts once with the upstream package installed
+(``tools/auk_parity_reference.py --auk-repo ... --ckpt-dir ... --qwen-dir ...
+--out /path/to/auk-parity``; it writes ``parity_ref/<variant>`` and
+``fusion_ref``), then run::
+
+    AUK_OMNI_CKPT_DIR=/path/to/auk-omni-base \
+    AUK_PARITY_REF=/path/to/auk-parity/parity_ref/base \
+    python -m pytest -s tests/diffusion/models/auk/test_pipeline_auk.py
+
+``AUK_OMNI_CKPT_DIR`` is the assembled directory this pipeline loads, which is
+not the same thing as the released AuK snapshot that the transformer and codec
+parity tests in this directory read from ``AUK_CKPT_DIR``. ``AUK_CKPT_DIR`` is
+accepted as a fallback, and the test skips rather than fails when the directory
+it resolves to is not an assembled one.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+import os
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import pytest
+import soundfile as sf
+import torch
+import torch.nn.functional as F
+import torchaudio
+from torch import nn
+
+from vllm_omni.diffusion.data import OmniDiffusionConfig
+from vllm_omni.diffusion.models.auk import pipeline_auk
+from vllm_omni.diffusion.models.auk.pipeline_auk import AuKPipeline
+from vllm_omni.diffusion.request import OmniDiffusionRequest
+from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+LATENT_DIM = 64
+HOP = 480
+SAMPLE_RATE = 24000
+TEXT_HIDDEN_DIM = 2048
+
+# The distilled student's grid, exact values from the released checkpoint.
+FLASH_T_GRID = [0.0, 0.07612049579620361, 0.2928932309150696, 0.6173166036605835, 1.0]
+
+CKPT_DIR = os.environ.get("AUK_OMNI_CKPT_DIR") or os.environ.get("AUK_CKPT_DIR")
+PARITY_REF = os.environ.get("AUK_PARITY_REF")
+# An assembled directory is the only thing this pipeline can load.
+IS_ASSEMBLED = bool(CKPT_DIR) and (Path(CKPT_DIR).expanduser() / "config.json").is_file()
+
+# Measured on the released base checkpoint: mean frame cosine 0.961 to 0.968,
+# relative latent MSE 0.051 to 0.063, log-mel distance 0.34. That spread is
+# bf16 against fp32 DiT weights plus where the codec folds its weight norm,
+# neither of which is worth gating on. A port that has lost the conditioning
+# sits at 0.110 cosine, 1.82 relative MSE and 2.88 log-mel, so these gates
+# still separate the two by an order of magnitude.
+PARITY_MIN_FRAME_COSINE = 0.93
+PARITY_MAX_RELATIVE_MSE = 0.15
+PARITY_MAX_MEL_DISTANCE = 0.6
+
+
+class _StubTransformer(nn.Module):
+    """Records its construction arguments; owns one weight so strict loading runs."""
+
+    def __init__(
+        self,
+        *,
+        dim: int,
+        heads: int,
+        dim_head: int,
+        ff_mult: float,
+        latent_dim: int,
+        text_hidden_dim: int,
+        num_layers: int,
+        num_single_layers: int,
+        attn_mask_enabled: bool = True,
+    ) -> None:
+        super().__init__()
+        self.init_kwargs = {
+            "dim": dim,
+            "heads": heads,
+            "dim_head": dim_head,
+            "ff_mult": ff_mult,
+            "latent_dim": latent_dim,
+            "text_hidden_dim": text_hidden_dim,
+            "num_layers": num_layers,
+            "num_single_layers": num_single_layers,
+            "attn_mask_enabled": attn_mask_enabled,
+        }
+        self.latent_dim = latent_dim
+        self.proj = nn.Linear(latent_dim, latent_dim, bias=False)
+
+
+class _StubVAE(nn.Module):
+    """Deterministic stand-in for the codec, one latent frame per hop."""
+
+    hop_size = HOP
+    sample_rate = SAMPLE_RATE
+    latent_dim = LATENT_DIM
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.encode_calls: list[dict[str, Any]] = []
+        self.decode_calls = 0
+        self.weights_path: str | None = None
+        self.config: dict[str, Any] = {}
+
+    @classmethod
+    def from_config(cls, cfg: dict[str, Any]) -> _StubVAE:
+        vae = cls()
+        vae.config = dict(cfg)
+        return vae
+
+    def load_weights(self, path: str, **_: Any) -> tuple[list[str], list[str]]:
+        self.weights_path = str(path)
+        return [], []
+
+    def encode(
+        self,
+        wav: torch.Tensor,
+        *,
+        sample: bool = False,
+        generator: torch.Generator | None = None,
+    ) -> torch.Tensor:
+        frames = wav.shape[-1] // HOP
+        self.encode_calls.append({"samples": int(wav.shape[-1]), "sample": sample, "generator": generator})
+        if sample:
+            return torch.randn(1, frames, LATENT_DIM, generator=generator, device=wav.device)
+        return torch.zeros(1, frames, LATENT_DIM, device=wav.device)
+
+    def decode(self, latents: torch.Tensor) -> torch.Tensor:
+        self.decode_calls += 1
+        return torch.zeros(1, latents.shape[1] * HOP, device=latents.device)
+
+
+def _stub_sampler(calls: list[dict[str, Any]]):
+    """Record the ODE arguments and return noise drawn from the request generator."""
+
+    def sample_latents(dit: nn.Module, **kwargs: Any) -> torch.Tensor:
+        calls.append(kwargs)
+        shape = (1, kwargs["gen_frames"], kwargs["latent_dim"])
+        generator = kwargs.get("generator")
+        if generator is None:
+            return torch.zeros(*shape, device=kwargs["device"], dtype=kwargs["dtype"])
+        return torch.randn(*shape, generator=generator, device=kwargs["device"], dtype=kwargs["dtype"])
+
+    return sample_latents
+
+
+def _write_checkpoint(root: Path, variant: str) -> Path:
+    """Write a tiny assembled checkpoint the stubs can load."""
+
+    from safetensors.torch import save_file
+
+    model_dir = root / f"auk-{variant}"
+    model_dir.mkdir(parents=True, exist_ok=True)
+    config = {
+        "model_type": "auk",
+        "architectures": ["AuKForConditionalGeneration"],
+        "dit": {
+            "dim": 16,
+            "heads": 2,
+            "dim_head": 8,
+            "ff_mult": 2,
+            "text_hidden_dim": TEXT_HIDDEN_DIM,
+            "num_layers": 1,
+            "num_single_layers": 1,
+            "attn_mask_enabled": True,
+        },
+        "vae": {
+            "latent_dim": LATENT_DIM,
+            "downsample_rate": HOP,
+            "target_sample_rate": SAMPLE_RATE,
+            "model_init_kwargs": {"latent_dim": LATENT_DIM},
+        },
+        "variant": variant,
+        "flash_t_grid": FLASH_T_GRID,
+        "defaults": {"nfe": 32, "cfg": 2.0, "sway": -1.0},
+    }
+    (model_dir / "config.json").write_text(json.dumps(config))
+    save_file(
+        {
+            "transformer.proj.weight": torch.zeros(LATENT_DIM, LATENT_DIM),
+            "layer_weights": torch.zeros(36),
+            "layer_scale": torch.ones(1),
+        },
+        str(model_dir / "auk.safetensors"),
+    )
+    save_file({"global_mean": torch.zeros(LATENT_DIM)}, str(model_dir / "vae.safetensors"))
+    return model_dir
+
+
+@pytest.fixture
+def build_pipeline(tmp_path, monkeypatch):
+    """Build an AuKPipeline whose transformer, codec and ODE are stubs."""
+
+    monkeypatch.setattr(pipeline_auk, "get_local_device", lambda: torch.device("cpu"))
+    monkeypatch.setattr(pipeline_auk, "AuKTransformer", _StubTransformer)
+    monkeypatch.setattr(pipeline_auk, "AuKVAE", _StubVAE)
+
+    def _build(variant: str = "base") -> tuple[AuKPipeline, list[dict[str, Any]]]:
+        calls: list[dict[str, Any]] = []
+        monkeypatch.setattr(pipeline_auk, "sample_latents", _stub_sampler(calls))
+        od_config = OmniDiffusionConfig(
+            model=str(_write_checkpoint(tmp_path, variant)),
+            dtype=torch.float32,
+            model_class_name="AuKPipeline",
+        )
+        return AuKPipeline(od_config=od_config), calls
+
+    return _build
+
+
+def _prompt(
+    *,
+    tokens: int = 8,
+    audio: Any = None,
+    knobs: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Build the diffusion prompt the stage input processor would emit."""
+
+    prompt: dict[str, Any] = {
+        "prompt": "",
+        "prompt_embeds": torch.zeros(tokens, TEXT_HIDDEN_DIM),
+        "additional_information": {"auk": dict(knobs or {})},
+    }
+    if audio is not None:
+        prompt["multi_modal_data"] = {"audio": audio}
+    return prompt
+
+
+def _batch(prompt: dict[str, Any], **sampling: Any) -> DiffusionRequestBatch:
+    request = OmniDiffusionRequest(
+        prompt=prompt,
+        sampling_params=OmniDiffusionSamplingParams(**sampling),
+        request_id="auk-test-0",
+    )
+    return DiffusionRequestBatch(requests=[request])
+
+
+def _silence(seconds: float, sample_rate: int = SAMPLE_RATE) -> tuple[np.ndarray, int]:
+    return np.zeros(int(seconds * sample_rate), dtype=np.float32), sample_rate
+
+
+@pytest.mark.core_model
+@pytest.mark.cpu
+class TestRequestParsing:
+    def test_pipeline_declares_audio_output(self, build_pipeline):
+        pipeline, _ = build_pipeline()
+
+        assert pipeline.support_audio_output is True
+        assert pipeline.audio_sample_rate == SAMPLE_RATE
+        assert pipeline.supports_request_batch is False
+        # The warmup request cannot carry an encoder-stage text condition.
+        assert pipeline.dummy_run_num_frames == 0
+
+    def test_config_reaches_the_transformer(self, build_pipeline):
+        pipeline, _ = build_pipeline()
+
+        assert pipeline.dit.init_kwargs["latent_dim"] == LATENT_DIM
+        assert pipeline.dit.init_kwargs["text_hidden_dim"] == TEXT_HIDDEN_DIM
+        assert pipeline.dit.init_kwargs["attn_mask_enabled"] is True
+
+    def test_gen_seconds_sets_the_target_length(self, build_pipeline):
+        pipeline, calls = build_pipeline()
+
+        outputs = pipeline.forward(_batch(_prompt(audio=_silence(2.0), knobs={"gen_seconds": 6.0}), seed=1))
+
+        assert calls[0]["gen_frames"] == math.ceil(6.0 * SAMPLE_RATE / HOP)
+        assert calls[0]["ref"].shape == (1, 100, LATENT_DIM)
+        assert calls[0]["ref_mask"].shape == (1, 100)
+        assert calls[0]["c_mask"].shape == (1, 8)
+        assert outputs[0].output.shape == (300 * HOP,)
+        assert outputs[0].output.dtype is torch.float32
+
+    def test_target_length_falls_back_to_the_source_clip(self, build_pipeline):
+        pipeline, calls = build_pipeline()
+
+        pipeline.forward(_batch(_prompt(audio=_silence(2.0), knobs={"gen_seconds": None}), seed=1))
+
+        assert calls[0]["gen_frames"] == 100
+
+    def test_text_only_request_without_a_duration_is_rejected(self, build_pipeline):
+        pipeline, calls = build_pipeline()
+
+        with pytest.raises(ValueError, match="gen_seconds"):
+            pipeline.forward(_batch(_prompt(knobs={"gen_seconds": None}), seed=1))
+        assert calls == []
+
+    def test_text_only_request_gets_an_empty_reference(self, build_pipeline):
+        pipeline, calls = build_pipeline()
+
+        pipeline.forward(_batch(_prompt(knobs={"gen_seconds": 3.5}), seed=1))
+
+        assert calls[0]["ref"].shape == (1, 0, LATENT_DIM)
+        assert calls[0]["gen_frames"] == 175
+
+    def test_source_clip_is_resampled_to_the_codec_rate(self, build_pipeline):
+        pipeline, _ = build_pipeline()
+
+        pipeline.forward(_batch(_prompt(audio=_silence(1.0, 16000), knobs={"gen_seconds": 1.0}), seed=1))
+
+        assert pipeline.vae.encode_calls[0]["samples"] == SAMPLE_RATE
+
+    def test_stereo_source_is_mixed_to_mono(self, build_pipeline):
+        pipeline, _ = build_pipeline()
+        stereo = np.zeros((2, SAMPLE_RATE), dtype=np.float32)
+
+        pipeline.forward(_batch(_prompt(audio=(stereo, SAMPLE_RATE), knobs={"gen_seconds": 1.0}), seed=1))
+
+        assert pipeline.vae.encode_calls[0]["samples"] == SAMPLE_RATE
+
+    def test_missing_text_condition_is_rejected(self, build_pipeline):
+        pipeline, _ = build_pipeline()
+        prompt = _prompt(knobs={"gen_seconds": 1.0})
+        del prompt["prompt_embeds"]
+
+        with pytest.raises(ValueError, match="prompt_embeds"):
+            pipeline.forward(_batch(prompt, seed=1))
+
+    def test_base_variant_uses_the_requested_schedule(self, build_pipeline):
+        pipeline, calls = build_pipeline()
+
+        pipeline.forward(
+            _batch(
+                _prompt(audio=_silence(1.0), knobs={"gen_seconds": 1.0, "sway": -1.0}),
+                seed=1,
+                num_inference_steps=16,
+                guidance_scale=3.0,
+            )
+        )
+
+        assert calls[0]["nfe"] == 16
+        assert calls[0]["cfg_strength"] == 3.0
+        assert calls[0]["sway_sampling_coef"] == -1.0
+        assert calls[0]["t_grid"] is None
+
+    def test_schedule_defaults_come_from_the_checkpoint(self, build_pipeline):
+        pipeline, calls = build_pipeline()
+
+        pipeline.forward(_batch(_prompt(audio=_silence(1.0), knobs={"gen_seconds": 1.0, "sway": None}), seed=1))
+
+        assert calls[0]["nfe"] == 32
+        assert calls[0]["cfg_strength"] == 2.0
+        assert calls[0]["sway_sampling_coef"] == -1.0
+
+    def test_flash_variant_locks_the_distilled_recipe(self, build_pipeline):
+        pipeline, calls = build_pipeline("flash")
+
+        pipeline.forward(
+            _batch(
+                _prompt(audio=_silence(1.0), knobs={"gen_seconds": 1.0, "sway": -1.0}),
+                seed=1,
+                num_inference_steps=32,
+                guidance_scale=2.0,
+            )
+        )
+
+        assert calls[0]["nfe"] == 4
+        assert calls[0]["cfg_strength"] == 0.0
+        assert calls[0]["sway_sampling_coef"] is None
+        assert calls[0]["t_grid"] == FLASH_T_GRID
+
+    def test_noise_comes_from_a_seeded_request_generator(self, build_pipeline):
+        pipeline, calls = build_pipeline()
+
+        outputs = pipeline.forward(
+            _batch(_prompt(knobs={"gen_seconds": 1.0}), seed=0, output_type="latent"),
+        )
+
+        expected = torch.randn(1, 50, LATENT_DIM, generator=torch.Generator().manual_seed(0))
+        assert torch.equal(outputs[0].output, expected)
+        # The global RNG is never seeded on the pipeline's behalf.
+        assert calls[0]["seed"] is None
+        assert isinstance(calls[0]["generator"], torch.Generator)
+
+    def test_latent_output_type_skips_the_decoder(self, build_pipeline):
+        pipeline, _ = build_pipeline()
+
+        outputs = pipeline.forward(_batch(_prompt(knobs={"gen_seconds": 1.0}), seed=1, output_type="latent"))
+
+        assert outputs[0].output.shape == (1, 50, LATENT_DIM)
+        assert pipeline.vae.decode_calls == 0
+
+    def test_vae_sample_draws_from_the_request_generator(self, build_pipeline):
+        pipeline, _ = build_pipeline()
+
+        pipeline.forward(_batch(_prompt(audio=_silence(1.0), knobs={"gen_seconds": 1.0, "vae_sample": True}), seed=1))
+
+        call = pipeline.vae.encode_calls[0]
+        assert call["sample"] is True
+        assert isinstance(call["generator"], torch.Generator)
+
+    def test_one_request_per_forward(self, build_pipeline):
+        pipeline, _ = build_pipeline()
+        batch = _batch(_prompt(knobs={"gen_seconds": 1.0}), seed=1)
+        batch.requests.append(batch.requests[0])
+
+        with pytest.raises(AssertionError, match="one request per forward"):
+            pipeline.forward(batch)
+
+
+def _reference_audio_path(messages: list[dict[str, Any]]) -> str:
+    for message in messages:
+        for item in message.get("content") or ():
+            if isinstance(item, dict) and item.get("type") == "audio":
+                path = item.get("audio") or item.get("audio_url")
+                if path:
+                    return str(path)
+    raise AssertionError("the saved reference case carries no source clip")
+
+
+def _log_mel_distance(left: torch.Tensor, right: torch.Tensor, sample_rate: int) -> float:
+    """Mean absolute log-mel difference between two mono waveforms."""
+
+    mel = torchaudio.transforms.MelSpectrogram(sample_rate=sample_rate, n_fft=1024, hop_length=256, n_mels=80)
+    length = min(left.shape[-1], right.shape[-1])
+    spectra = [torch.log(mel(wav[..., :length].float()) + 1e-5) for wav in (left, right)]
+    return float((spectra[0] - spectra[1]).abs().mean())
+
+
+@pytest.mark.local_model
+@pytest.mark.diffusion
+@pytest.mark.skipif(
+    not (IS_ASSEMBLED and PARITY_REF),
+    reason="needs AUK_PARITY_REF and AUK_OMNI_CKPT_DIR pointing at an assembled checkpoint directory",
+)
+def test_zero_shot_tts_tracks_the_upstream_reference():
+    """Replay the saved zero-shot TTS case and report the distances."""
+
+    parity_dir = Path(PARITY_REF)
+    fusion_dir = Path(os.environ.get("AUK_FUSION_REF") or parity_dir.parent.parent / "fusion_ref")
+    reference = torch.load(parity_dir / "zs_tts_en.pt", map_location="cpu", weights_only=False)
+    fusion = torch.load(fusion_dir / "zs_tts_audio.pt", map_location="cpu", weights_only=False)
+
+    # soundfile rather than torchaudio.load: the repo's test convention, and
+    # torchaudio's decoder needs an ffmpeg the port environment does not have.
+    samples, source_rate = sf.read(_reference_audio_path(reference["messages"]), dtype="float32", always_2d=True)
+    source = torch.from_numpy(samples).transpose(0, 1)
+    knobs = {"gen_seconds": reference["gen_seconds"], "sway": -1.0, "t_grid": None, "vae_sample": False}
+    prompt = {
+        "prompt": "",
+        # The encoder stage emits bf16; the saved fusion is an fp32 forward.
+        "prompt_embeds": fusion["fused"].to(torch.bfloat16),
+        "multi_modal_data": {"audio": (source, int(source_rate))},
+        "additional_information": {"auk": knobs},
+    }
+    od_config = OmniDiffusionConfig(model=CKPT_DIR, dtype=torch.bfloat16, model_class_name="AuKPipeline")
+    pipeline = AuKPipeline(od_config=od_config)
+
+    def run(output_type: str) -> torch.Tensor:
+        batch = _batch(
+            dict(prompt),
+            seed=reference["seed"],
+            num_inference_steps=32,
+            guidance_scale=2.0,
+            output_type=output_type,
+        )
+        return pipeline.forward(batch)[0].output
+
+    # Two deterministic runs: the ODE is seeded, so the latents belong to the
+    # waveform even though the decode happens in the second call.
+    latents = run("latent")
+    waveform = run("pt")
+
+    ref_frames = int(reference["ref_latent_lens"][0])
+    expected = reference["generated"][:, ref_frames:, :].float()
+    assert latents.shape == expected.shape
+    assert torch.isfinite(latents).all()
+    assert torch.isfinite(waveform).all()
+    assert waveform.shape[-1] == expected.shape[1] * HOP
+
+    cosine = F.cosine_similarity(latents[0], expected[0], dim=-1)
+    metrics = {
+        "gen_frames": int(expected.shape[1]),
+        "ref_frames": ref_frames,
+        "latent_mse": float(torch.mean((latents - expected) ** 2)),
+        "latent_relative_mse": float(torch.mean((latents - expected) ** 2) / expected.var()),
+        "frame_cosine_mean": float(cosine.mean()),
+        "frame_cosine_min": float(cosine.min()),
+        "log_mel_distance": _log_mel_distance(waveform, reference["audio"].reshape(-1), int(reference["sr"])),
+        "rms_port": float(waveform.pow(2).mean().sqrt()),
+        "rms_reference": float(reference["audio"].reshape(-1).pow(2).mean().sqrt()),
+    }
+    print("\nAuK zero-shot TTS parity:", json.dumps(metrics, indent=1))
+
+    assert metrics["frame_cosine_mean"] > PARITY_MIN_FRAME_COSINE
+    assert metrics["latent_relative_mse"] < PARITY_MAX_RELATIVE_MSE
+    assert metrics["log_mel_distance"] < PARITY_MAX_MEL_DISTANCE
diff --git a/tests/diffusion/models/bagel/test_bagel_lora.py b/tests/diffusion/models/bagel/test_bagel_lora.py
index c285758fe..1e73318ce 100644
--- a/tests/diffusion/models/bagel/test_bagel_lora.py
+++ b/tests/diffusion/models/bagel/test_bagel_lora.py
@@ -122,8 +122,10 @@ class TestStage1DiTLoRA:
             lambda root, name, sub: fake_replace_submodule(root, name, sub, replace_calls),
         )
 
-        # Build pipeline with bagel component
+        # Build pipeline with bagel component declared via _lora_components,
+        # matching how BagelPipeline opts in.
         pipeline = torch.nn.Module()
+        pipeline._lora_components = ["bagel"]
         pipeline.bagel = torch.nn.Module()
         lm = torch.nn.Module()
         lm.stacked_params_mapping = [
@@ -194,8 +196,11 @@ class TestBagelLoRARoundTrip:
 
         monkeypatch.setattr(manager_mod, "BaseLayerWithLoRA", DummyBaseLayerWithLoRA)
 
-        # Build pipeline with bagel.language_model.foo (simple non-packed layer)
+        # Build pipeline with bagel.language_model.foo (simple non-packed layer);
+        # the bagel component is declared via _lora_components, matching how
+        # BagelPipeline opts in.
         pipeline = torch.nn.Module()
+        pipeline._lora_components = ["bagel"]
         pipeline.bagel = torch.nn.Module()
         lm = torch.nn.Module()
         lm.foo = _FakeLinearBase()
diff --git a/tests/diffusion/models/boogu_image/test_boogu_image_transformer.py b/tests/diffusion/models/boogu_image/test_boogu_image_transformer.py
index 43e2f12f4..32061f648 100644
--- a/tests/diffusion/models/boogu_image/test_boogu_image_transformer.py
+++ b/tests/diffusion/models/boogu_image/test_boogu_image_transformer.py
@@ -26,7 +26,9 @@ NORM_EPS = 1e-5
 def _init_distributed(request):
     """Initialize the minimal single-rank distributed environment required by
     the vLLM parallel linear layers (tensor-parallel group must exist)."""
-    if request.node.name.startswith("test_real_rotary_"):
+    if request.node.name.startswith(
+        ("test_real_rotary_", "test_packed_rope_table", "test_fused_qk_norm_rope", "test_fallback_with_no")
+    ):
         yield
         return
 
@@ -438,29 +440,86 @@ def test_transformer_rejects_prompt_tuning():
         BooguImageTransformer2DModel(od_config=_tiny_od_config(prompt_tuning_configs={"use_prompt_tuning": True}))
 
 
-def _native_to_checkpoint_name(name: str) -> str:
-    """Inverse of ``load_weights`` remapping: native param name -> diffusers name.
+_QKV_FANOUT = {
+    "to_qkv": ("to_q", "to_k", "to_v"),
+    "img_to_qkv": ("img_to_q", "img_to_k", "img_to_v"),
+    "instruct_to_qkv": ("instruct_to_q", "instruct_to_k", "instruct_to_v"),
+}
+
+
+def _native_to_checkpoint_weights(name: str, param: torch.Tensor) -> list[tuple[str, torch.Tensor]]:
+    """Inverse of ``load_weights`` remapping: native param -> diffusers weights.
+
+    The diffusers checkpoint stores fused projections as separate matrices, so a
+    single merged native param (QKV or FFN gate/up) fans out into several
+    checkpoint weights. Returns ``(diffusers_name, value)`` pairs whose values,
+    when fed through ``load_weights``, reassemble into the original ``param``.
 
     - ``.to_out.<suffix>`` -> ``.to_out.0.<suffix>`` (diffusers ModuleList wrap).
     - promoted joint-attention projections move back under ``.processor.``.
     """
+    q_size = NUM_HEADS * HEAD_DIM
+    kv_size = NUM_KV_HEADS * HEAD_DIM
+
+    # Fused QKV projections split back into per-matrix q/k/v weights.
+    for token, (q_name, k_name, v_name) in _QKV_FANOUT.items():
+        marker = f".{token}."
+        if marker in name:
+            q, k, v = param[:q_size], param[q_size : q_size + kv_size], param[q_size + kv_size :]
+            results = []
+            for sub_name, value in ((q_name, q), (k_name, k), (v_name, v)):
+                ckpt_name = name.replace(marker, f".{sub_name}.")
+                if token != "to_qkv":
+                    # Joint-attention projections live under `.processor.` upstream.
+                    ckpt_name = ckpt_name.replace(".img_instruct_attn.", ".img_instruct_attn.processor.")
+                results.append((ckpt_name, value))
+            return results
+
+    # Fused FFN gate/up splits into linear_1 (gate) / linear_3 (input).
+    if ".gate_up_proj." in name:
+        inner = param.shape[0] // 2
+        return [
+            (name.replace(".gate_up_proj.", ".linear_1."), param[:inner]),
+            (name.replace(".gate_up_proj.", ".linear_3."), param[inner:]),
+        ]
+
+    # Default: 1:1 with the existing diffusers name promotions.
     if ".to_out." in name:
         name = name.replace(".to_out.", ".to_out.0.")
-    for proj in (
-        "img_to_q",
-        "img_to_k",
-        "img_to_v",
-        "instruct_to_q",
-        "instruct_to_k",
-        "instruct_to_v",
-        "instruct_out",
-        "img_out",
-    ):
+    for proj in ("instruct_out", "img_out"):
         token = f".img_instruct_attn.{proj}."
         if token in name:
             name = name.replace(token, f".img_instruct_attn.processor.{proj}.")
             break
-    return name
+    return [(name, param)]
+
+
+def test_transformer_exposes_stacked_params_mapping():
+    """The packed -> sub-layer mapping must be discoverable from the module tree.
+
+    ``diffusion/lora/loader.py`` and the quantized weight loaders read
+    ``stacked_params_mapping`` off the model, so it has to exist before (and
+    independently of) ``load_weights``.
+    """
+    from vllm_omni.diffusion.models.boogu_image.boogu_image_transformer import (
+        _BOOGU_STACKED_PARAMS_MAPPING,
+        BooguImageTransformer2DModel,
+    )
+
+    model = BooguImageTransformer2DModel(od_config=_tiny_od_config())
+
+    assert tuple(model.stacked_params_mapping) == _BOOGU_STACKED_PARAMS_MAPPING
+    # A per-instance copy, so consumers cannot mutate the module constant.
+    assert model.stacked_params_mapping is not _BOOGU_STACKED_PARAMS_MAPPING
+
+    # Every entry is a (param, shard, shard_id) triple.
+    for param_name, shard_name, shard_id in model.stacked_params_mapping:
+        assert param_name.startswith(".") and shard_name.startswith(".")
+        assert shard_id in {"q", "k", "v", 0, 1}
+
+    # The mapping targets exactly the fused projections this port creates.
+    mapped_leaves = {param.strip(".").split(".")[-1] for param, _, _ in model.stacked_params_mapping}
+    assert mapped_leaves == {"to_qkv", "img_to_qkv", "instruct_to_qkv", "gate_up_proj"}
 
 
 def test_transformer_load_weights_round_trip():
@@ -471,24 +530,59 @@ def test_transformer_load_weights_round_trip():
     model = BooguImageTransformer2DModel(od_config=_tiny_od_config())
     native_params = dict(model.named_parameters())
 
-    # Build synthetic diffusers-named weights (one per native parameter).
-    checkpoint_weights = {}
+    # Build synthetic diffusers-named weights. Fused native projections fan out
+    # into the separate matrices the diffusers checkpoint stores.
+    expected: dict[str, torch.Tensor] = {}
+    checkpoint_weights: dict[str, torch.Tensor] = {}
     for native_name, param in native_params.items():
-        checkpoint_weights[_native_to_checkpoint_name(native_name)] = torch.randn_like(param)
+        full = torch.randn_like(param)
+        expected[native_name] = full
+        for ckpt_name, value in _native_to_checkpoint_weights(native_name, full):
+            checkpoint_weights[ckpt_name] = value
 
-    # The remapping must be a bijection over the parameter set.
-    assert len(checkpoint_weights) == len(native_params)
+    # Every checkpoint name is unique; merged params fan out to >=1 weight.
+    assert len(checkpoint_weights) >= len(native_params)
 
     loaded = model.load_weights(list(checkpoint_weights.items()))
 
     # No missing / unexpected parameters.
     assert loaded == set(native_params.keys())
 
-    # Values landed on the right parameters (TP=1: weight_loader copies verbatim).
+    # Values landed on the right parameters (TP=1: weight_loader copies verbatim;
+    # fused shards are placed at their q/k/v / gate/up offsets).
     reloaded = dict(model.named_parameters())
     for native_name in native_params:
-        expected = checkpoint_weights[_native_to_checkpoint_name(native_name)]
-        assert torch.allclose(reloaded[native_name], expected)
+        assert torch.allclose(reloaded[native_name], expected[native_name])
+
+
+def test_transformer_load_weights_rejects_partial_fused_params():
+    """A fused parameter must not count as loaded until all its shards arrive.
+
+    The loader compares parameter *names*, so reporting ``to_qkv`` complete
+    after a single ``to_q`` would let a checkpoint carrying only ``to_q`` start
+    up with the ``k``/``v`` slices left uninitialized.
+    """
+    from vllm_omni.diffusion.models.boogu_image.boogu_image_transformer import (
+        BooguImageTransformer2DModel,
+    )
+
+    model = BooguImageTransformer2DModel(od_config=_tiny_od_config())
+    native_params = dict(model.named_parameters())
+
+    complete_name = "noise_refiner.0.attn.to_qkv.weight"
+    partial_name = "noise_refiner.0.feed_forward.gate_up_proj.weight"
+    assert complete_name in native_params
+    assert partial_name in native_params
+
+    weights = list(_native_to_checkpoint_weights(complete_name, native_params[complete_name]))
+    # Only the gate half of the FFN, so its fused parameter stays incomplete.
+    gate_ckpt, gate_value = _native_to_checkpoint_weights(partial_name, native_params[partial_name])[0]
+    weights.append((gate_ckpt, gate_value))
+
+    loaded = model.load_weights(weights)
+
+    assert complete_name in loaded
+    assert partial_name not in loaded
 
 
 def test_transformer_load_weights_warns_for_unexpected_and_unloaded():
@@ -511,12 +605,15 @@ def test_transformer_load_weights_warns_for_unexpected_and_unloaded():
     try:
         model = BooguImageTransformer2DModel(od_config=_tiny_od_config())
         native_params = dict(model.named_parameters())
-        loaded_name = next(iter(native_params))
-        checkpoint_name = _native_to_checkpoint_name(loaded_name)
+        # A non-fused parameter, so one checkpoint entry loads it completely.
+        loaded_name = "x_embedder.weight"
+        assert loaded_name in native_params
+        (checkpoint_name, checkpoint_value), *_ = _native_to_checkpoint_weights(loaded_name, native_params[loaded_name])
+        checkpoint_value = torch.randn_like(checkpoint_value)
 
         loaded = model.load_weights(
             [
-                (checkpoint_name, torch.randn_like(native_params[loaded_name])),
+                (checkpoint_name, checkpoint_value),
                 ("unexpected.weight", torch.ones(1)),
             ]
         )
@@ -600,3 +697,152 @@ def test_transformer_forward_ti2i_shape():
 
     assert out.shape == (batch_size, model.out_channels, latent_h, latent_w)
     assert torch.isfinite(out).all()
+
+
+# ---------------------------------------------------------------------------
+# The three tests below are for the fused qk-norm+RoPE kernel's wiring into
+# this transformer: the packed-table layout conversion, the fused path against
+# the previous eager chain, and the fallback when no packed table is present.
+# They need CUDA (the module-level marks are CPU; these add the cuda mark and
+# skip on CPU-only runners) and real Boogu geometry rather than the mock dims
+# above.
+# ---------------------------------------------------------------------------
+
+_FUSED_HEAD_DIM = 120
+_FUSED_Q_HEADS = 28
+_FUSED_KV_HEADS = 7
+_FUSED_EPS = 1e-5
+
+
+def _fused_rotary_pair(tokens: int):
+    theta = torch.randn(1, tokens, _FUSED_HEAD_DIM // 2, device="cuda", dtype=torch.float32)
+    return (
+        torch.cos(theta).repeat_interleave(2, dim=-1),
+        torch.sin(theta).repeat_interleave(2, dim=-1),
+    )
+
+
+def _fused_norms():
+    from vllm.config import VllmConfig, set_current_vllm_config
+    from vllm.model_executor.layers.layernorm import RMSNorm
+
+    with set_current_vllm_config(VllmConfig()):
+        norm_q = RMSNorm(_FUSED_HEAD_DIM, eps=_FUSED_EPS).cuda().to(torch.bfloat16)
+        norm_k = RMSNorm(_FUSED_HEAD_DIM, eps=_FUSED_EPS).cuda().to(torch.bfloat16)
+    with torch.no_grad():
+        norm_q.weight.copy_(torch.randn(_FUSED_HEAD_DIM))
+        norm_k.weight.copy_(torch.randn(_FUSED_HEAD_DIM))
+    return norm_q, norm_k
+
+
+def _operand_ulp_bound(x, weight, cos, sin):
+    """One bf16 rounding of a normalized operand, propagated through RoPE."""
+    import torch.nn.functional as F
+
+    n = F.rms_norm(x, (_FUSED_HEAD_DIM,), weight, _FUSED_EPS).float().abs()
+    c = cos[..., ::2].float().abs().unsqueeze(2)
+    s = sin[..., ::2].float().abs().unsqueeze(2)
+    even_mag = n[..., ::2] * c + n[..., 1::2] * s
+    odd_mag = n[..., ::2] * s + n[..., 1::2] * c
+    return 2.0**-6 * torch.stack((even_mag, odd_mag), dim=-1).flatten(-2) + 1e-6
+
+
+@pytest.mark.cuda
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA required")
+def test_packed_rope_table_layout(monkeypatch):
+    from vllm_omni.diffusion.models.boogu_image.boogu_image_transformer import (
+        _with_packed_rope_table,
+    )
+
+    monkeypatch.delenv("VLLM_OMNI_FUSED_QK_NORM_ROPE_MIN_TOKENS", raising=False)
+    torch.manual_seed(0)
+    tokens = 2311  # above _FUSED_MIN_TOKENS
+    cos, sin = _fused_rotary_pair(tokens)
+    out = _with_packed_rope_table((cos, sin))
+    assert len(out) == 3
+    assert out[0] is cos and out[1] is sin
+    packed = out[2]
+    assert packed.shape == (tokens, _FUSED_HEAD_DIM)
+    assert packed.dtype == torch.float32 and packed.is_contiguous()
+    half = _FUSED_HEAD_DIM // 2
+    assert torch.equal(packed[:, :half], cos[0, :, ::2])
+    assert torch.equal(packed[:, half:], sin[0, :, ::2])
+    # Below _FUSED_MIN_TOKENS the tuple passes through unchanged (host-bound
+    # regime: the fused path would cost more than it saves).
+    short = _with_packed_rope_table(_fused_rotary_pair(17))
+    assert len(short) == 2
+
+
+@pytest.mark.cuda
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA required")
+def test_fused_qk_norm_rope_matches_eager_chain():
+    """The fused path vs the previous eager chain at real Boogu shapes.
+
+    Every element must sit within one bf16 ulp of a normalized operand
+    propagated through the rotation (the two paths legitimately differ by
+    single- vs double-rounding of the norm's weight multiply).
+    """
+    from vllm.triton_utils import HAS_TRITON
+
+    if not HAS_TRITON:
+        pytest.skip("Triton required")
+    from vllm_omni.diffusion.models.boogu_image.boogu_image_transformer import (
+        _qk_norm_rope,
+        _with_packed_rope_table,
+    )
+
+    torch.manual_seed(0)
+    norm_q, norm_k = _fused_norms()
+    q = torch.randn(1, 4139, _FUSED_Q_HEADS, _FUSED_HEAD_DIM, device="cuda", dtype=torch.bfloat16)
+    k = torch.randn(1, 4139, _FUSED_KV_HEADS, _FUSED_HEAD_DIM, device="cuda", dtype=torch.bfloat16)
+    cos, sin = _fused_rotary_pair(4139)
+    with_table = _with_packed_rope_table((cos, sin))
+
+    fused = _qk_norm_rope(q, k, norm_q, norm_k, with_table, torch.bfloat16)
+    eager = _qk_norm_rope(q, k, norm_q, norm_k, (cos, sin), torch.bfloat16)
+    for fused_t, eager_t, x, w in zip(fused, eager, (q, k), (norm_q.weight, norm_k.weight)):
+        bound = _operand_ulp_bound(x, w, cos, sin)
+        diff = (fused_t.float() - eager_t.float()).abs()
+        assert (diff <= bound).all(), "fused path beyond one operand ulp of the eager chain"
+
+
+@pytest.mark.cuda
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA required")
+def test_fallback_with_no_packed_table():
+    """Without a packed table the helper is bit-exact to the old chain."""
+    from vllm_omni.diffusion.models.boogu_image.boogu_image_transformer import (
+        _qk_norm_rope,
+        apply_rotary_emb,
+    )
+
+    torch.manual_seed(0)
+    norm_q, norm_k = _fused_norms()
+    q = torch.randn(1, 64, _FUSED_Q_HEADS, _FUSED_HEAD_DIM, device="cuda", dtype=torch.bfloat16)
+    k = torch.randn(1, 64, _FUSED_KV_HEADS, _FUSED_HEAD_DIM, device="cuda", dtype=torch.bfloat16)
+    cos, sin = _fused_rotary_pair(64)
+
+    out_q, out_k = _qk_norm_rope(q, k, norm_q, norm_k, (cos, sin), torch.bfloat16)
+    ref_q = apply_rotary_emb(norm_q(q), (cos, sin)).to(torch.bfloat16)
+    ref_k = apply_rotary_emb(norm_k(k), (cos, sin)).to(torch.bfloat16)
+    assert torch.equal(out_q, ref_q)
+    assert torch.equal(out_k, ref_k)
+
+
+def test_packed_rope_table_env_override(monkeypatch):
+    """VLLM_OMNI_FUSED_QK_NORM_ROPE_MIN_TOKENS steers the packing gate: 0 packs
+    even a 43-token table, a huge value leaves a 4139-token table untouched,
+    unset keeps the 2048 default routing."""
+    from vllm_omni.diffusion.models.boogu_image.boogu_image_transformer import (
+        _with_packed_rope_table,
+    )
+
+    env = "VLLM_OMNI_FUSED_QK_NORM_ROPE_MIN_TOKENS"
+    short, long = _identity_rotary_emb(1, 43), _identity_rotary_emb(1, 4139)
+
+    monkeypatch.setenv(env, "0")
+    assert len(_with_packed_rope_table(short)) == 3
+    monkeypatch.setenv(env, str(10**9))
+    assert _with_packed_rope_table(long) is long
+    monkeypatch.delenv(env)
+    assert len(_with_packed_rope_table(long)) == 3
+    assert _with_packed_rope_table(short) is short
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/cosmos3/test_cosmos3_framework_compat.py b/tests/diffusion/models/cosmos3/test_cosmos3_framework_compat.py
new file mode 100644
index 000000000..25f06b7a9
--- /dev/null
+++ b/tests/diffusion/models/cosmos3/test_cosmos3_framework_compat.py
@@ -0,0 +1,144 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+from importlib.util import find_spec
+
+import pytest
+import torch
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+_FRAMEWORK_AVAILABLE = find_spec("cosmos_framework") is not None
+requires_cosmos_framework = pytest.mark.skipif(
+    not _FRAMEWORK_AVAILABLE,
+    reason="cosmos_framework source is not present on PYTHONPATH",
+)
+
+
+def test_framework_preflight_checks_every_policy_symbol(monkeypatch) -> None:
+    from vllm_omni.diffusion.models.cosmos3 import utils as cosmos3_utils
+
+    imported = []
+
+    def record_import(module_name: str, symbol_name: str, error_message: str):
+        imported.append((module_name, symbol_name, error_message))
+        return object()
+
+    monkeypatch.setattr(cosmos3_utils, "lazy_import", record_import)
+
+    cosmos3_utils.preflight_cosmos3_action_framework_imports()
+
+    expected_symbols = {
+        "ActionTransformPipeline",
+        "FlowUniPCMultistepScheduler",
+        "build_abs_pose_from_components",
+        "convert_rotation",
+        "get_domain_id",
+        "pose_abs_to_rel",
+        "pose_rel_to_abs",
+    }
+    assert {symbol_name for _, symbol_name, _ in imported} == expected_symbols
+    assert [(module_name, symbol_name) for module_name, symbol_name, _ in imported] == list(
+        cosmos3_utils._ROBOLAB_FRAMEWORK_IMPORTS.values()
+    )
+
+
+def test_lazy_import_reports_framework_symbol_skew(monkeypatch) -> None:
+    from vllm_omni.diffusion.models.cosmos3 import utils as cosmos3_utils
+
+    monkeypatch.setattr(cosmos3_utils, "import_module", lambda _module_name: object())
+
+    with pytest.raises(ImportError, match="MissingSymbol") as exc_info:
+        cosmos3_utils.lazy_import(
+            "cosmos_framework.fake_module",
+            "MissingSymbol",
+            "Cosmos Framework compatibility error.",
+        )
+
+    assert isinstance(exc_info.value.__cause__, AttributeError)
+
+
+@requires_cosmos_framework
+def test_action_domain_table_matches_current_framework_and_legacy_aliases() -> None:
+    from cosmos_framework.data.generator.action.utils.domain_utils import (
+        EMBODIMENT_TO_DOMAIN_ID as FRAMEWORK_DOMAIN_IDS,
+    )
+
+    from vllm_omni.diffusion.models.cosmos3.action import EMBODIMENT_TO_DOMAIN_ID as VLLM_DOMAIN_IDS
+    from vllm_omni.diffusion.models.cosmos3.utils import _LEGACY_EMBODIMENT_ALIASES
+
+    canonical_vllm_domain_ids = {
+        name: domain_id for name, domain_id in VLLM_DOMAIN_IDS.items() if name not in _LEGACY_EMBODIMENT_ALIASES
+    }
+
+    assert canonical_vllm_domain_ids == FRAMEWORK_DOMAIN_IDS
+    assert {alias: VLLM_DOMAIN_IDS[alias] for alias in _LEGACY_EMBODIMENT_ALIASES} == {
+        alias: FRAMEWORK_DOMAIN_IDS[canonical_name] for alias, canonical_name in _LEGACY_EMBODIMENT_ALIASES.items()
+    }
+
+
+@requires_cosmos_framework
+def test_current_cosmos_framework_policy_modules_import_and_instantiate() -> None:
+    from cosmos_framework.data.generator.action.utils.domain_utils import get_domain_id
+    from cosmos_framework.data.generator.action.utils.pose_utils import (
+        build_abs_pose_from_components,
+        convert_rotation,
+        pose_abs_to_rel,
+        pose_rel_to_abs,
+    )
+    from cosmos_framework.data.generator.action.utils.transforms import ActionTransformPipeline
+    from cosmos_framework.model.generator.diffusion.samplers.fm_solvers_unipc import (
+        FlowUniPCMultistepScheduler,
+    )
+
+    transform = ActionTransformPipeline(
+        max_action_dim=64,
+        cfg_dropout_rate=0.0,
+        format_prompt_as_json=True,
+    )
+    scheduler = FlowUniPCMultistepScheduler(
+        num_train_timesteps=1000,
+        shift=1.0,
+        use_dynamic_shifting=False,
+    )
+    scheduler.set_timesteps(4, device=torch.device("cpu"), shift=5.0)
+
+    assert transform.prompt_json_formatter is not None
+    assert len(scheduler.timesteps) == 4
+    assert get_domain_id("droid_lerobot") == 8
+    assert convert_rotation([0.0, 0.0, 0.0, 1.0], "quat_xyzw", "rot6d").shape == (6,)
+    assert callable(pose_abs_to_rel)
+    assert callable(pose_rel_to_abs)
+    assert callable(build_abs_pose_from_components)
+
+
+@requires_cosmos_framework
+def test_real_action_transform_pipeline_matches_droid_policy_contract() -> None:
+    from cosmos_framework.data.generator.action.utils.transforms import ActionTransformPipeline
+
+    transform = ActionTransformPipeline(
+        max_action_dim=64,
+        cfg_dropout_rate=0.0,
+        format_prompt_as_json=True,
+    )
+    sample = {
+        "ai_caption": "Pick up the cube.",
+        "video": torch.zeros((3, 3, 192, 320), dtype=torch.uint8),
+        "action": torch.zeros((3, 8), dtype=torch.float32),
+        "conditioning_fps": torch.tensor(15, dtype=torch.long),
+        "mode": "wam",
+        "domain_id": torch.tensor(8, dtype=torch.long),
+        "viewpoint": "concat_view",
+        "additional_view_description": "Wrist view above two exterior views.",
+    }
+
+    transformed = transform(sample, "256")
+
+    assert isinstance(transformed["ai_caption"], dict)
+    assert transformed["action"].shape == (3, 64)
+    assert int(transformed["raw_action_dim"].item()) == 8
+    assert transformed["sequence_plan"].has_action is True
+    assert transformed["mode"] == "wam"
+    assert int(transformed["domain_id"].item()) == 8
diff --git a/tests/diffusion/models/cosmos3/test_cosmos3_pipeline.py b/tests/diffusion/models/cosmos3/test_cosmos3_pipeline.py
index 72e4ab962..e73dd7ff6 100644
--- a/tests/diffusion/models/cosmos3/test_cosmos3_pipeline.py
+++ b/tests/diffusion/models/cosmos3/test_cosmos3_pipeline.py
@@ -1,13 +1,16 @@
 # 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 json
 import sys
 import types
+from contextlib import contextmanager
 from dataclasses import dataclass
 from types import SimpleNamespace
 from typing import Any
+from unittest.mock import Mock
 
 import numpy as np
 import pytest
@@ -21,6 +24,20 @@ from vllm_omni.experimental.world_models.session_state import SessionStateManage
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
 
 
+@pytest.mark.parametrize(
+    ("alias", "canonical_name"),
+    [
+        ("galbot", "embodiment_b"),
+        ("agibot_gear_gripper", "embodiment_c_gripper"),
+        ("agibot_gear_gripper_ext", "embodiment_c_gripper_ext"),
+    ],
+)
+def test_action_domain_table_preserves_legacy_aliases(alias: str, canonical_name: str) -> None:
+    from vllm_omni.diffusion.models.cosmos3.action import resolve_domain_id
+
+    assert resolve_domain_id(domain_name=alias) == resolve_domain_id(domain_name=canonical_name)
+
+
 def test_pipeline_declares_layerwise_offload_components() -> None:
     from vllm_omni.diffusion.models.cosmos3.pipeline_cosmos3 import Cosmos3OmniDiffusersPipeline
 
@@ -69,6 +86,7 @@ class StubScheduler:
         flow_shift: float = 1.0,
     ) -> None:
         self.timesteps = torch.tensor(timesteps or [9, 3], dtype=torch.int64)
+        self.sigmas = self.timesteps.float() / 10
         self.config = SimpleNamespace(
             num_train_timesteps=1000,
             flow_shift=flow_shift,
@@ -97,6 +115,7 @@ class StubScheduler:
         else:
             assert num_inference_steps is not None
             self.timesteps = torch.arange(num_inference_steps, 0, -1, dtype=torch.int64, device=device)
+        self.sigmas = self.timesteps.float()
 
     def step(self, noise_pred: torch.Tensor, timestep: torch.Tensor, latents: torch.Tensor, **kwargs):
         del kwargs
@@ -234,7 +253,7 @@ def passthrough_progress_bar(iterable):
 
 @pytest.fixture(autouse=True)
 def fake_cosmos3_guardrails(monkeypatch: pytest.MonkeyPatch):
-    module = types.ModuleType("vllm_omni.diffusion.models.cosmos3.guardrails")
+    module: Any = types.ModuleType("vllm_omni.diffusion.models.cosmos3.guardrails")
     module.is_guardrails_enabled = lambda od_config, sampling_params=None: False
     module.ensure_initialized = lambda od_config: None
     module.check_text_safety = lambda text: None
@@ -267,6 +286,8 @@ def make_cosmos3_pipeline():
         pipeline.is_edge_model = False
         pipeline._guidance_scale = None
         pipeline._num_timesteps = None
+        pipeline._current_step_index = None
+        pipeline._current_sigma = None
         pipeline._cosmos3_branch_caches = None
         pipeline._cache_dit_requires_paired_cfg = False
         pipeline._sound_tokenizer = None
@@ -284,7 +305,7 @@ def sequential_cfg_parallel(monkeypatch: pytest.MonkeyPatch) -> None:
 
 
 def make_sampling_params(**overrides: Any) -> SimpleNamespace:
-    values = {
+    values: dict[str, Any] = {
         "height": None,
         "width": None,
         "num_frames": None,
@@ -361,23 +382,31 @@ def _capture_tokenize_calls(pipeline: Any) -> list[dict[str, Any]]:
 
 
 @pytest.mark.parametrize(
-    ("provided", "value", "default", "is_distilled", "expected"),
+    ("provided", "value", "default", "is_distilled", "expected", "expected_warning"),
     [
-        (False, 1.0, 7.0, False, 7.0),
-        (True, 1.0, 7.0, False, 1.0),
-        (True, 4.5, 7.0, False, 4.5),
-        (False, 1.0, 7.0, True, 1.0),
-        (True, 4.5, 7.0, True, 1.0),
+        (False, 1.0, 7.0, False, 7.0, False),
+        (True, 1.0, 7.0, False, 1.0, False),
+        (True, 4.5, 7.0, False, 4.5, False),
+        (False, 1.0, 7.0, True, 1.0, False),
+        (True, 1.0, 7.0, True, 1.0, False),
+        (True, 4.5, 7.0, True, 1.0, True),
+        (True, 0.0, 7.0, True, 1.0, True),
     ],
 )
 def test_resolve_guidance_scale(
     make_cosmos3_pipeline,
+    monkeypatch: pytest.MonkeyPatch,
     provided: bool,
     value: float,
     default: float,
     is_distilled: bool,
     expected: float,
+    expected_warning: bool,
 ) -> None:
+    from vllm_omni.diffusion.models.cosmos3 import pipeline_cosmos3
+
+    warning_once = Mock()
+    monkeypatch.setattr(pipeline_cosmos3.logger, "warning_once", warning_once)
     pipeline = make_cosmos3_pipeline()
     pipeline.is_distilled_model = is_distilled
     sp = make_sampling_params(
@@ -386,6 +415,12 @@ def test_resolve_guidance_scale(
     )
 
     assert pipeline._resolve_guidance_scale(sp, default) == expected
+    if expected_warning:
+        warning_once.assert_called_once()
+        assert "overridden to 1.0" in warning_once.call_args.args[0]
+        assert "negative_prompt does not affect generation" in warning_once.call_args.args[0]
+    else:
+        warning_once.assert_not_called()
 
 
 def test_distilled_generation_accepts_t2i_and_i2v(make_cosmos3_pipeline) -> None:
@@ -479,6 +514,69 @@ def test_forward_threads_request_id_to_robolab(make_cosmos3_pipeline) -> None:
     assert captured["session_id"] == "robolab-request-7"
 
 
+@pytest.mark.parametrize("format_prompt_as_json", [False, True])
+def test_robolab_input_builder_threads_prompt_format_and_uses_wam(
+    make_cosmos3_pipeline,
+    monkeypatch: pytest.MonkeyPatch,
+    format_prompt_as_json: bool,
+) -> None:
+    from vllm_omni.diffusion.models.cosmos3 import pipeline_cosmos3
+
+    pipeline = make_cosmos3_pipeline()
+    pipeline.transformer = StubCosmos3Transformer(action_gen=True, action_dim=64)
+    captured: dict[str, Any] = {}
+
+    def fake_transform(sample, resolution):
+        captured["sample_mode"] = sample["mode"]
+        captured["resolution"] = resolution
+        sample["sequence_plan"] = SimpleNamespace(
+            condition_frame_indexes_action=[0],
+            action_start_frame_offset=1,
+        )
+        sample["raw_action_dim"] = torch.tensor(8)
+        sample["image_size"] = torch.tensor([16, 16, 16, 16])
+        if format_prompt_as_json:
+            sample["ai_caption"] = {"actions": {"instruction": sample["ai_caption"]}}
+        return sample
+
+    def fake_get_transform(*, format_prompt_as_json: bool):
+        captured["format_prompt_as_json"] = format_prompt_as_json
+        return fake_transform
+
+    pipeline._get_robolab_transform = fake_get_transform
+    monkeypatch.setattr(pipeline_cosmos3, "get_robolab_domain_id", lambda name: 8)
+    obs = {
+        "prompt": "Pick up the cube.",
+        "observation/image": np.zeros((16, 16, 3), dtype=np.uint8),
+        "observation/joint_position": np.zeros(7, dtype=np.float32),
+        "observation/gripper_position": np.zeros(1, dtype=np.float32),
+    }
+    sampling_params = make_sampling_params(
+        extra_args={
+            "robot_obs": obs,
+            "action_chunk_size": 2,
+            "image_height": 16,
+            "image_width": 16,
+            "format_prompt_as_json": format_prompt_as_json,
+        }
+    )
+
+    inputs = pipeline._build_robolab_policy_inputs(sampling_params, request_id="request-1")
+
+    assert inputs is not None
+    assert captured == {
+        "sample_mode": "wam",
+        "resolution": "480",
+        "format_prompt_as_json": format_prompt_as_json,
+    }
+    assert inputs.domain_id == 8
+    assert inputs.raw_action_dim == 8
+    if format_prompt_as_json:
+        assert json.loads(inputs.prompt) == {"actions": {"instruction": "Pick up the cube."}}
+    else:
+        assert inputs.prompt == "Pick up the cube."
+
+
 @pytest.mark.parametrize(
     ("prompt", "sampling_params", "message"),
     [
@@ -657,6 +755,7 @@ def _make_od_config(
         custom_pipeline_args={},
         model_config=model_config or {},
         tf_model_config=tf_model_config,
+        parallel_config=SimpleNamespace(cfg_parallel_size=1, ulysses_degree=1),
     )
 
 
@@ -692,6 +791,7 @@ def test_pipeline_init_uses_flow_unipc_with_cosmos3_defaults(stub_real_pipeline_
     assert pipeline._engine_init_flow_shift == 2.5
 
 
+@pytest.mark.parametrize("cfg_parallel_size,ulysses_degree", [(1, 1), (1, 2), (2, 1), (2, 2)])
 @pytest.mark.parametrize(
     ("scheduler_class_name", "expected_distilled"),
     [
@@ -705,6 +805,8 @@ def test_pipeline_resolves_scheduler_class_from_checkpoint_file(
     monkeypatch: pytest.MonkeyPatch,
     scheduler_class_name: str,
     expected_distilled: bool,
+    cfg_parallel_size: int,
+    ulysses_degree: int,
 ) -> None:
     import json
 
@@ -717,7 +819,7 @@ def test_pipeline_resolves_scheduler_class_from_checkpoint_file(
     t_list = [1.0, 0.75, 0.5, 0.25]
     scheduler_dir = tmp_path / "scheduler"
     scheduler_dir.mkdir()
-    scheduler_config = {"_class_name": scheduler_class_name}
+    scheduler_config: dict[str, Any] = {"_class_name": scheduler_class_name}
     if expected_distilled:
         scheduler_config["fixed_step_sampler_config"] = {"sample_type": "sde", "t_list": t_list}
     (scheduler_dir / "scheduler_config.json").write_text(json.dumps(scheduler_config))
@@ -753,6 +855,20 @@ def test_pipeline_resolves_scheduler_class_from_checkpoint_file(
 
     od_config = _make_od_config(sound_gen=False)
     od_config.model = str(tmp_path)
+    od_config.parallel_config.cfg_parallel_size = cfg_parallel_size
+    od_config.parallel_config.ulysses_degree = ulysses_degree
+    if expected_distilled and cfg_parallel_size > 1:
+        monkeypatch.setattr(
+            pipeline_cosmos3.AutoTokenizer,
+            "from_pretrained",
+            lambda *args, **kwargs: pytest.fail("component loading must not start for distilled CFG parallelism"),
+        )
+        with pytest.raises(ValueError, match="Set --cfg-parallel-size 1 and use --ulysses-degree"):
+            Cosmos3OmniDiffusersPipeline(od_config=od_config)
+        assert StubFlowMatchScheduler.from_config_calls == []
+        assert StubFlowUniPCScheduler.from_config_calls == []
+        return
+
     pipeline = Cosmos3OmniDiffusersPipeline(od_config=od_config)
 
     assert pipeline.is_distilled_model is expected_distilled
@@ -1420,7 +1536,7 @@ def test_ir_op_priority_hook_preserves_platform_fields(monkeypatch: pytest.Monke
         fused_add_rms_norm: list[str]
         custom_op: list[str]
 
-    fake_kernel = types.ModuleType("vllm.config.kernel")
+    fake_kernel: Any = types.ModuleType("vllm.config.kernel")
     fake_kernel.IrOpPriorityConfig = FakeIrOpPriorityConfig
     monkeypatch.setitem(sys.modules, fake_kernel.__name__, fake_kernel)
 
@@ -2043,6 +2159,47 @@ def test_diffuse_covers_cfg_i2v_and_multimodal_steps(make_cosmos3_pipeline) -> N
     torch.testing.assert_close(action_result, torch.full((), 44.0).expand_as(action_result))
 
 
+def test_diffuse_publishes_exact_seacache_metadata_and_cfg_contexts(make_cosmos3_pipeline) -> None:
+    pipeline = make_cosmos3_pipeline()
+    pipeline.scheduler.sigmas = torch.tensor([0.91, 0.17])
+    observations: list[tuple[str, int | None, float | None, int | None]] = []
+
+    class RecordingHook:
+        @contextmanager
+        def cache_context(self, name: str):
+            sigma = pipeline.current_sigma
+            observations.append(
+                (
+                    name,
+                    pipeline.current_step_index,
+                    None if sigma is None else float(sigma),
+                    pipeline.num_timesteps,
+                )
+            )
+            yield
+
+    pipeline._cache_context_factory = RecordingHook().cache_context
+    pipeline.diffuse(
+        latents=torch.zeros(1, 2, 1, 1, 1),
+        timesteps=torch.tensor([900, 100]),
+        cond_ids=_ids(2),
+        cond_mask=_mask(),
+        uncond_ids=_ids(1),
+        uncond_mask=_mask(),
+        guidance_scale=3.0,
+        shared_kwargs={"video_shape": (1, 1, 1), "fps": 24.0},
+    )
+
+    assert observations == [
+        ("cond", 0, pytest.approx(0.91), 2),
+        ("uncond", 0, pytest.approx(0.91), 2),
+        ("cond", 1, pytest.approx(0.17), 2),
+        ("uncond", 1, pytest.approx(0.17), 2),
+    ]
+    assert pipeline.current_step_index is None
+    assert pipeline.current_sigma is None
+
+
 def test_diffuse_drops_session_when_progress_iteration_fails(make_cosmos3_pipeline) -> None:
     pipeline = make_cosmos3_pipeline()
     pipeline._use_session_state = True
@@ -2102,6 +2259,53 @@ def test_diffuse_transfer_applies_control_cfg(make_cosmos3_pipeline, sequential_
     torch.testing.assert_close(result, torch.full_like(latents, 254.0))
 
 
+def test_diffuse_transfer_uses_named_seacache_contexts(make_cosmos3_pipeline, sequential_cfg_parallel) -> None:
+    pipeline = make_cosmos3_pipeline()
+    pipeline.scheduler.sigmas = torch.tensor([0.42])
+    contexts: list[tuple[str, int | None, float | None, int | None]] = []
+
+    class RecordingHook:
+        @contextmanager
+        def cache_context(self, name: str):
+            sigma = pipeline.current_sigma
+            contexts.append(
+                (
+                    name,
+                    pipeline.current_step_index,
+                    None if sigma is None else float(sigma),
+                    pipeline.num_timesteps,
+                )
+            )
+            yield
+
+    pipeline._cache_context_factory = RecordingHook().cache_context
+    latents = torch.zeros(1, 2, 1, 1, 1)
+    velocity_mask = torch.ones(1, 1, 1, 1, 1)
+    pipeline.diffuse_transfer(
+        latents=latents,
+        timesteps=torch.tensor([7]),
+        cond_ids=_ids(2),
+        cond_mask=_mask(),
+        uncond_ids=_ids(1),
+        uncond_mask=_mask(),
+        guidance_scale=3.0,
+        control_guidance=1.5,
+        control_guidance_interval=None,
+        control_latents=[torch.zeros_like(latents)],
+        shared_kwargs={"video_shape": (1, 1, 1), "fps": 24.0, "noisy_frame_mask": velocity_mask},
+        velocity_mask=velocity_mask,
+        condition_latents=torch.zeros_like(latents),
+    )
+
+    assert contexts == [
+        ("cond", 0, pytest.approx(0.42), 1),
+        ("cond_no_control", 0, pytest.approx(0.42), 1),
+        ("uncond", 0, pytest.approx(0.42), 1),
+    ]
+    assert pipeline.current_step_index is None
+    assert pipeline.current_sigma is None
+
+
 def test_diffuse_transfer_rejects_session_state_manager(make_cosmos3_pipeline) -> None:
     pipeline = make_cosmos3_pipeline()
     pipeline._use_session_state = True
@@ -2472,7 +2676,7 @@ def test_diffuse_keeps_paired_cfg_when_cache_dit_active(make_cosmos3_pipeline) -
 
 class TestForwardRouting:
     def _install_forward_stubs(self, pipeline):
-        captured: dict[str, object] = {"diffuse_calls": [], "prepare_calls": []}
+        captured: dict[str, Any] = {"diffuse_calls": [], "prepare_calls": []}
 
         def fake_format(
             prompt,
diff --git a/tests/diffusion/models/cosmos3/test_cosmos3_transformer.py b/tests/diffusion/models/cosmos3/test_cosmos3_transformer.py
index 44bd8e9a7..de14ee233 100644
--- a/tests/diffusion/models/cosmos3/test_cosmos3_transformer.py
+++ b/tests/diffusion/models/cosmos3/test_cosmos3_transformer.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
 
@@ -513,6 +513,108 @@ def test_forward_returns_video_prediction(monkeypatch: pytest.MonkeyPatch) -> No
     assert tuple(output.shape) == (1, 2, 1, 2, 2)
 
 
+def test_cache_execution_residual_spans_final_gen_norm(monkeypatch: pytest.MonkeyPatch) -> None:
+    from vllm_omni.diffusion.cache.teacache.extractors import extract_cosmos3_context
+    from vllm_omni.diffusion.models.cosmos3 import transformer_cosmos3
+
+    class TrackingNorm(nn.Module):
+        def __init__(self) -> None:
+            super().__init__()
+            self.calls = 0
+
+        def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+            self.calls += 1
+            return hidden_states + 5.0
+
+    monkeypatch.setattr(transformer_cosmos3, "_get_ulysses_state", lambda: (1, 0, None))
+    model = transformer_cosmos3.Cosmos3VFMTransformer(
+        SimpleNamespace(tf_model_config=_tiny_cosmos3_config(), dtype=torch.float32)
+    )
+    norm = TrackingNorm()
+    model.norm_moe_gen = norm
+    captured: dict[str, torch.Tensor] = {}
+
+    def run_gen_layers(hidden_gen: torch.Tensor, **kwargs) -> torch.Tensor:
+        del kwargs
+        captured["input"] = hidden_gen.detach().clone()
+        return hidden_gen + 2.0
+
+    monkeypatch.setattr(model, "_run_gen_layers", run_gen_layers)
+    forward_kwargs = {
+        "hidden_states": torch.zeros(1, 2, 1, 2, 2),
+        "timestep": torch.tensor([1.0]),
+        "text_ids": torch.tensor([[1, 2]], dtype=torch.long),
+        "text_mask": torch.ones(1, 2, dtype=torch.long),
+        "video_shape": (1, 2, 2),
+        "fps": 24.0,
+    }
+
+    full_output = model(**forward_kwargs)
+
+    assert norm.calls == 1
+    norm.calls = 0
+
+    ctx = extract_cosmos3_context(model, **forward_kwargs)
+    execution_input = ctx.hidden_states.detach().clone()
+    execution_output = ctx.run_transformer_blocks()[0]
+    residual = execution_output - execution_input
+    extracted_output = ctx.postprocess(execution_output)
+
+    assert norm.calls == 1
+    expected_residual = ((captured["input"] + 2.0) + 5.0) - captured["input"]
+    assert torch.equal(residual, expected_residual)
+    assert torch.equal(extracted_output, full_output)
+
+    norm.calls = 0
+
+    def fail_if_gen_layers_run(*args, **kwargs):
+        del args, kwargs
+        raise AssertionError("SeaCache hit unexpectedly executed GEN layers")
+
+    monkeypatch.setattr(model, "_run_gen_layers", fail_if_gen_layers_run)
+
+    cached_ctx = extract_cosmos3_context(model, **forward_kwargs)
+    cached_output = cached_ctx.postprocess(cached_ctx.hidden_states + residual)
+
+    assert norm.calls == 0
+    assert torch.equal(cached_output, full_output)
+    for name in ("_seacache_skip", "_seacache_record", "_seacache_residual", "_seacache_last_residual"):
+        assert not hasattr(model, name)
+
+
+def test_no_cache_still_runs_final_gen_norm_once(monkeypatch: pytest.MonkeyPatch) -> None:
+    from vllm_omni.diffusion.models.cosmos3 import transformer_cosmos3
+
+    class CountingNorm(nn.Module):
+        def __init__(self, original: nn.Module) -> None:
+            super().__init__()
+            self.original = original
+            self.calls = 0
+
+        def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+            self.calls += 1
+            return self.original(hidden_states)
+
+    monkeypatch.setattr(transformer_cosmos3, "_get_ulysses_state", lambda: (1, 0, None))
+    model = transformer_cosmos3.Cosmos3VFMTransformer(
+        SimpleNamespace(tf_model_config=_tiny_cosmos3_config(), dtype=torch.float32)
+    )
+    norm = CountingNorm(model.norm_moe_gen)
+    model.norm_moe_gen = norm
+
+    output = model(
+        hidden_states=torch.zeros(1, 2, 1, 2, 2),
+        timestep=torch.tensor([1.0]),
+        text_ids=torch.tensor([[1, 2]], dtype=torch.long),
+        text_mask=torch.ones(1, 2, dtype=torch.long),
+        video_shape=(1, 2, 2),
+        fps=24.0,
+    )
+
+    assert norm.calls == 1
+    assert tuple(output.shape) == (1, 2, 1, 2, 2)
+
+
 def test_qwen_gen_mlp_remains_gated() -> None:
     from vllm_omni.diffusion.models.cosmos3.transformer_cosmos3 import Cosmos3GatedMLP, Cosmos3VFMTransformer
 
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/flux2/test_flux2_transformer_tp.py b/tests/diffusion/models/flux2/test_flux2_transformer_tp.py
index c935871a0..489a948d5 100644
--- a/tests/diffusion/models/flux2/test_flux2_transformer_tp.py
+++ b/tests/diffusion/models/flux2/test_flux2_transformer_tp.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 import pytest
 import torch
 from pytest_mock import MockerFixture
@@ -265,7 +268,7 @@ class TestFlux2TransformerLayerwiseOffload:
         ]
 
     def test_get_blocks_from_dit(self):
-        from vllm_omni.diffusion.offloader.layerwise_backend import LayerWiseOffloadBackend
+        from vllm_omni.diffusion.offloader.block_discovery import get_blocks_from_dit
 
         # Block discovery only needs the ModuleList structure, not production dims.
         model = Flux2Transformer2DModel(
@@ -275,6 +278,6 @@ class TestFlux2TransformerLayerwiseOffload:
             attention_head_dim=4,
             joint_attention_dim=16,
         )
-        attr_names, blocks = LayerWiseOffloadBackend.get_blocks_from_dit(model)
+        attr_names, blocks = get_blocks_from_dit(model)
         assert attr_names == ["transformer_blocks", "single_transformer_blocks"]
         assert len(blocks) == 4
diff --git a/tests/diffusion/models/glm_image/test_glm_image_quantization.py b/tests/diffusion/models/glm_image/test_glm_image_quantization.py
index 1a6170ca2..dfcd15b1a 100644
--- a/tests/diffusion/models/glm_image/test_glm_image_quantization.py
+++ b/tests/diffusion/models/glm_image/test_glm_image_quantization.py
@@ -399,15 +399,14 @@ class TestGlmImagePrepareModule:
         prepare = GlmImagePrepare(
             image_projector=projector,
             rope=rope,
-            patch_size=2,
         )
 
         # Test forward pass
         hidden_states = torch.randn(1, 16, 64, 64)  # [B, C, H, W]
         result = prepare(hidden_states)
 
-        assert len(result) == 5
-        hidden_out, rope_cos, rope_sin, height, width = result
+        assert len(result) == 3
+        hidden_out, rope_cos, rope_sin = result
         assert hidden_out.shape[0] == 1  # batch size
         assert hidden_out.shape[1] == 1024  # seq_len (32 * 32)
         assert hidden_out.shape[2] == 2560  # hidden_dim
diff --git a/vllm_omni/diffusion/layers/mot/__init__.py b/tests/diffusion/models/helios/__init__.py
similarity index 100%
rename from vllm_omni/diffusion/layers/mot/__init__.py
rename to tests/diffusion/models/helios/__init__.py
diff --git a/tests/diffusion/models/helios/test_helios_usp_2rank.py b/tests/diffusion/models/helios/test_helios_usp_2rank.py
new file mode 100644
index 000000000..7b16d1d4f
--- /dev/null
+++ b/tests/diffusion/models/helios/test_helios_usp_2rank.py
@@ -0,0 +1,258 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Two-process USP smoke test for the Helios transformer.
+
+Pins the multi-rank mechanism that ``test_helios_usp_shard.py`` (unit tests
+of ``_sp_split_seq`` alone) cannot see:
+
+  * the manual ``_sp_shard_depth`` bump in ``forward()`` must make attn1 run
+    the Ulysses all-to-all (not ``NoParallelAttention``);
+  * attn2 cross-attention must stay rank-local (``skip_sequence_parallel=
+    True``): if replicated text K/V were fed through Ulysses they would be
+    ws-fold duplicated and outputs would diverge from the single-rank run;
+  * end-to-end correctness: ws=2 output equals the ws=1 baseline for the same
+    weights/inputs (divisible shapes, so the padding path is not involved).
+
+Runs ``HeliosTransformer3DModel.forward`` with tiny random weights via
+``torch.multiprocessing.spawn``: first a baseline (world_size=1), then an
+SP run (world_size=2, ulysses_degree=2); rank-0 outputs are compared.
+
+Requires >= 2 devices; skipped otherwise.
+"""
+
+import os
+import tempfile
+
+import pytest
+import torch
+
+from tests.helpers.mark import hardware_marks
+from vllm_omni.diffusion.config import set_current_diffusion_config
+from vllm_omni.diffusion.data import DiffusionParallelConfig, OmniDiffusionConfig
+from vllm_omni.diffusion.distributed.parallel_state import (
+    destroy_distributed_env,
+    init_distributed_environment,
+    initialize_model_parallel,
+)
+from vllm_omni.diffusion.distributed.sp_plan import (
+    SequenceParallelConfig,
+    get_sp_plan_from_model,
+)
+from vllm_omni.diffusion.forward_context import get_forward_context, set_forward_context
+from vllm_omni.diffusion.hooks.sequence_parallel import apply_sequence_parallel
+from vllm_omni.diffusion.models.helios.helios_transformer import HeliosTransformer3DModel
+from vllm_omni.platforms import current_omni_platform
+
+_L4_TWO_GPU = hardware_marks(res={"cuda": "L4"}, num_cards=2)
+pytestmark = [pytest.mark.full_model, pytest.mark.diffusion, *_L4_TWO_GPU]
+
+RANDOM_SEED = 42
+DTYPE = torch.float32  # keep both runs on the SDPA fallback for tight tolerance
+
+# Tiny but architecturally faithful config:
+#   inner_dim = 4 * 32 = 128, rope_dim sums to head_dim (32),
+#   current chunk 2x4x6 latent -> (1,2,2) patch -> 2*2*3 = 12 tokens,
+#   short history 1x4x6 latent -> (1,2,2) patch -> 6 tokens.
+# All component lengths are even, so ws=2 needs no padding replicas.
+TINY_MODEL_KWARGS = dict(
+    patch_size=(1, 2, 2),
+    num_attention_heads=4,
+    attention_head_dim=32,
+    in_channels=4,
+    out_channels=4,
+    text_dim=64,
+    freq_dim=32,
+    ffn_dim=128,
+    num_layers=2,
+    rope_dim=(12, 10, 10),
+    rope_theta=10000.0,
+    guidance_cross_attn=True,
+    zero_history_timestep=True,
+    has_multi_term_memory_patch=True,
+    is_amplify_history=False,
+)
+
+BATCH = 1
+CUR_FRAMES, LAT_H, LAT_W = 2, 4, 6  # -> 12 current tokens
+HIST_FRAMES = 1  # short history -> 6 tokens
+TEXT_LEN = 5
+
+
+def _update_env(envs_dict: dict[str, str]) -> None:
+    for k, v in envs_dict.items():
+        os.environ[k] = v
+
+
+def _make_inputs(device: torch.device) -> dict[str, torch.Tensor]:
+    torch.manual_seed(RANDOM_SEED + 1)
+    return {
+        "hidden_states": torch.randn(BATCH, 4, CUR_FRAMES, LAT_H, LAT_W, device=device, dtype=DTYPE),
+        "timestep": torch.full((BATCH,), 500.0, device=device),
+        "encoder_hidden_states": torch.randn(
+            BATCH, TEXT_LEN, TINY_MODEL_KWARGS["text_dim"], device=device, dtype=DTYPE
+        ),
+        "indices_latents_history_short": torch.tensor([[0]], device=device),
+        "latents_history_short": torch.randn(BATCH, 4, HIST_FRAMES, LAT_H, LAT_W, device=device, dtype=DTYPE),
+    }
+
+
+def _spy_strategies(model: HeliosTransformer3DModel) -> dict[str, list[str]]:
+    """Record the parallel strategy each Attention resolves to during forward."""
+    seen: dict[str, list[str]] = {"attn1": [], "attn2": []}
+    for name, attn in (("attn1", model.blocks[0].attn1.attn), ("attn2", model.blocks[0].attn2.attn)):
+        original = attn._get_active_parallel_strategy
+
+        def spy(original=original, name=name):
+            strategy = original()
+            seen[name].append(getattr(strategy, "name", type(strategy).__name__))
+            return strategy
+
+        attn._get_active_parallel_strategy = spy
+    return seen
+
+
+def helios_forward_on_model(
+    local_rank: int,
+    world_size: int,
+    ulysses_degree: int,
+    output_file: str,
+    model_state_file: str,
+    is_baseline: bool,
+) -> None:
+    device = torch.device(f"{current_omni_platform.device_type}:{local_rank}")
+    current_omni_platform.set_device(device)
+    torch.set_default_device(device)
+    torch.set_default_dtype(DTYPE)
+
+    _update_env(
+        {
+            "RANK": str(local_rank),
+            "LOCAL_RANK": str(local_rank),
+            "WORLD_SIZE": str(world_size),
+            "MASTER_ADDR": "localhost",
+            "MASTER_PORT": "12361",
+        }
+    )
+    init_distributed_environment()
+
+    parallel_config = DiffusionParallelConfig(
+        pipeline_parallel_size=1,
+        data_parallel_size=1,
+        tensor_parallel_size=1,
+        sequence_parallel_size=ulysses_degree,
+        ulysses_degree=ulysses_degree,
+        ring_degree=1,
+        allgather_degree=1,
+        cfg_parallel_size=1,
+    )
+    od_config = OmniDiffusionConfig.from_kwargs(
+        model="test_model",
+        dtype=DTYPE,
+        parallel_config=parallel_config,
+        diffusion_attention_backend="TORCH_SDPA",
+    )
+    initialize_model_parallel(
+        data_parallel_size=1,
+        cfg_parallel_size=1,
+        sequence_parallel_size=ulysses_degree,
+        ulysses_degree=ulysses_degree,
+        ring_degree=1,
+        allgather_degree=1,
+        tensor_parallel_size=1,
+        pipeline_parallel_size=1,
+    )
+
+    with set_forward_context(omni_diffusion_config=od_config), set_current_diffusion_config(od_config):
+        torch.manual_seed(RANDOM_SEED)
+        model = HeliosTransformer3DModel(**TINY_MODEL_KWARGS).to(device).to(DTYPE)
+
+        if is_baseline and local_rank == 0:
+            with open(model_state_file, "wb") as f:
+                torch.save({k: v.cpu() for k, v in model.state_dict().items()}, f)
+
+        if world_size > 1:
+            torch.distributed.barrier()
+
+        with open(model_state_file, "rb") as f:
+            model_state = torch.load(f)
+        model.load_state_dict({k: v.to(device).to(DTYPE) for k, v in model_state.items()})
+
+        if not is_baseline:
+            # Mirror registry._apply_sequence_parallel_if_enabled: install the
+            # proj_out gather hook from the model's own _sp_plan and flip
+            # sp_plan_hooks_applied so sp_active follows _sp_shard_depth
+            # (i.e. the manual bump in Helios forward is what enables Ulysses).
+            plan = get_sp_plan_from_model(model)
+            assert plan is not None, "HeliosTransformer3DModel must define _sp_plan"
+            apply_sequence_parallel(model, SequenceParallelConfig(ulysses_degree=ulysses_degree), plan)
+            get_forward_context().sp_plan_hooks_applied = True
+
+        seen = _spy_strategies(model)
+        inputs = _make_inputs(device)
+        output = model(**inputs).sample
+
+        assert output.shape == (BATCH, 4, CUR_FRAMES, LAT_H, LAT_W), f"unexpected output shape {output.shape}"
+
+        if is_baseline:
+            assert seen["attn1"] and all(n == "none" for n in seen["attn1"]), (
+                f"baseline attn1 must use NoParallelAttention ('none'), saw {seen['attn1']}"
+            )
+        else:
+            # attn1: SP communication must be active inside the block loop
+            # (regression here = the manual _sp_shard_depth bump was lost).
+            assert seen["attn1"] and all(n == "ulysses" for n in seen["attn1"]), (
+                f"attn1 must run Ulysses under USP (manual _sp_shard_depth bump), saw {seen['attn1']}"
+            )
+            # attn2: replicated text K/V must stay rank-local
+            # (regression here = the ws-fold duplicated-keys bug).
+            assert seen["attn2"] and all(n == "none" for n in seen["attn2"]), (
+                f"attn2 must skip sequence parallel (replicated text K/V), saw {seen['attn2']}"
+            )
+
+        if local_rank == 0:
+            with open(output_file, "wb") as f:
+                torch.save(output.detach().cpu().float(), f)
+
+        destroy_distributed_env()
+
+
+def test_helios_usp2_matches_single_rank():
+    """ws=2 (Ulysses) must reproduce the ws=1 output for identical weights/inputs."""
+    available_devices = current_omni_platform.get_device_count()
+    if available_devices < 2:
+        pytest.skip(f"Test requires 2 devices but only {available_devices} available")
+
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".pkl") as f:
+        baseline_output_file = f.name
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".pkl") as f:
+        sp_output_file = f.name
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".pkl") as f:
+        model_state_file = f.name
+
+    try:
+        torch.multiprocessing.spawn(
+            helios_forward_on_model,
+            args=(1, 1, baseline_output_file, model_state_file, True),
+            nprocs=1,
+        )
+        torch.multiprocessing.spawn(
+            helios_forward_on_model,
+            args=(2, 2, sp_output_file, model_state_file, False),
+            nprocs=2,
+        )
+
+        with open(baseline_output_file, "rb") as f:
+            baseline = torch.load(f)
+        with open(sp_output_file, "rb") as f:
+            sp = torch.load(f)
+
+        assert baseline.shape == sp.shape
+        max_abs_diff = (baseline - sp).abs().max().item()
+        assert torch.allclose(baseline, sp, atol=1e-3, rtol=1e-3), (
+            f"USP=2 output diverges from single-rank baseline: max_abs_diff={max_abs_diff:.6e}"
+        )
+    finally:
+        for path in [baseline_output_file, sp_output_file, model_state_file]:
+            if os.path.exists(path):
+                os.remove(path)
diff --git a/tests/diffusion/models/helios/test_helios_usp_shard.py b/tests/diffusion/models/helios/test_helios_usp_shard.py
new file mode 100644
index 000000000..88301a851
--- /dev/null
+++ b/tests/diffusion/models/helios/test_helios_usp_shard.py
@@ -0,0 +1,225 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Unit tests for Helios per-component sequence splitting.
+
+These tests verify the manual sharding logic that replaces the broken
+rope/blocks.0 hooks in the Helios ``_sp_plan``.  They exercise the *real*
+``HeliosTransformer3DModel._sp_split_seq`` (the parallel-state getters it
+imports lazily inside the method body are monkeypatched), so the model-side
+helper cannot drift silently from what is tested.  For the multi-rank
+mechanism around the helper (manual ``_sp_shard_depth`` bump, attn1/attn2
+parallel strategy, ws=2 vs ws=1 output equivalence) see
+``test_helios_usp_2rank.py``.
+
+Coverage:
+  1. USP disabled (ws == 1) returns the tensor unchanged.
+  2. Divisible split gives each rank the expected slice.
+  3. Non-divisible split pads with replicated tokens (no crash).
+  4. Per-component split: history + current tokens are distributed so
+     that *both* ranks receive some current tokens (no mosaic regression).
+  5. Edge cases: 1-D tensor, empty seq, 4-D tensor.
+"""
+
+from collections.abc import Iterator
+from contextlib import contextmanager
+
+import pytest
+import torch
+
+import vllm_omni.diffusion.distributed.parallel_state as sp_parallel_state
+from vllm_omni.diffusion.models.helios.helios_transformer import HeliosTransformer3DModel
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+
+@contextmanager
+def _fake_sp_state(ws: int, rank: int) -> Iterator[None]:
+    """Patch the parallel-state getters used by the real helper.
+
+    ``_sp_split_seq`` imports these names from the module *inside* its
+    function body, so replacing the module attributes takes effect.
+    """
+    prev_ws = sp_parallel_state.get_sequence_parallel_world_size
+    prev_rank = sp_parallel_state.get_sequence_parallel_rank
+    sp_parallel_state.get_sequence_parallel_world_size = lambda: ws
+    sp_parallel_state.get_sequence_parallel_rank = lambda: rank
+    try:
+        yield
+    finally:
+        sp_parallel_state.get_sequence_parallel_world_size = prev_ws
+        sp_parallel_state.get_sequence_parallel_rank = prev_rank
+
+
+def _sp_split_seq(x: torch.Tensor, ws: int, rank: int) -> torch.Tensor:
+    """Call the real model-side helper without constructing a model."""
+    with _fake_sp_state(ws, rank):
+        return HeliosTransformer3DModel._sp_split_seq(None, x)
+
+
+# ---------------------------------------------------------------------------
+# Tests
+# ---------------------------------------------------------------------------
+
+
+class TestSpSplitSeqDisabled:
+    """When USP is off (ws == 1) the helper must be a no-op."""
+
+    def test_ws1_returns_unchanged(self):
+        x = torch.randn(2, 100, 64)
+        out = _sp_split_seq(x, ws=1, rank=0)
+        assert torch.equal(out, x)
+        assert out is x
+
+
+class TestSpSplitSeqDivisible:
+    """Divisible sequences: each rank gets exactly seq_len / ws tokens."""
+
+    def test_each_rank_gets_correct_slice(self):
+        for ws in [2, 4, 8]:
+            seq_len = ws * 10
+            x = torch.arange(seq_len * 4).float().reshape(1, seq_len, 4)
+            for rank in range(ws):
+                out = _sp_split_seq(x, ws=ws, rank=rank)
+                n = seq_len // ws
+                expected = x[:, rank * n : (rank + 1) * n, :]
+                assert out.shape == (1, n, 4)
+                assert torch.equal(out, expected)
+
+    def test_output_is_contiguous(self):
+        x = torch.randn(1, 20, 8)
+        out = _sp_split_seq(x, ws=2, rank=0)
+        assert out.is_contiguous()
+
+
+class TestSpSplitSeqNonDivisible:
+    """Non-divisible sequences are padded with replicated tokens."""
+
+    def test_non_divisible_pads_instead_of_crash(self):
+        """400x272 → 9*25*17 = 3825 tokens, USP=2 → not divisible.
+        Should pad to 3826 and split, not crash."""
+        x = torch.randn(1, 3825, 8)
+        for rank in range(2):
+            out = _sp_split_seq(x, ws=2, rank=rank)
+            # 3825 → pad 1 → 3826 → /2 = 1913
+            assert out.shape[1] == 1913
+
+    def test_non_divisible_pads_with_replicated_last_token(self):
+        """Verify the padding is the replicated last token, not zeros."""
+        x = torch.randn(1, 7, 4)  # 7 % 2 = 1, pad 1
+        last_token = x[:, -1:, :].clone()
+        out = _sp_split_seq(x, ws=2, rank=0)
+        # rank 0 gets tokens [0:4] (first 4 of the padded 8)
+        assert out.shape == (1, 4, 4)
+        # rank 1 gets tokens [4:8] — token 7 (the padded one) = last token
+        out1 = _sp_split_seq(x, ws=2, rank=1)
+        assert out1.shape == (1, 4, 4)
+        assert torch.equal(out1[:, -1:, :], last_token)
+
+    def test_non_divisible_7_4(self):
+        """7 tokens, ws=4 → pad 1 → 8 → /4 = 2 per rank."""
+        x = torch.randn(1, 7, 8)
+        for rank in range(4):
+            out = _sp_split_seq(x, ws=4, rank=rank)
+            assert out.shape[1] == 2
+
+    def test_non_divisible_15_4(self):
+        """15 tokens, ws=4 → pad 1 → 16 → /4 = 4 per rank."""
+        x = torch.randn(1, 15, 8)
+        for rank in range(4):
+            out = _sp_split_seq(x, ws=4, rank=rank)
+            assert out.shape[1] == 4
+
+
+class TestSpSplitSeqPerComponent:
+    """Simulate Helios forward: split current + history components so that
+    *both* ranks receive some current tokens (no mosaic regression)."""
+
+    def test_both_ranks_get_current_tokens(self):
+        """history=2400, current=540, ws=2.
+        After per-component split, each rank must have > 0 current tokens."""
+        current = torch.randn(1, 540, 64)
+        history = torch.randn(1, 2400, 64)
+
+        for rank in range(2):
+            cur_local = _sp_split_seq(current, ws=2, rank=rank)
+            hist_local = _sp_split_seq(history, ws=2, rank=rank)
+
+            assert cur_local.shape[1] > 0, f"Rank {rank} received 0 current tokens"
+            assert cur_local.shape[1] == 270  # 540 / 2
+            assert hist_local.shape[1] == 1200  # 2400 / 2
+
+            original_context_length = cur_local.shape[1]
+            assert original_context_length > 0  # no mosaic regression
+
+    def test_gather_restores_full_current(self):
+        """After splitting current into 2 ranks, simulating proj_out
+        gather must restore the full current sequence length so that
+        the original unpatchify reshape succeeds."""
+        current = torch.randn(1, 540, 64)
+        local_chunks = [_sp_split_seq(current, ws=2, rank=rank) for rank in range(2)]
+        gathered = torch.cat(local_chunks, dim=1)
+        assert gathered.shape[1] == 540  # full current restored
+
+    def test_gather_with_padding_truncates_correctly(self):
+        """Non-divisible current (3825) → pad to 3826 → split →
+        gather → 3826. Slice to 3825 for unpatchify."""
+        current = torch.randn(1, 3825, 64)
+        local_chunks = [_sp_split_seq(current, ws=2, rank=rank) for rank in range(2)]
+        gathered = torch.cat(local_chunks, dim=1)
+        assert gathered.shape[1] == 3826  # padded size
+        # Simulate the slice before unpatchify
+        expected_seq = 3825
+        if gathered.shape[1] > expected_seq:
+            gathered = gathered[:, :expected_seq, :]
+        assert gathered.shape[1] == 3825  # correct after slice
+
+    def test_rotary_emb_aligned_with_hidden_states(self):
+        """rotary_emb and hidden_states must be split at the same
+        positions so that tokens align inside the attention layer."""
+        hidden = torch.randn(1, 540, 5120)
+        rotary = torch.randn(1, 540, 256)
+        for rank in range(2):
+            h_local = _sp_split_seq(hidden, ws=2, rank=rank)
+            r_local = _sp_split_seq(rotary, ws=2, rank=rank)
+            assert h_local.shape[1] == r_local.shape[1]
+
+    def test_whole_split_causes_mosaic_but_per_component_does_not(self):
+        """Demonstrates why per-component split is needed:
+        with whole split (simulated), rank 0 gets 0 current tokens;
+        with per-component split, both ranks get current tokens."""
+        history = torch.randn(1, 2400, 64)
+        current = torch.randn(1, 540, 64)
+        full = torch.cat([history, current], dim=1)  # 2940
+
+        # Whole split (the OLD broken behavior)
+        whole_n = full.shape[1] // 2  # 1470
+        rank0_whole = full[:, :whole_n, :]
+        rank0_current = rank0_whole.shape[1] - 2400  # negative → 0 current
+        assert rank0_current <= 0, "Whole split should give rank 0 no current"
+
+        # Per-component split (the NEW correct behavior)
+        for rank in range(2):
+            cur_local = _sp_split_seq(current, ws=2, rank=rank)
+            assert cur_local.shape[1] == 270  # both ranks have current
+
+
+class TestSpSplitSeqEdgeCases:
+    """Edge cases that should not crash or silently misbehave."""
+
+    def test_1d_tensor_skipped(self):
+        """1-D tensors must be returned unchanged (dim < 2 guard)."""
+        x = torch.randn(100)
+        out = _sp_split_seq(x, ws=2, rank=0)
+        assert torch.equal(out, x)
+
+    def test_empty_seq_skipped(self):
+        """Empty sequence dimension must be returned unchanged."""
+        x = torch.randn(1, 0, 64)
+        out = _sp_split_seq(x, ws=2, rank=0)
+        assert out.shape == x.shape
+
+    def test_4d_tensor_split_on_dim1(self):
+        """4-D tensor [B, S, H, D] should split along dim=1."""
+        x = torch.randn(1, 20, 8, 32)
+        out = _sp_split_seq(x, ws=2, rank=1)
+        assert out.shape == (1, 10, 8, 32)
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/hunyuan_image3/test_prompt_utils.py b/tests/diffusion/models/hunyuan_image3/test_prompt_utils.py
index 7cb7ea83a..7a467e359 100644
--- a/tests/diffusion/models/hunyuan_image3/test_prompt_utils.py
+++ b/tests/diffusion/models/hunyuan_image3/test_prompt_utils.py
@@ -13,9 +13,11 @@ from vllm_omni.diffusion.models.hunyuan_image3.prompt_utils import (
     HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS,
     available_bot_tasks,
     available_tasks,
+    build_ar_prompt_inputs,
     build_prompt,
     build_prompt_tokens,
     resolve_stop_token_ids,
+    validate_special_token_ids,
 )
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
@@ -296,19 +298,42 @@ def _repo_root() -> pathlib.Path:
     return pathlib.Path(__file__).resolve().parents[4]
 
 
-def test_end2end_routes_through_shared_prompt_utils():
-    end2end_path = _repo_root() / "examples" / "offline_inference" / "hunyuan_image3" / "end2end.py"
-    tree = ast.parse(end2end_path.read_text(encoding="utf-8"))
+def test_example_routes_through_shared_seam():
+    """Neither the shared task examples nor the ``model_extras`` seam itself
+    should duplicate AR prompt tokenization.
 
-    local_func_names = {n.name for n in ast.walk(tree) if isinstance(n, ast.FunctionDef)}
-    assert not (local_func_names & {"build_prompt", "build_prompt_tokens"})
+    After the model_extras migration, t2i / image-editing run through the
+    shared ``text_to_image.py`` / ``image_edit.py`` examples (both call
+    ``build_ar_stage_inputs``), and t2t / i2t run through the shared
+    ``x_to_text.py`` example (which calls ``build_x_to_text_prompt``). This
+    test pins that both ``model_extras.hunyuan_image3`` seam functions
+    delegate to ``prompt_utils.build_ar_prompt_inputs`` / ``build_ar_stage_inputs``
+    rather than re-implementing tokenization inline.
+    """
+    seam_path = _repo_root() / "vllm_omni" / "model_extras" / "hunyuan_image3.py"
+    seam_tree = ast.parse(seam_path.read_text(encoding="utf-8"))
 
-    imported_from_prompt_utils: set[str] = set()
-    for node in ast.walk(tree):
+    local_func_names = {n.name for n in ast.walk(seam_tree) if isinstance(n, ast.FunctionDef)}
+    assert not (local_func_names & {"build_prompt", "build_prompt_tokens", "resolve_stop_token_ids"})
+
+    # build_x_to_text_prompt must route through build_ar_stage_inputs, not
+    # re-derive the AR prefill / stop-token logic itself.
+    build_x_to_text_prompt_node = next(
+        n for n in ast.walk(seam_tree) if isinstance(n, ast.FunctionDef) and n.name == "build_x_to_text_prompt"
+    )
+    called_names = {
+        node.func.id
+        for node in ast.walk(build_x_to_text_prompt_node)
+        if isinstance(node, ast.Call) and isinstance(node.func, ast.Name)
+    }
+    assert "build_ar_stage_inputs" in called_names
+
+    # The model_extras seam itself must delegate to the shared prompt_utils.
+    routed_from_prompt_utils: set[str] = set()
+    for node in ast.walk(seam_tree):
         if isinstance(node, ast.ImportFrom) and node.module and node.module.endswith("hunyuan_image3.prompt_utils"):
-            imported_from_prompt_utils.update(alias.name for alias in node.names)
-    expected_imports = {"build_prompt_tokens", "resolve_stop_token_ids", "resolve_sys_type"}
-    assert expected_imports <= imported_from_prompt_utils
+            routed_from_prompt_utils.update(alias.name for alias in node.names)
+    assert "build_ar_prompt_inputs" in routed_from_prompt_utils
 
 
 _HUNYUAN_MODEL_ID = "tencent/HunyuanImage-3.0-Instruct"
@@ -331,3 +356,87 @@ def test_segment_tokenize_diverges_from_full_string_encode():
     full_ids = tok.encode(build_prompt(user_prompt, task="i2t", bot_task=None), add_special_tokens=False)
     assert seg_ids != full_ids
     assert len(seg_ids) >= len(full_ids)
+
+
+def test_build_ar_prompt_inputs_tokenizer_path_matches_build_prompt_tokens():
+    """With a tokenizer, the helper delegates to build_prompt_tokens (parity)."""
+    tok = FakeTokenizer()
+    ar = build_ar_prompt_inputs("a red panda", task="t2i", bot_task="think", tokenizer=tok)
+    expected = build_prompt_tokens("a red panda", FakeTokenizer(), task="t2i", bot_task="think")
+    assert ar.prompt is None
+    assert ar.prompt_token_ids == expected.token_ids
+    assert ar.system_prompt_type == expected.system_prompt_type
+    # think + no explicit size -> AR predicts ratio, so stop range is non-trivial.
+    assert len(ar.stop_token_ids) > 1
+
+
+def test_build_ar_prompt_inputs_string_fallback_without_tokenizer():
+    """Without a tokenizer, the helper returns the build_prompt string form."""
+    ar = build_ar_prompt_inputs("a red panda", task="t2i", bot_task="recaption")
+    assert ar.prompt_token_ids is None
+    assert ar.prompt == build_prompt("a red panda", task="t2i", bot_task="recaption")
+    assert ar.system_prompt_type
+    assert ar.stop_token_ids
+
+
+def test_build_ar_prompt_inputs_explicit_size_stops_at_terminator():
+    """Explicit image_size makes 'recaption' stop at </recaption> only."""
+    ar = build_ar_prompt_inputs("x", task="t2i", bot_task="recaption", image_size="1024x1024")
+    assert ar.stop_token_ids == [HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS["</recaption>"]]
+
+
+def test_build_ar_prompt_inputs_comprehension_stops_on_answer():
+    """Text-output tasks (t2t / i2t) stop on <answer>."""
+    ar = build_ar_prompt_inputs("hi", task="t2t")
+    assert ar.stop_token_ids == [HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS["<answer>"]]
+
+
+class _MatchingTokenizer:
+    """Reports exactly HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS -- a "real" tokenizer
+    that hasn't drifted from the hardcoded table."""
+
+    def convert_tokens_to_ids(self, tok: str) -> int:
+        return HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS[tok]
+
+
+class _DriftedTokenizer:
+    """Reports a different id for one token -- simulates a model/tokenizer
+    revision bump shifting special-token ids out from under the hardcoded
+    table."""
+
+    def convert_tokens_to_ids(self, tok: str) -> int:
+        if tok == "<think>":
+            return 999999
+        return HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS[tok]
+
+
+class _BaseCheckpointTokenizer:
+    """Simulates tencent/HunyuanImage-3.0 (base): reports the same
+    model_class_name as -Instruct, but its vocab doesn't include the
+    Instruct-only <img_ratio_33>-<img_ratio_36> tokens -- convert_tokens_to_ids
+    falls back to unk_token_id for those, like a real HF tokenizer would."""
+
+    unk_token_id = 0
+    _INSTRUCT_ONLY = {"<img_ratio_33>", "<img_ratio_36>"}
+
+    def convert_tokens_to_ids(self, tok: str) -> int:
+        if tok in self._INSTRUCT_ONLY:
+            return self.unk_token_id
+        return HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS[tok]
+
+
+def test_validate_special_token_ids_passes_for_matching_tokenizer():
+    validate_special_token_ids(_MatchingTokenizer())  # must not raise
+
+
+def test_validate_special_token_ids_raises_on_drift():
+    with pytest.raises(ValueError, match="<think>.*expected 128023.*got 999999"):
+        validate_special_token_ids(_DriftedTokenizer())
+
+
+def test_validate_special_token_ids_tolerates_base_checkpoint_missing_tokens():
+    """The base checkpoint's tokenizer not recognizing Instruct-only ratio
+    tokens (unk_token_id, not a real drifted id) must not be flagged as a
+    mismatch -- both checkpoints share model_class_name, so this hook fires
+    for either one."""
+    validate_special_token_ids(_BaseCheckpointTokenizer())  # must not raise
diff --git a/tests/diffusion/models/lance/test_pipeline_lance.py b/tests/diffusion/models/lance/test_pipeline_lance.py
new file mode 100644
index 000000000..32ff9bd10
--- /dev/null
+++ b/tests/diffusion/models/lance/test_pipeline_lance.py
@@ -0,0 +1,171 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+from PIL import Image
+
+from vllm_omni.diffusion.models.lance.lance_transformer import LanceBagel
+from vllm_omni.diffusion.models.lance.pipeline_lance import LancePipeline
+from vllm_omni.model_executor.models.utils import normalize_decoded_video_frames
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class FramesWithMetadata(list[Image.Image]):
+    def __init__(self, frames: list[Image.Image], **metadata: object) -> None:
+        super().__init__(frames)
+        for name, value in metadata.items():
+            setattr(self, name, value)
+
+
+class StopAfterVideoPreprocessError(Exception):
+    pass
+
+
+def test_normalize_decoded_video_frames_preserves_rgb_pixels_and_fps():
+    red = Image.new("RGB", (3, 2), color=(255, 0, 0))
+    rgba = Image.new("RGBA", (3, 2), color=(0, 255, 0, 64))
+    rgba_bytes = rgba.tobytes()
+
+    video, fps = normalize_decoded_video_frames(FramesWithMetadata([red, rgba], fps=8), default_fps=24.0)
+
+    assert video.shape == (2, 2, 3, 3)
+    assert video.dtype == np.uint8
+    assert video.flags.c_contiguous
+    np.testing.assert_array_equal(video[0, 0, 0], [255, 0, 0])
+    np.testing.assert_array_equal(video[1, 0, 0], [0, 255, 0])
+    assert fps == 8.0
+    assert rgba.mode == "RGBA"
+    assert rgba.tobytes() == rgba_bytes
+
+
+def test_normalize_decoded_video_frames_uses_frame_rate_when_fps_is_missing():
+    frames = FramesWithMetadata([Image.new("RGB", (2, 2))] * 2, frame_rate=12)
+
+    _, fps = normalize_decoded_video_frames(frames, default_fps=24.0)
+
+    assert fps == 12.0
+
+
+def test_normalize_decoded_video_frames_prefers_valid_fps_over_frame_rate():
+    frames = FramesWithMetadata([Image.new("RGB", (2, 2))] * 2, fps=8, frame_rate=12)
+
+    _, fps = normalize_decoded_video_frames(frames, default_fps=24.0)
+
+    assert fps == 8.0
+
+
+def test_normalize_decoded_video_frames_uses_default_fps_for_plain_list_and_tuple():
+    frames = [Image.new("RGB", (2, 2)), Image.new("RGB", (2, 2))]
+
+    assert normalize_decoded_video_frames(frames, default_fps=24.0)[1] == 24.0
+    assert normalize_decoded_video_frames(tuple(frames), default_fps=24.0)[1] == 24.0
+
+
+def test_normalize_decoded_video_frames_accepts_numeric_string_fps():
+    frames = FramesWithMetadata([Image.new("RGB", (2, 2))] * 2, fps="12.5")
+
+    _, frame_rate = normalize_decoded_video_frames(frames, default_fps=24.0)
+
+    assert frame_rate == 12.5
+
+
+@pytest.mark.parametrize(
+    ("fps", "frame_rate", "expected"),
+    [
+        (float("nan"), 12, 12.0),
+        (0, 15, 15.0),
+        (-1, 8, 8.0),
+        (float("inf"), 10, 10.0),
+        ("invalid", "6.5", 6.5),
+    ],
+)
+def test_normalize_decoded_video_frames_uses_valid_frame_rate_after_invalid_fps(fps, frame_rate, expected):
+    frames = FramesWithMetadata([Image.new("RGB", (2, 2))] * 2, fps=fps, frame_rate=frame_rate)
+
+    _, frame_rate = normalize_decoded_video_frames(frames, default_fps=24.0)
+
+    assert frame_rate == expected
+
+
+def test_normalize_decoded_video_frames_uses_default_when_both_metadata_values_are_invalid():
+    frames = FramesWithMetadata([Image.new("RGB", (2, 2))] * 2, fps="invalid", frame_rate=0)
+
+    _, frame_rate = normalize_decoded_video_frames(frames, default_fps=24.0)
+
+    assert frame_rate == 24.0
+
+
+@pytest.mark.parametrize(
+    ("frames", "match"),
+    [
+        ([], "empty decoded video frame sequence"),
+        ([Image.new("RGB", (2, 2)), object()], "must be a PIL.Image.Image"),
+        (
+            [Image.new("RGB", (2, 2)), Image.new("RGB", (3, 2))],
+            "must have identical dimensions",
+        ),
+    ],
+)
+def test_normalize_decoded_video_frames_rejects_invalid_sequences(frames, match):
+    with pytest.raises(ValueError, match=match):
+        normalize_decoded_video_frames(frames, default_fps=24.0)
+
+
+@pytest.mark.parametrize(
+    ("frames", "match"),
+    [
+        ([Image.new("RGB", (0, 16))], r"index 0.*0x16"),
+        ([Image.new("RGB", (16, 0))], r"index 0.*16x0"),
+        ([Image.new("RGB", (0, 0))], r"index 0.*0x0"),
+        (
+            [Image.new("RGB", (16, 16)), Image.new("RGB", (0, 16))],
+            r"index 1.*0x16",
+        ),
+    ],
+)
+def test_normalize_decoded_video_frames_rejects_zero_dimensions(frames, match):
+    with pytest.raises(ValueError, match=match):
+        normalize_decoded_video_frames(frames, default_fps=24.0)
+
+
+@pytest.mark.parametrize(
+    ("video_input", "expected_fps"),
+    [
+        (FramesWithMetadata([Image.new("RGB", (3, 2))] * 2, fps=8), 8.0),
+        (tuple([Image.new("RGBA", (3, 2))] * 2), 12.0),
+    ],
+)
+def test_lance_video_edit_normalizes_decoded_frame_sequences(monkeypatch, video_input, expected_fps):
+    captured = {}
+
+    def capture_preprocessed_input(video, fps):
+        captured["video"] = video
+        captured["fps"] = fps
+        raise StopAfterVideoPreprocessError
+
+    monkeypatch.setattr(LanceBagel, "_lance_video_preprocess", staticmethod(capture_preprocessed_input))
+    request = SimpleNamespace(
+        prompts=[
+            {
+                "modalities": ["video"],
+                "user_text": "edit the video",
+                "multi_modal_data": {"video": video_input},
+                "extra_args": {"origin_fps": 12.0},
+            }
+        ],
+        sampling_params=SimpleNamespace(extra_args={}, num_inference_steps=1),
+    )
+
+    with pytest.raises(StopAfterVideoPreprocessError):
+        object.__new__(LancePipeline)._forward_video_edit(request)
+
+    video = captured["video"]
+    assert isinstance(video, np.ndarray)
+    assert video.shape == (2, 2, 3, 3)
+    assert video.dtype == np.uint8
+    assert video.flags.c_contiguous
+    assert captured["fps"] == expected_fps
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 f5567a706..7e12b3db3 100644
--- a/tests/diffusion/models/lingbot_world/test_lingbot_world_attention.py
+++ b/tests/diffusion/models/lingbot_world/test_lingbot_world_attention.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
 
@@ -7,7 +7,7 @@ import importlib.util
 import math
 import sys
 from pathlib import Path
-from types import ModuleType
+from types import ModuleType, SimpleNamespace
 
 import pytest
 import torch
@@ -33,6 +33,10 @@ _STUBBED_MODULE_NAMES = (
     "vllm_omni.diffusion",
     "vllm_omni.diffusion.attention",
     "vllm_omni.diffusion.attention.layer",
+    "vllm_omni.diffusion.distributed",
+    "vllm_omni.diffusion.distributed.comm",
+    "vllm_omni.diffusion.distributed.parallel_state",
+    "vllm_omni.diffusion.distributed.sp_plan",
     "vllm_omni.diffusion.layers",
     "vllm_omni.diffusion.layers.norm",
     "vllm_omni.diffusion.layers.rope",
@@ -58,6 +62,58 @@ def _install_vllm_stubs() -> None:
     distributed.get_tensor_model_parallel_world_size = lambda: 1
     distributed.tensor_model_parallel_all_reduce = lambda value: value
 
+    class _SeqAllToAll4D:
+        @staticmethod
+        def apply(group, value, scatter_idx, gather_idx, use_sync=False):
+            del group, scatter_idx, gather_idx, use_sync
+            return value
+
+    setattr(
+        sys.modules["vllm_omni.diffusion.distributed.comm"],
+        "SeqAllToAll4D",
+        _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,
+            ulysses_rank=0,
+            ulysses_group=None,
+        )
+
+    setattr(
+        sys.modules["vllm_omni.diffusion.distributed.parallel_state"],
+        "get_sp_group",
+        get_sp_group,
+    )
+
+    class _SequenceParallelInput:
+        def __init__(self, split_dim, expected_dims=None, split_output=False, auto_pad=False):
+            self.split_dim = split_dim
+            self.expected_dims = expected_dims
+            self.split_output = split_output
+            self.auto_pad = auto_pad
+
+    class _SequenceParallelOutput:
+        def __init__(self, gather_dim, expected_dims=None):
+            self.gather_dim = gather_dim
+            self.expected_dims = expected_dims
+
+    sp_plan = sys.modules["vllm_omni.diffusion.distributed.sp_plan"]
+    setattr(sp_plan, "SequenceParallelInput", _SequenceParallelInput)
+    setattr(sp_plan, "SequenceParallelOutput", _SequenceParallelOutput)
+
     def set_weight_attrs(weight: torch.Tensor, attrs: dict) -> None:
         for name, value in attrs.items():
             setattr(weight, name, value)
@@ -541,3 +597,51 @@ def test_tp_rmsnorm_weight_loader_selects_rank_shard(monkeypatch: pytest.MonkeyP
     norm.weight.weight_loader(norm.weight, torch.tensor([10.0, 20.0, 30.0, 40.0]))
 
     torch.testing.assert_close(norm.weight, torch.tensor([30.0, 40.0]))
+
+
+@pytest.mark.parametrize("attention_class", ["LingBotSelfAttention"])
+def test_ulysses_rejects_non_divisible_head_count(monkeypatch, attention_class):
+    module = _load_module()
+    monkeypatch.setattr(
+        module,
+        "get_sp_group",
+        lambda: SimpleNamespace(
+            ulysses_world_size=3,
+            ulysses_rank=0,
+            ulysses_group=None,
+        ),
+    )
+    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 121364c07..98da24c7a 100644
--- a/tests/diffusion/models/lingbot_world/test_lingbot_world_camera.py
+++ b/tests/diffusion/models/lingbot_world/test_lingbot_world_camera.py
@@ -8,6 +8,7 @@ import math
 import subprocess
 import sys
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 import numpy as np
 import pytest
@@ -20,7 +21,10 @@ _CAMERA_MODULE = importlib.util.module_from_spec(_SPEC)
 sys.modules[_SPEC.name] = _CAMERA_MODULE
 _SPEC.loader.exec_module(_CAMERA_MODULE)
 
-CameraTrajectory = _CAMERA_MODULE.CameraTrajectory
+if TYPE_CHECKING:
+    from vllm_omni.diffusion.models.lingbot_world.camera import CameraTrajectory
+else:
+    CameraTrajectory = _CAMERA_MODULE.CameraTrajectory
 build_plucker_embedding = _CAMERA_MODULE.build_plucker_embedding
 interpolate_camera_trajectory = _CAMERA_MODULE.interpolate_camera_trajectory
 load_camera_trajectory = _CAMERA_MODULE.load_camera_trajectory
@@ -138,21 +142,20 @@ def test_load_camera_trajectory_rejects_object_dtype_before_materializing(tmp_pa
         load_camera_trajectory(_trusted(tmp_path))
 
 
-def test_load_camera_trajectory_accepts_official_length_and_materializes_request_prefix(tmp_path: Path) -> None:
-    _write_trajectory(
-        tmp_path,
-        _identity_poses(269),
-        np.arange(269 * 4, dtype=np.float32).reshape(269, 4),
-    )
+@pytest.mark.parametrize("num_frames", [129, 269, 4096])
+def test_load_camera_trajectory_preserves_all_bounded_source_frames(tmp_path: Path, num_frames: int) -> None:
+    poses = _identity_poses(num_frames)
+    poses[:, 0, 3] = np.arange(num_frames)
+    intrinsics = np.arange(num_frames * 4, dtype=np.float32).reshape(num_frames, 4)
+    _write_trajectory(tmp_path, poses, intrinsics)
 
     trajectory = load_camera_trajectory(_trusted(tmp_path))
 
-    assert trajectory.poses.shape == (117, 4, 4)
-    assert trajectory.intrinsics.shape == (117, 4)
-    np.testing.assert_array_equal(
-        trajectory.intrinsics.numpy(),
-        np.arange(269 * 4, dtype=np.float32).reshape(269, 4)[:117],
-    )
+    assert trajectory.poses.shape == (num_frames, 4, 4)
+    assert trajectory.intrinsics.shape == (num_frames, 4)
+    assert trajectory.poses.dtype == trajectory.intrinsics.dtype == torch.float32
+    np.testing.assert_array_equal(trajectory.poses.numpy(), poses.astype(np.float32))
+    np.testing.assert_array_equal(trajectory.intrinsics.numpy(), intrinsics)
 
 
 def test_load_camera_trajectory_rejects_unbounded_source_frame_count(tmp_path: Path) -> None:
@@ -419,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(
         [
@@ -437,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 e2e2a08b6..e11c34e35 100644
--- a/tests/diffusion/models/lingbot_world/test_lingbot_world_transformer.py
+++ b/tests/diffusion/models/lingbot_world/test_lingbot_world_transformer.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
 
@@ -7,14 +7,17 @@ import hashlib
 import inspect
 import json
 import math
+from datetime import timedelta
 from pathlib import Path
+from types import SimpleNamespace
 
 import pytest
 import torch
 
 from tests.diffusion.models.lingbot_world import test_lingbot_world_attention as attention_tests
+from tests.helpers.mark import hardware_test
 
-pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion]
 
 _FIXTURE_PATH = Path(__file__).with_name("fixtures") / "lingbot_world_weight_index_names.json.fixture"
 _SHAPE_FIXTURE_PATH = Path(__file__).with_name("fixtures") / "lingbot_world_official_shapes.json.fixture"
@@ -32,11 +35,13 @@ def _tiny_model(
     num_layers: int = 2,
     num_frames_per_block: int = 1,
     sliding_window_num_frames: int = 3,
+    attention_head_dim: int = 2,
+    rope_max_seq_len: int = 16,
 ):
     return module.CausalLingBotWorldTransformer3DModel(
         patch_size=(1, 2, 2),
         num_attention_heads=2,
-        attention_head_dim=2,
+        attention_head_dim=attention_head_dim,
         in_channels=36,
         out_channels=2,
         text_dim=6,
@@ -45,7 +50,7 @@ def _tiny_model(
         num_layers=num_layers,
         cross_attn_norm=True,
         eps=1e-6,
-        rope_max_seq_len=16,
+        rope_max_seq_len=rope_max_seq_len,
         sink_size=1,
         num_frames_per_block=num_frames_per_block,
         sliding_window_num_frames=sliding_window_num_frames,
@@ -117,7 +122,9 @@ def _assert_self_cache_unchanged(cache, snapshot) -> None:
         attention_tests._assert_cache_unchanged(layer_cache, layer_snapshot)
 
 
-def test_tiny_transformer_runs_four_chunks_with_explicit_cache_commit_and_camera_path() -> None:
+@pytest.mark.cpu
+@pytest.mark.parametrize("num_chunks", [4, 18])
+def test_tiny_transformer_runs_contiguous_chunks_with_explicit_cache_commit_and_camera_path(num_chunks) -> None:
     torch.manual_seed(7)
     module = attention_tests._load_module()
     model = _tiny_model(module).eval()
@@ -131,7 +138,7 @@ def test_tiny_transformer_runs_four_chunks_with_explicit_cache_commit_and_camera
     assert model.patch_embedding.in_channels == 36
     assert model.patch_embedding_wancamctrl.in_features == 6 * 8 * 8 * 1 * 2 * 2
 
-    for start_frame in range(4):
+    for start_frame in range(num_chunks):
         hidden_states = torch.randn(1, 36, 1, 4, 4)
         timestep = torch.tensor([float(start_frame + 1)])
         snapshot = _self_cache_snapshot(cache)
@@ -165,7 +172,7 @@ def test_tiny_transformer_runs_four_chunks_with_explicit_cache_commit_and_camera
         expected_token_end = (start_frame + 1) * 2 * 2
         assert all(layer_cache.absolute_end == expected_token_end for layer_cache in cache.self_attention)
 
-    assert len(outputs) == 4
+    assert len(outputs) == num_chunks
     assert all(len(outputs) == 1 for outputs in cross_key_outputs)
     assert len(text_projection_outputs) == 1
 
@@ -191,6 +198,7 @@ def test_tiny_transformer_runs_four_chunks_with_explicit_cache_commit_and_camera
     assert not torch.equal(camera_output, alternate_output)
 
 
+@pytest.mark.cpu
 def test_partial_cross_attention_cache_projects_text_only_for_missing_layers() -> None:
     module = attention_tests._load_module()
     model = _tiny_model(module, num_layers=2).eval()
@@ -229,6 +237,7 @@ def test_partial_cross_attention_cache_projects_text_only_for_missing_layers() -
 
 
 @pytest.mark.parametrize("frames", [1, 6], ids=("partial", "multiple_blocks"))
+@pytest.mark.cpu
 def test_forward_rejects_chunks_that_do_not_equal_configured_block_size(frames: int) -> None:
     module = attention_tests._load_module()
     model = _tiny_model(
@@ -257,6 +266,7 @@ def test_forward_rejects_chunks_that_do_not_equal_configured_block_size(frames:
     assert cache.cross_attention == [None]
 
 
+@pytest.mark.cpu
 def test_forward_accepts_exactly_one_configured_frame_block() -> None:
     module = attention_tests._load_module()
     model = _tiny_model(
@@ -279,6 +289,7 @@ def test_forward_accepts_exactly_one_configured_frame_block() -> None:
     assert output.shape == (1, 2, 3, 4, 4)
 
 
+@pytest.mark.cpu
 def test_transformer_allocates_request_cache_from_its_configured_geometry() -> None:
     module = attention_tests._load_module()
     model = _tiny_model(
@@ -303,6 +314,7 @@ def test_transformer_allocates_request_cache_from_its_configured_geometry() -> N
     assert all(layer.value.shape == (2, 6 * 4 * 6, 2, 2) for layer in cache.self_attention)
 
 
+@pytest.mark.cpu
 def test_video_patch_embedding_uses_temporal_height_width_token_order() -> None:
     module = attention_tests._load_module()
     model = _tiny_model(module, num_layers=1, num_frames_per_block=2)
@@ -323,6 +335,7 @@ def test_video_patch_embedding_uses_temporal_height_width_token_order() -> None:
     torch.testing.assert_close(tokens[0, :, 0], torch.tensor([1.0, 3.0, 9.0, 11.0]))
 
 
+@pytest.mark.cpu
 def test_unpatchify_restores_two_frame_channel_and_spatial_order() -> None:
     module = attention_tests._load_module()
     model = _tiny_model(module, num_layers=1, num_frames_per_block=2)
@@ -363,6 +376,7 @@ def test_unpatchify_restores_two_frame_channel_and_spatial_order() -> None:
     torch.testing.assert_close(output, expected)
 
 
+@pytest.mark.cpu
 def test_head_modulation_broadcasts_distinct_condition_per_frame() -> None:
     module = attention_tests._load_module()
     model = _tiny_model(module, num_layers=1, num_frames_per_block=2)
@@ -381,6 +395,7 @@ def test_head_modulation_broadcasts_distinct_condition_per_frame() -> None:
     torch.testing.assert_close(output, expected)
 
 
+@pytest.mark.cpu
 def test_constructor_defaults_match_official_checkpoint_config() -> None:
     module = attention_tests._load_module()
     parameters = inspect.signature(module.CausalLingBotWorldTransformer3DModel.__init__).parameters
@@ -406,6 +421,7 @@ def test_constructor_defaults_match_official_checkpoint_config() -> None:
     assert {name: parameters[name].default for name in expected} == expected
 
 
+@pytest.mark.cpu
 def test_transformer_exposes_parameter_dtype_for_pipeline_runtime() -> None:
     module = attention_tests._load_module()
     model = _tiny_model(module)
@@ -413,12 +429,14 @@ def test_transformer_exposes_parameter_dtype_for_pipeline_runtime() -> None:
     assert model.dtype == next(model.parameters()).dtype
 
 
+@pytest.mark.cpu
 def test_transformer_declares_regional_compile_block() -> None:
     module = attention_tests._load_module()
 
     assert module.CausalLingBotWorldTransformer3DModel._repeated_blocks == ["LingBotAttentionBlock"]
 
 
+@pytest.mark.cpu
 def test_lingbot_rms_norm_uses_global_tp_square_mean(monkeypatch) -> None:
     module = attention_tests._load_module()
     reduced_values: list[torch.Tensor] = []
@@ -440,6 +458,7 @@ def test_lingbot_rms_norm_uses_global_tp_square_mean(monkeypatch) -> None:
     torch.testing.assert_close(reduced_values[0], torch.tensor([[25.0]]))
 
 
+@pytest.mark.cpu
 def test_attention_rejects_heads_not_divisible_by_tp_size(monkeypatch) -> None:
     module = attention_tests._load_module()
     monkeypatch.setattr(module, "get_tensor_model_parallel_world_size", lambda: 3)
@@ -448,6 +467,7 @@ def test_attention_rejects_heads_not_divisible_by_tp_size(monkeypatch) -> None:
         module.LingBotSelfAttention(dim=4, num_heads=2)
 
 
+@pytest.mark.cpu
 def test_constructor_rejects_unsupported_qk_norm_with_config_error() -> None:
     module = attention_tests._load_module()
 
@@ -456,6 +476,7 @@ def test_constructor_rejects_unsupported_qk_norm_with_config_error() -> None:
 
 
 @pytest.mark.parametrize("field", ["image_dim", "added_kv_proj_dim", "pos_embed_seq_len"])
+@pytest.mark.cpu
 def test_constructor_rejects_non_null_image_embedding_fields(field: str) -> None:
     module = attention_tests._load_module()
 
@@ -463,6 +484,7 @@ def test_constructor_rejects_non_null_image_embedding_fields(field: str) -> None
         module.CausalLingBotWorldTransformer3DModel(**{field: 4})
 
 
+@pytest.mark.cpu
 def test_constructor_rejects_unsupported_quantization_with_runtime_error() -> None:
     module = attention_tests._load_module()
 
@@ -470,6 +492,7 @@ def test_constructor_rejects_unsupported_quantization_with_runtime_error() -> No
         module.CausalLingBotWorldTransformer3DModel(quant_config=object())
 
 
+@pytest.mark.cpu
 def test_from_config_accepts_diffusers_metadata_and_normalizes_patch_size() -> None:
     module = attention_tests._load_module()
 
@@ -522,6 +545,7 @@ def test_from_config_accepts_diffusers_metadata_and_normalizes_patch_size() -> N
         ("sink_size", 0),
     ],
 )
+@pytest.mark.cpu
 def test_from_config_rejects_checkpoint_topology_drift(field: str, value: object) -> None:
     module = attention_tests._load_module()
     config = {
@@ -554,6 +578,7 @@ def test_from_config_rejects_checkpoint_topology_drift(field: str, value: object
         module.CausalLingBotWorldTransformer3DModel.from_config(config)
 
 
+@pytest.mark.cpu
 def test_from_config_ignores_non_semantic_checkpoint_metadata() -> None:
     module = attention_tests._load_module()
     config = {
@@ -569,6 +594,7 @@ def test_from_config_ignores_non_semantic_checkpoint_metadata() -> None:
     assert model.config.num_layers == 40
 
 
+@pytest.mark.cpu
 def test_load_weights_uses_parameter_loaders_and_rejects_unknown_model_keys() -> None:
     module = attention_tests._load_module()
     model = _tiny_model(module, num_layers=1)
@@ -606,6 +632,7 @@ def test_load_weights_uses_parameter_loaders_and_rejects_unknown_model_keys() ->
         model.load_weights([("unexpected_model.weight", torch.ones(1))])
 
 
+@pytest.mark.cpu
 def test_load_weights_consumes_checkpoint_iterator_incrementally() -> None:
     module = attention_tests._load_module()
     model = _tiny_model(module, num_layers=1)
@@ -619,6 +646,7 @@ def test_load_weights_consumes_checkpoint_iterator_incrementally() -> None:
     assert model.load_weights(weights()) == {first_name}
 
 
+@pytest.mark.cpu
 def test_real_auto_weights_loader_covers_fused_model_parameter_namespace() -> None:
     utils = pytest.importorskip("vllm.model_executor.models.utils")
     module = attention_tests._load_module()
@@ -638,6 +666,7 @@ def test_real_auto_weights_loader_covers_fused_model_parameter_namespace() -> No
     assert set(dict(pipeline.named_parameters())) <= loaded
 
 
+@pytest.mark.cpu
 def test_checkpoint_weight_index_fixture_matches_model_namespaces() -> None:
     module = attention_tests._load_module()
     fixture = json.loads(_FIXTURE_PATH.read_text())
@@ -667,6 +696,7 @@ def test_checkpoint_weight_index_fixture_matches_model_namespaces() -> None:
     assert all(len(shard["parameter_names_sha256"]) == 64 for shard in fixture["shards"].values())
 
 
+@pytest.mark.cpu
 def test_official_default_shapes_match_public_safetensors_header_fixture() -> None:
     module = attention_tests._load_module()
     fixture = json.loads(_SHAPE_FIXTURE_PATH.read_text())
@@ -683,3 +713,377 @@ def test_official_default_shapes_match_public_safetensors_header_fixture() -> No
         shape, dtype = parameter_specs[name]
         assert tuple(shape) == tuple(expected_shape), name
         assert dtype == expected_dtype
+
+
+@pytest.mark.cpu
+def test_timestep_expansion_only_runs_with_ulysses(monkeypatch):
+    dtype = torch.bfloat16
+    module = attention_tests._load_module()
+    hidden = torch.randn(2, 12, 4).to(dtype)
+    camera = torch.randn_like(hidden)
+    table = torch.randn(2, 3, 6, 4).to(dtype)
+    rotary = (torch.randn(12, 2), torch.randn(12, 2))
+    prepare = module._LingBotSPPrepare()
+    assert prepare(hidden, camera, table, rotary)[2] is table
+    monkeypatch.setattr(module, "get_sp_group", lambda: SimpleNamespace(ulysses_world_size=2))
+    expanded = prepare(hidden, camera, table, rotary)[2]
+    assert expanded.shape == (2, 12, 6, 4)
+    torch.testing.assert_close(expanded, table.repeat_interleave(4, dim=1), rtol=0, atol=0)
+
+
+@pytest.mark.parametrize("unsharded", [None, 3], ids=["missing-hook", "unsharded-rope"])
+@pytest.mark.cpu
+def test_missing_or_partial_sp_split_fails_before_attention(monkeypatch, unsharded):
+    module = attention_tests._load_module()
+    model = _tiny_model(module, num_frames_per_block=3, sliding_window_num_frames=6)
+    cache = _cache(module, model)
+    for block in model.blocks:
+        block.self_attn.ulysses_world_size = 2
+    monkeypatch.setattr(module, "get_sp_group", lambda: SimpleNamespace(ulysses_world_size=2))
+    original = model.sp_prepare.forward
+
+    def partial_split(*args):
+        values = original(*args)
+        if unsharded is None:
+            return values
+        return tuple(
+            value if i == unsharded else value.chunk(2, dim=1 if i < 3 else 0)[0] for i, value in enumerate(values)
+        )
+
+    monkeypatch.setattr(model.sp_prepare, "forward", partial_split)
+
+    def forbidden(*args, **kwargs):
+        raise AssertionError("attention/collectives must not run before shard validation")
+
+    monkeypatch.setattr(model.blocks[0], "forward", forbidden)
+    with pytest.raises(RuntimeError, match="SP input hooks"):
+        model(
+            torch.randn(1, 36, 3, 4, 4),
+            torch.tensor([1.0]),
+            torch.randn(1, 3, 6),
+            torch.randn(1, 384, 3, 4, 4),
+            cache=cache,
+            start_frame=0,
+            update_cache=False,
+        )
+
+
+# Real multi-rank regression: synthetic weights, native SP/TP and attention.
+_HEADS, _HEAD_DIM, _LAYERS = 8, 32, 2
+_FRAMES, _SIDE, _TOKENS_PER_FRAME = 3, 32, 256
+
+
+def _model(dtype):
+    from vllm_omni.diffusion.models.lingbot_world.transformer import CausalLingBotWorldTransformer3DModel
+
+    model = CausalLingBotWorldTransformer3DModel(
+        num_attention_heads=_HEADS,
+        attention_head_dim=_HEAD_DIM,
+        num_layers=_LAYERS,
+        in_channels=4,
+        out_channels=4,
+        text_dim=8,
+        freq_dim=16,
+        ffn_dim=512,
+        patch_size=(1, 2, 2),
+        sink_size=1,
+        num_frames_per_block=_FRAMES,
+        sliding_window_num_frames=6,
+        rope_max_seq_len=32,
+    ).eval()
+    return model.to(device=torch.device("cuda", torch.accelerator.current_device_index()), dtype=dtype)
+
+
+def _checkpoint(model):
+    weights = {}
+    generator = torch.Generator().manual_seed(17)
+    for name, param in sorted(model.named_parameters()):
+        data = torch.randn(param.shape, generator=generator) * 0.02
+        if "norm" in name and name.endswith("weight"):
+            data.fill_(1)
+        if name.endswith("modulation") and data.shape[-2] == 6:
+            data[..., 2, :] = 1
+            data[..., 5, :] = 1
+        data = data.to(param.dtype)
+        param.copy_(data)
+        if ".self_attn.qkv." in name:
+            for component, chunk in zip(("q", "k", "v"), data.chunk(3), strict=True):
+                weights[name.replace(".self_attn.qkv.", f".self_attn.{component}.")] = chunk
+        else:
+            weights[name] = data
+    return weights
+
+
+def _rollout(model, mode, dtype, batch):
+    from vllm_omni.diffusion.models.lingbot_world.transformer import LingBotTransformerCache
+    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
+
+    device = next(model.parameters()).device
+    state = None
+    if mode == "paged":
+        kv = ARDiffusionKVCache(
+            ARDiffusionKVConfig(enable=True, chunk_size=_TOKENS_PER_FRAME, window_chunks=5, sink_chunks=1),
+            num_layers=_LAYERS,
+            num_kv_heads=model.blocks[0].self_attn.num_sp_heads,
+            head_size=_HEAD_DIM,
+            dtype=dtype,
+            block_size=_TOKENS_PER_FRAME,
+            max_model_len=4096,
+            available_bytes=1 << 27,
+            kv_branches=(ARDiffusionKVBranchSpec("main", 0),),
+            session_capacity=1,
+            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)
+        cache = LingBotTransformerCache(self_attention=[], cross_attention=[None] * _LAYERS)
+    else:
+        cache = model.allocate_cache(
+            batch_size=batch, latent_height=_SIDE, latent_width=_SIDE, device=device, dtype=dtype
+        )
+    generator = torch.Generator().manual_seed(123)
+    text = torch.randn(batch, 5, 8, generator=generator).to(device, dtype)
+    outputs = []
+    try:
+        for start in range(0, 12, _FRAMES):
+            latent = torch.randn(batch, 4, _FRAMES, _SIDE, _SIDE, generator=generator).to(device, dtype)
+            camera = torch.randn(batch, 384, _FRAMES, _SIDE, _SIDE, generator=generator).to(device, dtype)
+            for commit in (False, False, True):
+                if state is not None:
+                    cache.self_attention = state.get_kv_caches(
+                        "main", seq_len=_FRAMES * _TOKENS_PER_FRAME, commit_current=commit
+                    )
+                output = model(
+                    latent,
+                    torch.tensor([100.0, 400.0, 900.0], device=device).expand(batch, -1),
+                    text,
+                    camera,
+                    cache=cache,
+                    start_frame=start,
+                    update_cache=commit,
+                )
+                outputs.append(output.float().cpu())
+                if state is not None:
+                    if not state.is_cross_attention_populated("main", "text"):
+                        state.populate_cross_attention(
+                            "main", "text", [(layer.key, layer.value) for layer in cache.cross_attention]
+                        )
+                        for layer, pool in zip(
+                            cache.cross_attention, state.get_cross_attention_kv("main", "text"), strict=True
+                        ):
+                            layer.key, layer.value = pool["k"], pool["v"]
+                    state.commit_paged_context("main")
+        cross = [
+            (layer.key.detach().float().cpu(), layer.value.detach().float().cpu()) for layer in cache.cross_attention
+        ]
+        return torch.stack(outputs), cross
+    finally:
+        if state is not None:
+            state.close()
+
+
+def _worker(rank, world_size, sp_size, tp_size, mode, dtype, batch, rendezvous):
+    from vllm.config import VllmConfig
+    from vllm.config.vllm import set_current_vllm_config
+    from vllm.distributed import get_tensor_model_parallel_rank
+
+    from vllm_omni.diffusion.config import set_current_diffusion_config
+    from vllm_omni.diffusion.data import AttentionConfig, AttentionSpec, DiffusionParallelConfig, OmniDiffusionConfig
+    from vllm_omni.diffusion.distributed.parallel_state import (
+        destroy_distributed_env,
+        destroy_model_parallel,
+        init_distributed_environment,
+        initialize_model_parallel,
+    )
+    from vllm_omni.diffusion.forward_context import set_forward_context
+    from vllm_omni.diffusion.registry import _apply_sequence_parallel_if_enabled
+    from vllm_omni.platforms import current_omni_platform
+
+    current_omni_platform.set_device(torch.device("cuda", rank))
+    torch.backends.cuda.matmul.allow_tf32 = False
+    torch.backends.cudnn.allow_tf32 = False
+    torch.distributed.init_process_group(
+        "nccl", init_method=f"file://{rendezvous}", world_size=world_size, rank=rank, timeout=timedelta(seconds=90)
+    )
+    init_distributed_environment(world_size=world_size, rank=rank, local_rank=rank, backend="nccl")
+    try:
+        with torch.inference_mode(), set_current_vllm_config(VllmConfig()):
+            for baseline in (True, False):
+                sp, tp = (1, 1) if baseline else (sp_size, tp_size)
+                initialize_model_parallel(
+                    data_parallel_size=world_size // (sp * tp),
+                    sequence_parallel_size=sp,
+                    ulysses_degree=sp,
+                    tensor_parallel_size=tp,
+                )
+                config = OmniDiffusionConfig(
+                    model=str(Path(rendezvous).parent),
+                    dtype=dtype,
+                    enforce_eager=True,
+                    parallel_config=DiffusionParallelConfig(
+                        data_parallel_size=world_size // (sp * tp),
+                        sequence_parallel_size=sp,
+                        ulysses_degree=sp,
+                        tensor_parallel_size=tp,
+                    ),
+                    diffusion_attention_config=AttentionConfig(default=AttentionSpec(backend="TORCH_SDPA")),
+                )
+                with set_current_diffusion_config(config), set_forward_context(omni_diffusion_config=config):
+                    model = _model(dtype)
+                    if baseline:
+                        weights = _checkpoint(model)
+                    else:
+                        model.load_weights(iter(weights.items()))
+                    _apply_sequence_parallel_if_enabled(SimpleNamespace(transformer=model), config)
+                    result, cross = _rollout(model, mode, dtype, batch)
+                    if baseline:
+                        expected, expected_cross = result, cross
+                    else:
+                        assert expected.abs().max() > 1e-3
+                        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}"
+                        # 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(
+                                k, ek[:, :, first : first + local_heads], rtol=tolerance, atol=tolerance
+                            )
+                            torch.testing.assert_close(
+                                v, ev[:, :, first : first + local_heads], rtol=tolerance, atol=tolerance
+                            )
+                        if rank == 0:
+                            print(f"{mode} {dtype} TP{tp} SP{sp}: relative L2={error.item():.3g}", flush=True)
+                    del model
+                torch.distributed.barrier()
+                destroy_model_parallel()
+    finally:
+        destroy_distributed_env()
+
+
+def _run(tmp_path: Path, sp, tp, mode, dtype, batch):
+    if torch.accelerator.device_count() < sp * tp:
+        pytest.skip(f"requires {sp * tp} GPUs")
+    torch.multiprocessing.spawn(
+        _worker, args=(sp * tp, sp, tp, mode, dtype, batch, str(tmp_path / "rendezvous")), nprocs=sp * tp
+    )
+
+
+@pytest.mark.parallel
+@hardware_test(res={"cuda": "L4"}, num_cards=2)
+def test_sp2_direct_matches_sp1_fp32(tmp_path):
+    _run(tmp_path, 2, 1, "direct", torch.float32, 2)
+
+
+@pytest.mark.parallel
+@hardware_test(res={"cuda": "L4"}, num_cards=4)
+def test_sp4_direct_matches_sp1_bf16(tmp_path):
+    _run(tmp_path, 4, 1, "direct", torch.bfloat16, 1)
+
+
+@pytest.mark.parallel
+@hardware_test(res={"cuda": "L4"}, num_cards=4)
+def test_tp2_sp2_paged_matches_sp1_bf16(tmp_path):
+    _run(tmp_path, 2, 2, "paged", torch.bfloat16, 1)
+
+
+@pytest.mark.cpu
+@pytest.mark.parametrize("start_frame", [0, 1021, 1023, 1024, 21600])
+@pytest.mark.parametrize("dtype", [torch.float32, torch.bfloat16])
+def test_temporal_rope_matches_absolute_positions_without_growing_cache(start_frame, dtype):
+    module = attention_tests._load_module()
+    model = _tiny_model(module, num_layers=1, attention_head_dim=128, rope_max_seq_len=1024).to(dtype)
+    buffers = {name: (value.data_ptr(), value.shape) for name, value in model.named_buffers()}
+    cosine, sine = model._rotary_embedding(
+        frames=3, height=2, width=3, start_frame=start_frame, dtype=dtype, device=torch.device("cpu")
+    )
+    # Independent complex-valued reference uses absolute (time, height, width)
+    # coordinates, including blocks crossing the original precomputed table.
+    grids = torch.meshgrid(
+        torch.arange(start_frame, start_frame + 3, dtype=torch.float64),
+        torch.arange(2, dtype=torch.float64),
+        torch.arange(3, dtype=torch.float64),
+        indexing="ij",
+    )
+    reference = []
+    for positions, dim in zip(grids, (44, 42, 42), strict=True):
+        frequencies = 1.0 / 10000 ** (torch.arange(0, dim, 2, dtype=torch.float64) / dim)
+        phase = positions.flatten()[:, None] * frequencies[None, :]
+        reference.append(torch.polar(torch.ones_like(phase), phase))
+    expected = torch.cat(reference, dim=-1)
+    torch.testing.assert_close(cosine, expected.real.float().to(dtype), rtol=0, atol=0)
+    torch.testing.assert_close(sine, expected.imag.float().to(dtype), rtol=0, atol=0)
+    assert {name: (value.data_ptr(), value.shape) for name, value in model.named_buffers()} == buffers
+
+
+@pytest.mark.cpu
+def test_temporal_rope_extension_keeps_spatial_limit():
+    module = attention_tests._load_module()
+    model = _tiny_model(module, num_layers=1)
+    with pytest.raises(ValueError, match="Spatial RoPE"):
+        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 52113208a..91ae00b7d 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,
@@ -127,7 +131,9 @@ class _RecordingTransformer(nn.Module):
         )
         self.blocks = nn.ModuleList([nn.Identity(), nn.Identity()])
         for block in self.blocks:
-            block.self_attn = SimpleNamespace(num_local_heads=2, head_dim=4)
+            # 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
@@ -147,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):
@@ -172,10 +179,82 @@ class _RecordingTransformer(nn.Module):
         return {name for name, _ in self.loaded_weights}
 
 
+class _StubCausalDecoder:
+    """Stand-in for the Wan causal decoder's cache protocol.
+
+    Reproduces only what streaming depends on: each call walks ``feat_idx``
+    across one cache slot per causal convolution, and the session's opening
+    frame (``first_chunk``) expands to a single raw frame while every later
+    frame expands by the temporal factor.
+    """
+
+    NUM_CONVS = 3
+
+    def __init__(self) -> None:
+        self.first_chunk_flags: list[bool] = []
+        # Identity of the cache each call wrote through, so an interleaved run
+        # can assert that a session never advanced another session's context.
+        self.cache_ids: list[int] = []
+
+    def __call__(self, x: torch.Tensor, *, feat_cache, feat_idx, first_chunk: bool = False):
+        self.first_chunk_flags.append(bool(first_chunk))
+        self.cache_ids.append(id(feat_cache))
+        for _ in range(self.NUM_CONVS):
+            index = feat_idx[0]
+            feat_cache[index] = x.detach().clone()
+            feat_idx[0] = index + 1
+        num_frames = 1 if first_chunk else 4
+        return x.new_zeros(x.shape[0], 3, num_frames, x.shape[-2] * 8, x.shape[-1] * 8)
+
+
+class _StubCausalEncoder(nn.Module):
+    """Minimal Wan cache layout; the real tiny VAE below checks numerical parity."""
+
+    def __init__(self):
+        super().__init__()
+        self.conv_in = nn.Conv3d(3, 16, 1)
+        self.down_blocks = nn.ModuleList([lingbot_pipeline.WanResample(16, mode="downsample2d") for _ in range(3)])
+        self.mid_block = SimpleNamespace(resnets=[])
+        self.conv_out = nn.Conv3d(16, 32, 1)
+        self.inputs: list[torch.Tensor] = []
+
+    def forward(self, video, *, feat_cache, feat_idx):
+        self.inputs.append(video.detach().clone())
+        first = feat_cache[0] is None
+        tail = video[:, :, -2:].clone()
+        if tail.shape[2] == 1 and feat_cache[0] is not None:
+            tail = torch.cat((feat_cache[0][:, :, -1:], tail), dim=2)
+        feat_cache[0] = tail
+        height, width = video.shape[-2] // 8, video.shape[-1] // 8
+        previous_frames = 0 if feat_cache[1] is None else feat_cache[1].shape[2]
+        feat_cache[1] = video.new_zeros(1, 16, min(2, previous_frames + 1), height, width)
+        feat_idx[0] += 2
+        moments = video.new_zeros(1, 32, 1, height, width)
+        if first:
+            moments[:, :16] = 2.0
+        return moments
+
+
 class _StubVAE(_FakePretrained):
     dtype = torch.float32
 
-    def __init__(self):
+    def __init__(self, *, streaming: bool = True):
+        self.encoder = _StubCausalEncoder()
+        self.quant_conv = nn.Identity()
+        self._cached_conv_counts = {"encoder": 2}
+        self._enc_feat_map = ["module-owned"]
+        self._enc_conv_idx = [71]
+        if streaming:
+            self.decoder = _StubCausalDecoder()
+            # Recorded, not discarded: on the streaming branch this is the only
+            # place the tensor handed to the decoder can be observed, and it is
+            # what carries the checkpoint's latent rescale.
+            self.post_quant_inputs: list[torch.Tensor] = []
+            self.post_quant_conv = self._record_post_quant
+            self._cached_conv_counts["decoder"] = _StubCausalDecoder.NUM_CONVS
+            # Module-owned cache the shared VAE keeps for whole-clip decode;
+            # streaming must never write through it.
+            self._feat_map = ["module-owned"]
         self.config = SimpleNamespace(
             z_dim=16,
             scale_factor_temporal=4,
@@ -187,6 +266,10 @@ class _StubVAE(_FakePretrained):
         self.decode_inputs: list[torch.Tensor] = []
         self.on_decode = None
 
+    def _record_post_quant(self, latent: torch.Tensor) -> torch.Tensor:
+        self.post_quant_inputs.append(latent.detach().clone())
+        return latent
+
     def encode(self, video: torch.Tensor):
         self.encode_inputs.append(video.detach().clone())
         latent_frames = (video.shape[2] - 1) // 4 + 1
@@ -337,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)
@@ -387,6 +472,9 @@ def _od_config(**overrides):
         "parallel_config": SimpleNamespace(
             pipeline_parallel_size=1,
             sequence_parallel_size=1,
+            ulysses_degree=1,
+            ring_degree=1,
+            allgather_degree=1,
             cfg_parallel_size=1,
             vae_patch_parallel_size=1,
             use_hsdp=False,
@@ -438,15 +526,15 @@ def test_pipeline_respects_loader_managed_component_placement(offload_field: str
     assert getattr(pipeline.vae, "to_calls", []) == []
 
 
-def test_ar_diffusion_capability_uses_fixed_tp_local_lingbot_geometry() -> None:
+def test_ar_diffusion_capability_uses_transformer_local_head_geometry() -> None:
     module = _load_pipeline_module()
-    module.get_tensor_model_parallel_world_size = lambda: 1
     pipeline = _pipeline(module)
-
+    # Use the constructed head count even when the config describes a different geometry.
+    pipeline.transformer.blocks[0].self_attn = SimpleNamespace(num_sp_heads=1)
     spec = pipeline.ar_diffusion_kv_cache_spec()
 
     assert spec.num_layers == 2
-    assert spec.num_kv_heads == 2
+    assert spec.num_kv_heads == 1
     assert spec.head_size == 4
     assert spec.tokens_per_frame == 1
     assert spec.frames_per_block == 3
@@ -454,7 +542,56 @@ def test_ar_diffusion_capability_uses_fixed_tp_local_lingbot_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}
-    assert spec.model_owned_state_bytes_per_session == 9_600
+    # 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 + 384 + 2 * encoder_bytes + 2_421_248
+
+
+def test_session_admission_accounts_for_the_streaming_decoder_cache() -> None:
+    """Admission includes encoder state and the prompt embedding even when the decoder cannot stream."""
+    module = _load_pipeline_module()
+
+    def spec_pipeline():
+        pipeline = _pipeline(module)
+        # The spec reads the constructed attention's head count; the head count
+        # plays no part in model-owned bytes, so any value will do here.
+        pipeline.transformer.blocks[0].self_attn = SimpleNamespace(num_sp_heads=1)
+        return pipeline
+
+    small = spec_pipeline().ar_diffusion_kv_cache_spec().model_owned_state_bytes_per_session
+
+    wide = spec_pipeline()
+    wide._ar_width = wide._ar_width * 2
+    widened = wide.ar_diffusion_kv_cache_spec().model_owned_state_bytes_per_session
+    # Twice the area: the decoder cache doubles, so the total grows by far more
+    # than the image condition alone could account for.
+    assert widened - small > 2_000_000
+
+    # 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 + 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:
@@ -604,7 +741,6 @@ def test_component_discovery_uses_official_checkpoint_contract() -> None:
     ("field", "value", "feature"),
     [
         ("pipeline_parallel_size", 2, "pipeline parallelism"),
-        ("sequence_parallel_size", 2, "sequence parallelism"),
         ("cfg_parallel_size", 2, "CFG parallelism"),
         ("vae_patch_parallel_size", 2, "VAE parallelism"),
         ("use_hsdp", True, "HSDP"),
@@ -622,6 +758,43 @@ def test_unsupported_parallel_modes_fail_before_component_loading(field: str, va
     assert module._loader_state.prefetch_calls == []
 
 
+def test_pure_ulysses_parallel_config_is_supported() -> None:
+    module = _load_pipeline_module()
+    parallel_config = _od_config().parallel_config
+    parallel_config.sequence_parallel_size = 2
+    parallel_config.ulysses_degree = 2
+
+    pipeline = module.LingBotWorldCausalDMDPipeline(od_config=_od_config(parallel_config=parallel_config))
+
+    assert pipeline.transformer is not None
+
+
+@pytest.mark.parametrize(
+    "overrides",
+    [
+        {"sequence_parallel_size": 4, "ring_degree": 2},  # Normalized hybrid.
+        {"ulysses_degree": 1, "allgather_degree": 2},  # Normalized AllGather-KV.
+        {"ring_degree": 2},  # Isolate each clause from the SP-size mismatch.
+        {"allgather_degree": 2},
+        {"ulysses_mode": "advanced_uaa"},
+        {"ulysses_a2a_permute": True},
+        {"ulysses_degree": None},  # Missing degree must not imply pure Ulysses.
+    ],
+)
+def test_unsupported_sp_config_fails_before_component_loading(overrides):
+    module = _load_pipeline_module()
+    config = _od_config().parallel_config
+    config.sequence_parallel_size = config.ulysses_degree = 2
+    for name, value in overrides.items():
+        if value is None:
+            delattr(config, name)
+        else:
+            setattr(config, name, value)
+    with pytest.raises(NotImplementedError, match="pure Ulysses"):
+        module.LingBotWorldCausalDMDPipeline(od_config=_od_config(parallel_config=config))
+    assert module._loader_state.prefetch_calls == []
+
+
 def test_unsupported_quantization_fails_before_component_loading() -> None:
     module = _load_pipeline_module()
 
@@ -1086,20 +1259,19 @@ def test_request_validation_rejects_unsupported_contracts(request_batch, message
         _pipeline(module)._parse_request(request_batch)
 
 
-def test_resource_limits_accept_exact_documented_boundaries() -> None:
+def test_request_validation_accepts_frames_beyond_previous_limit() -> None:
     module = _load_pipeline_module()
-    sampling = _SamplingParams(height=480, width=832, num_frames=117, max_sequence_length=512)
+    sampling = _SamplingParams(height=480, width=832, num_frames=129, max_sequence_length=512)
 
     parsed = _pipeline(module)._parse_request(_RequestBatch(_prompt(), sampling))
 
-    assert (parsed.height, parsed.width, parsed.num_frames, parsed.max_sequence_length) == (480, 832, 117, 512)
+    assert (parsed.height, parsed.width, parsed.num_frames, parsed.max_sequence_length) == (480, 832, 129, 512)
 
 
 @pytest.mark.parametrize(
     ("sampling", "message"),
     [
         (_SamplingParams(height=480, width=848), "pixel area|480.*832"),
-        (_SamplingParams(num_frames=129), "num_frames.*117"),
         (_SamplingParams(max_sequence_length=511), "max_sequence_length.*512"),
         (_SamplingParams(max_sequence_length=513), "max_sequence_length.*512"),
         (_SamplingParams(max_sequence_length=512.0), "max_sequence_length.*512"),
@@ -1436,9 +1608,9 @@ def test_multi_chunk_generation_uses_one_request_local_cache_and_decodes_accumul
     assert cache_ref() is None
 
 
-def _tick_extra_args(*, chunk_index: int, prompt: str = "move through the room"):
+def _tick_extra_args(*, chunk_index: int, prompt: str = "move through the room", session_id: str = "world-1"):
     return ARDiffusionTickRequest(
-        session_id="world-1",
+        session_id=session_id,
         request_id="legacy-lingbot-request",
         chunk_index=chunk_index,
         applied_event_ids=(chunk_index,),
@@ -1453,6 +1625,16 @@ def _tick_extra_args(*, chunk_index: int, prompt: str = "move through the room")
     ).to_extra_args()
 
 
+def test_realtime_rejects_pixel_output_before_condition_encoding() -> None:
+    pipeline = _pipeline(_load_pipeline_module())
+    pipeline._ar_diffusion_kv_state = object()
+    sampling = _SamplingParams(output_type="np", extra_args=_tick_extra_args(chunk_index=0))
+    with pytest.raises(ValueError, match="require output_type='latent'"):
+        pipeline(_request(sampling=sampling))
+    assert pipeline._ar_sessions == {}
+    assert pipeline.vae.encoder.inputs == []
+
+
 def test_typed_ticks_generate_one_global_block_and_return_standard_metadata(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -1515,7 +1697,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)
@@ -1629,6 +1810,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)
@@ -1655,7 +1837,7 @@ def test_typed_tick_rejects_non_contiguous_chunk_index(
         pipeline(_request(sampling=sampling))
 
 
-def test_typed_tick_rejects_chunk_beyond_realtime_condition_horizon(
+def test_typed_ticks_keep_bounded_encoder_state_beyond_ten_chunks(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     module = _load_pipeline_module()
@@ -1663,22 +1845,304 @@ def test_typed_tick_rejects_chunk_beyond_realtime_condition_horizon(
     pipeline._ar_height = 16
     pipeline._ar_width = 16
     pipeline._ar_diffusion_kv_state = object()
-    pipeline._ar_sessions["world-1"] = module._LingBotARSessionState(
-        next_chunk_index=10,
-    )
+    generated = []
     monkeypatch.setattr(
         pipeline,
-        "encode_prompt",
-        lambda *args, **kwargs: pytest.fail("the realtime horizon must be validated before prompt encoding"),
+        "_ar_text_caches",
+        lambda *args, **kwargs: [SimpleNamespace()],
     )
 
-    sampling = _SamplingParams(extra_args=_tick_extra_args(chunk_index=10))
-    with pytest.raises(
-        ValueError,
-        match=r"at most 10 ticks.*chunk_index 0 through 9.*117 pixel frames",
-    ):
+    def generate_block(**kwargs):
+        generated.append(
+            {
+                "condition": kwargs["condition"].clone(),
+                "start_frame": kwargs["start_frame"],
+            }
+        )
+        return torch.zeros_like(kwargs["condition"][:, :16])
+
+    monkeypatch.setattr(pipeline, "_generate_block", generate_block)
+
+    for chunk_index in range(11):
+        sampling = _SamplingParams(
+            extra_args=_tick_extra_args(chunk_index=chunk_index),
+        )
         pipeline(_request(sampling=sampling))
 
+    assert pipeline.vae.encode_inputs == []
+    # 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"]
+    assert pipeline.vae._enc_conv_idx == [71]
+    assert pipeline._ar_sessions["world-1"].next_chunk_index == 11
+    assert [item["start_frame"] for item in generated] == list(range(0, 33, 3))
+    assert torch.count_nonzero(generated[0]["condition"][:, :4]) > 0
+    torch.testing.assert_close(
+        generated[1]["condition"][:, :4],
+        torch.zeros_like(generated[1]["condition"][:, :4]),
+    )
+    for item in generated[2:]:
+        torch.testing.assert_close(item["condition"], generated[1]["condition"])
+
+
+def _tiny_condition_pipeline(monkeypatch: pytest.MonkeyPatch):
+    from diffusers import AutoencoderKLWan
+
+    from vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2 import retrieve_latents
+
+    pipeline = _pipeline(_load_pipeline_module())
+    with torch.random.fork_rng(devices=[]):
+        torch.manual_seed(7)
+        pipeline.vae = AutoencoderKLWan(
+            base_dim=4,
+            z_dim=16,
+            dim_mult=[1, 1, 1, 1],
+            num_res_blocks=1,
+            temperal_downsample=[False, True, True],
+        ).eval()
+    monkeypatch.setattr(lingbot_pipeline, "retrieve_latents", retrieve_latents)
+    monkeypatch.setattr(pipeline, "_ar_text_caches", lambda *args, **kwargs: [SimpleNamespace()])
+    return pipeline
+
+
+@pytest.mark.parametrize("mode", ["realtime", "stepwise"])
+def test_condition_continues_real_causal_vae_beyond_initial_horizon(
+    monkeypatch: pytest.MonkeyPatch,
+    mode: str,
+) -> None:
+    pipeline = _tiny_condition_pipeline(monkeypatch)
+    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)
+    module_cache = pipeline.vae._enc_feat_map
+    seen = []
+
+    def check(condition):
+        index = len(seen)
+        torch.testing.assert_close(condition, expected[:, :, index * 3 : (index + 1) * 3], rtol=1e-6, atol=1e-6)
+        seen.append(condition.clone())
+
+    if mode == "realtime":
+        pipeline._ar_diffusion_kv_state = object()
+
+        def generate_block(**kwargs):
+            check(kwargs["condition"])
+            return torch.zeros_like(kwargs["condition"][:, :16])
+
+        monkeypatch.setattr(pipeline, "_generate_block", generate_block)
+        session_id = "world-1"
+        outputs = (
+            pipeline(_request(sampling=_SamplingParams(extra_args=_tick_extra_args(chunk_index=index))))
+            for index in range(blocks)
+        )
+    else:
+
+        def probe_step(**kwargs):
+            if kwargs["step_index"] == 0:
+                check(kwargs["condition"])
+            return torch.ones_like(kwargs["current_latents"])
+
+        monkeypatch.setattr(pipeline._dmd_blocks, "probe_step", probe_step)
+        monkeypatch.setattr(pipeline._dmd_blocks, "commit_block_kv", lambda **kwargs: None)
+        state = _stepwise_state(num_frames=(blocks * 3 - 1) * 4 + 1)
+        session_id = state.request_id
+        outputs = _stepwise_chunks(pipeline, state, _FakeARState(session_id))
+
+    cache_sizes = []
+    for _ in outputs:
+        state = pipeline._ar_sessions.get(session_id)
+        if state is not None:
+            for cache in (state.encoder_cache, state.pending_encoder_cache):
+                if cache is not None:
+                    size = sum(t.numel() * t.element_size() for t in cache if t is not None)
+                    assert size == pipeline._condition_encoder_cache_bytes()
+                    assert all(t.grad_fn is None for t in cache if t is not None)
+                    cache_sizes.append(size)
+    assert len(seen) == blocks and len(set(cache_sizes)) == 1
+    assert pipeline.vae._enc_feat_map is module_cache and all(t is None for t in module_cache)
+    pipeline.close_ar_diffusion_session(session_id)
+    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()
+    prompts = {
+        "a": _prompt(images=Image.new("RGB", (16, 16), (255, 0, 0))),
+        "b": _prompt(images=Image.new("RGB", (16, 16), (0, 255, 0))),
+    }
+    expected = {}
+    with torch.inference_mode():
+        for name, prompt in prompts.items():
+            inputs = pipeline._parse_request(_request(prompt=prompt, sampling=_SamplingParams(num_frames=45)))
+            expected[name] = pipeline._prepare_condition(inputs, dtype=torch.float32)
+    assert not torch.equal(expected["a"], expected["b"])
+    active = None
+    failure = None
+    original_encoder = pipeline.vae.encoder.forward
+
+    def encoder(*args, **kwargs):
+        output = original_encoder(*args, **kwargs)
+        if failure == "encoder":
+            raise RuntimeError("injected encoder failure")
+        return output
+
+    def generate_block(**kwargs):
+        index = kwargs["start_frame"]
+        torch.testing.assert_close(kwargs["condition"], expected[active][:, :, index : index + 3], rtol=1e-6, atol=1e-6)
+        if failure == "dit":
+            raise RuntimeError("injected DiT failure")
+        return torch.zeros_like(kwargs["condition"][:, :16])
+
+    monkeypatch.setattr(pipeline.vae.encoder, "forward", encoder)
+    monkeypatch.setattr(pipeline, "_generate_block", generate_block)
+
+    def run(name, index):
+        nonlocal active
+        active = name
+        sampling = _SamplingParams(extra_args=_tick_extra_args(chunk_index=index, session_id=name))
+        return pipeline(_request(prompt=prompts[name], sampling=sampling))
+
+    run("a", 0)
+    for index, kind in [(1, "encoder"), (2, "dit")]:
+        state = pipeline._ar_sessions["a"]
+        committed = state.encoder_cache
+        saved = [t.clone() if t is not None else None for t in committed]
+        failure = kind
+        with pytest.raises(RuntimeError, match="injected"):
+            run("a", index)
+        assert state.next_chunk_index == index and state.encoder_cache is committed
+        assert state.pending_encoder_cache is None
+        for before, after in zip(saved, committed, strict=True):
+            if before is not None:
+                torch.testing.assert_close(before, after, rtol=0, atol=0)
+        failure = None
+        run("b", index - 1)
+        run("a", index)
+
+    old_a = pipeline._ar_sessions["a"]
+    pipeline.reset_ar_diffusion_session("a")
+    assert old_a.encoder_cache is None and old_a.pending_encoder_cache is None
+    assert "a" not in pipeline._ar_sessions and "b" in pipeline._ar_sessions
+    run("a", 0)
+    old_b = pipeline._ar_sessions["b"]
+    pipeline.close_ar_diffusion_session("b")
+    assert old_b.encoder_cache is None and old_b.pending_encoder_cache is None
+    assert "a" in pipeline._ar_sessions and "b" not in pipeline._ar_sessions
+    pipeline.close_ar_diffusion_session("a")
+    assert pipeline._ar_sessions == {}
+
+
+def test_stepwise_failed_chunk_releases_pending_encoder_on_close(monkeypatch: pytest.MonkeyPatch) -> None:
+    pipeline = _pipeline(_load_pipeline_module())
+    state = _stepwise_state()
+    transformer = pipeline.transformer
+    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"):
+            pipeline.denoise_step(None, states=[state])
+        assert session.next_chunk_index == 0 and session.encoder_cache is None
+    pipeline.close_ar_diffusion_session(state.request_id)
+    assert session.encoder_cache is None and session.pending_encoder_cache is None
+    assert state.request_id not in pipeline._ar_sessions
+
+
+@pytest.mark.parametrize("mode", ["realtime", "stepwise"])
+def test_stateful_condition_rejects_tiled_encoder(monkeypatch: pytest.MonkeyPatch, mode: str) -> None:
+    pipeline = _pipeline(_load_pipeline_module())
+    _enable_vae_tiling(pipeline, tile_sample_min=8)
+    with pytest.raises(ValueError, match="does not support tiled VAE encoding"):
+        if mode == "realtime":
+            pipeline._ar_diffusion_kv_state = object()
+            pipeline(_request(sampling=_SamplingParams(extra_args=_tick_extra_args(chunk_index=0))))
+        else:
+            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())
+
 
 def test_request_cache_is_released_before_vae_decode() -> None:
     module = _load_pipeline_module()
@@ -1706,25 +2170,25 @@ def test_request_cache_is_released_before_vae_decode() -> None:
     assert result.output.shape[2] == 21
 
 
-def test_117_frame_request_generates_ten_complete_latent_blocks() -> None:
+def test_129_frame_request_generates_eleven_complete_latent_blocks() -> None:
     module = _load_pipeline_module()
     transformer = _RecordingTransformer()
     pipeline = _pipeline(module, transformer=transformer)
     trajectory = _CameraTrajectory(
-        poses=torch.eye(4).repeat(117, 1, 1),
-        intrinsics=torch.tensor([[100.0, 100.0, 8.0, 8.0]]).repeat(117, 1),
+        poses=torch.eye(4).repeat(129, 1, 1),
+        intrinsics=torch.tensor([[100.0, 100.0, 8.0, 8.0]]).repeat(129, 1),
     )
     sampling = _SamplingParams(
-        num_frames=117,
+        num_frames=129,
         output_type="latent",
         extra_args={"_lingbot_camera_trajectory": trajectory},
     )
 
     result = pipeline(_request(sampling=sampling))
 
-    assert result.output.shape == (1, 16, 30, 2, 2)
-    assert len(transformer.calls) == 50
-    assert [call["start_frame"] for call in transformer.calls[::5]] == list(range(0, 30, 3))
+    assert result.output.shape == (1, 16, 33, 2, 2)
+    assert len(transformer.calls) == 55
+    assert [call["start_frame"] for call in transformer.calls[::5]] == list(range(0, 33, 3))
 
 
 def test_request_cache_becomes_unreachable_after_transformer_error() -> None:
@@ -1807,14 +2271,75 @@ 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
 
 
+def _stepwise_chunks(pipeline, state, ar_state):
+    """Yield one chunk at a time, binding AR state around each invocation.
+
+    The runner binds runner-owned KV for the duration of one stepwise
+    invocation and releases it again, so a generator that suspends at each
+    chunk boundary is what lets two requests be driven the way the scheduler
+    drives them at session_capacity > 1: A-chunk0, B-chunk0, A-chunk1, ...
+    """
+    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):
+            noise = pipeline.denoise_step(None, states=[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)
@@ -1895,13 +2420,14 @@ def test_stepwise_progress_metadata_and_commit_trace() -> None:
         assert output.output["payload"]["latents"].shape == (1, 16, 3, 2, 2)
 
 
-def test_stepwise_matches_tick_transformer_trace_and_latents() -> None:
+@pytest.mark.parametrize("num_chunks", [2, 12])
+def test_stepwise_matches_tick_transformer_trace_and_latents(num_chunks) -> None:
     module = _load_pipeline_module()
     transformer = _RecordingTransformer()
     pipeline = _pipeline(module, transformer=transformer)
     pipeline._ar_height = 16
     pipeline._ar_width = 16
-    script = ((("w",), ("w",), ("w",)), (("d",), ("d",), ("d",)))
+    script = ((("w",), ("w",), ("w",)), (("d",), ("d",), ("d",))) * (num_chunks // 2)
     fake = _FakeARState("world-1")
 
     with pipeline.bind_ar_diffusion_state("world-1", fake):
@@ -1928,7 +2454,7 @@ def test_stepwise_matches_tick_transformer_trace_and_latents() -> None:
     transformer.calls.clear()
     pipeline.close_ar_diffusion_session("world-1")
 
-    stepwise_state = _stepwise_state(request_id="req-1", num_frames=21, script=script, seed=17)
+    stepwise_state = _stepwise_state(request_id="req-1", num_frames=12 * num_chunks - 3, script=script, seed=17)
     stepwise_fake = _FakeARState(stepwise_state.request_id)
     with pipeline.bind_ar_diffusion_state(stepwise_state.request_id, stepwise_fake):
         stepwise_outputs = _run_stepwise(pipeline, stepwise_state)
@@ -1937,6 +2463,18 @@ def test_stepwise_matches_tick_transformer_trace_and_latents() -> None:
     assert [call["start_frame"] for call in transformer.calls] == [call["start_frame"] for call in tick_calls]
     for tick_latent, output in zip(tick_latents, stepwise_outputs, strict=True):
         torch.testing.assert_close(output.output["payload"]["latents"], tick_latent)
+    for step_call, tick_call in zip(transformer.calls, tick_calls, strict=True):
+        torch.testing.assert_close(step_call["hidden_states"], tick_call["hidden_states"])
+        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 == []
+    # 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 == []
 
 
 def test_stepwise_trajectory_camera_matches_request_mode_under_non_uniform_speed(monkeypatch) -> None:
@@ -2002,25 +2540,31 @@ def test_stepwise_emits_latents_without_touching_the_vae() -> None:
     assert pipeline.vae.decode_inputs == []
 
 
-def test_stepwise_decodes_each_chunk_for_streaming_consumers(monkeypatch) -> None:
-    """A non-latent request must stream pixels under the primary "video" key."""
-    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 = []
+    processed: list[tuple[int, ...]] = []
 
-    class VideoProcessor:
-        def __init__(self, *, vae_scale_factor):
-            assert vae_scale_factor == 8
+    def uint8_frames(video):
+        processed.append(tuple(video.shape))
+        return f"frames-{len(processed)}"
 
-        def postprocess_video(self, video, *, output_type):
-            processed.append((tuple(video.shape), output_type))
-            return f"frames-{len(processed)}"
+    monkeypatch.setattr(module, "_uint8_frames", uint8_frames)
+    return processed
 
-    monkeypatch.setattr(video_processor_module, "VideoProcessor", VideoProcessor)
+
+def _streaming_pipeline(module):
     pipeline = _pipeline(module, transformer=_RecordingTransformer())
     pipeline._ar_height = 16
     pipeline._ar_width = 16
+    return pipeline
+
+
+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_pixel_conversion(monkeypatch)
+    pipeline = _streaming_pipeline(module)
     state = _stepwise_state(num_frames=21)
     state.sampling.output_type = "np"
     fake = _FakeARState(state.request_id)
@@ -2028,14 +2572,324 @@ 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)
 
-    # One decode per AR block, each seeing only that block's three latent frames.
-    assert [tuple(latents.shape) for latents in pipeline.vae.decode_inputs] == [(1, 16, 3, 2, 2)] * 2
-    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]
 
 
+def test_stepwise_chunks_continue_one_sessions_temporal_decode(monkeypatch) -> None:
+    """Chunk N + 1 must continue chunk N instead of restarting the decoder.
+
+    Only the session's opening latent frame collapses to a single raw frame,
+    so the streamed timeline carries the same frame count an offline decode of
+    the same latents would: 9 frames, then 12.
+    """
+    module = _load_pipeline_module()
+    processed = _capture_pixel_conversion(monkeypatch)
+    pipeline = _streaming_pipeline(module)
+    state = _stepwise_state(num_frames=21)
+    state.sampling.output_type = "np"
+    fake = _FakeARState(state.request_id)
+
+    with pipeline.bind_ar_diffusion_state(state.request_id, fake):
+        _run_stepwise(pipeline, state)
+
+    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
+    # the shared VAE keeps for it is untouched.
+    assert pipeline.vae.decode_inputs == []
+    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_pixel_conversion(monkeypatch)
+    pipeline = _streaming_pipeline(module)
+    state = _stepwise_state(request_id="req-stream", num_frames=21)
+    state.sampling.output_type = "np"
+    fake = _FakeARState(state.request_id)
+
+    with pipeline.bind_ar_diffusion_state(state.request_id, fake):
+        _run_stepwise(pipeline, state)
+
+    decode_state = pipeline._streaming_decode_states["req-stream"]
+    assert decode_state.session_id == "req-stream"
+    assert decode_state.frames_decoded == 6
+    assert decode_state.nbytes() > 0
+
+    pipeline.close_ar_diffusion_session("req-stream")
+    assert "req-stream" not in pipeline._streaming_decode_states
+    # Release drops the cache itself, not just the pipeline's reference to it.
+    assert decode_state.nbytes() == 0
+    assert decode_state.frames_decoded == 0
+
+
+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_pixel_conversion(monkeypatch)
+    pipeline = _streaming_pipeline(module)
+    state = _stepwise_state(request_id="req-reset", num_frames=21)
+    state.sampling.output_type = "np"
+    fake = _FakeARState(state.request_id)
+
+    with pipeline.bind_ar_diffusion_state(state.request_id, fake):
+        _run_stepwise(pipeline, state)
+
+    pipeline.reset_ar_diffusion_session("req-reset")
+    assert pipeline._streaming_decode_states == {}
+    # Releasing a session that never decoded is a no-op, not an error.
+    pipeline.reset_ar_diffusion_session("req-reset")
+
+
+def test_streaming_decode_keeps_interleaved_sessions_isolated(monkeypatch) -> None:
+    """Two sessions ticking alternately must not share one temporal cache.
+
+    Running one rollout to completion before the other starts would only show
+    that the dict is keyed by request id. The failure worth catching is chunk N
+    of one session advancing the other's cache mid-rollout, which needs the
+    interleaving the scheduler actually produces.
+    """
+    module = _load_pipeline_module()
+    processed = _capture_pixel_conversion(monkeypatch)
+    pipeline = _streaming_pipeline(module)
+    states = []
+    for request_id in ("req-a", "req-b"):
+        state = _stepwise_state(request_id=request_id, num_frames=21)
+        state.sampling.output_type = "np"
+        states.append(state)
+    runs = [_stepwise_chunks(pipeline, state, _FakeARState(state.request_id)) for state in states]
+
+    chunks: list[tuple[str, int]] = []
+    while runs:
+        for run in list(runs):
+            try:
+                output = next(run)
+            except StopIteration:
+                runs.remove(run)
+                continue
+            metadata = output.output["metadata"]["ar_diffusion"]
+            chunks.append((metadata["session_id"], metadata["chunk_index"]))
+
+    # A-chunk0, B-chunk0, A-chunk1, B-chunk1: the sessions really are interleaved.
+    assert chunks == [("req-a", 0), ("req-b", 0), ("req-a", 1), ("req-b", 1)]
+
+    caches = pipeline._streaming_decode_states
+    assert set(caches) == {"req-a", "req-b"}
+    assert caches["req-a"].feat_map is not caches["req-b"].feat_map
+    # Every frame of a session was decoded through that session's own cache,
+    # three frames per chunk, and each session opened exactly one rollout.
+    cache_a, cache_b = (id(caches["req-a"].feat_map), id(caches["req-b"].feat_map))
+    assert pipeline.vae.decoder.cache_ids == [cache_a] * 3 + [cache_b] * 3 + [cache_a] * 3 + [cache_b] * 3
+    assert pipeline.vae.decoder.first_chunk_flags == (
+        [True, False, False] + [True, False, False] + [False] * 3 + [False] * 3
+    )
+    assert processed == [
+        (1, 3, 9, 16, 16),
+        (1, 3, 9, 16, 16),
+        (1, 3, 12, 16, 16),
+        (1, 3, 12, 16, 16),
+    ]
+
+
+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_pixel_conversion(monkeypatch)
+    pipeline = _streaming_pipeline(module)
+    state = _stepwise_state(request_id="req-boom", num_frames=21)
+    state.sampling.output_type = "np"
+
+    def explode(*args, **kwargs):
+        raise RuntimeError("decoder blew up")
+
+    pipeline.vae.decoder = explode
+
+    with pytest.raises(RuntimeError, match="decoder blew up"):
+        with pipeline.bind_ar_diffusion_state(state.request_id, _FakeARState(state.request_id)):
+            _run_stepwise(pipeline, state)
+
+    assert pipeline._streaming_decode_states == {}
+
+
+def _enable_vae_tiling(pipeline, *, tile_sample_min: int) -> None:
+    """Configure the stub VAE the way registry.py configures the real one."""
+    pipeline.vae.use_tiling = True
+    pipeline.vae.spatial_compression_ratio = 8
+    pipeline.vae.tile_sample_min_height = tile_sample_min
+    pipeline.vae.tile_sample_min_width = tile_sample_min
+
+
+def test_streaming_decode_receives_rescaled_latents(monkeypatch) -> None:
+    """The streaming branch must invert the checkpoint's latent statistics.
+
+    Nothing downstream can catch a miss here: the pixels stay finite and
+    correctly shaped, only wrongly scaled. Request mode and the fallback path
+    observe the rescale through ``vae.decode``'s recorded input, which streaming
+    never reaches, so this asserts on what ``post_quant_conv`` received.
+    """
+    module = _load_pipeline_module()
+    _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()
+        pipeline.post_decode(state)
+
+    shape = (1, -1, 1, 1, 1)
+    latent_mean = torch.as_tensor(pipeline.vae.config.latents_mean, dtype=model_space.dtype).view(*shape)
+    latent_std = torch.as_tensor(pipeline.vae.config.latents_std, dtype=model_space.dtype).view(*shape)
+    expected = (model_space * latent_std + latent_mean).to(dtype=pipeline.vae.dtype)
+
+    recorded = torch.cat(pipeline.vae.post_quant_inputs, dim=2)
+    assert recorded.shape == expected.shape, "one recorded frame per latent frame in the chunk"
+    torch.testing.assert_close(recorded, expected, rtol=0, atol=0)
+    # And the rescale is not a no-op on this fixture, so the assertion bites.
+    assert not torch.equal(expected, model_space.to(dtype=pipeline.vae.dtype))
+
+
+def test_streaming_decode_is_reported_to_the_profiler(monkeypatch) -> None:
+    """A streamed rollout must report decode time, not zero.
+
+    The profiler wraps ``vae.decode``, which streaming never calls, so without
+    its own stage the one stage this path changes would be invisible -- and a
+    perf regression in the streaming decoder would be too.
+    """
+    module = _load_pipeline_module()
+    _capture_pixel_conversion(monkeypatch)
+    pipeline = _pipeline(
+        module,
+        transformer=_RecordingTransformer(),
+        od_config=_od_config(
+            enable_diffusion_pipeline_profiler=True,
+        ),
+    )
+    pipeline._ar_height = 16
+    pipeline._ar_width = 16
+    state = _stepwise_state(num_frames=21)
+    state.sampling.output_type = "np"
+
+    with pipeline.bind_ar_diffusion_state(state.request_id, _FakeARState(state.request_id)):
+        outputs = _run_stepwise(pipeline, state)
+
+    stage = f"{type(pipeline).__name__}._streaming_decode_chunk"
+    durations = pipeline.stage_durations
+    assert stage in durations, f"streamed decode is unprofiled; stages seen: {sorted(durations)}"
+    assert durations[stage] > 0.0
+    assert durations[f"{type(pipeline).__name__}._prepare_condition_chunk"] > 0.0
+    # The stage reaches the consumer on every streamed chunk, not just at the end.
+    assert all(stage in (output.stage_durations or {}) for output in outputs)
+
+
+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_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), 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 processed == [(1, 3, 9, 16, 16), (1, 3, 9, 16, 16)]
+    assert outputs == ["frames-1", "frames-2"]
+
+
+def test_streaming_decode_survives_tiling_enabled_below_the_tile_threshold(monkeypatch) -> None:
+    """``use_tiling`` alone does not tile, so such a shape must still stream.
+
+    ``AutoencoderKLWan._decode`` tiles only when the latent exceeds a tile. A
+    gate on the flag alone would give up streaming -- and a frame per block --
+    on a configuration that would never have tiled.
+    """
+    module = _load_pipeline_module()
+    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)
+    state = _stepwise_state(num_frames=21)
+    state.sampling.output_type = "np"
+
+    with pipeline.bind_ar_diffusion_state(state.request_id, _FakeARState(state.request_id)):
+        _run_stepwise(pipeline, state)
+
+    assert pipeline.vae.decode_inputs == []
+    assert pipeline.vae.decoder.first_chunk_flags == [True] + [False] * 5
+    assert processed == [(1, 3, 9, 16, 16), (1, 3, 12, 16, 16)]
+
+
 def test_registry_and_model_exports_resolve_official_pipeline_class_name() -> None:
     module = _load_pipeline_module()
     resolved, entry, cache_acceleration_disabled, preprocess_name, preprocess = _resolve_pipeline_through_real_registry(
@@ -2054,3 +2908,315 @@ def test_registry_and_model_exports_resolve_official_pipeline_class_name() -> No
     assert "from .pipeline import" in lingbot_init
     assert '"LingBotWorldCausalDMDPipeline"' in lingbot_init
     assert '"CausalLingBotWorldTransformer3DModel"' in lingbot_init
+
+
+# ---------------------------------------------------------------------------
+# a prompt is encoded once, whichever path asks for it
+# ---------------------------------------------------------------------------
+def _counting_text_encoder(pipeline) -> list[str]:
+    """Give ``pipeline`` its real encode_prompt over stubs that record each encode."""
+    del pipeline.encode_prompt  # _pipeline() replaces it; these tests need the real one
+    encoded: list[str] = []
+
+    def tokenizer(texts, **kwargs):
+        del kwargs
+        encoded.extend(texts)
+        return SimpleNamespace(
+            input_ids=torch.arange(512).view(1, 512),
+            attention_mask=torch.ones(1, 512, dtype=torch.long),
+        )
+
+    def text_encoder(input_ids, attention_mask):
+        del input_ids, attention_mask
+        return SimpleNamespace(last_hidden_state=torch.full((1, 512, 8), float(len(encoded))))
+
+    pipeline.tokenizer = tokenizer
+    pipeline.text_encoder = text_encoder
+    return encoded
+
+
+def test_the_text_encoder_runs_once_per_distinct_prompt() -> None:
+    module = _load_pipeline_module()
+    pipeline = _pipeline(module)
+    encoded = _counting_text_encoder(pipeline)
+
+    def encode(prompt, *, length=512, dtype=torch.float32):
+        return pipeline.encode_prompt(prompt, max_sequence_length=length, dtype=dtype)
+
+    first = encode("move through the room")
+    assert encode("move through the room") is first
+    # The key is the text the tokenizer actually sees, so spacing alone is not new.
+    assert encode("  move   through the room ") is first
+    assert encoded == ["move through the room"]
+
+    encode("enter the snowy valley")
+    # dtype and sequence length change the tensor, so each is its own entry.
+    encode("move through the room", dtype=torch.float16)
+    encode("move through the room", length=256)
+    assert encoded == [
+        "move through the room",
+        "enter the snowy valley",
+        "move through the room",
+        "move through the room",
+    ]
+
+
+def test_the_prompt_encode_cache_is_bounded() -> None:
+    module = _load_pipeline_module()
+    pipeline = _pipeline(module)
+    encoded = _counting_text_encoder(pipeline)
+    size = module._PROMPT_EMBEDS_CACHE_SIZE
+
+    for index in range(size + 1):
+        pipeline.encode_prompt(f"prompt {index}", max_sequence_length=512, dtype=torch.float32)
+    assert len(pipeline._prompt_embeds_cache) == size
+
+    # The oldest entry was the one evicted, so it is the one encoded again.
+    pipeline.encode_prompt("prompt 0", max_sequence_length=512, dtype=torch.float32)
+    pipeline.encode_prompt(f"prompt {size}", max_sequence_length=512, dtype=torch.float32)
+    assert encoded == [f"prompt {index}" for index in range(size + 1)] + ["prompt 0"]
+
+
+def test_realtime_ticks_reuse_the_encode_and_still_invalidate_on_a_prompt_change(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    module = _load_pipeline_module()
+    pipeline = _pipeline(module)
+    pipeline._ar_height = 16
+    pipeline._ar_width = 16
+    pipeline._ar_diffusion_kv_state = object()
+    encoded = _counting_text_encoder(pipeline)
+    invalidations: list[bool] = []
+
+    def ar_text_caches(prompt_embeds, *, invalidate):
+        del prompt_embeds
+        invalidations.append(invalidate)
+        return [SimpleNamespace()]
+
+    monkeypatch.setattr(pipeline, "_ar_text_caches", ar_text_caches)
+    monkeypatch.setattr(
+        pipeline,
+        "_generate_block",
+        lambda **kwargs: torch.randn((1, 16, 3, 2, 2), generator=kwargs["generator"]),
+    )
+
+    for chunk_index in range(3):
+        pipeline(_request(sampling=_SamplingParams(extra_args=_tick_extra_args(chunk_index=chunk_index))))
+    switched = _prompt()
+    switched["prompt"] = "enter the snowy valley"
+    pipeline(
+        _request(
+            sampling=_SamplingParams(extra_args=_tick_extra_args(chunk_index=3, prompt=switched["prompt"])),
+            prompt=switched,
+        )
+    )
+
+    assert encoded == ["move through the room", "enter the snowy valley"]
+    # A new prompt must still drop the cross-attention K/V built from the old one.
+    assert invalidations == [False, False, False, True]
+
+
+def test_stepwise_requests_with_the_same_prompt_share_one_encode() -> None:
+    module = _load_pipeline_module()
+    pipeline = _pipeline(module, transformer=_RecordingTransformer())
+    pipeline._ar_height = 16
+    pipeline._ar_width = 16
+    encoded = _counting_text_encoder(pipeline)
+
+    states = [_stepwise_state(request_id=request_id, num_frames=21) for request_id in ("req-a", "req-b")]
+    for state in states:
+        with pipeline.bind_ar_diffusion_state(state.request_id, _FakeARState(state.request_id)):
+            pipeline.prepare_encode(state)
+
+    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/ltx2/test_ltx2_transformer.py b/tests/diffusion/models/ltx2/test_ltx2_transformer.py
index f12fbc466..679b7ca37 100644
--- a/tests/diffusion/models/ltx2/test_ltx2_transformer.py
+++ b/tests/diffusion/models/ltx2/test_ltx2_transformer.py
@@ -233,6 +233,7 @@ def _fake_ltx_parallel_attention():
 
     layer = object.__new__(ltx2_transformer._LTX2ParallelAttention)
     nn.Module.__init__(layer)
+    layer.allow_fp32_fallback = False
     layer.attn_backend = Backend
     layer.attention = SimpleNamespace(forward=run("native"))
     layer.sdpa_fallback = SimpleNamespace(forward=run("sdpa"))
diff --git a/tests/diffusion/models/magi2/test_native_compile.py b/tests/diffusion/models/magi2/test_native_compile.py
new file mode 100644
index 000000000..0abac75f8
--- /dev/null
+++ b/tests/diffusion/models/magi2/test_native_compile.py
@@ -0,0 +1,137 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from __future__ import annotations
+
+import pytest
+import torch
+
+from tests.diffusion.models.magi2.test_native_packing import (
+    _longer_text_tensors,
+    _sampler_tensors,
+    _tiny_model,
+    _tiny_sampler,
+)
+from vllm_omni.diffusion.models.magi2.sampler_magi2 import CFGConfig
+
+pytestmark = [pytest.mark.diffusion, pytest.mark.cpu, pytest.mark.core_model]
+
+
+def test_layer_regions_bracket_the_eager_kernels() -> None:
+    moe_layer, dense_layer = _tiny_model().block.layers
+
+    assert moe_layer.region_methods == ("_attention_input", "_moe_input", "_moe_output")
+    assert dense_layer.region_methods == ("_attention_input", "_dense_output")
+
+
+def test_compile_regions_fullgraph_matches_eager_bitwise() -> None:
+    model = _tiny_model()
+    sampler = _tiny_sampler(model)
+    steps = [
+        sampler.prepare_model_input(**_sampler_tensors(seed), t=t, cfg_config=CFGConfig())
+        for seed, t in enumerate((torch.tensor([900.0]), torch.tensor([450.0])))
+    ]
+    expected = [sampler.forward(step) for step in steps]
+
+    torch._dynamo.reset()
+    graphs_before = torch._dynamo.utils.counters["stats"]["unique_graphs"]
+    model.compile_regions(fullgraph=True, backend="eager", dynamic=True)
+    first = sampler.forward(steps[0])
+    graphs = torch._dynamo.utils.counters["stats"]["unique_graphs"] - graphs_before
+    with torch._dynamo.config.patch(error_on_recompile=True):
+        second = sampler.forward(steps[1])
+
+    for (video, audio), (video_ref, audio_ref) in zip((first, second), expected, strict=True):
+        assert torch.equal(video, video_ref)
+        assert torch.equal(audio, audio_ref)
+    # pre adapter, post adapter, three MoE-layer regions, two dense-layer regions
+    assert graphs == 7
+
+
+def test_pipeline_setup_compile_forwards_config_dynamic() -> None:
+    from vllm_omni.diffusion.data import OmniDiffusionConfig
+    from vllm_omni.diffusion.models.magi2.pipeline_magi2 import Magi2Pipeline
+
+    calls: list[dict[str, object]] = []
+
+    class _Transformer(torch.nn.Module):
+        def compile_regions(self, **compile_kwargs: object) -> None:
+            calls.append(compile_kwargs)
+
+    pipeline = object.__new__(Magi2Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.od_config = OmniDiffusionConfig(
+        model="sand-ai/MAGI-2-preview",
+        model_class_name="Magi2Pipeline",
+        diffusion_compile_dynamic=False,
+    )
+    pipeline.transformer = _Transformer()
+
+    pipeline.setup_compile()
+
+    assert calls == [{"fullgraph": True, "dynamic": False, "options": {"emulate_precision_casts": True}}]
+
+
+def test_pipeline_setup_compile_warns_when_granularity_is_not_regional(caplog: pytest.LogCaptureFixture) -> None:
+    from vllm_omni.diffusion.data import OmniDiffusionConfig
+    from vllm_omni.diffusion.models.magi2.pipeline_magi2 import Magi2Pipeline
+
+    calls: list[dict[str, object]] = []
+
+    class _Transformer(torch.nn.Module):
+        def compile_regions(self, **compile_kwargs: object) -> None:
+            calls.append(compile_kwargs)
+
+    pipeline = object.__new__(Magi2Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.od_config = OmniDiffusionConfig(
+        model="sand-ai/MAGI-2-preview",
+        model_class_name="Magi2Pipeline",
+        diffusion_compile_granularity="full",
+    )
+    pipeline.transformer = _Transformer()
+
+    pipeline.setup_compile()
+
+    assert calls == [{"fullgraph": True, "dynamic": True, "options": {"emulate_precision_casts": True}}]
+    assert "diffusion_compile_granularity='full'" in caplog.text
+
+
+def test_compiled_graphs_are_shared_across_layers_of_one_kind() -> None:
+    model = _tiny_model(moe_layers=2)
+    sampler = _tiny_sampler(model)
+    step = sampler.prepare_model_input(**_sampler_tensors(0), t=torch.tensor([900.0]), cfg_config=CFGConfig())
+    expected = sampler.forward(step)
+
+    torch._dynamo.reset()
+    graphs_before = torch._dynamo.utils.counters["stats"]["unique_graphs"]
+    model.compile_regions(fullgraph=True, backend="eager", dynamic=True)
+    actual = sampler.forward(step)
+
+    assert torch.equal(actual[0], expected[0])
+    # Two MoE layers and two dense layers still compile one graph per region
+    # kind: pre adapter, post adapter, three MoE regions, two dense regions.
+    assert torch._dynamo.utils.counters["stats"]["unique_graphs"] - graphs_before == 7
+
+
+def test_compiled_regions_survive_new_requests_without_recompiling() -> None:
+    model = _tiny_model()
+    sampler = _tiny_sampler(model)
+    t = torch.tensor([900.0])
+    first_request = sampler.prepare_model_input(**_sampler_tensors(0), t=t, cfg_config=CFGConfig())
+    second_request = sampler.prepare_model_input(**_sampler_tensors(1), t=t, cfg_config=CFGConfig())
+    longer_request = sampler.prepare_model_input(**_longer_text_tensors(2), t=t, cfg_config=CFGConfig())
+    expected = [sampler.forward(request) for request in (first_request, second_request, longer_request)]
+
+    torch._dynamo.reset()
+    graphs_before = torch._dynamo.utils.counters["stats"]["unique_graphs"]
+    model.compile_regions(fullgraph=True, backend="eager", dynamic=True)
+    actual = [sampler.forward(first_request)]
+    with torch._dynamo.config.patch(error_on_recompile=True):
+        actual.append(sampler.forward(second_request))
+        actual.append(sampler.forward(longer_request))
+
+    for (video, audio), (video_ref, audio_ref) in zip(actual, expected, strict=True):
+        assert torch.equal(video, video_ref)
+        assert torch.equal(audio, audio_ref)
+    assert torch._dynamo.utils.counters["stats"]["unique_graphs"] - graphs_before == 7
diff --git a/tests/diffusion/models/magi2/test_native_compile_cuda.py b/tests/diffusion/models/magi2/test_native_compile_cuda.py
new file mode 100644
index 000000000..f6f87f0d1
--- /dev/null
+++ b/tests/diffusion/models/magi2/test_native_compile_cuda.py
@@ -0,0 +1,78 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from __future__ import annotations
+
+import pytest
+import torch
+
+from tests.diffusion.models.magi2.test_native_packing import (
+    _longer_text_tensors,
+    _sampler_tensors,
+    _tiny_model,
+    _tiny_sampler,
+)
+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 current_omni_platform.is_cuda(), reason="requires CUDA"),
+]
+
+
+def _cuda_steps(sampler, tensors=_sampler_tensors):
+    timesteps = (torch.tensor([900.0]), torch.tensor([600.0]), torch.tensor([300.0]))
+    return [
+        sampler.prepare_model_input(
+            **{name: value.cuda() for name, value in tensors(seed).items()},
+            t=t,
+            cfg_config=CFGConfig(),
+        )
+        for seed, t in enumerate(timesteps)
+    ]
+
+
+def test_inductor_regions_match_eager_in_deterministic_mode(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("MAGI2_DETERMINISTIC", "1")
+    model = _tiny_model(params_dtype=torch.bfloat16).cuda()
+    sampler = _tiny_sampler(model)
+    steps = _cuda_steps(sampler)
+    expected = [sampler.forward(step) for step in steps]
+    new_request_step = _cuda_steps(sampler)[0]
+    longer_text_step = _cuda_steps(sampler, _longer_text_tensors)[0]
+    expected_new_request = sampler.forward(new_request_step)
+    expected_longer_text = sampler.forward(longer_text_step)
+
+    torch._dynamo.reset()
+    graphs_before = torch._dynamo.utils.counters["stats"]["unique_graphs"]
+    # The pipeline compiles with inductor emulating eager's intermediate
+    # low-precision casts, so fused bf16 chains keep eager's rounding.
+    model.compile_regions(fullgraph=True, dynamic=True, options={"emulate_precision_casts": True})
+    first = sampler.forward(steps[0])
+    with torch._dynamo.config.patch(error_on_recompile=True):
+        compiled = [first, sampler.forward(steps[1]), sampler.forward(steps[2])]
+        repeated = [sampler.forward(step) for step in steps]
+        # A second request repacks the same shapes; a third changes the
+        # text length and therefore every token count.
+        compiled_new_request = sampler.forward(new_request_step)
+        compiled_longer_text = sampler.forward(longer_text_step)
+
+    # Emulated precision casts restore eager's rounding boundaries; what is
+    # left is one-ulp transcendental noise that some Triton backends carry.
+    for (video, audio), (video_ref, audio_ref) in zip(compiled, expected, strict=True):
+        torch.testing.assert_close(video, video_ref, atol=1e-6, rtol=0)
+        torch.testing.assert_close(audio, audio_ref, atol=1e-6, rtol=0)
+    for (video, audio), (video_again, audio_again) in zip(compiled, repeated, strict=True):
+        assert torch.equal(video, video_again)
+        assert torch.equal(audio, audio_again)
+    for (video, audio), (video_ref, audio_ref) in (
+        (compiled_new_request, expected_new_request),
+        (compiled_longer_text, expected_longer_text),
+    ):
+        torch.testing.assert_close(video, video_ref, atol=1e-6, rtol=0)
+        torch.testing.assert_close(audio, audio_ref, atol=1e-6, rtol=0)
+    assert torch._dynamo.utils.counters["stats"]["unique_graphs"] - graphs_before == 7
diff --git a/tests/diffusion/models/magi2/test_native_compile_distributed.py b/tests/diffusion/models/magi2/test_native_compile_distributed.py
new file mode 100644
index 000000000..03f6f601c
--- /dev/null
+++ b/tests/diffusion/models/magi2/test_native_compile_distributed.py
@@ -0,0 +1,179 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from __future__ import annotations
+
+import os
+import tempfile
+from contextlib import ExitStack, contextmanager
+from unittest.mock import patch
+
+import pytest
+import torch
+import torch.distributed as dist
+import torch.multiprocessing as mp
+import torch.nn as nn
+from torch.distributed import init_device_mesh
+from torch.distributed.fsdp import MixedPrecisionPolicy
+
+import vllm_omni.diffusion.offloader.distributed_layerwise_backend as dlo_module
+from tests.diffusion.models.magi2.test_native_distributed_parity import (
+    _current_group,
+    _new_groups,
+    _patched_groups,
+)
+from tests.diffusion.models.magi2.test_native_packing import _tiny_config, _tiny_model, _tiny_sampler
+from tests.diffusion.offloader.helpers import patch_offload_runtime
+from vllm_omni.diffusion.distributed.hsdp import shard_model
+from vllm_omni.diffusion.models.magi2.modeling_magi2 import Magi2PreviewTransformer
+from vllm_omni.diffusion.models.magi2.parallel import Magi2ParallelGroup
+from vllm_omni.diffusion.models.magi2.pipeline_magi2 import Magi2Pipeline
+from vllm_omni.diffusion.models.magi2.sampler_magi2 import CFGConfig
+from vllm_omni.diffusion.offloader.base import OffloadConfig
+from vllm_omni.diffusion.offloader.config import OffloadStrategy
+
+_WORLD_SIZE = 4
+pytestmark = [pytest.mark.diffusion, pytest.mark.cpu, pytest.mark.core_model]
+
+
+@contextmanager
+def _cpu_offload_runtime():
+    with pytest.MonkeyPatch.context() as monkeypatch:
+        patch_offload_runtime(monkeypatch, dlo_module.current_omni_platform, synchronize=True)
+        yield
+
+
+def _enable_dlo(
+    model: Magi2PreviewTransformer,
+    *,
+    dp_group: dist.ProcessGroup | None,
+    dp_size: int,
+    dp_rank: int,
+) -> None:
+    pipeline = Magi2Pipeline.__new__(Magi2Pipeline)
+    nn.Module.__init__(pipeline)
+    pipeline.transformer = model
+    backend = dlo_module.DistributedLayerwiseOffloadBackend(
+        OffloadConfig(
+            strategy=OffloadStrategy.DISTRIBUTED_LAYER_WISE,
+            pin_cpu_memory=False,
+            dp_size=dp_size,
+            dlo_use_allgather=dp_size > 1,
+        ),
+        torch.device("cpu"),
+    )
+    backend.dp_group = dp_group
+    backend.rank = dp_rank
+    backend.enable(pipeline)
+    assert backend.enabled
+
+
+def _enable_hsdp(model: Magi2PreviewTransformer) -> None:
+    mesh = init_device_mesh("cpu", mesh_shape=(1, _WORLD_SIZE), mesh_dim_names=("replicate", "shard"))
+    ignored = {
+        parameter for name in model._hsdp_ignored_modules for parameter in model.get_submodule(name).parameters()
+    }
+    shard_model(
+        model,
+        mesh=mesh,
+        mp_policy=MixedPrecisionPolicy(cast_forward_inputs=False),
+        hsdp_shard_conditions=model._hsdp_shard_conditions,
+        ignored_params=ignored,
+    )
+    model.requires_grad_(False)
+
+
+def _sampler_tensors(seed: int) -> dict[str, torch.Tensor]:
+    # 14 tokens per CFG branch, so the packed sequence splits evenly across
+    # two Ulysses ranks; gloo cannot gather uneven shards.
+    generator = torch.Generator(device="cpu").manual_seed(seed)
+    return {
+        "latent": torch.randn(1, 4, 2, 1, 3, generator=generator),
+        "audio_latent": torch.randn(1, 5, 4, generator=generator),
+        "txt_feat": torch.randn(1, 3, 4, generator=generator),
+        "null_txt_feat": torch.randn(1, 3, 4, generator=generator),
+    }
+
+
+def _steps(sampler):
+    return [
+        sampler.prepare_model_input(**_sampler_tensors(seed), t=t, cfg_config=CFGConfig())
+        for seed, t in enumerate((torch.tensor([900.0]), torch.tensor([450.0])))
+    ]
+
+
+def _run(model: Magi2PreviewTransformer, *, compile_regions: bool) -> list[tuple[torch.Tensor, torch.Tensor]]:
+    sampler = _tiny_sampler(model)
+    steps = _steps(sampler)
+    if not compile_regions:
+        return [sampler.forward(step) for step in steps]
+    torch._dynamo.reset()
+    model.compile_regions(fullgraph=True, backend="eager", dynamic=True)
+    outputs = [sampler.forward(steps[0])]
+    with torch._dynamo.config.patch(error_on_recompile=True):
+        outputs.append(sampler.forward(steps[1]))
+    return outputs
+
+
+def _assert_same(actual, expected, *, exact: bool, label: str) -> None:
+    for (video, audio), (video_ref, audio_ref) in zip(actual, expected, strict=True):
+        if exact:
+            assert torch.equal(video, video_ref), label
+            assert torch.equal(audio, audio_ref), label
+        else:
+            torch.testing.assert_close(video, video_ref, atol=2e-5, rtol=2e-4, msg=label)
+            torch.testing.assert_close(audio, audio_ref, atol=2e-5, rtol=2e-4, msg=label)
+
+
+def _distributed_worker(rank: int, rendezvous: str) -> None:
+    torch.set_num_threads(1)
+    dist.init_process_group("gloo", init_method=rendezvous, rank=rank, world_size=_WORLD_SIZE)
+    try:
+        singleton = Magi2ParallelGroup(None, world_size=1, rank=0)
+        with _patched_groups(singleton, singleton):
+            oracle = _tiny_model()
+            checkpoint = [(name, value.detach().clone()) for name, value in oracle.state_dict().items()]
+            expected = _run(oracle, compile_regions=False)
+
+        sp2_groups = _new_groups(((0, 1), (2, 3)))
+        dp2_groups = _new_groups(((0, 2), (1, 3)))
+        sp_group = _current_group(rank, sp2_groups)
+        dp_ranks, dp_process_group = next((ranks, group) for ranks, group in dp2_groups if rank in ranks)
+
+        def dlo_rank_local(model: Magi2PreviewTransformer) -> None:
+            _enable_dlo(model, dp_group=None, dp_size=1, dp_rank=0)
+
+        def dlo_allgather(model: Magi2PreviewTransformer) -> None:
+            _enable_dlo(model, dp_group=dp_process_group, dp_size=len(dp_ranks), dp_rank=dp_ranks.index(rank))
+
+        variants = (
+            ("dlo_rank_local_sp2", sp_group, dlo_rank_local),
+            ("dlo_allgather_dp2sp2", sp_group, dlo_allgather),
+            ("hsdp4", singleton, _enable_hsdp),
+        )
+        for name, ulysses_group, enable in variants:
+            with ExitStack() as stack:
+                stack.enter_context(_patched_groups(singleton, ulysses_group))
+                stack.enter_context(_cpu_offload_runtime())
+                outputs = {}
+                for compile_regions in (False, True):
+                    model = Magi2PreviewTransformer(_tiny_config())
+                    assert model.load_weights(checkpoint) == set(model.state_dict())
+                    enable(model)
+                    outputs[compile_regions] = _run(model, compile_regions=compile_regions)
+            _assert_same(outputs[False], expected, exact=False, label=f"{name} eager vs single-rank oracle")
+            _assert_same(outputs[True], outputs[False], exact=True, label=f"{name} compiled vs eager")
+            dist.barrier()
+    finally:
+        dist.destroy_process_group()
+
+
+@pytest.mark.skipif(
+    not dist.is_available() or not dist.is_gloo_available(),
+    reason="requires torch.distributed gloo",
+)
+def test_compiled_regions_match_eager_under_dlo_and_hsdp() -> None:
+    with tempfile.TemporaryDirectory() as temp_dir:
+        rendezvous = f"file://{os.path.join(temp_dir, 'gloo-rendezvous')}"
+        with patch.dict(os.environ, {"CUDA_VISIBLE_DEVICES": ""}):
+            mp.spawn(_distributed_worker, args=(rendezvous,), nprocs=_WORLD_SIZE, join=True)
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_packing.py b/tests/diffusion/models/magi2/test_native_packing.py
new file mode 100644
index 000000000..cedabebcb
--- /dev/null
+++ b/tests/diffusion/models/magi2/test_native_packing.py
@@ -0,0 +1,118 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from __future__ import annotations
+
+import pytest
+import torch
+
+from vllm_omni.diffusion.models.magi2.configuration_magi2 import (
+    Magi2MHCConfig,
+    Magi2MoEConfig,
+    Magi2PreviewConfig,
+)
+from vllm_omni.diffusion.models.magi2.layers import MultiModalityRMSNorm
+from vllm_omni.diffusion.models.magi2.mh_moe import Magi2MultiHeadMoE
+from vllm_omni.diffusion.models.magi2.modeling_magi2 import Magi2PreviewTransformer
+from vllm_omni.diffusion.models.magi2.preview_data_proxy import (
+    Magi2DataProxy,
+    Magi2PreviewDataProxyConfig,
+)
+from vllm_omni.diffusion.models.magi2.sampler_magi2 import CFGConfig, Magi2PreviewSampler
+
+pytestmark = [pytest.mark.diffusion, pytest.mark.cpu, pytest.mark.core_model]
+
+
+def _tiny_config(params_dtype: torch.dtype = torch.float32, *, moe_layers: int = 1) -> Magi2PreviewConfig:
+    # The leading layers are multimodal with MoE, the rest single-modality
+    # dense, so every layer belongs to one of two kinds.
+    moe_indices = tuple(range(moe_layers))
+    return Magi2PreviewConfig(
+        num_layers=2 * moe_layers,
+        hidden_size=16,
+        head_dim=8,
+        num_query_groups=2,
+        video_in_channels=4,
+        audio_in_channels=4,
+        text_in_channels=4,
+        intermediate_factor=2,
+        multimodal_layers=moe_indices,
+        params_dtype=params_dtype,
+        mhc=Magi2MHCConfig(num_streams=2),
+        moe=Magi2MoEConfig(
+            num_heads=2,
+            num_experts=4,
+            top_k=2,
+            expert_intermediate_size=8,
+            shared_expert_intermediate_size=8,
+            modality_shared_expert_intermediate_size=8,
+            layers=moe_indices,
+        ),
+    )
+
+
+def _tiny_model(
+    seed: int = 11,
+    params_dtype: torch.dtype = torch.float32,
+    *,
+    moe_layers: int = 1,
+) -> Magi2PreviewTransformer:
+    model = Magi2PreviewTransformer(_tiny_config(params_dtype, moe_layers=moe_layers))
+    generator = torch.Generator(device="cpu").manual_seed(seed)
+    with torch.no_grad():
+        for parameter in model.parameters():
+            parameter.copy_(torch.randn(parameter.shape, generator=generator, dtype=parameter.dtype) * 0.02)
+        for module in model.modules():
+            if isinstance(module, MultiModalityRMSNorm):
+                module.weight.zero_()
+            elif isinstance(module, Magi2MultiHeadMoE):
+                module.router.expert_bias.zero_()
+                module.router.expert_bias_ema.zero_()
+    return model
+
+
+def _tiny_sampler(model: torch.nn.Module) -> Magi2PreviewSampler:
+    return Magi2PreviewSampler(model, Magi2DataProxy(Magi2PreviewDataProxyConfig(time_channel_dim=8)))
+
+
+def _sampler_tensors(seed: int) -> dict[str, torch.Tensor]:
+    generator = torch.Generator(device="cpu").manual_seed(seed)
+    return {
+        "latent": torch.randn(1, 4, 2, 1, 3, generator=generator),
+        "audio_latent": torch.randn(1, 5, 4, generator=generator),
+        "txt_feat": torch.randn(1, 3, 4, generator=generator),
+        "null_txt_feat": torch.randn(1, 2, 4, generator=generator),
+    }
+
+
+def _longer_text_tensors(seed: int) -> dict[str, torch.Tensor]:
+    tensors = _sampler_tensors(seed)
+    generator = torch.Generator(device="cpu").manual_seed(seed + 100)
+    tensors["txt_feat"] = torch.randn(1, 4, 4, generator=generator)
+    return tensors
+
+
+def test_prepare_model_input_keeps_lengths_on_host() -> None:
+    sampler = Magi2PreviewSampler(torch.nn.Identity())
+    model_input = sampler.prepare_model_input(**_sampler_tensors(0), t=torch.tensor([500.0]), cfg_config=CFGConfig())
+
+    assert model_input.audio_feat_len == [5, 5]
+    assert model_input.txt_feat_len == [3, 2]
+    assert model_input.ref_audio_feat_len == [0, 0]
+    assert model_input.ref_video_feat_len == [0, 0]
+
+    positive, negative = Magi2PreviewSampler._split_cfg_model_input(model_input)
+    assert positive.txt_feat_len == [3]
+    assert negative.txt_feat_len == [2]
+
+
+def test_pre_adapter_embeds_directly_in_checkpoint_dtype() -> None:
+    model = _tiny_model(params_dtype=torch.bfloat16)
+    packed = torch.randn(6, 4)
+    indices = torch.tensor([0, 1]), torch.tensor([2, 3]), torch.tensor([4, 5])
+
+    with torch.no_grad():
+        hidden = model.pre_adapter(packed, *indices)
+
+    assert hidden.dtype == torch.bfloat16
+    assert hidden.shape == (6, model.config.virtual_width)
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/vllm_omni/diffusion/layers/mot/ops/__init__.py b/tests/diffusion/models/mammoth_moda2/__init__.py
similarity index 100%
rename from vllm_omni/diffusion/layers/mot/ops/__init__.py
rename to tests/diffusion/models/mammoth_moda2/__init__.py
diff --git a/tests/diffusion/models/mammoth_moda2/test_dit_attention.py b/tests/diffusion/models/mammoth_moda2/test_dit_attention.py
new file mode 100644
index 000000000..bab2fee7d
--- /dev/null
+++ b/tests/diffusion/models/mammoth_moda2/test_dit_attention.py
@@ -0,0 +1,189 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""MammothModa2 DiT self-attention runs through the shared Omni attention layer.
+
+``_reference_attention`` is the arithmetic the processor used before it was
+wired to the shared layer: SDPA over K/V replicated to the query head count,
+padded rows zeroed. Both sides read the same module weights, so any drift in
+the projections, the QK RMSNorm, the interleaved real RoPE, the softmax scale
+or the padding mask shows up as a mismatch here.
+"""
+
+import pytest
+import torch
+import torch.nn.functional as F
+
+from vllm_omni.diffusion.attention.backends.registry import DiffusionAttentionBackendEnum
+from vllm_omni.diffusion.config import set_current_diffusion_config
+from vllm_omni.diffusion.data import OmniDiffusionConfig
+from vllm_omni.diffusion.models.mammoth_moda2.mammothmoda2_dit_model import (
+    TransformerBlock,
+    apply_real_rotary_emb,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+# Small stand-in for the real 2520 / 21 / 7 (head_dim 120) layout.
+DIM, HEADS = 48, 6
+SEQ, BATCH = 37, 2
+
+# The shared layer resolves its backend from the diffusion config at construction;
+# without one it takes the platform default, which on a CUDA host is FLASH_ATTN
+# and cannot run CPU tensors. Pin SDPA the way a deployment would.
+_SDPA_CONFIG = OmniDiffusionConfig(diffusion_attention_config={"default": {"backend": "TORCH_SDPA"}})
+
+
+def _block(kv_heads: int, modulation: bool = True) -> TransformerBlock:
+    torch.manual_seed(0)
+    with set_current_diffusion_config(_SDPA_CONFIG):
+        block = TransformerBlock(
+            DIM,
+            HEADS,
+            kv_heads,
+            multiple_of=8,
+            ffn_dim_multiplier=1.0,
+            norm_eps=1e-5,
+            modulation=modulation,
+        )
+    return block.eval()
+
+
+def _inputs(head_dim: int):
+    torch.manual_seed(1)
+    hidden = torch.randn(BATCH, SEQ, DIM)
+    mask = torch.ones(BATCH, SEQ, dtype=torch.bool)
+    mask[0, SEQ - 9 :] = False
+    mask[1, SEQ - 2 :] = False
+    angles = torch.rand(1, SEQ, head_dim) * 6.283
+    rotary = (angles.cos(), angles.sin())
+    temb = torch.randn(BATCH, min(DIM, 1024))
+    return hidden, mask, rotary, temb
+
+
+def _reference_attention(attn, hidden, mask, rotary):
+    """The pre-change processor, kept verbatim as the oracle."""
+    batch, seq, _ = hidden.shape
+    query, key, value = attn.to_q(hidden), attn.to_k(hidden), attn.to_v(hidden)
+    head_dim = query.shape[-1] // attn.heads
+    kv_heads = key.shape[-1] // head_dim
+    query = attn.norm_q(query.view(batch, seq, attn.heads, head_dim))
+    key = attn.norm_k(key.view(batch, seq, kv_heads, head_dim))
+    value = value.view(batch, seq, kv_heads, head_dim)
+    query = apply_real_rotary_emb(query, rotary[0], rotary[1])
+    key = apply_real_rotary_emb(key, rotary[0], rotary[1])
+    query, key, value = query.transpose(1, 2), key.transpose(1, 2), value.transpose(1, 2)
+    if kv_heads < attn.heads:
+        key = key.repeat_interleave(attn.heads // kv_heads, dim=1)
+        value = value.repeat_interleave(attn.heads // kv_heads, dim=1)
+    out = F.scaled_dot_product_attention(query, key, value, attn_mask=mask.view(batch, 1, 1, seq), scale=attn.scale)
+    out = (out * mask[:, None, :, None]).transpose(1, 2).reshape(batch, seq, attn.heads * head_dim)
+    return attn.to_out[1](attn.to_out[0](out))
+
+
+@pytest.mark.parametrize("kv_heads", [2, HEADS], ids=["gqa_3to1", "mha"])
+def test_processor_matches_previous_arithmetic(kv_heads):
+    block = _block(kv_heads)
+    hidden, mask, rotary, _ = _inputs(block.head_dim)
+    with torch.no_grad():
+        got = block.attn(
+            hidden_states=hidden, encoder_hidden_states=hidden, attention_mask=mask, image_rotary_emb=rotary
+        )
+        want = _reference_attention(block.attn, hidden, mask, rotary)
+    torch.testing.assert_close(got, want, atol=1e-5, rtol=1e-5)
+    assert torch.count_nonzero(got[~mask]) == 0, "padded rows must stay zero"
+
+
+def test_no_mask_equals_all_valid_mask():
+    block = _block(2)
+    hidden, _, rotary, _ = _inputs(block.head_dim)
+    full = torch.ones(BATCH, SEQ, dtype=torch.bool)
+    with torch.no_grad():
+        unmasked = block.attn(
+            hidden_states=hidden, encoder_hidden_states=hidden, attention_mask=None, image_rotary_emb=rotary
+        )
+        masked = block.attn(
+            hidden_states=hidden, encoder_hidden_states=hidden, attention_mask=full, image_rotary_emb=rotary
+        )
+    torch.testing.assert_close(unmasked, masked, atol=1e-6, rtol=1e-6)
+
+
+@pytest.mark.parametrize("modulation", [True, False], ids=["noise_block", "context_refiner"])
+def test_block_forward_hands_native_kv_heads_to_shared_layer(monkeypatch, modulation):
+    """Through the block's real forward, on both of its branches (the modulated
+    noise/refiner blocks and the unmodulated context refiner): the shared layer
+    is what runs, and it receives K/V with their native head count -- no
+    replication before the call."""
+    block = _block(2, modulation=modulation)
+    hidden, mask, rotary, temb = _inputs(block.head_dim)
+    if not modulation:
+        temb = None
+    seen = []
+    original = block.attn.omni_attn.forward
+
+    def spy(query, key, value, attn_metadata=None):
+        seen.append((tuple(query.shape), tuple(key.shape), tuple(value.shape), attn_metadata))
+        return original(query, key, value, attn_metadata)
+
+    monkeypatch.setattr(block.attn.omni_attn, "forward", spy)
+    with torch.no_grad():
+        out = block(hidden, mask, rotary, temb)
+    assert out.shape == hidden.shape and torch.isfinite(out).all()
+    assert len(seen) == 1
+    q_shape, k_shape, v_shape, metadata = seen[0]
+    assert q_shape == (BATCH, SEQ, HEADS, block.head_dim)
+    assert k_shape == v_shape == (BATCH, SEQ, 2, block.head_dim)
+    assert metadata is not None and metadata.attn_mask.dtype == torch.bool
+    assert torch.equal(metadata.attn_mask, mask)
+
+
+def test_backend_selection_reaches_the_dit_layer():
+    """The diffusion config selects the backend when the DiT layer is constructed."""
+    assert _block(2).attn.omni_attn.attn_backend is DiffusionAttentionBackendEnum.TORCH_SDPA.get_class()
+    with set_current_diffusion_config(
+        OmniDiffusionConfig(diffusion_attention_config={"default": {"backend": "FLASH_ATTN"}})
+    ):
+        block = TransformerBlock(DIM, HEADS, 2, multiple_of=8, ffn_dim_multiplier=1.0, norm_eps=1e-5)
+    assert block.attn.omni_attn.attn_backend is DiffusionAttentionBackendEnum.FLASH_ATTN.get_class()
+
+
+def test_shared_layer_owns_no_parameters_and_keeps_checkpoint_keys():
+    block = _block(2)
+    assert sum(p.numel() for p in block.attn.omni_attn.parameters()) == 0
+    assert not list(block.attn.omni_attn.buffers())
+    keys = set(block.state_dict())
+    assert not any("omni_attn" in key for key in keys)
+    # The projections and QK norms the checkpoint provides are still where they were.
+    for expected in (
+        "attn.to_q.weight",
+        "attn.to_k.weight",
+        "attn.to_v.weight",
+        "attn.to_out.0.weight",
+        "attn.norm_q.weight",
+        "attn.norm_k.weight",
+    ):
+        assert expected in keys, expected
+
+
+@pytest.mark.parametrize("with_mask", [True, False], ids=["empty_mask", "no_mask"])
+def test_empty_text_stream_skips_the_kernel(monkeypatch, with_mask):
+    """CFG's unconditional branch carries zero text tokens (the pipeline's default
+    negative_prompt_embeds has no rows), so the context refiner attends over an
+    empty sequence. The flash-attention varlen fallback cannot take that
+    (arange step 0), so the processor must not reach the shared layer at all."""
+    block = _block(kv_heads=2, modulation=False)
+    attn = block.attn
+
+    def _never(*args, **kwargs):
+        raise AssertionError("shared layer called with an empty sequence")
+
+    monkeypatch.setattr(attn.omni_attn, "forward", _never)
+    hidden = torch.randn(BATCH, 0, DIM)
+    mask = torch.ones(BATCH, 0, dtype=torch.bool) if with_mask else None
+    angles = torch.rand(1, 0, block.head_dim)
+    out = attn(
+        hidden_states=hidden,
+        encoder_hidden_states=hidden,
+        attention_mask=mask,
+        image_rotary_emb=(angles.cos(), angles.sin()),
+    )
+    assert out.shape == (BATCH, 0, DIM)
diff --git a/tests/diffusion/models/mammoth_moda2/test_dit_attention_cuda.py b/tests/diffusion/models/mammoth_moda2/test_dit_attention_cuda.py
new file mode 100644
index 000000000..62415953a
--- /dev/null
+++ b/tests/diffusion/models/mammoth_moda2/test_dit_attention_cuda.py
@@ -0,0 +1,151 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Real-shape check of the MammothModa2 DiT attention on CUDA: the shared
+backend (FLASH_ATTN by default, head_dim 120) against the pre-change arithmetic
+in bf16, with the padding mask the joint text+image sequence carries."""
+
+import pytest
+import torch
+
+import vllm_omni.diffusion.attention.backends.sdpa as sdpa_backend
+from tests.helpers.mark import hardware_marks
+from vllm_omni.diffusion.models.mammoth_moda2.mammothmoda2_dit_model import TransformerBlock
+
+from .test_dit_attention import _reference_attention
+
+pytestmark = [
+    pytest.mark.core_model,
+    pytest.mark.advanced_model,
+    pytest.mark.cuda,
+    *hardware_marks(res={"cuda": "L4"}, num_cards=1),
+]
+
+# MammothModa2-Preview gen_dit_config: hidden 2520, 21 heads, 7 KV heads, head_dim 120.
+DIM, HEADS, KV_HEADS = 2520, 21, 7
+
+
+@pytest.mark.parametrize("seq", [77 + 4096, 512], ids=["t2i_1024", "short"])
+def test_real_shape_matches_previous_arithmetic_bf16(seq):
+    torch.manual_seed(0)
+    block = (
+        TransformerBlock(DIM, HEADS, KV_HEADS, multiple_of=256, ffn_dim_multiplier=1.0, norm_eps=1e-5)
+        .cuda()
+        .to(torch.bfloat16)
+        .eval()
+    )
+    hidden = torch.randn(2, seq, DIM, device="cuda", dtype=torch.bfloat16)
+    mask = torch.ones(2, seq, dtype=torch.bool, device="cuda")
+    mask[0, seq - 300 :] = False
+    mask[1, seq - 17 :] = False
+    angles = torch.rand(1, seq, block.head_dim, device="cuda") * 6.283
+    rotary = (angles.cos().to(torch.bfloat16), angles.sin().to(torch.bfloat16))
+    with torch.no_grad():
+        got = block.attn(
+            hidden_states=hidden, encoder_hidden_states=hidden, attention_mask=mask, image_rotary_emb=rotary
+        )
+        want = _reference_attention(block.attn, hidden, mask, rotary)
+    assert torch.isfinite(got).all()
+    assert torch.count_nonzero(got[~mask]) == 0
+    diff = (got.float() - want.float()).abs()[mask]
+    # bf16 kernels differ in accumulation order; measured on A800: max 1.0e-3, mean 5e-5.
+    assert diff.max().item() < 2e-2, diff.max().item()
+    assert diff.mean().item() < 1e-3, diff.mean().item()
+
+
+def test_empty_text_stream_on_the_default_backend():
+    """The recipe's text-to-image request with text_guidance_scale > 1 runs the
+    context refiner on a zero-token unconditional prompt. Before the guard this
+    raised ``RuntimeError: step must be nonzero`` from the FA varlen fallback."""
+    torch.manual_seed(0)
+    block = (
+        TransformerBlock(DIM, HEADS, KV_HEADS, multiple_of=256, ffn_dim_multiplier=1.0, norm_eps=1e-5, modulation=False)
+        .cuda()
+        .to(torch.bfloat16)
+        .eval()
+    )
+    hidden = torch.randn(1, 0, DIM, device="cuda", dtype=torch.bfloat16)
+    mask = torch.ones(1, 0, dtype=torch.bool, device="cuda")
+    angles = torch.rand(1, 0, block.head_dim, device="cuda")
+    with torch.no_grad():
+        out = block.attn(
+            hidden_states=hidden,
+            encoder_hidden_states=hidden,
+            attention_mask=mask,
+            image_rotary_emb=(angles.cos().to(torch.bfloat16), angles.sin().to(torch.bfloat16)),
+        )
+    assert out.shape == (1, 0, DIM)
+
+
+@pytest.mark.parametrize(
+    ("seq", "force_gqa_fallback"),
+    [(512, False), (77 + 4096, False), (32, True)],
+    ids=["short", "t2i_1024", "unsupported_native_gqa"],
+)
+def test_fp32_falls_back_to_sdpa_and_matches_reference(monkeypatch, seq, force_gqa_fallback):
+    """FP32 keeps its dtype and reaches shared SDPA's GQA compatibility check.
+
+    Cover the long masked shape that otherwise falls back to quadratic math
+    attention, and force the unsupported-GQA branch independently of hardware.
+    """
+    torch.manual_seed(0)
+    dt = torch.float32
+    block = (
+        TransformerBlock(DIM, HEADS, KV_HEADS, multiple_of=256, ffn_dim_multiplier=1.0, norm_eps=1e-5)
+        .cuda()
+        .to(dt)
+        .eval()
+    )
+    hidden = torch.randn(1, seq, DIM, device="cuda", dtype=dt)
+    mask = torch.ones(1, seq, dtype=torch.bool, device="cuda")
+    mask[:, -13:] = False
+    angles = torch.rand(1, seq, block.head_dim, device="cuda")
+    rotary = (angles.cos().to(dt), angles.sin().to(dt))
+    capabilities, calls, phases = [], [], []
+    can_use_fused_gqa = sdpa_backend.can_sdpa_use_fused_gqa
+    sdpa = torch.nn.functional.scaled_dot_product_attention
+    strategy = block.attn.omni_attn._get_active_parallel_strategy()
+    pre_attention, post_attention = strategy.pre_attention, strategy.post_attention
+
+    def prepare(*args):
+        phases.append("pre")
+        return pre_attention(*args)
+
+    def restore(*args):
+        phases.append("post")
+        return post_attention(*args)
+
+    def check_gqa(*args):
+        supported = False if force_gqa_fallback else can_use_fused_gqa(*args)
+        capabilities.append(supported)
+        return supported
+
+    def record_sdpa(query, key, value, **kwargs):
+        phases.append("sdpa")
+        calls.append((query.shape, key.shape, value.shape, query.dtype, kwargs))
+        return sdpa(query, key, value, **kwargs)
+
+    with torch.no_grad(), monkeypatch.context() as patch:
+        patch.setattr(sdpa_backend, "can_sdpa_use_fused_gqa", check_gqa)
+        patch.setattr(torch.nn.functional, "scaled_dot_product_attention", record_sdpa)
+        patch.setattr(strategy, "pre_attention", prepare)
+        patch.setattr(strategy, "post_attention", restore)
+        got = block.attn(hidden, hidden, attention_mask=mask, image_rotary_emb=rotary)
+
+    assert phases == ["pre", "sdpa", "post"], "FP32 must preserve the shared parallel dispatch"
+    assert len(capabilities) == len(calls) == 1, "FP32 must use shared SDPA's runtime GQA check"
+    q_shape, k_shape, v_shape, dtype, kwargs = calls[0]
+    expected_kv_heads = KV_HEADS if capabilities[0] else HEADS
+    assert q_shape == (1, HEADS, seq, block.head_dim)
+    assert k_shape == v_shape == (1, expected_kv_heads, seq, block.head_dim)
+    assert dtype == got.dtype == torch.float32
+    assert kwargs["enable_gqa"] == capabilities[0]
+    assert kwargs["scale"] == block.attn.scale
+    assert kwargs["is_causal"] is False
+    assert torch.equal(kwargs["attn_mask"], mask[:, None, None, :])
+
+    with torch.no_grad():
+        want = _reference_attention(block.attn, hidden, mask, rotary)
+    assert torch.isfinite(got).all()
+    assert torch.count_nonzero(got[~mask]) == 0
+    diff = (got.float() - want.float()).abs()[mask]
+    assert diff.max().item() < 1e-3, diff.max().item()
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
new file mode 100644
index 000000000..796c6d93f
--- /dev/null
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_collectives.py
@@ -0,0 +1,158 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import os
+import time
+from datetime import timedelta
+from types import SimpleNamespace
+
+import pytest
+import torch
+import torch.distributed as dist
+import torch.multiprocessing as mp
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion]
+
+
+def _collective_worker(rank, rendezvous, backend):
+    from vllm_omni.diffusion.models.minimax_h3 import pipeline_minimax_h3 as module
+    from vllm_omni.errors import OmniClientError
+    from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+    from vllm_omni.model_executor.models.minimax_h3.conditioning import MiniMaxH3EncoderMediaInput
+    from vllm_omni.platforms import current_omni_platform
+
+    torch.set_num_threads(1)
+    device = torch.device("cuda", rank) if backend == "nccl" else torch.device("cpu")
+    if backend == "nccl":
+        current_omni_platform.set_device(device)
+    dist.init_process_group(
+        backend, init_method=f"file://{rendezvous}", rank=rank, world_size=2, timeout=timedelta(seconds=45)
+    )
+    try:
+        module._dit_rank_world = lambda: (dist.group.WORLD, rank, 2)
+
+        class VisualCodec:
+            fail = False
+
+            def is_distributed_enabled(self):
+                return True
+
+            def collective(self):
+                value = torch.ones(1, device=device)
+                dist.all_reduce(value)
+                assert value.item() == 2
+
+            def encode_image(self, image):
+                self.collective()
+                assert image.size == (32, 32)
+                return torch.ones(1, 96)
+
+            def encode_video(self, frames):
+                self.collective()
+                assert frames.shape == (4, 32, 32, 3)
+                if self.fail and rank == 1:
+                    raise ValueError("codec failed on rank 1")
+                return torch.full((1, 96), 2.0), (1, 2, 2)
+
+        class AudioCodec:
+            def encode_waveform(self, waveform, sample_rate):
+                assert rank == 0
+                assert sample_rate == 32000
+                assert waveform.shape == (64000,)
+                return torch.full((160, 32), 3.0), 80
+
+        model = object.__new__(module.MiniMaxH3Pipeline)
+        torch.nn.Module.__init__(model)
+        model.device = device
+        model.od_config = SimpleNamespace(enable_layerwise_offload=False)
+        model.video_vae = VisualCodec()
+        model.audio_vae = AudioCodec()
+        model.partition = "combined"
+        model.supported_tasks = frozenset({"t2va", "fl2va", "ref2va"})
+        model.text_encoder_tp_size = 2
+        model.text_encoder_group = SimpleNamespace(
+            world_size=2, ranks=[0, 1], rank_in_group=rank, device_group=dist.group.WORLD
+        )
+        model.processor = SimpleNamespace(image_processor=SimpleNamespace(merge_size=2))
+        model.tokenizer = lambda text, **kwargs: {"input_ids": [1, 2, 3]}
+
+        def encode_text(ids, kwargs):
+            assert ids.tolist() == [1, 2, 3]
+            assert not kwargs
+            hidden = torch.ones(3, 5120, device=device, dtype=torch.bfloat16)
+            dist.all_reduce(hidden)
+            return hidden
+
+        model._encode_text_hidden = encode_text
+        sampling = OmniDiffusionSamplingParams(
+            height=32, width=32, num_frames=96, extra_args={"task": "t2va", "aspect_ratio": "1:1"}
+        )
+        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
+
+        media = (
+            MiniMaxH3EncoderMediaInput(
+                task="ref2va",
+                height=32,
+                width=32,
+                num_frames=107,
+                latent_t=32,
+                audio_t=178,
+                images=(torch.zeros(32, 32, 3, dtype=torch.uint8),),
+                videos=(torch.zeros(4, 32, 32, 3, dtype=torch.uint8),),
+                video_audios=(None,),
+                audios=((torch.zeros(64000), 32000),),
+            )
+            if rank == 0
+            else None
+        )
+        conditioning = model._encode_local_media(media)
+        assert [block["kind"] for block in conditioning.ref_blocks] == ["image", "video", "audio"]
+        torch.testing.assert_close(
+            conditioning.visual_condition.cpu(), torch.cat([torch.ones(1, 96), torch.full((1, 96), 2.0)])
+        )
+        torch.testing.assert_close(conditioning.audio_condition.cpu(), torch.full((160, 32), 3.0))
+        assert conditioning.audio_condition_lengths == (80,)
+
+        model.video_vae.fail = True
+        with pytest.raises(OmniClientError, match="codec failed on rank 1"):
+            model._encode_local_media(media)
+        with pytest.raises(OmniClientError, match="non-empty prompt"):
+            model._prepare_local_conditioning({"prompt": ""}, sampling)
+        model.video_vae.fail = False
+        assert model._encode_local_media(media).visual_condition_shapes == ((1, 2, 2), (1, 2, 2))
+    finally:
+        dist.destroy_process_group()
+
+
+def _run_collectives(tmp_path, backend):
+    context = mp.spawn(_collective_worker, args=(str(tmp_path / "rendezvous"), backend), nprocs=2, join=False)
+    deadline = time.monotonic() + 150
+    try:
+        while not context.join(timeout=1):
+            if time.monotonic() > deadline:
+                pytest.fail("MiniMax H3 collectives did not finish within 150 seconds")
+    finally:
+        for process in context.processes:
+            if process.is_alive():
+                process.terminate()
+            process.join(timeout=5)
+
+
+@pytest.mark.cpu
+def test_two_rank_conditioning_and_errors_gloo(tmp_path):
+    _run_collectives(tmp_path, "gloo")
+
+
+@pytest.mark.cuda
+@pytest.mark.parallel
+@pytest.mark.skipif(
+    os.environ.get("VLLM_TEST_MINIMAX_H3_COLLECTIVES") != "1",
+    reason="set VLLM_TEST_MINIMAX_H3_COLLECTIVES=1 with two reserved GPUs",
+)
+def test_two_rank_conditioning_and_errors_nccl(tmp_path):
+    if torch.accelerator.device_count() < 2:
+        pytest.skip("requires two GPUs")
+    _run_collectives(tmp_path, "nccl")
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 a94f842c5..aca8bdb83 100644
--- a/tests/diffusion/models/minimax_h3/test_minimax_h3_contract.py
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_contract.py
@@ -27,11 +27,34 @@ def _append_and_return(items: list[_ItemT], item: _ItemT, result: _ResultT) -> _
     return result
 
 
-def _turbo_spec(filename: str) -> TurboSpec:
-    """Build the spec a loaded artifact of this name would carry."""
-    spec = parse_turbo_filename(filename)
-    assert spec is not None
-    return spec
+def _encoder_payload(
+    *,
+    task: str = "t2va",
+    height: int = 768,
+    width: int = 1344,
+    num_frames: int = 124,
+) -> dict[str, Any]:
+    from vllm_omni.diffusion.models.minimax_h3.time_request import MINIMAX_H3_SHAPE_PLANNER
+    from vllm_omni.model_executor.models.minimax_h3.conditioning import MiniMaxH3EncoderConditioning
+
+    conditioning = MiniMaxH3EncoderConditioning(
+        hidden_states=torch.ones(1, 5120, dtype=torch.bfloat16),
+        token_tags=torch.ones(1, dtype=torch.int64),
+        task=task,
+        height=height,
+        width=width,
+        num_frames=num_frames,
+        latent_t=MINIMAX_H3_SHAPE_PLANNER.video_latent_t(num_frames),
+        audio_t=MINIMAX_H3_SHAPE_PLANNER.audio_latent_t(num_frames / 24),
+    )
+    return conditioning.to_omni_payload()
+
+
+def _encoder_prompt(text: str = "test") -> dict[str, Any]:
+    return {
+        "prompt": text,
+        "additional_information": {"encoder_output": _encoder_payload()},
+    }
 
 
 def test_h3_prepares_resolved_cache_state_immediately_before_denoise():
@@ -42,25 +65,22 @@ def test_h3_prepares_resolved_cache_state_immediately_before_denoise():
 
     pipeline = object.__new__(MiniMaxH3Pipeline)
     torch.nn.Module.__init__(pipeline)
+    pipeline.load_text_encoder = False
+    pipeline.load_vae_encoder = False
     pipeline.partition = "fl2va"
     pipeline.supported_tasks = frozenset({"t2va"})
     pipeline.default_video_shift = 12.0
     pipeline.default_audio_shift = 3.0
     pipeline.device = torch.device("cpu")
     pipeline.od_config = SimpleNamespace()
-    pipeline.text_encoder = object()
+    pipeline.load_text_encoder = False
+    pipeline.load_vae_encoder = False
     cache_spec = object()
     quality_plan = SimpleNamespace(cache_dit=cache_spec)
     pipeline._quality_policy = Mock()
     pipeline._quality_policy.resolve.return_value = quality_plan
     events = []
     pipeline._cache_dit_runtime = SimpleNamespace(prepare=lambda spec: events.append(("prepare", spec)))
-    pipeline.encode_prompt = Mock(
-        return_value=(
-            torch.ones(1, 2),
-            torch.ones(1, dtype=torch.long),
-        )
-    )
 
     def diffuse(**kwargs):
         events.append(("diffuse", kwargs))
@@ -81,7 +101,7 @@ def test_h3_prepares_resolved_cache_state_immediately_before_denoise():
     batch = DiffusionRequestBatch(
         [
             OmniDiffusionRequest(
-                prompt="quality boundary",
+                prompt=_encoder_prompt("quality boundary"),
                 sampling_params=sampling,
                 request_id="quality-boundary",
             )
@@ -124,7 +144,7 @@ def test_pipeline_import_registry_and_component_discovery():
     assert MiniMaxH3Pipeline._vae_modules == ["video_vae", "audio_vae"]
 
 
-def test_encoder_free_stage_skips_text_encoder_during_dlo_discovery():
+def test_diffusion_stage_has_only_dit_and_decoder_vaes_during_discovery():
     from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
     from vllm_omni.diffusion.offloader.module_collector import ModuleDiscovery
 
@@ -133,7 +153,6 @@ def test_encoder_free_stage_skips_text_encoder_during_dlo_discovery():
     pipeline.transformer = torch.nn.Linear(1, 1)
     pipeline.video_vae = torch.nn.Linear(1, 1)
     pipeline.audio_vae = torch.nn.Linear(1, 1)
-    pipeline.text_encoder = None
     pipeline._dit_modules = ["transformer"]
     pipeline._encoder_modules = []
     pipeline._vae_modules = ["video_vae", "audio_vae"]
@@ -145,6 +164,14 @@ def test_encoder_free_stage_skips_text_encoder_during_dlo_discovery():
     assert discovered.vae_names == ["video_vae", "audio_vae"]
 
 
+def test_diffusion_stage_requires_the_encoder_payload():
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+    from vllm_omni.errors import OmniClientError
+
+    with pytest.raises(OmniClientError, match="requires encoder conditioning"):
+        MiniMaxH3Pipeline._extract_encoder_conditioning(None)
+
+
 def test_encoder_free_stage_skips_missing_component_during_dlo_registration():
     from vllm_omni.diffusion.models.minimax_h3 import pipeline_minimax_h3 as pipeline_module
 
@@ -176,10 +203,11 @@ def _write_partition_index(path, *, partition, tasks):
     )
 
 
+@pytest.mark.skip(reason="upstream utility was removed from this branch")
 def test_modular_diffusers_index_is_resolved_generically(tmp_path):
-    from vllm_omni.config.resolver import resolve_omni_config
     from vllm_omni.diffusion.data import OmniDiffusionConfig, resolve_model_class_name
     from vllm_omni.diffusion.utils.hf_utils import is_diffusion_model
+    from vllm_omni.entrypoints.utils import resolve_model_config_path
 
     (tmp_path / "modular_model_index.json").write_text(
         json.dumps(
@@ -193,16 +221,7 @@ def test_modular_diffusers_index_is_resolved_generically(tmp_path):
 
     assert is_diffusion_model(str(tmp_path))
     assert resolve_model_class_name(str(tmp_path)) == "MiniMaxH3ModularPipeline"
-    resolved = resolve_omni_config(
-        str(tmp_path),
-        trust_remote_code=False,
-        deploy_config_path=None,
-        cli_overrides=None,
-        stage_overrides=None,
-        strategy_config_path=None,
-    )
-    assert resolved.config_path is None
-    assert resolved.stage_by_id(0).engine_args.model_class_name == "MiniMaxH3ModularPipeline"
+    assert resolve_model_config_path(str(tmp_path)) is None
 
     config = OmniDiffusionConfig(model=str(tmp_path))
     config.enrich_config()
@@ -249,7 +268,7 @@ def test_startup_task_rejects_unsupported_value():
         _minimax_h3_partition_for_task("unsupported")
 
 
-def test_combined_task_inference_and_transformer_routing():
+def test_encoder_task_validation_and_transformer_routing():
     from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
     from vllm_omni.errors import OmniClientError
 
@@ -263,15 +282,44 @@ def test_combined_task_inference_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(None, {"image": object()}) == "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"})
@@ -287,15 +335,15 @@ def test_combined_task_inference_and_transformer_routing():
         "component_partition",
         "source_partitions",
         "expected_tasks",
-        "load_text_encoder",
     ),
     [
-        (None, "combined", 2, "FL2VA", ["FL2VA", "Ref2VA"], {"t2va", "fl2va", "ref2va"}, True),
-        ("fl2va", "fl2va", 1, "FL2VA", ["FL2VA"], {"t2va", "fl2va"}, True),
-        ("ref2va", "ref2va", 1, "Ref2VA", ["Ref2VA"], {"ref2va"}, True),
-        ("fl2va", "fl2va", 1, "FL2VA", ["FL2VA"], {"t2va", "fl2va"}, False),
+        (None, "combined", 2, "FL2VA", ["FL2VA", "Ref2VA"], {"t2va", "fl2va", "ref2va"}),
+        ("fl2va", "fl2va", 1, "FL2VA", ["FL2VA"], {"t2va", "fl2va"}),
+        ("ref2va", "ref2va", 1, "Ref2VA", ["Ref2VA"], {"ref2va"}),
     ],
 )
+@pytest.mark.parametrize("load_text_encoder", [None, True, False])
+@pytest.mark.parametrize("trust_remote_code", [False, True])
 def test_pipeline_loads_task_selected_components_with_encoder_ownership(
     monkeypatch,
     tmp_path,
@@ -306,6 +354,7 @@ def test_pipeline_loads_task_selected_components_with_encoder_ownership(
     source_partitions,
     expected_tasks,
     load_text_encoder,
+    trust_remote_code,
 ):
     from vllm_omni.diffusion.data import (
         DiffusionParallelConfig,
@@ -328,15 +377,13 @@ def test_pipeline_loads_task_selected_components_with_encoder_ownership(
     for partition_name in ("FL2VA", "Ref2VA"):
         for component in (
             "transformer",
-            "tokenizer",
-            "processor",
-            "text_encoder",
             "video_vae",
             "audio_vae",
         ):
             (tmp_path / partition_name / component).mkdir()
 
-    created: dict[str, list[Any]] = {"dit": [], "text_encoder": [], "video_vae": [], "audio_vae": []}
+    created: dict[str, list[Any]] = {"dit": [], "video_vae": [], "audio_vae": [], "text_encoder": []}
+    component_options = {}
 
     class FakeModule(torch.nn.Module):
         def __init__(self, *args, **kwargs):
@@ -350,26 +397,17 @@ def test_pipeline_loads_task_selected_components_with_encoder_ownership(
     def component_factory(name):
         def create(path, *args, **kwargs):
             created[name].append(str(path))
+            component_options[name] = kwargs
             return FakeModule()
 
         return create
 
-    tokenizer_calls: list[Any] = []
-    processor_calls: list[Any] = []
-    tokenizer_cls = Mock(spec=pipeline_module.Qwen2TokenizerFast)
-    tokenizer_cls.from_pretrained.side_effect = lambda *args, **kwargs: _append_and_return(
-        tokenizer_calls, (args, kwargs), object()
-    )
-    processor_cls = Mock(spec=pipeline_module.Qwen3VLProcessor)
-    processor_cls.from_pretrained.side_effect = lambda *args, **kwargs: _append_and_return(
-        processor_calls, (args, kwargs), object()
-    )
     monkeypatch.setattr(pipeline_module, "MiniMaxH3DiTModel", FakeDiT)
-    monkeypatch.setattr(
-        pipeline_module,
-        "MiniMaxH3Qwen3VLEncoder",
-        component_factory("text_encoder"),
-    )
+    monkeypatch.setattr(pipeline_module, "MiniMaxH3Qwen3VLEncoder", component_factory("text_encoder"))
+    tokenizer_loader = Mock()
+    processor_loader = Mock()
+    monkeypatch.setattr(pipeline_module.Qwen2TokenizerFast, "from_pretrained", tokenizer_loader)
+    monkeypatch.setattr(pipeline_module.Qwen3VLProcessor, "from_pretrained", processor_loader)
     monkeypatch.setattr(
         pipeline_module,
         "MiniMaxH3VideoVAE",
@@ -380,21 +418,6 @@ def test_pipeline_loads_task_selected_components_with_encoder_ownership(
         "MiniMaxH3AudioVAE",
         component_factory("audio_vae"),
     )
-    monkeypatch.setattr(
-        pipeline_module,
-        "Qwen2TokenizerFast",
-        tokenizer_cls,
-    )
-    monkeypatch.setattr(
-        pipeline_module,
-        "Qwen3VLProcessor",
-        processor_cls,
-    )
-    monkeypatch.setattr(
-        pipeline_module,
-        "_dit_rank_world",
-        lambda: (None, 0, 1),
-    )
     monkeypatch.setattr(
         pipeline_module,
         "get_local_device",
@@ -414,73 +437,66 @@ def test_pipeline_loads_task_selected_components_with_encoder_ownership(
 
     od_config = OmniDiffusionConfig(
         model="MiniMaxAI/MiniMax-H3",
+        trust_remote_code=trust_remote_code,
         revision=None,
         task_type=task_type,
         quantization_config=None,
-        model_loaded={
-            "transformer": True,
-            "vae": True,
-            "text_encoder": load_text_encoder,
-        },
-        parallel_config=DiffusionParallelConfig(
-            cfg_parallel_size=1,
-            text_encoder_tp_size=1,
-        ),
+        parallel_config=DiffusionParallelConfig(cfg_parallel_size=1),
     )
+    if load_text_encoder is not None:
+        od_config.model_loaded["text_encoder"] = load_text_encoder
+        od_config.model_loaded["vae_encoder"] = load_text_encoder
     pipeline = pipeline_module.MiniMaxH3Pipeline(od_config=od_config)
+    expect_encoder = load_text_encoder is not False
 
     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")]
+    assert created["text_encoder"] == ([str(component_path / "text_encoder")] if expect_encoder else [])
+    assert tokenizer_loader.call_count == processor_loader.call_count == int(expect_encoder)
+    assert pipeline.load_text_encoder is expect_encoder
+    assert pipeline._encoder_modules == (["text_encoder"] if expect_encoder else [])
+    assert ("text_encoder" in pipeline._offload_plan.encoder_block_attrs) is expect_encoder
+    assert ("text_encoder" in pipeline._offload_plan.on_demand_component_paths) is expect_encoder
+    assert ("encode_prompt" in pipeline._PROFILER_TARGETS) is expect_encoder
+    assert ("_encode_local_media" in pipeline._PROFILER_TARGETS) is expect_encoder
+    assert component_options["video_vae"]["decode_only"] is not expect_encoder
+    assert component_options["audio_vae"]["decode_only"] is not expect_encoder
+    assert component_options["video_vae"]["trust_remote_code"] is trust_remote_code
+    assert component_options["audio_vae"]["trust_remote_code"] is trust_remote_code
+    from vllm_omni.diffusion.offloader.module_collector import ModuleDiscovery
+
+    assert ModuleDiscovery.discover(pipeline).encoder_names == (["text_encoder"] if expect_encoder else [])
     expected_dit_modules = ["transformer", "transformers_ref"] if expected_dits == 2 else ["transformer"]
     assert pipeline._dit_modules == expected_dit_modules
     assert hasattr(pipeline, "transformers_ref") is (expected_dits == 2)
-    if load_text_encoder:
-        assert created["text_encoder"] == [str(component_path / "text_encoder")]
-        assert len(tokenizer_calls) == 1
-        assert len(processor_calls) == 1
-        assert pipeline.text_encoder is not None
-        assert pipeline.tokenizer is not None
-        assert pipeline.processor is not None
-        assert pipeline._encoder_modules == ["text_encoder"]
-        assert pipeline.text_encoder_tp_size == 1
-    else:
-        assert created["text_encoder"] == []
-        assert tokenizer_calls == []
-        assert processor_calls == []
-        assert pipeline.text_encoder is None
-        assert pipeline.tokenizer is None
-        assert pipeline.processor is None
-        assert pipeline._encoder_modules == []
-        assert pipeline.text_encoder_tp_size == 0
-        assert pipeline.text_encoder_group is None
     if expected_partition == "ref2va":
         assert pipeline._transformer_for_task("ref2va") is pipeline.transformer
     assert [source.model_or_path for source in pipeline.weights_sources] == [
         *(str(tmp_path / partition_name) for partition_name in source_partitions),
-        *((str(component_path),) if load_text_encoder else ()),
+        *([str(component_path)] if expect_encoder else []),
     ]
     assert [source.subfolder for source in pipeline.weights_sources] == [
         *("transformer" for _ in source_partitions),
-        *(("text_encoder",) if load_text_encoder else ()),
+        *(["text_encoder"] if expect_encoder else []),
     ]
     expected_prefixes = ["transformer."]
     if expected_dits == 2:
         expected_prefixes.append("transformers_ref.")
-    if load_text_encoder:
+    if expect_encoder:
         expected_prefixes.append("text_encoder.")
     assert [source.prefix for source in pipeline.weights_sources] == expected_prefixes
-    if load_text_encoder:
+    expected_patterns = pipeline_module.MINIMAX_H3_DIFFUSION_DOWNLOAD_PATTERNS[expected_partition]
+    if expect_encoder:
         expected_patterns = (
             pipeline_module.MINIMAX_H3_DOWNLOAD_PATTERNS
             if expected_partition == "combined"
             else pipeline_module.MINIMAX_H3_TASK_DOWNLOAD_PATTERNS[expected_partition]
         )
-    else:
-        expected_patterns = pipeline_module.MINIMAX_H3_DIFFUSION_DOWNLOAD_PATTERNS[expected_partition]
     assert download_calls == [
         {
             "model_name_or_path": "MiniMaxAI/MiniMax-H3",
@@ -512,7 +528,6 @@ def test_combined_weight_loader_routes_each_contiguous_partition():
     torch.nn.Module.__init__(pipeline)
     pipeline.transformer = FakeTransformer()
     pipeline.transformers_ref = FakeTransformer()
-    pipeline.text_encoder = torch.nn.Identity()
     pipeline.video_vae = torch.nn.Identity()
     pipeline.audio_vae = torch.nn.Identity()
     loaded = pipeline.load_weights(
@@ -565,26 +580,6 @@ def test_joint_postprocess_is_multiprocessing_picklable():
     assert result["fps"] == 24
 
 
-def test_joint_video_output_is_quantized_before_transfer():
-    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
-        _minimax_h3_post_process,
-        _prepare_minimax_h3_video_output,
-    )
-
-    video = torch.linspace(-0.1, 1.1, 2 * 3 * 2 * 4 * 5, dtype=torch.float64).reshape(2, 3, 2, 4, 5)
-    expected = torch.round(video.float().clamp(0, 1) * 255).to(torch.uint8).permute(0, 2, 3, 4, 1)
-    prepared = _prepare_minimax_h3_video_output(video)
-
-    assert prepared.dtype == torch.uint8
-    assert prepared.is_contiguous()
-    assert prepared.shape == (2, 2, 4, 5, 3)
-    torch.testing.assert_close(prepared, expected, rtol=0, atol=0)
-
-    result = _minimax_h3_post_process((prepared, torch.zeros(1, 2, 6)))
-    assert result["video"][0].dtype == np.uint8
-    np.testing.assert_array_equal(result["video"][0], expected[0].numpy())
-
-
 def test_cfg_parallel_is_rejected_for_distilled_checkpoint():
     from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
 
@@ -690,17 +685,12 @@ def _distilled_pipeline(diffuse_calls, base_schedule_by_partition):
     pipeline.default_audio_shift = 3.0
     pipeline.device = torch.device("cpu")
     pipeline.od_config = SimpleNamespace()
-    pipeline.text_encoder = Mock()
     pipeline._base_schedule_by_partition = schedules
+    pipeline.load_text_encoder = False
+    pipeline.load_vae_encoder = False
     pipeline._quality_policy = Mock()
     pipeline._quality_policy.resolve.return_value = SimpleNamespace(cache_dit=None)
     pipeline._cache_dit_runtime = SimpleNamespace(prepare=lambda spec: None)
-    pipeline.encode_prompt = Mock(
-        return_value=(
-            torch.ones(1, 2),
-            torch.ones(1, dtype=torch.long),
-        )
-    )
 
     def diffuse(**kwargs):
         diffuse_calls.append(kwargs)
@@ -728,7 +718,7 @@ def _t2va_batch(num_inference_steps=None):
     return DiffusionRequestBatch(
         [
             OmniDiffusionRequest(
-                prompt="distilled schedule",
+                prompt=_encoder_prompt("distilled schedule"),
                 sampling_params=sampling,
                 request_id="distilled",
             )
@@ -849,10 +839,6 @@ def test_cudnn_packed_attention_uses_python_length_without_padding_mask():
 
 
 def test_packed_attention_skips_mask_for_packed_mask_free_backend():
-    from vllm_omni.diffusion.attention.backends.abstract import (
-        VideoTokenLayout,
-        VideoTokenSpan,
-    )
     from vllm_omni.diffusion.models.minimax_h3.minimax_h3_transformer import (
         MiniMaxH3Attention,
     )
@@ -879,10 +865,6 @@ def test_packed_attention_skips_mask_for_packed_mask_free_backend():
     torch.nn.Module.__init__(attention)
     attention.attention = FakeAttention()
     q = torch.randn(8, 2, 4)
-    video_layout = VideoTokenLayout(
-        used_len=5,
-        video_spans=(VideoTokenSpan(start=3, latent_grid=(1, 1, 2), role="target"),),
-    )
 
     attention._run_packed_attention(
         q,
@@ -891,9 +873,6 @@ def test_packed_attention_skips_mask_for_packed_mask_free_backend():
         cu_seqlens=torch.tensor([0, 5, 8], dtype=torch.int32),
         max_seqlen=5,
         packed_total=8,
-        video_layout=video_layout,
-        vsa_prefix_segments=(1, 2),
-        gate_compress=torch.ones_like(q),
     )
 
     metadata = attention.attention.metadata
@@ -901,11 +880,6 @@ def test_packed_attention_skips_mask_for_packed_mask_free_backend():
     assert metadata.attn_mask is None
     assert metadata.extra["valid_kv_length"] == 5
     assert metadata.extra["npu_attn_varlen"] is True
-    assert metadata.video_layout is video_layout
-    assert metadata.extra["vsa_h3_prefix_segments"] == (1, 2)
-    assert "vsa_h3_video_shape" not in metadata.extra
-    assert "vsa_h3_target_start" not in metadata.extra
-    assert metadata.extra["gate_compress"].shape == (1, *q.shape)
     packed_padding = metadata.packed_padding
     assert packed_padding is not None
     assert packed_padding.q_length == 5
@@ -959,6 +933,64 @@ def test_packed_attention_keeps_padding_mask_for_other_backends():
     )
 
 
+def test_ring_packed_attention_publishes_prefix_length_without_global_mask():
+    attention = _fake_packed_attention("CUDNN_ATTN")
+    attention.attention.use_ring = True
+    q = torch.randn(4, 2, 4)
+
+    attention._run_packed_attention(
+        q,
+        q,
+        q,
+        cu_seqlens=torch.tensor([0, 5, 8], dtype=torch.int32),
+        max_seqlen=5,
+        packed_total=8,
+    )
+
+    metadata = attention.attention.metadata
+    assert metadata.attn_mask is None
+    assert metadata.extra["valid_kv_length"] == 5
+
+
+def test_ring_packed_attention_keeps_mask_when_runtime_sp_is_inactive(monkeypatch):
+    from vllm_omni.diffusion.models.minimax_h3 import minimax_h3_transformer
+
+    class InactiveContext:
+        sp_active = False
+
+    attention = _fake_packed_attention("CUDNN_ATTN")
+    attention.attention.use_ring = True
+    monkeypatch.setattr(
+        minimax_h3_transformer,
+        "is_forward_context_available",
+        lambda: True,
+        raising=False,
+    )
+    monkeypatch.setattr(
+        minimax_h3_transformer,
+        "get_forward_context",
+        InactiveContext,
+        raising=False,
+    )
+    q = torch.randn(8, 2, 4)
+
+    attention._run_packed_attention(
+        q,
+        q,
+        q,
+        cu_seqlens=torch.tensor([0, 5, 8], dtype=torch.int32),
+        max_seqlen=5,
+        packed_total=8,
+    )
+
+    metadata = attention.attention.metadata
+    assert torch.equal(
+        metadata.attn_mask,
+        torch.tensor([[True, True, True, True, True, False, False, False]]),
+    )
+    assert metadata.extra["npu_attn_varlen"] is True
+
+
 def _fake_packed_attention(
     backend_name: str,
     *,
@@ -980,6 +1012,10 @@ def _fake_packed_attention(
         def supports_multi_doc_packed_varlen(cls) -> bool:
             return supports_multi_doc
 
+        @classmethod
+        def supports_packed_mask_free(cls) -> bool:
+            return False
+
     class FakeAttention(torch.nn.Module):
         attn_backend = FakeBackend
 
@@ -1035,23 +1071,73 @@ 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
 
-    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
-        _reference_image_shape,
+    from vllm_omni.model_executor.models.minimax_h3.preprocessing import (
+        resolve_minimax_h3_reference_image_shape,
     )
 
-    assert _reference_image_shape(Image.new("RGB", (1080, 1440))) == (
+    assert resolve_minimax_h3_reference_image_shape(Image.new("RGB", (1080, 1440))) == (
         2048,
         2720,
     )
     with pytest.raises(ValueError, match="aspect ratio"):
-        _reference_image_shape(Image.new("RGB", (100, 501)))
+        resolve_minimax_h3_reference_image_shape(Image.new("RGB", (100, 501)))
 
 
 def test_fl2va_supports_first_last_and_explicit_frame_index_contracts():
-    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
+    from vllm_omni.model_executor.models.minimax_h3.encoder_processing import (
         _resolve_fl2va_keyframe_indices,
     )
 
@@ -1064,21 +1150,20 @@ def test_fl2va_supports_first_last_and_explicit_frame_index_contracts():
 
 
 def test_minimax_h3_uses_the_official_output_canvas_policy():
-    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
-        _resolve_output_canvas,
+    from vllm_omni.model_executor.models.minimax_h3.preprocessing import (
+        resolve_minimax_h3_output_canvas,
     )
 
-    assert _resolve_output_canvas(21 / 9, 768) == (672, 1536)
-    assert _resolve_output_canvas(16 / 9, 768) == (768, 1344)
-    assert _resolve_output_canvas(9 / 16, 768) == (1344, 768)
+    assert resolve_minimax_h3_output_canvas(21 / 9, 768) == (672, 1536)
+    assert resolve_minimax_h3_output_canvas(16 / 9, 768) == (768, 1344)
+    assert resolve_minimax_h3_output_canvas(9 / 16, 768) == (1344, 768)
     with pytest.raises(ValueError, match="short_edge"):
-        _resolve_output_canvas(16 / 9, 720)
+        resolve_minimax_h3_output_canvas(16 / 9, 720)
 
 
 def test_minimax_h3_accepts_sglang_auto_aspect_ratio_alias():
-    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import MiniMaxH3Pipeline
+    from vllm_omni.model_executor.models.minimax_h3.encoder_processing import resolve_minimax_h3_shape
 
-    pipeline = object.__new__(MiniMaxH3Pipeline)
     sampling = SimpleNamespace(
         fps=24,
         num_frames=1,
@@ -1086,7 +1171,7 @@ def test_minimax_h3_accepts_sglang_auto_aspect_ratio_alias():
         width=None,
         extra_args={"duration": 5.0, "aspect_ratio": "auto"},
     )
-    height, width, *_ = pipeline._resolve_shape("ref2va", sampling, None)
+    height, width, *_ = resolve_minimax_h3_shape("ref2va", sampling, None)
     assert (height, width) == (768, 1344)
 
 
@@ -1094,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):
@@ -1239,12 +1325,6 @@ def test_text_encoder_stub_constructs_without_group_or_weights():
     from vllm_omni.diffusion.models.minimax_h3.encoder import (
         MiniMaxH3Qwen3VLEncoder,
     )
-    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
-        MiniMaxH3Pipeline,
-    )
-    from vllm_omni.diffusion.offloader.component_utils import (
-        get_encoder_block_groups,
-    )
 
     encoder = MiniMaxH3Qwen3VLEncoder(
         "/nonexistent/text_encoder",
@@ -1257,25 +1337,6 @@ def test_text_encoder_stub_constructs_without_group_or_weights():
     # The stub has no parameters, so it never contributes to the runner's
     # strict missing-parameter check on non-encoder ranks.
     assert list(encoder.named_parameters()) == []
-    assert (
-        get_encoder_block_groups(
-            encoder,
-            "text_encoder",
-            MiniMaxH3Pipeline._offload_plan,
-            strict=True,
-        )
-        == []
-    )
-
-    # An arbitrary empty module is not silently treated as a distributed
-    # stub; explicit plans still validate their declared paths.
-    with pytest.raises(ValueError, match=r"text_encoder\.vision\.blocks was not found"):
-        get_encoder_block_groups(
-            nn.Module(),
-            "text_encoder",
-            MiniMaxH3Pipeline._offload_plan,
-            strict=True,
-        )
 
 
 def test_global_quant_config_is_shared_by_dit_and_encoder():
@@ -1338,149 +1399,22 @@ def test_text_encoder_linear_delegates_quantization_to_vllm_factory():
     quant_config.get_quant_method.assert_called_once_with(linear, prefix=prefix)
 
 
-def test_no_offload_keeps_text_encoder_resident():
+def test_distributed_layerwise_offload_stages_vae_component():
     from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
 
     pipeline = object.__new__(MiniMaxH3Pipeline)
     torch.nn.Module.__init__(pipeline)
     pipeline.od_config = SimpleNamespace(
-        enable_cpu_offload=False,
         enable_layerwise_offload=False,
-    )
-    pipeline.text_encoder = Mock()
-    expected = torch.ones(2, 3)
-    pipeline.text_encoder.encode_ids.return_value = expected
-    input_ids = torch.tensor([1, 2])
-
-    actual = pipeline._encode_text_hidden(input_ids, {})
-
-    assert actual is expected
-    pipeline.text_encoder.load_to_device.assert_called_once_with()
-    pipeline.text_encoder.offload_to_cpu.assert_not_called()
-
-
-def test_model_offload_uses_hooked_text_encoder_call():
-    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
-
-    pipeline = object.__new__(MiniMaxH3Pipeline)
-    torch.nn.Module.__init__(pipeline)
-    pipeline.od_config = SimpleNamespace(
-        enable_cpu_offload=True,
-        enable_layerwise_offload=False,
-    )
-    expected = torch.ones(2, 3)
-    pipeline.text_encoder = Mock(return_value=expected)
-    pipeline._model_cpu_offload_modules = [pipeline.text_encoder]
-    input_ids = torch.tensor([1, 2])
-    vision_kwargs = {"pixel_values": torch.ones(1, 4)}
-
-    actual = pipeline._encode_text_hidden(input_ids, vision_kwargs)
-
-    assert actual is expected
-    pipeline.text_encoder.assert_called_once_with(input_ids, **vision_kwargs)
-    pipeline.text_encoder.load_to_device.assert_not_called()
-
-
-@pytest.mark.parametrize(
-    ("enable_layerwise", "enable_distributed"),
-    [(True, False), (False, True)],
-)
-def test_legacy_layer_offload_preserves_minimax_stage_lifecycle(enable_layerwise, enable_distributed):
-    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
-
-    pipeline = object.__new__(MiniMaxH3Pipeline)
-    torch.nn.Module.__init__(pipeline)
-    pipeline.od_config = SimpleNamespace(
-        diffusion_offload_config=None,
-        enable_cpu_offload=False,
-        enable_layerwise_offload=enable_layerwise,
-        enable_distributed_layerwise_offload=enable_distributed,
-    )
-    pipeline.text_encoder = Mock()
-    expected = torch.ones(2, 3)
-    pipeline.text_encoder.encode_ids.return_value = expected
-
-    actual = pipeline._encode_text_hidden(torch.tensor([1, 2]), {})
-
-    assert actual is expected
-    pipeline.text_encoder.load_to_device.assert_called_once_with()
-    pipeline.text_encoder.offload_to_cpu.assert_called_once_with()
-
-    vae = Mock()
-    with pipeline._component_on_device(vae):
-        pass
-    vae.load_to_device.assert_called_once_with()
-    vae.offload_to_cpu.assert_called_once_with()
-
-
-def test_layerwise_encoder_selection_releases_text_encoder():
-    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
-
-    pipeline = object.__new__(MiniMaxH3Pipeline)
-    torch.nn.Module.__init__(pipeline)
-    pipeline.od_config = SimpleNamespace(
-        enable_cpu_offload=False,
-        enable_layerwise_offload=False,
-        enable_distributed_layerwise_offload=False,
-        diffusion_offload_config={
-            "mode": "layer",
-            "components": ["text_encoder"],
-        },
-    )
-    pipeline.text_encoder = Mock()
-    expected = torch.ones(2, 3)
-    pipeline.text_encoder.encode_ids.return_value = expected
-
-    actual = pipeline._encode_text_hidden(torch.tensor([1, 2]), {})
-
-    assert actual is expected
-    pipeline.text_encoder.load_to_device.assert_called_once_with()
-    pipeline.text_encoder.offload_to_cpu.assert_called_once_with()
-
-
-def test_layerwise_dit_only_keeps_text_encoder_resident():
-    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
-
-    pipeline = object.__new__(MiniMaxH3Pipeline)
-    torch.nn.Module.__init__(pipeline)
-    pipeline.od_config = SimpleNamespace(
-        enable_cpu_offload=False,
-        enable_layerwise_offload=False,
-        enable_distributed_layerwise_offload=False,
-        diffusion_offload_config={"mode": "layer", "components": ["dit"]},
-    )
-    pipeline.text_encoder = Mock()
-    expected = torch.ones(2, 3)
-    pipeline.text_encoder.encode_ids.return_value = expected
-
-    actual = pipeline._encode_text_hidden(torch.tensor([1, 2]), {})
-
-    assert actual is expected
-    pipeline.text_encoder.load_to_device.assert_called_once_with()
-    pipeline.text_encoder.offload_to_cpu.assert_not_called()
-
-
-def test_dit_encoder_selection_keeps_vae_resident():
-    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
-
-    pipeline = object.__new__(MiniMaxH3Pipeline)
-    torch.nn.Module.__init__(pipeline)
-    pipeline.od_config = SimpleNamespace(
-        enable_cpu_offload=False,
-        enable_layerwise_offload=False,
-        enable_distributed_layerwise_offload=False,
-        diffusion_offload_config={
-            "mode": "layer",
-            "components": ["dit", "text_encoder"],
-        },
+        enable_distributed_layerwise_offload=True,
     )
     component = Mock()
 
     with pipeline._component_on_device(component):
-        pass
+        component.load_to_device.assert_called_once_with()
+        component.offload_to_cpu.assert_not_called()
 
-    component.load_to_device.assert_not_called()
-    component.offload_to_cpu.assert_not_called()
+    component.offload_to_cpu.assert_called_once_with()
 
 
 def test_distributed_layerwise_resident_blocks_are_stage_scoped():
@@ -1529,6 +1463,58 @@ def test_distributed_layerwise_resident_blocks_can_be_skipped():
     controller.offload_resident_layers.assert_not_called()
 
 
+@pytest.mark.skip(reason="encoder layerwise API is not part of this branch")
+def test_encoder_layerwise_offload_keeps_tp_blocks_rank_local(monkeypatch):
+    from vllm_omni.diffusion.models.minimax_h3.encoder import (
+        MiniMaxH3Qwen3VLEncoder,
+    )
+
+    class Stack(torch.nn.Module):
+        def __init__(self, count):
+            super().__init__()
+            self.blocks = torch.nn.ModuleList([torch.nn.Linear(2, 2) for _ in range(count)])
+
+    class TextStack(torch.nn.Module):
+        def __init__(self, count):
+            super().__init__()
+            self.layers = torch.nn.ModuleList([torch.nn.Linear(2, 2) for _ in range(count)])
+
+    hooks = []
+
+    def fake_apply(block, next_block, device, stream, pin_memory):
+        hook = SimpleNamespace(
+            block=block,
+            next_block=next_block,
+            device=device,
+            stream=stream,
+            pin_memory=pin_memory,
+            _prev_hook=None,
+            offload_layer=Mock(),
+        )
+        hooks.append(hook)
+        return hook
+
+    monkeypatch.setattr(
+        "vllm_omni.diffusion.offloader.layerwise_backend.apply_block_hook",
+        fake_apply,
+    )
+    monkeypatch.setattr(
+        "vllm_omni.platforms.current_omni_platform.Stream",
+        Mock(return_value="copy-stream"),
+    )
+    encoder = object.__new__(MiniMaxH3Qwen3VLEncoder)
+    torch.nn.Module.__init__(encoder)
+    encoder.device_target = torch.device("cpu")
+    encoder.vision = Stack(2)
+    encoder.text_model = TextStack(3)
+
+    encoder.enable_omni_layerwise_offload(pin_memory=False)
+
+    assert len(hooks) == 5
+    assert all(hook._prev_hook is not None for hook in hooks)
+    assert all(hook.device == torch.device("cpu") for hook in hooks)
+
+
 def test_video_vae_keeps_reference_fp32_weights(monkeypatch):
     from vllm_omni.diffusion.models.minimax_h3 import vae as vae_module
 
@@ -1549,7 +1535,7 @@ def test_video_vae_keeps_reference_fp32_weights(monkeypatch):
     monkeypatch.setattr(
         vae_module,
         "_load_remote_component",
-        lambda _path, _config: FakeRemote(),
+        lambda _path, _config, *, trust_remote_code: FakeRemote(),
     )
 
     video_vae = vae_module.MiniMaxH3VideoVAE(
@@ -1560,97 +1546,6 @@ def test_video_vae_keeps_reference_fp32_weights(monkeypatch):
     assert next(video_vae.parameters()).dtype == torch.float32
 
 
-def test_keyframe_encode_pins_and_restores_cudnn_settings():
-    from vllm_omni.diffusion.models.minimax_h3.vae import (
-        _minimax_h3_keyframe_encode_context,
-    )
-
-    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")):
-            assert cudnn.enabled
-            assert not cudnn.benchmark
-            assert cudnn.deterministic
-            assert cudnn.allow_tf32
-
-        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
-
-
-@pytest.mark.parametrize("fail_encode", [False, True])
-def test_keyframe_encode_enters_backend_context(monkeypatch, fail_encode):
-    from PIL import Image
-
-    from vllm_omni.diffusion.models.minimax_h3 import vae as vae_module
-
-    events = []
-    input_image = Image.new("RGB", (32, 32))
-
-    @contextmanager
-    def track_context(device):
-        assert device == torch.device("cpu")
-        events.append("enter")
-        try:
-            yield
-        finally:
-            events.append("exit")
-
-    class FakeModel(torch.nn.Module):
-        def __init__(self):
-            super().__init__()
-            self.weight = torch.nn.Parameter(torch.ones(1))
-            self.parallel_tiling = True
-
-        def encode_images(self, image, *, use_fp16_latent):
-            assert events == ["enter"]
-            assert image is input_image
-            assert use_fp16_latent
-            events.append("encode")
-            if fail_encode:
-                raise RuntimeError("encode failed")
-            return [torch.ones(1, 1, 2, 2)]
-
-    video_vae = object.__new__(vae_module.MiniMaxH3VideoVAE)
-    torch.nn.Module.__init__(video_vae)
-    video_vae.model = FakeModel()
-    video_vae.config_dict = {
-        "latent_channels": 1,
-        "latents_mean": [0.0],
-        "latents_std": [1.0],
-    }
-    monkeypatch.setattr(vae_module, "_minimax_h3_keyframe_encode_context", track_context)
-
-    if fail_encode:
-        with pytest.raises(RuntimeError, match="encode failed"):
-            video_vae.encode_image(input_image)
-    else:
-        rows = video_vae.encode_image(input_image)
-        torch.testing.assert_close(rows, torch.ones(1, 4))
-
-    assert events == ["enter", "encode", "exit"]
-    assert video_vae.model.parallel_tiling
-
-
 def test_video_vae_can_load_on_cpu_for_staged_gpu_residency(monkeypatch):
     from vllm_omni.diffusion.models.minimax_h3 import vae as vae_module
 
@@ -1671,7 +1566,7 @@ def test_video_vae_can_load_on_cpu_for_staged_gpu_residency(monkeypatch):
     monkeypatch.setattr(
         vae_module,
         "_load_remote_component",
-        lambda _path, _config: FakeRemote(),
+        lambda _path, _config, *, trust_remote_code: FakeRemote(),
     )
 
     video_vae = vae_module.MiniMaxH3VideoVAE(
@@ -1706,7 +1601,7 @@ def test_video_vae_uses_snapshot_stager_for_accelerator_target(monkeypatch):
     monkeypatch.setattr(
         vae_module,
         "_load_remote_component",
-        lambda _path, _config: FakeRemote(),
+        lambda _path, _config, *, trust_remote_code: FakeRemote(),
     )
     monkeypatch.setattr(vae_module, "PinnedModuleStager", stager_cls)
 
@@ -1727,6 +1622,123 @@ def test_video_vae_uses_snapshot_stager_for_accelerator_target(monkeypatch):
     stager.offload.assert_called_once_with()
 
 
+def test_remote_component_refuses_untrusted_checkpoint_code(monkeypatch):
+    from vllm_omni.diffusion.models.minimax_h3 import vae as vae_module
+
+    loaded = []
+
+    def spy_get_class(class_reference, component_path):
+        loaded.append((class_reference, component_path))
+        raise AssertionError("checkpoint code must not be resolved when untrusted")
+
+    monkeypatch.setattr(vae_module, "get_class_from_dynamic_module", spy_get_class)
+
+    with pytest.raises(ValueError, match="--trust-remote-code"):
+        vae_module._load_remote_component(
+            "/checkpoints/video_vae",
+            {"auto_map": {"AutoModel": "modeling_vae.VideoVAE"}},
+            trust_remote_code=False,
+        )
+
+    assert loaded == []
+
+
+def test_remote_component_resolves_checkpoint_code_when_trusted(monkeypatch):
+    from vllm_omni.diffusion.models.minimax_h3 import vae as vae_module
+
+    class FakeComponent(torch.nn.Module):
+        @classmethod
+        def from_pretrained(cls, component_path):
+            module = cls()
+            module.loaded_from = component_path
+            return module
+
+    loaded = []
+
+    def spy_get_class(class_reference, component_path):
+        loaded.append((class_reference, component_path))
+        return FakeComponent
+
+    monkeypatch.setattr(vae_module, "get_class_from_dynamic_module", spy_get_class)
+
+    module = vae_module._load_remote_component(
+        "/checkpoints/video_vae",
+        {"auto_map": {"AutoModel": "modeling_vae.VideoVAE"}},
+        trust_remote_code=True,
+    )
+
+    # Negative control: the trusted path stays byte-for-byte the pre-gate call.
+    assert loaded == [("modeling_vae.VideoVAE", "/checkpoints/video_vae")]
+    assert module.loaded_from == "/checkpoints/video_vae"
+
+
+@pytest.mark.parametrize("vae_cls_name", ["MiniMaxH3VideoVAE", "MiniMaxH3AudioVAE"])
+@pytest.mark.parametrize("trusted", [True, False])
+def test_vae_forwards_trust_remote_code_to_loader(monkeypatch, vae_cls_name, trusted):
+    from vllm_omni.diffusion.models.minimax_h3 import vae as vae_module
+
+    class FakeRemote(torch.nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.model = torch.nn.Linear(1, 1)
+
+    forwarded = []
+
+    def spy_load(_component_path, _config, *, trust_remote_code):
+        forwarded.append(trust_remote_code)
+        return FakeRemote()
+
+    monkeypatch.setattr(
+        vae_module,
+        "_load_component_config",
+        lambda _path: {
+            "latent_channels": 1,
+            "latents_mean": [0.0],
+            "latents_std": [1.0],
+            "sample_rate": 32000,
+        },
+    )
+    monkeypatch.setattr(vae_module, "_load_remote_component", spy_load)
+
+    vae_cls = getattr(vae_module, vae_cls_name)
+    vae_cls(
+        "unused",
+        device=torch.device("cpu"),
+        trust_remote_code=trusted,
+    )
+
+    assert forwarded == [trusted]
+
+
+@pytest.mark.parametrize("vae_cls_name", ["MiniMaxH3VideoVAE", "MiniMaxH3AudioVAE"])
+def test_vae_defaults_to_refusing_checkpoint_code(monkeypatch, vae_cls_name):
+    from vllm_omni.diffusion.models.minimax_h3 import vae as vae_module
+
+    forwarded = []
+
+    def spy_load(_component_path, _config, *, trust_remote_code):
+        forwarded.append(trust_remote_code)
+        raise AssertionError("unreachable")
+
+    monkeypatch.setattr(
+        vae_module,
+        "_load_component_config",
+        lambda _path: {
+            "latent_channels": 1,
+            "latents_mean": [0.0],
+            "latents_std": [1.0],
+            "sample_rate": 32000,
+        },
+    )
+    monkeypatch.setattr(vae_module, "_load_remote_component", spy_load)
+
+    vae_cls = getattr(vae_module, vae_cls_name)
+    with pytest.raises(AssertionError, match="unreachable"):
+        vae_cls("unused", device=torch.device("cpu"))
+
+    assert forwarded == [False]
+
+
 def test_video_vae_encode_uses_configured_parallel_tiling():
     from vllm_omni.diffusion.models.minimax_h3.vae import (
         MiniMaxH3VideoVAE,
@@ -1761,69 +1773,6 @@ def test_video_vae_encode_uses_configured_parallel_tiling():
     assert shape == (2, 2, 2)
 
 
-def test_distributed_video_vae_encodes_references_sequentially(monkeypatch):
-    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
-    from vllm_omni.diffusion.models.minimax_h3 import (
-        pipeline_minimax_h3 as pipeline_module,
-    )
-
-    prepared = [
-        {"prepared_path": "video-1.mp4"},
-        {"prepared_path": "video-2.mp4"},
-    ]
-
-    class FakeVideoVAE:
-        def __init__(self):
-            self.calls = []
-
-        def is_distributed_enabled(self):
-            return True
-
-        def encode_video(self, frames):
-            self.calls.append(frames)
-            index = len(self.calls)
-            return torch.full((1, 2), index, dtype=torch.float32), (index, 2, 3)
-
-    pipeline = object.__new__(MiniMaxH3Pipeline)
-    torch.nn.Module.__init__(pipeline)
-    pipeline.device = torch.device("cpu")
-    pipeline.video_vae = FakeVideoVAE()
-
-    monkeypatch.setattr(
-        pipeline_module,
-        "_dit_rank_world",
-        lambda: ("dit-group", 1, 4),
-    )
-
-    def fake_broadcast_object_list(values, *, src, group, device):
-        assert values == [None]
-        assert (src, group, device) == (0, "dit-group", torch.device("cpu"))
-        values[0] = prepared
-
-    monkeypatch.setattr(
-        pipeline_module.dist,
-        "broadcast_object_list",
-        fake_broadcast_object_list,
-    )
-    monkeypatch.setattr(
-        pipeline_module,
-        "load_video_frames",
-        lambda path: f"frames:{path}",
-    )
-
-    rows, shapes = pipeline._encode_video_conditions_resident(None, count=2)
-
-    assert pipeline.video_vae.calls == [
-        "frames:video-1.mp4",
-        "frames:video-2.mp4",
-    ]
-    torch.testing.assert_close(
-        rows,
-        torch.tensor([[1.0, 1.0], [2.0, 2.0]]),
-    )
-    assert shapes == [(1, 2, 3), (2, 2, 3)]
-
-
 @pytest.mark.parametrize(
     ("case", "extra", "image_count", "expected"),
     [
@@ -1832,7 +1781,7 @@ def test_distributed_video_vae_encodes_references_sequentially(monkeypatch):
     ],
 )
 def test_f1_f2_official_fl2va_keyframe_matrix(case, extra, image_count, expected):
-    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
+    from vllm_omni.model_executor.models.minimax_h3.encoder_processing import (
         _resolve_fl2va_keyframe_indices,
     )
 
@@ -1852,7 +1801,7 @@ def test_f1_f2_official_fl2va_keyframe_matrix(case, extra, image_count, expected
     ],
 )
 def test_r1_r6_ref2va_reference_count_matrix(case, counts):
-    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
+    from vllm_omni.model_executor.models.minimax_h3.encoder_processing import (
         _validate_ref2va_reference_counts,
     )
 
@@ -1861,10 +1810,10 @@ def test_r1_r6_ref2va_reference_count_matrix(case, counts):
 
 
 def test_ref2va_reference_count_validation_preserves_client_error_metadata():
-    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
+    from vllm_omni.errors import OmniClientError
+    from vllm_omni.model_executor.models.minimax_h3.encoder_processing import (
         _validate_ref2va_reference_counts,
     )
-    from vllm_omni.errors import OmniClientError
 
     with pytest.raises(OmniClientError, match="at least one image or video"):
         _validate_ref2va_reference_counts(0, 0, 0)
@@ -1968,32 +1917,6 @@ def test_prepared_reference_video_descriptor_rejects_unknown_fields():
         deserialize_prepared_reference_videos('{"artifact_dir":"/tmp","videos":[{"path":"x"}]}')
 
 
-def test_stage_one_reuses_existing_prepared_reference_video(tmp_path):
-    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
-        _reuse_prepared_reference_videos,
-    )
-
-    prepared_path = tmp_path / "prepared.mp4"
-    prepared_path.touch()
-    prepared = [{"prepared_path": str(prepared_path)}]
-
-    assert _reuse_prepared_reference_videos(prepared, expected_count=1) is prepared
-
-
-def test_stage_one_rejects_invalid_prepared_reference_video(tmp_path):
-    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
-        _reuse_prepared_reference_videos,
-    )
-
-    with pytest.raises(ValueError, match="count does not match"):
-        _reuse_prepared_reference_videos([], expected_count=1)
-    with pytest.raises(ValueError, match="prepared reference video is unavailable"):
-        _reuse_prepared_reference_videos(
-            [{"prepared_path": str(tmp_path / "missing.mp4")}],
-            expected_count=1,
-        )
-
-
 def test_ref2va_qwen_sampling_uses_one_selective_decode(monkeypatch):
     from vllm_omni.diffusion.models.minimax_h3 import reference_video as reference_video_module
 
@@ -2313,9 +2236,8 @@ def test_ref2va_two_video_recipe_rejects_real_duration_overflow(monkeypatch, tmp
 
 @pytest.mark.parametrize("duration", [4.0, 15.0])
 def test_g2_output_duration_accepts_official_boundaries(duration):
-    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+    from vllm_omni.model_executor.models.minimax_h3.encoder_processing import resolve_minimax_h3_shape
 
-    pipeline = object.__new__(MiniMaxH3Pipeline)
     sampling = SimpleNamespace(
         fps=24,
         num_frames=1,
@@ -2324,15 +2246,14 @@ def test_g2_output_duration_accepts_official_boundaries(duration):
         extra_args={"duration": duration},
     )
 
-    height, width, *_ = pipeline._resolve_shape("ref2va", sampling, None)
+    height, width, *_ = resolve_minimax_h3_shape("ref2va", sampling, None)
     assert height > 0 and width > 0
 
 
 @pytest.mark.parametrize("duration", [3.99, 15.01, float("nan"), "not-a-duration"])
 def test_g2_output_duration_rejects_out_of_contract_values(duration):
-    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+    from vllm_omni.model_executor.models.minimax_h3.encoder_processing import resolve_minimax_h3_shape
 
-    pipeline = object.__new__(MiniMaxH3Pipeline)
     sampling = SimpleNamespace(
         fps=24,
         num_frames=1,
@@ -2341,7 +2262,7 @@ def test_g2_output_duration_rejects_out_of_contract_values(duration):
         extra_args={"duration": duration},
     )
     with pytest.raises(ValueError, match="duration"):
-        pipeline._resolve_shape("ref2va", sampling, None)
+        resolve_minimax_h3_shape("ref2va", sampling, None)
 
 
 def test_g1_fanout_uses_incrementing_output_seeds():
@@ -2359,26 +2280,25 @@ def test_g1_fanout_uses_incrementing_output_seeds():
 def test_g3_task_specific_aspect_ratio_policy():
     from PIL import Image
 
-    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
-        _resolve_minimax_h3_aspect_ratio,
+    from vllm_omni.model_executor.models.minimax_h3.preprocessing import (
+        resolve_minimax_h3_aspect_ratio,
     )
 
     image = Image.new("RGB", (1280, 720))
-    assert _resolve_minimax_h3_aspect_ratio("fl2va", "9:16", image) == pytest.approx(16 / 9)
-    assert _resolve_minimax_h3_aspect_ratio("ref2va", None, None) == pytest.approx(16 / 9)
-    assert _resolve_minimax_h3_aspect_ratio("ref2va", "auto", None) == pytest.approx(16 / 9)
+    assert resolve_minimax_h3_aspect_ratio("fl2va", "9:16", image) == pytest.approx(16 / 9)
+    assert resolve_minimax_h3_aspect_ratio("ref2va", None, None) == pytest.approx(16 / 9)
+    assert resolve_minimax_h3_aspect_ratio("ref2va", "auto", None) == pytest.approx(16 / 9)
     with pytest.raises(ValueError, match="requires an explicit"):
-        _resolve_minimax_h3_aspect_ratio("t2va", None, None)
+        resolve_minimax_h3_aspect_ratio("t2va", None, None)
     with pytest.raises(ValueError, match="one of"):
-        _resolve_minimax_h3_aspect_ratio("t2va", "2:1", None)
+        resolve_minimax_h3_aspect_ratio("t2va", "2:1", None)
 
 
 def test_g3_t2va_shape_requires_a_named_ratio_and_fl2va_ignores_override():
     from PIL import Image
 
-    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+    from vllm_omni.model_executor.models.minimax_h3.encoder_processing import resolve_minimax_h3_shape
 
-    pipeline = object.__new__(MiniMaxH3Pipeline)
     t2va_sampling = SimpleNamespace(
         fps=24,
         num_frames=1,
@@ -2387,7 +2307,7 @@ def test_g3_t2va_shape_requires_a_named_ratio_and_fl2va_ignores_override():
         extra_args={"duration": 5.0},
     )
     with pytest.raises(ValueError, match="requires an explicit aspect_ratio"):
-        pipeline._resolve_shape("t2va", t2va_sampling, None)
+        resolve_minimax_h3_shape("t2va", t2va_sampling, None)
 
     fl2va_sampling = SimpleNamespace(
         fps=24,
@@ -2396,14 +2316,14 @@ def test_g3_t2va_shape_requires_a_named_ratio_and_fl2va_ignores_override():
         width=None,
         extra_args={"duration": 5.0, "aspect_ratio": "9:16"},
     )
-    height, width, *_ = pipeline._resolve_shape("fl2va", fl2va_sampling, Image.new("RGB", (1280, 720)))
+    height, width, *_ = resolve_minimax_h3_shape("fl2va", fl2va_sampling, Image.new("RGB", (1280, 720)))
     assert (height, width) == (768, 1344)
 
 
 def test_g4_reference_image_boundaries_and_aspect_ratio():
     from PIL import Image
 
-    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
+    from vllm_omni.model_executor.models.minimax_h3.encoder_processing import (
         _validate_reference_image,
     )
 
@@ -2418,18 +2338,18 @@ def test_g4_reference_image_boundaries_and_aspect_ratio():
 def test_g4_reference_image_file_format_and_size_contract(tmp_path):
     from PIL import Image
 
-    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
-        _load_image,
+    from vllm_omni.model_executor.models.minimax_h3.preprocessing import (
+        load_minimax_h3_images,
     )
 
     valid_path = tmp_path / "reference.png"
     Image.new("RGB", (256, 256)).save(valid_path)
-    assert _load_image(valid_path).size == (256, 256)
+    assert load_minimax_h3_images(valid_path)[0].size == (256, 256)
 
     invalid_path = tmp_path / "reference.bmp"
     Image.new("RGB", (256, 256)).save(invalid_path)
     with pytest.raises(ValueError, match="must use"):
-        _load_image(invalid_path)
+        load_minimax_h3_images(invalid_path)
 
 
 def test_g4_standalone_audio_duration_and_total_duration_contract():
@@ -2455,47 +2375,6 @@ def test_g4_standalone_audio_duration_and_total_duration_contract():
         )
 
 
-def test_ref2va_audio_duration_validation_precedes_rank_branch(monkeypatch):
-    from vllm_omni.diffusion.models.minimax_h3 import pipeline_minimax_h3 as pipeline_module
-
-    pipeline = object.__new__(pipeline_module.MiniMaxH3Pipeline)
-    pipeline.device = torch.device("cpu")
-    monkeypatch.setattr(pipeline_module, "_dit_rank_world", lambda: (None, 1, 2))
-
-    waveform = torch.zeros(1, 10)
-    with pytest.raises(ValueError, match="max_duration_seconds must be positive"):
-        pipeline._encode_audio_conditions_resident(
-            [(waveform, 10)],
-            max_duration_seconds=0,
-        )
-
-
-def test_ref2va_standalone_audio_condition_is_bounded_to_output_duration():
-    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import MiniMaxH3Pipeline
-
-    pipeline = object.__new__(MiniMaxH3Pipeline)
-    pipeline.device = torch.device("cpu")
-    observed = []
-
-    class FakeAudioVAE:
-        def encode_waveform(self, waveform, sample_rate):
-            observed.append((waveform.clone(), sample_rate))
-            return waveform, waveform.shape[-1]
-
-    pipeline.audio_vae = FakeAudioVAE()
-    waveform = torch.arange(40, dtype=torch.float32).reshape(1, 40)
-
-    encoded, lengths = pipeline._encode_audio_conditions_resident(
-        [(waveform, 10)],
-        max_duration_seconds=2.5,
-    )
-
-    assert observed[0][0].shape == (1, 25)
-    assert observed[0][1] == 10
-    assert encoded.shape == (1, 25)
-    assert lengths == [25]
-
-
 @pytest.mark.parametrize(
     ("field", "value", "message"),
     [
@@ -2559,9 +2438,8 @@ def _one_layer_text_encoder():
         MiniMaxH3Qwen3VLQKVParallelLinear,
         MiniMaxH3Qwen3VLRMSNorm,
     )
-    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import _SingleRankEncoderGroup
 
-    group = _SingleRankEncoderGroup(0)
+    group = SimpleNamespace(rank_in_group=0, world_size=1, device_group=None, ranks=[0])
     layer = nn.Module()
     layer.self_attn = nn.Module()
     layer.mlp = nn.Module()
@@ -2676,3 +2554,633 @@ def test_encoder_load_places_every_source_in_its_own_rows(tmp_path):
     }
     for source, rows in slices.items():
         assert torch.equal(rows, torch.full_like(rows, _SOURCE_FILL[source])), source
+
+
+def _pad_seq_len_batch(pad_seq_len):
+    """A t2va request that pins the packed length through ``extra_args``."""
+    from vllm_omni.diffusion.request import OmniDiffusionRequest
+    from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+    from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+    extra_args = {"task": "t2va", "aspect_ratio": "16:9"}
+    if pad_seq_len is not None:
+        extra_args["pad_seq_len"] = pad_seq_len
+    sampling = OmniDiffusionSamplingParams(
+        quality="lossless",
+        width=1344,
+        height=768,
+        fps=24,
+        num_frames=124,
+        num_inference_steps=None,
+        extra_args=extra_args,
+    )
+    return DiffusionRequestBatch(
+        [
+            OmniDiffusionRequest(
+                prompt=_encoder_prompt("pinned packed length"),
+                sampling_params=sampling,
+                request_id="pad-seq-len",
+            )
+        ]
+    )
+
+
+@pytest.mark.parametrize("pinned, expected", [(None, None), (54080, 54080)])
+def test_pad_seq_len_reaches_diffuse_from_extra_args(pinned, expected):
+    """The request field must arrive at ``diffuse``, not stop at validation."""
+    diffuse_calls: list[dict[str, Any]] = []
+    pipeline = _distilled_pipeline(diffuse_calls, {"fl2va": None, "ref2va": None})
+
+    pipeline.forward(_pad_seq_len_batch(pinned))
+
+    assert [call["pad_seq_len"] for call in diffuse_calls] == [expected]
+
+
+@pytest.mark.parametrize("task", ["t2va", "ref2va"])
+def test_pad_seq_len_reaches_the_packer_for_every_task_family(task, monkeypatch):
+    """``diffuse`` must hand the pin to whichever packer the task uses."""
+    import vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 as module
+
+    class _CapturedError(Exception):
+        pass
+
+    recorded = {}
+
+    def _capture(**kwargs):
+        recorded.update(kwargs)
+        raise _CapturedError
+
+    monkeypatch.setattr(module, "minimax_h3_packed_sequence", _capture)
+    monkeypatch.setattr(module, "minimax_h3_packed_sequence_ref2va_blocks", _capture)
+
+    pipeline = _distilled_pipeline([], {"fl2va": None, "ref2va": None})
+    pipeline._initial_noise = lambda **kwargs: (torch.zeros(1), torch.zeros(1))
+
+    with pytest.raises(_CapturedError):
+        pipeline._build_denoise_inputs(
+            task=task,
+            text_embeddings=torch.ones(7, 2),
+            text_tags=torch.ones(7, dtype=torch.long),
+            seed=0,
+            latent_t=2,
+            latent_h=4,
+            latent_w=6,
+            audio_t=3,
+            num_frames=5,
+            num_steps=2,
+            video_shift=12.0,
+            audio_shift=3.0,
+            base_schedule=None,
+            visual_condition=None,
+            visual_condition_shape=(1, 4, 6),
+            audio_condition=None,
+            ref_audio_t=1,
+            pad_seq_len=192,
+        )
+
+    assert recorded["seq_len"] == 192
+
+
+@pytest.mark.parametrize("value", [0, -64, 100, "128", True, 1.5, (1 << 20) + 64])
+def test_pad_seq_len_request_validation_rejects_bad_values(value):
+    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
+        _resolve_pad_seq_len,
+    )
+    from vllm_omni.errors import OmniClientError
+
+    with pytest.raises(OmniClientError):
+        _resolve_pad_seq_len(value)
+
+
+def test_pad_seq_len_request_validation_accepts_aligned_values():
+    from vllm_omni.diffusion.models.minimax_h3.packed_sequence import (
+        MINIMAX_H3_MAX_PAD_SEQ_LEN,
+    )
+    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
+        _resolve_pad_seq_len,
+    )
+
+    assert _resolve_pad_seq_len(None) is None
+    assert _resolve_pad_seq_len(54080) == 54080
+    assert _resolve_pad_seq_len(MINIMAX_H3_MAX_PAD_SEQ_LEN) == MINIMAX_H3_MAX_PAD_SEQ_LEN
+
+
+def _turbo_spec(filename: str) -> TurboSpec:
+    """Build the spec a loaded artifact of this name would carry."""
+    spec = parse_turbo_filename(filename)
+    assert spec is not None
+    return spec
+
+
+def test_joint_video_output_is_quantized_before_transfer():
+    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
+        _minimax_h3_post_process,
+        _prepare_minimax_h3_video_output,
+    )
+
+    video = torch.linspace(-0.1, 1.1, 2 * 3 * 2 * 4 * 5, dtype=torch.float64).reshape(2, 3, 2, 4, 5)
+    expected = torch.round(video.float().clamp(0, 1) * 255).to(torch.uint8).permute(0, 2, 3, 4, 1)
+    prepared = _prepare_minimax_h3_video_output(video)
+
+    assert prepared.dtype == torch.uint8
+    assert prepared.is_contiguous()
+    assert prepared.shape == (2, 2, 4, 5, 3)
+    torch.testing.assert_close(prepared, expected, rtol=0, atol=0)
+
+    result = _minimax_h3_post_process((prepared, torch.zeros(1, 2, 6)))
+    assert result["video"][0].dtype == np.uint8
+    np.testing.assert_array_equal(result["video"][0], expected[0].numpy())
+
+
+def test_no_offload_keeps_text_encoder_resident():
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.od_config = SimpleNamespace(
+        enable_cpu_offload=False,
+        enable_layerwise_offload=False,
+    )
+    pipeline.text_encoder = Mock()
+    expected = torch.ones(2, 3)
+    pipeline.text_encoder.encode_ids.return_value = expected
+    input_ids = torch.tensor([1, 2])
+
+    actual = pipeline._encode_text_hidden(input_ids, {})
+
+    assert actual is expected
+    pipeline.text_encoder.load_to_device.assert_called_once_with()
+    pipeline.text_encoder.offload_to_cpu.assert_not_called()
+
+
+def test_model_offload_uses_hooked_text_encoder_call():
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.od_config = SimpleNamespace(
+        enable_cpu_offload=True,
+        enable_layerwise_offload=False,
+    )
+    expected = torch.ones(2, 3)
+    pipeline.text_encoder = Mock(return_value=expected)
+    pipeline._model_cpu_offload_modules = [pipeline.text_encoder]
+    input_ids = torch.tensor([1, 2])
+    vision_kwargs = {"pixel_values": torch.ones(1, 4)}
+
+    actual = pipeline._encode_text_hidden(input_ids, vision_kwargs)
+
+    assert actual is expected
+    pipeline.text_encoder.assert_called_once_with(input_ids, **vision_kwargs)
+    pipeline.text_encoder.load_to_device.assert_not_called()
+
+
+@pytest.mark.parametrize(
+    ("enable_layerwise", "enable_distributed"),
+    [(True, False), (False, True)],
+)
+def test_legacy_layer_offload_preserves_minimax_stage_lifecycle(enable_layerwise, enable_distributed):
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.od_config = SimpleNamespace(
+        diffusion_offload_config=None,
+        enable_cpu_offload=False,
+        enable_layerwise_offload=enable_layerwise,
+        enable_distributed_layerwise_offload=enable_distributed,
+    )
+    pipeline.text_encoder = Mock()
+    expected = torch.ones(2, 3)
+    pipeline.text_encoder.encode_ids.return_value = expected
+
+    actual = pipeline._encode_text_hidden(torch.tensor([1, 2]), {})
+
+    assert actual is expected
+    pipeline.text_encoder.load_to_device.assert_called_once_with()
+    pipeline.text_encoder.offload_to_cpu.assert_called_once_with()
+
+    vae = Mock()
+    with pipeline._component_on_device(vae):
+        pass
+    vae.load_to_device.assert_called_once_with()
+    vae.offload_to_cpu.assert_called_once_with()
+
+
+def test_layerwise_encoder_selection_releases_text_encoder():
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.od_config = SimpleNamespace(
+        enable_cpu_offload=False,
+        enable_layerwise_offload=False,
+        enable_distributed_layerwise_offload=False,
+        diffusion_offload_config={
+            "mode": "layer",
+            "components": ["text_encoder"],
+        },
+    )
+    pipeline.text_encoder = Mock()
+    expected = torch.ones(2, 3)
+    pipeline.text_encoder.encode_ids.return_value = expected
+
+    actual = pipeline._encode_text_hidden(torch.tensor([1, 2]), {})
+
+    assert actual is expected
+    pipeline.text_encoder.load_to_device.assert_called_once_with()
+    pipeline.text_encoder.offload_to_cpu.assert_called_once_with()
+
+
+def test_layerwise_dit_only_keeps_text_encoder_resident():
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.od_config = SimpleNamespace(
+        enable_cpu_offload=False,
+        enable_layerwise_offload=False,
+        enable_distributed_layerwise_offload=False,
+        diffusion_offload_config={"mode": "layer", "components": ["dit"]},
+    )
+    pipeline.text_encoder = Mock()
+    expected = torch.ones(2, 3)
+    pipeline.text_encoder.encode_ids.return_value = expected
+
+    actual = pipeline._encode_text_hidden(torch.tensor([1, 2]), {})
+
+    assert actual is expected
+    pipeline.text_encoder.load_to_device.assert_called_once_with()
+    pipeline.text_encoder.offload_to_cpu.assert_not_called()
+
+
+def test_dit_encoder_selection_keeps_vae_resident():
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.od_config = SimpleNamespace(
+        enable_cpu_offload=False,
+        enable_layerwise_offload=False,
+        enable_distributed_layerwise_offload=False,
+        diffusion_offload_config={
+            "mode": "layer",
+            "components": ["dit", "text_encoder"],
+        },
+    )
+    component = Mock()
+
+    with pipeline._component_on_device(component):
+        pass
+
+    component.load_to_device.assert_not_called()
+    component.offload_to_cpu.assert_not_called()
+
+
+def test_keyframe_encode_pins_and_restores_cudnn_settings():
+    from vllm_omni.diffusion.models.minimax_h3.vae import (
+        _minimax_h3_keyframe_encode_context,
+    )
+
+    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")):
+            assert cudnn.enabled
+            assert not cudnn.benchmark
+            assert cudnn.deterministic
+            assert cudnn.allow_tf32
+
+        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
+
+
+@pytest.mark.parametrize("fail_encode", [False, True])
+def test_keyframe_encode_enters_backend_context(monkeypatch, fail_encode):
+    from PIL import Image
+
+    from vllm_omni.diffusion.models.minimax_h3 import vae as vae_module
+
+    events = []
+    input_image = Image.new("RGB", (32, 32))
+
+    @contextmanager
+    def track_context(device):
+        assert device == torch.device("cpu")
+        events.append("enter")
+        try:
+            yield
+        finally:
+            events.append("exit")
+
+    class FakeModel(torch.nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.weight = torch.nn.Parameter(torch.ones(1))
+            self.parallel_tiling = True
+
+        def encode_images(self, image, *, use_fp16_latent):
+            assert events == ["enter"]
+            assert image is input_image
+            assert use_fp16_latent
+            events.append("encode")
+            if fail_encode:
+                raise RuntimeError("encode failed")
+            return [torch.ones(1, 1, 2, 2)]
+
+    video_vae = object.__new__(vae_module.MiniMaxH3VideoVAE)
+    torch.nn.Module.__init__(video_vae)
+    video_vae.model = FakeModel()
+    video_vae.config_dict = {
+        "latent_channels": 1,
+        "latents_mean": [0.0],
+        "latents_std": [1.0],
+    }
+    monkeypatch.setattr(vae_module, "_minimax_h3_keyframe_encode_context", track_context)
+
+    if fail_encode:
+        with pytest.raises(RuntimeError, match="encode failed"):
+            video_vae.encode_image(input_image)
+    else:
+        rows = video_vae.encode_image(input_image)
+        torch.testing.assert_close(rows, torch.ones(1, 4))
+
+    assert events == ["enter", "encode", "exit"]
+    assert video_vae.model.parallel_tiling
+
+
+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: list["FakeEncoder"] = []
+
+        def __init__(self, **kwargs):
+            self.pushes = []
+            self.kwargs = kwargs
+            self.__class__.instances.append(self)
+
+        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"
+
+        def abort(self):
+            raise AssertionError("unexpected abort")
+
+    class FakeAudioVAE:
+        def decode_latent(self, latent):
+            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))
+
+    pipeline = object.__new__(mod.MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.audio_vae = FakeAudioVAE()
+    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.chunked_video.ChunkedMP4Encoder",
+        FakeEncoder,
+    )
+
+    output = pipeline.decode_to_mp4(
+        torch.zeros(1),
+        torch.zeros(1),
+        height=2,
+        width=2,
+        batch_frames=4,
+    )
+
+    assert output == b"mp4"
+    encoder = FakeEncoder.instances[-1]
+    assert [frames.shape[0] for frames in encoder.pushes] == [6, 3]
+    assert np.array_equal(encoder.pushes[0][0], np.full((2, 2, 3), 0, dtype=np.uint8))
+    assert np.array_equal(encoder.pushes[0][3], np.full((2, 2, 3), 64, dtype=np.uint8))
+    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: list["FakeEncoder"] = []
+
+        def __init__(self, **kwargs):
+            self.kwargs = kwargs
+            self.__class__.instances.append(self)
+
+        def push(self, frames, *, on_consumed=None):
+            del frames
+            if on_consumed is not None:
+                on_consumed()
+
+        def finish(self):
+            return b"mp4"
+
+        def abort(self):
+            raise AssertionError("unexpected abort")
+
+    class FakeAudioVAE:
+        def decode_latent(self, latent):
+            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))
+
+    pipeline = object.__new__(mod.MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.audio_vae = FakeAudioVAE()
+    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.chunked_video.ChunkedMP4Encoder", FakeEncoder)
+
+    pipeline.decode_to_mp4(
+        torch.zeros(1),
+        torch.zeros(1),
+        height=2,
+        width=2,
+        video_codec_options={"preset": "ultrafast"},
+    )
+
+    assert FakeEncoder.instances[-1].kwargs["video_codec_options"] == {"preset": "ultrafast"}
+
+
+@pytest.mark.parametrize(
+    ("codec_extra", "expected"),
+    [
+        ({}, {"preset": "ultrafast", "threads": "0"}),
+        ({"video_codec_options": {"preset": "slow", "threads": 2}}, {"preset": "slow", "threads": "2"}),
+        ({"video_codec_options": {}}, {}),
+        ({"video_codec_options": None}, None),
+    ],
+)
+@pytest.mark.parametrize("batch_extra, batch_frames", [({}, 17), ({"preencode_batch_frames": 5}, 5)])
+def test_preencode_request_preserves_serving_codec_defaults(codec_extra, expected, batch_extra, batch_frames):
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+    from vllm_omni.diffusion.request import OmniDiffusionRequest
+    from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+    from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.partition = "fl2va"
+    pipeline.supported_tasks = frozenset({"t2va"})
+    pipeline.default_video_shift = 12.0
+    pipeline.default_audio_shift = 3.0
+    pipeline.device = torch.device("cpu")
+    pipeline.od_config = SimpleNamespace()
+    pipeline.load_text_encoder = False
+    pipeline.load_vae_encoder = False
+    pipeline.text_encoder = object()
+    pipeline.encode_prompt = Mock(return_value=(torch.ones(1, 2), torch.ones(1, dtype=torch.long)))
+    pipeline._quality_policy = Mock()
+    pipeline._cache_dit_runtime = Mock()
+    pipeline.diffuse = Mock(return_value=(torch.zeros(1), torch.zeros(1)))
+    pipeline.decode_to_mp4 = Mock(return_value=b"mp4")
+    sampling = OmniDiffusionSamplingParams(
+        width=1344,
+        height=768,
+        fps=24,
+        num_frames=124,
+        num_inference_steps=50,
+        extra_args={"task": "t2va", "aspect_ratio": "16:9", "preencode_mp4": True, **codec_extra, **batch_extra},
+    )
+    batch = DiffusionRequestBatch(
+        [OmniDiffusionRequest(prompt=_encoder_prompt("test"), sampling_params=sampling, request_id="codec-defaults")]
+    )
+
+    pipeline.forward(batch)
+
+    assert pipeline.decode_to_mp4.call_args.kwargs["video_codec_options"] == expected
+    assert pipeline.decode_to_mp4.call_args.kwargs["batch_frames"] == batch_frames
+
+
+def test_video_codec_options_are_normalized_for_the_encoder():
+    from vllm_omni.diffusion.utils.media_utils import normalize_video_codec_options
+
+    assert normalize_video_codec_options({"preset": "ultrafast", "threads": 0}) == {
+        "preset": "ultrafast",
+        "threads": "0",
+    }
+    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_execution_modes.py b/tests/diffusion/models/minimax_h3/test_minimax_h3_execution_modes.py
new file mode 100644
index 000000000..510a7b33e
--- /dev/null
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_execution_modes.py
@@ -0,0 +1,133 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from types import SimpleNamespace
+from typing import Any
+from unittest.mock import Mock
+
+import pytest
+import torch
+from PIL import Image
+
+from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+
+@pytest.fixture
+def pipeline():
+    model = object.__new__(MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(model)
+    model.load_text_encoder = True
+    model.load_vae_encoder = True
+    model.device = torch.device("cpu")
+    model.partition = "combined"
+    model.supported_tasks = frozenset({"t2va", "fl2va", "ref2va"})
+    model.default_video_shift = 12.0
+    model.default_audio_shift = 3.0
+    model.od_config = SimpleNamespace(enable_layerwise_offload=False)
+    model._quality_policy = SimpleNamespace(resolve=Mock(return_value=SimpleNamespace(cache_dit=None)))
+    model._cache_dit_runtime = SimpleNamespace(prepare=Mock())
+    model.encode_prompt = Mock(
+        return_value=(torch.ones(2, 5120, dtype=torch.bfloat16), torch.ones(2, dtype=torch.long))
+    )
+    model.video_vae = Mock()
+    model.video_vae.is_distributed_enabled.return_value = False
+    model.video_vae.encode_image.side_effect = lambda image: torch.ones((image.height // 32) * (image.width // 32), 96)
+    model.audio_vae = Mock()
+    model.transformer = torch.nn.Identity()
+    model.diffuse = Mock(return_value=(torch.zeros(1), torch.zeros(1)))
+    model.decode = Mock(return_value=(torch.zeros(1, 3, 1, 32, 32), torch.zeros(1)))
+    return model
+
+
+def _request(task):
+    prompt: dict[str, Any] = {"prompt": "A person waves."}
+    if task != "t2va":
+        prompt["multi_modal_data"] = {"image": Image.new("RGB", (256, 256))}
+    sampling = OmniDiffusionSamplingParams(
+        height=32, width=32, num_frames=96, num_inference_steps=2, extra_args={"task": task, "aspect_ratio": "1:1"}
+    )
+    return SimpleNamespace(prompts=[prompt], sampling_params=sampling)
+
+
+@pytest.mark.parametrize("task", ["t2va", "fl2va", "ref2va"])
+def test_single_stage_encodes_without_stage_zero(pipeline, task):
+    output = pipeline.forward(_request(task))
+    pipeline.encode_prompt.assert_called_once()
+    assert pipeline.video_vae.encode_image.call_count == int(task != "t2va")
+    pipeline.diffuse.assert_called_once()
+    assert pipeline.diffuse.call_args.kwargs["task"] == task
+    video, audio = output.output
+    torch.testing.assert_close(video, torch.zeros(1, 1, 32, 32, 3, dtype=torch.uint8))
+    torch.testing.assert_close(audio, pipeline.decode.return_value[1])
+
+
+def test_mixed_reference_conditioning_matches_stage_zero_handoff(pipeline, monkeypatch):
+    import numpy as np
+
+    from vllm_omni.data_entry_keys import flatten_payload
+    from vllm_omni.model_executor.models.minimax_h3 import encoder_processing as processing
+    from vllm_omni.model_executor.models.minimax_h3.conditioning import (
+        MiniMaxH3EncoderConditioning,
+        MiniMaxH3TextConditioning,
+    )
+    from vllm_omni.model_executor.models.minimax_h3.encoder import MiniMaxH3Encoder
+    from vllm_omni.model_executor.stage_input_processors.minimax_h3 import encoder2diffusion, prepare_encoder_prompt
+
+    frames = np.zeros((48, 32, 32, 3), dtype=np.uint8)
+    decode_frames = Mock(return_value=frames)
+    sampler = Mock(wraps=processing.sample_reference_video_frames)
+    monkeypatch.setattr(processing, "load_video_frames", decode_frames)
+    monkeypatch.setattr(processing, "sample_reference_video_frames", sampler)
+    monkeypatch.setattr(
+        processing,
+        "prepare_reference_videos",
+        Mock(
+            return_value=[{"prepared_path": "prepared.mp4", "original_path": "original.mp4", "input_has_audio": True}]
+        ),
+    )
+    monkeypatch.setattr(processing, "load_video_audio", Mock(return_value=(torch.full((64000,), 3.0), 32000)))
+    pipeline.video_vae.encode_video.return_value = (torch.full((1, 96), 2.0), (1, 2, 2))
+
+    def encode_audio(waveform, sample_rate):
+        length = round(waveform.shape[-1] / sample_rate * 40)
+        return torch.full((length * 2, 32), float(waveform[0])), length
+
+    pipeline.audio_vae.encode_waveform.side_effect = encode_audio
+    request = _request("ref2va")
+    request.prompts[0]["multi_modal_data"].update(video="original.mp4", audio=(torch.full((192000,), 4.0), 32000))
+    pipeline.forward(request)
+    local_kwargs = pipeline.diffuse.call_args.kwargs
+
+    transformed = prepare_encoder_prompt(request.prompts[0], [request.sampling_params])
+    stage_zero = object.__new__(MiniMaxH3Encoder)
+    torch.nn.Module.__init__(stage_zero)
+    stage_zero._component_leader = True
+    stage_zero.video_vae = pipeline.video_vae
+    stage_zero.audio_vae = pipeline.audio_vae
+    media = stage_zero._encode_media(stage_zero._media_input(transformed["additional_information"]))
+    text = MiniMaxH3TextConditioning(*pipeline.encode_prompt.return_value)
+    payload = MiniMaxH3EncoderConditioning.from_components(text, media).to_omni_payload()
+    source = SimpleNamespace(finished=True, outputs=[SimpleNamespace(multimodal_output=flatten_payload(payload))])
+    bridged = encoder2diffusion([source], request.prompts[0])
+    pipeline.load_text_encoder = False
+    pipeline.load_vae_encoder = False
+    pipeline.encode_prompt.reset_mock()
+    pipeline.forward(SimpleNamespace(prompts=[bridged], sampling_params=request.sampling_params))
+    external_kwargs = pipeline.diffuse.call_args.kwargs
+    for key, value in local_kwargs.items():
+        if isinstance(value, torch.Tensor):
+            torch.testing.assert_close(value, external_kwargs[key])
+        else:
+            assert value == external_kwargs[key]
+    pipeline.encode_prompt.assert_not_called()
+    assert decode_frames.call_count == sampler.call_count == 2
+    assert all(call.kwargs["decoded_frames"] is frames for call in sampler.call_args_list)
+    assert [block["kind"] for block in local_kwargs["ref_blocks"]] == ["image", "video_audio", "audio"]
+    assert local_kwargs["audio_condition_lengths"] == [80, round(107 / 24 * 40)]
+    assert all(
+        call.args[0].shape[-1] == round(107 / 24 * 32000)
+        for call in pipeline.audio_vae.encode_waveform.call_args_list[1::2]
+    )
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 e10fbe56a..fcca6f7ad 100644
--- a/tests/diffusion/models/minimax_h3/test_minimax_h3_modulation.py
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_modulation.py
@@ -6,10 +6,11 @@ import torch
 from vllm.triton_utils import HAS_TRITON
 
 from tests.helpers.mark import hardware_marks
-from vllm_omni.diffusion.attention.ops.minimax_h3_modulation import (
+from vllm_omni.diffusion.layers.indexed_modulation import (
     _MAX_1D_GRID_SIZE,
     _iter_row_chunks,
     _launch_row_chunks,
+    _use_hopper_bf16_affine_semantics,
     indexed_gate,
     indexed_gate_rms_norm_scale_shift,
     indexed_scale_shift_,
@@ -190,3 +191,55 @@ def test_fused_modulation_preserves_bf16_residual_boundary() -> None:
     )
 
     assert torch.equal(modulated_out, expected)
+
+
+@pytest.mark.cuda
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA required")
+@pytest.mark.skipif(
+    torch.cuda.is_available() and torch.cuda.get_device_capability()[0] != 9,
+    reason="SM90-specific precision path",
+)
+@pytest.mark.skipif(not HAS_TRITON, reason="Triton required")
+def test_hopper_fused_modulation_matches_pytorch_reference() -> None:
+    torch.manual_seed(42)
+    rows, hidden_size, conditions = 128, 3072, 4
+    residual = torch.randn(rows, hidden_size, device="cuda", dtype=torch.bfloat16)
+    gate = torch.randn(conditions, hidden_size, device="cuda", dtype=torch.bfloat16)
+    branch = torch.randn(rows, hidden_size, device="cuda", dtype=torch.bfloat16)
+    weight = torch.randn(hidden_size, device="cuda", dtype=torch.bfloat16)
+    shift = torch.randn(conditions, hidden_size, device="cuda", dtype=torch.bfloat16)
+    scale = torch.randn(conditions, hidden_size, device="cuda", dtype=torch.bfloat16)
+    indices = torch.arange(rows, device="cuda") % conditions
+    eps = 1e-6
+
+    reference_residual = (residual + gate.index_select(0, indices) * branch).to(torch.bfloat16)
+    normalized = reference_residual.float()
+    variance = normalized.pow(2).mean(-1, keepdim=True)
+    normalized = (weight.float() * (normalized * torch.rsqrt(variance + eps))).to(torch.bfloat16)
+    reference_modulated = (normalized * (1.0 + scale.index_select(0, indices)) + shift.index_select(0, indices)).to(
+        torch.bfloat16
+    )
+
+    actual_residual, actual_modulated = indexed_gate_rms_norm_scale_shift(
+        residual,
+        gate,
+        branch,
+        weight,
+        shift,
+        scale,
+        indices,
+        eps,
+    )
+
+    torch.testing.assert_close(actual_residual, reference_residual, atol=5e-2, rtol=5e-2)
+    torch.testing.assert_close(actual_modulated, reference_modulated, atol=5e-2, rtol=5e-2)
+
+
+@pytest.mark.cuda
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA required")
+def test_hopper_precision_dispatch_is_architecture_scoped(monkeypatch) -> None:
+    tensor = torch.empty(0, device="cuda")
+    monkeypatch.setattr(torch.cuda, "get_device_capability", lambda _device: (9, 0))
+    assert _use_hopper_bf16_affine_semantics(tensor)
+    monkeypatch.setattr(torch.cuda, "get_device_capability", lambda _device: (10, 3))
+    assert not _use_hopper_bf16_affine_semantics(tensor)
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 865b2248a..824ad2c63 100644
--- a/tests/diffusion/models/minimax_h3/test_minimax_h3_offload.py
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_offload.py
@@ -1,82 +1,282 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
-from contextlib import contextmanager
+import weakref
+from contextlib import contextmanager, nullcontext
 from types import SimpleNamespace
 from typing import Any
 from unittest.mock import Mock
 
 import pytest
 import torch
-from PIL import Image
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
 
 
-def test_h3_profiler_targets_cover_reference_encoders_and_vae_decoders():
+def test_h3_full_pipeline_profiler_includes_local_encoding():
     from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
 
     targets = MiniMaxH3Pipeline._PROFILER_TARGETS
-    assert "_encode_visual_conditions" in targets
-    assert "_encode_reference_audio_conditions" in targets
-    assert "video_vae.decode_latent" in targets
-    assert "audio_vae.decode_latent" in targets
-    assert "_encode_video_conditions" not in targets
-    assert "_encode_video_audio_conditions" not in targets
-    assert "_encode_audio_conditions" not in targets
+    assert targets == [
+        "encode_prompt",
+        "_encode_local_media",
+        "diffuse",
+        "decode",
+        "video_vae.decode_latent",
+        "audio_vae.decode_latent",
+        "prepare_encode",
+        "denoise_step",
+        "post_decode",
+    ]
 
 
-@pytest.mark.parametrize("distributed", [False, True])
-def test_manual_component_offload_wins_over_requested_model_offload(distributed):
+def test_decoded_output_is_unchanged_without_active_model_offload():
     from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
 
     pipeline = object.__new__(MiniMaxH3Pipeline)
     torch.nn.Module.__init__(pipeline)
-    pipeline.od_config = SimpleNamespace(
-        enable_cpu_offload=True,
-        enable_layerwise_offload=not distributed,
-        enable_distributed_layerwise_offload=distributed,
-    )
     pipeline._model_cpu_offload_modules = []
-    pipeline.text_encoder = Mock()
-    expected = torch.ones(2, 3)
-    pipeline.text_encoder.encode_ids.return_value = expected
-    component = Mock()
+    output = Mock()
 
-    actual = pipeline._encode_text_hidden(torch.tensor([1, 2]), {})
-    with pipeline._component_on_device(component):
-        component.load_to_device.assert_called_once_with()
-        component.offload_to_cpu.assert_not_called()
-
-    assert actual is expected
-    pipeline.text_encoder.load_to_device.assert_called_once_with()
-    pipeline.text_encoder.offload_to_cpu.assert_called_once_with()
-    component.offload_to_cpu.assert_called_once_with()
+    assert pipeline._offload_model_cpu_stage_output(output) is output
+    output.cpu.assert_not_called()
 
 
-def test_requested_model_offload_without_backend_uses_resident_components():
+def test_reply_rank_copies_decoded_output_to_host(monkeypatch):
     from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
 
     pipeline = object.__new__(MiniMaxH3Pipeline)
     torch.nn.Module.__init__(pipeline)
-    pipeline.od_config = SimpleNamespace(
-        enable_cpu_offload=True,
-        enable_layerwise_offload=False,
-        enable_distributed_layerwise_offload=False,
+    pipeline._model_cpu_offload_modules = [Mock()]
+    monkeypatch.setattr(pipeline, "_is_output_owner_rank", lambda: True)
+    output = Mock()
+    host_output = Mock()
+    output.cpu.return_value = host_output
+
+    assert pipeline._offload_model_cpu_stage_output(output) is host_output
+    output.cpu.assert_called_once_with()
+
+
+def test_non_reply_rank_drops_decoded_output_storage(monkeypatch):
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline._model_cpu_offload_modules = [Mock()]
+    monkeypatch.setattr(pipeline, "_is_output_owner_rank", lambda: False)
+    output = torch.ones((2, 3), dtype=torch.float16)
+
+    placeholder = pipeline._offload_model_cpu_stage_output(output)
+
+    assert placeholder.device.type == "meta"
+    assert placeholder.shape == output.shape
+    assert placeholder.dtype == output.dtype
+
+
+def test_decode_releases_only_audio_before_return(monkeypatch):
+    """Video is released by the callers of ``decode`` -- after quantization."""
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+    from vllm_omni.diffusion.models.minimax_h3 import pipeline_minimax_h3 as module
+
+    video = torch.ones((1, 1, 4, 4))
+    audio = torch.ones((1, 8))
+    pipeline = SimpleNamespace(
+        device=torch.device("cpu"),
+        video_vae=Mock(decode_latent=Mock(return_value=video)),
+        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,
+        "create_autocast_context",
+        lambda **kwargs: nullcontext(),
     )
-    pipeline._model_cpu_offload_modules = []
-    pipeline.text_encoder = Mock()
-    expected = torch.ones(2, 3)
-    pipeline.text_encoder.encode_ids.return_value = expected
 
-    actual = pipeline._encode_text_hidden(torch.tensor([1, 2]), {})
+    actual_video, actual_audio = MiniMaxH3Pipeline.decode(
+        pipeline,
+        torch.zeros(1),
+        torch.zeros(1),
+        height=2,
+        width=3,
+    )
 
-    assert actual is expected
-    pipeline.text_encoder.load_to_device.assert_called_once_with()
-    pipeline.text_encoder.encode_ids.assert_called_once()
+    assert actual_video.shape[-2:] == (2, 3)
+    assert actual_audio is audio
+    calls = pipeline._offload_model_cpu_stage_output.call_args_list
+    assert len(calls) == 1
+    assert calls[0].args[0] is audio
 
 
-def test_h3_model_cpu_offload_registers_direct_vae_stages(monkeypatch):
+def _recording_release(events, releases):
+    """Stand-in for ``_offload_model_cpu_stage_output`` that records what it got."""
+
+    def release(value):
+        events.append("release")
+        releases.append(value)
+        return value
+
+    return release
+
+
+def test_forward_releases_video_after_quantization_and_before_next_seed(monkeypatch):
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+
+    # MiniMaxH3VideoVAE.decode_latent ends in frames.float(), so this is what
+    # the release hook would see if it ran before the quantizer.
+    decoded_dtype = torch.float32
+    events: list[str] = []
+    releases: list[torch.Tensor] = []
+
+    def diffuse(**kwargs):
+        events.append(f"diffuse:{kwargs['seed']}")
+        return torch.zeros(1), torch.zeros(1)
+
+    def decode(video_latent, audio_latent, *, height, width):
+        events.append("decode")
+        return (
+            torch.zeros((1, 3, 2, height, width), dtype=decoded_dtype),
+            torch.zeros((1, 8)),
+        )
+
+    # ``forward`` indexes ``preencode_mp4`` (#7018): this test drives the
+    # tensor-decode branch, which is the one the release hook wraps.
+    context = {"num_outputs": 2, "seed": 41, "height": 4, "width": 4, "preencode_mp4": False}
+    pipeline = SimpleNamespace(
+        od_config=SimpleNamespace(),
+        _extract_prompt=lambda raw: ("a prompt", {}),
+        _extract_text_conditioning=lambda raw: None,
+        _extract_prepared_reference_videos=lambda raw: None,
+        _prepare_request_inputs=lambda *args, **kwargs: context,
+        _denoise_kwargs=lambda ctx: {},
+        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())
+
+    output = MiniMaxH3Pipeline.forward(pipeline, request)
+
+    # The release must see the quantized frames, not the decoded floats.
+    assert len(releases) == 2
+    assert [tensor.dtype for tensor in releases] == [torch.uint8, torch.uint8]
+    assert decoded_dtype is not torch.uint8
+    # ... and it must still happen before the next seed reloads the DiT.
+    assert events == ["diffuse:41", "decode", "release", "diffuse:42", "decode", "release"]
+    assert output.output[0].dtype is torch.uint8
+
+
+def test_forward_drops_the_decoded_video_before_the_next_seed_diffuses(monkeypatch):
+    """Releasing the copy is not enough if a local still pins the original.
+
+    ``_offload_model_cpu_stage_output`` hands back a *new* tensor, so the
+    decoded frames stay alive for as long as anything still references them.
+    The whole point of this branch is that they are gone before the next seed
+    reloads the DiT, and ``diffuse`` is where that reload happens.
+    """
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+
+    decoded_refs: list[weakref.ref] = []
+    alive_at_diffuse: list[int] = []
+
+    def diffuse(**kwargs):
+        alive_at_diffuse.append(sum(1 for ref in decoded_refs if ref() is not None))
+        return torch.zeros(1), torch.zeros(1)
+
+    def decode(video_latent, audio_latent, *, height, width):
+        video = torch.zeros((1, 3, 2, height, width), dtype=torch.float32)
+        decoded_refs.append(weakref.ref(video))
+        return video, torch.zeros((1, 8))
+
+    # ``forward`` indexes ``preencode_mp4`` (#7018): this test drives the
+    # tensor-decode branch, which is the one the release hook wraps.
+    context = {"num_outputs": 2, "seed": 41, "height": 4, "width": 4, "preencode_mp4": False}
+    pipeline = SimpleNamespace(
+        od_config=SimpleNamespace(),
+        _extract_prompt=lambda raw: ("a prompt", {}),
+        _extract_text_conditioning=lambda raw: None,
+        _extract_prepared_reference_videos=lambda raw: None,
+        _prepare_request_inputs=lambda *args, **kwargs: context,
+        _denoise_kwargs=lambda ctx: {},
+        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())
+
+    MiniMaxH3Pipeline.forward(pipeline, request)
+
+    assert len(decoded_refs) == 2
+    # Seed 1's diffuse sees nothing decoded yet; seed 2's must not see seed 1's
+    # decoded frames still resident.
+    assert alive_at_diffuse == [0, 0]
+
+
+def test_post_decode_releases_video_after_quantization(monkeypatch):
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+    from vllm_omni.diffusion.models.minimax_h3 import pipeline_minimax_h3 as module
+
+    events: list[str] = []
+    releases: list[torch.Tensor] = []
+
+    def decode(video_latent, audio_latent, *, height, width):
+        events.append("decode")
+        return (
+            torch.zeros((1, 3, 2, height, width), dtype=torch.float16),
+            torch.zeros((1, 8)),
+        )
+
+    pipeline = SimpleNamespace(
+        od_config=SimpleNamespace(),
+        _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),
+        extra={
+            module._STEP_BRANCH: object(),
+            module._STEP_AUDIO_ROWS: torch.zeros(1),
+            module._STEP_SHAPE: {
+                "latent_t": 1,
+                "latent_h": 1,
+                "latent_w": 1,
+                "audio_t": 1,
+                "height": 4,
+                "width": 4,
+            },
+        },
+    )
+
+    output = MiniMaxH3Pipeline.post_decode(pipeline, state)
+
+    assert events == ["decode", "release"]
+    assert len(releases) == 1
+    assert releases[0].dtype is torch.uint8
+    assert output.output[0] is releases[0]
+
+
+@pytest.mark.parametrize(
+    ("available", "initialized", "rank", "expected"),
+    [(False, False, 7, True), (True, False, 7, True), (True, True, 0, True), (True, True, 1, False)],
+)
+def test_output_owner_rank_matches_executor_contract(monkeypatch, available, initialized, rank, expected):
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+    from vllm_omni.diffusion.models.minimax_h3 import pipeline_minimax_h3 as module
+
+    monkeypatch.setattr(module.dist, "is_available", lambda: available)
+    monkeypatch.setattr(module.dist, "is_initialized", lambda: initialized)
+    monkeypatch.setattr(module.dist, "get_rank", lambda: rank)
+
+    assert MiniMaxH3Pipeline._is_output_owner_rank() is expected
+
+
+@pytest.mark.parametrize("load_text_encoder", [True, False])
+def test_h3_model_cpu_offload_registers_direct_vae_stages(monkeypatch, load_text_encoder):
     from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
     from vllm_omni.diffusion.models.minimax_h3 import pipeline_minimax_h3 as module
 
@@ -84,9 +284,11 @@ def test_h3_model_cpu_offload_registers_direct_vae_stages(monkeypatch):
     torch.nn.Module.__init__(pipeline)
     pipeline.transformer = torch.nn.Linear(2, 2)
     pipeline.transformers_ref = torch.nn.Linear(2, 2)
-    pipeline.text_encoder = torch.nn.Linear(2, 2)
     pipeline.video_vae = torch.nn.Linear(2, 2)
     pipeline.audio_vae = torch.nn.Linear(2, 2)
+    pipeline._encoder_modules = ["text_encoder"] if load_text_encoder else []
+    if load_text_encoder:
+        pipeline.text_encoder = torch.nn.Linear(2, 2)
     apply_offload = Mock()
     remove_offload = Mock()
     monkeypatch.setattr(module, "apply_sequential_offload", apply_offload)
@@ -99,7 +301,7 @@ def test_h3_model_cpu_offload_registers_direct_vae_stages(monkeypatch):
     )
 
     dits = [pipeline.transformer, pipeline.transformers_ref]
-    stages = [pipeline.text_encoder, pipeline.video_vae, pipeline.audio_vae]
+    stages = [*([pipeline.text_encoder] if load_text_encoder else []), pipeline.video_vae, pipeline.audio_vae]
     apply_offload.assert_called_once_with(
         dit_modules=dits,
         encoder_modules=stages,
@@ -114,6 +316,46 @@ def test_h3_model_cpu_offload_registers_direct_vae_stages(monkeypatch):
     remove_offload.assert_called_once_with([*dits, *stages])
 
 
+@pytest.mark.parametrize("decode_fails", [False, True])
+def test_h3_model_cpu_offload_scopes_direct_vae_call(monkeypatch, decode_fails):
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+    from vllm_omni.diffusion.models.minimax_h3 import pipeline_minimax_h3 as module
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    component = torch.nn.Linear(2, 2)
+    events: list[tuple[Any, ...]] = []
+
+    @contextmanager
+    def record_component(value):
+        events.append(("activate", value))
+        try:
+            yield
+        finally:
+            events.append(("offload", value))
+
+    monkeypatch.setattr(module, "sequential_offload_component", record_component)
+    pipeline._model_cpu_offload_modules = [component]
+
+    def decode():
+        with pipeline._component_on_device(component):
+            events.append(("decode", component))
+            if decode_fails:
+                raise RuntimeError("decode failed")
+
+    if decode_fails:
+        with pytest.raises(RuntimeError, match="decode failed"):
+            decode()
+    else:
+        decode()
+
+    assert events == [
+        ("activate", component),
+        ("decode", component),
+        ("offload", component),
+    ]
+
+
 def test_h3_model_cpu_offload_keeps_unselected_vaes_resident(monkeypatch):
     from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
     from vllm_omni.diffusion.models.minimax_h3 import pipeline_minimax_h3 as module
@@ -174,44 +416,20 @@ def test_h3_model_cpu_offload_rejects_unloaded_selected_encoder(monkeypatch):
     apply_offload.assert_not_called()
 
 
-@pytest.mark.parametrize("decode_fails", [False, True])
-def test_h3_model_cpu_offload_scopes_direct_vae_call(monkeypatch, decode_fails):
-    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
-    from vllm_omni.diffusion.models.minimax_h3 import pipeline_minimax_h3 as module
+def _encode_media(pipeline, **kwargs):
+    from vllm_omni.model_executor.models.minimax_h3.conditioning import MiniMaxH3EncoderMediaInput
+    from vllm_omni.model_executor.models.minimax_h3.encoder_processing import encode_media
 
-    pipeline = object.__new__(MiniMaxH3Pipeline)
-    torch.nn.Module.__init__(pipeline)
-    component = torch.nn.Linear(2, 2)
-    events: list[tuple[Any, ...]] = []
-
-    @contextmanager
-    def record_component(value):
-        events.append(("activate", value))
-        try:
-            yield
-        finally:
-            events.append(("offload", value))
-
-    monkeypatch.setattr(module, "sequential_offload_component", record_component)
-    pipeline._model_cpu_offload_modules = [component]
-
-    def decode():
-        with pipeline._component_on_device(component):
-            events.append(("decode", component))
-            if decode_fails:
-                raise RuntimeError("decode failed")
-
-    if decode_fails:
-        with pytest.raises(RuntimeError, match="decode failed"):
-            decode()
-    else:
-        decode()
-
-    assert events == [
-        ("activate", component),
-        ("decode", component),
-        ("offload", component),
-    ]
+    media = MiniMaxH3EncoderMediaInput(
+        task="ref2va", height=32, width=32, num_frames=124, latent_t=31, audio_t=208, **kwargs
+    )
+    return encode_media(
+        media,
+        video_vae=getattr(pipeline, "video_vae", None),
+        audio_vae=getattr(pipeline, "audio_vae", None),
+        emit_conditioning=True,
+        component_scope=pipeline._component_on_device,
+    )
 
 
 @pytest.mark.parametrize("encode_fails", [False, True])
@@ -221,7 +439,6 @@ def test_h3_model_cpu_offload_batches_visual_reference_scope(monkeypatch, encode
 
     pipeline = object.__new__(MiniMaxH3Pipeline)
     torch.nn.Module.__init__(pipeline)
-    pipeline.device = torch.device("cpu")
     pipeline.video_vae = Mock()
     pipeline._model_cpu_offload_modules = [pipeline.video_vae]
     events = []
@@ -242,17 +459,15 @@ def test_h3_model_cpu_offload_batches_visual_reference_scope(monkeypatch, encode
 
     pipeline.video_vae.encode_image.side_effect = encode_image
     monkeypatch.setattr(module, "sequential_offload_component", record_component)
-    monkeypatch.setattr(module, "_dit_rank_world", lambda: (None, 0, 1))
-    monkeypatch.setattr(module, "_broadcast_tensor", lambda value, **kwargs: value)
-    images = [Image.new("RGB", (16, 16)), Image.new("RGB", (32, 16))]
+    images = (torch.zeros(16, 16, 3, dtype=torch.uint8), torch.zeros(16, 32, 3, dtype=torch.uint8))
 
     if encode_fails:
         with pytest.raises(RuntimeError, match="encode failed"):
-            pipeline._encode_visual_conditions(images, None, video_count=0)
+            _encode_media(pipeline, images=images)
     else:
-        rows, shapes = pipeline._encode_visual_conditions(images, None, video_count=0)
-        assert rows.shape == (3, 4)
-        assert shapes == [(1, 1, 1), (1, 1, 2)]
+        result = _encode_media(pipeline, images=images)
+        assert result.visual_condition.shape == (3, 4)
+        assert result.visual_condition_shapes == ((1, 1, 1), (1, 1, 2))
 
     assert events == [
         ("activate", pipeline.video_vae),
@@ -268,9 +483,7 @@ def test_h3_model_cpu_offload_shares_image_and_video_scope(monkeypatch):
 
     pipeline = object.__new__(MiniMaxH3Pipeline)
     torch.nn.Module.__init__(pipeline)
-    pipeline.device = torch.device("cpu")
     pipeline.video_vae = Mock()
-    pipeline.video_vae.is_distributed_enabled.return_value = False
     pipeline._model_cpu_offload_modules = [pipeline.video_vae]
     events = []
 
@@ -287,31 +500,26 @@ def test_h3_model_cpu_offload_shares_image_and_video_scope(monkeypatch):
         return torch.ones(1, 4)
 
     def encode_video(frames):
-        events.append(("video", frames))
+        events.append(("video", frames.shape))
         return torch.ones(3, 4), (3, 2, 2)
 
     pipeline.video_vae.encode_image.side_effect = encode_image
     pipeline.video_vae.encode_video.side_effect = encode_video
     monkeypatch.setattr(module, "sequential_offload_component", record_component)
-    monkeypatch.setattr(module, "_dit_rank_world", lambda: (None, 0, 1))
-    monkeypatch.setattr(module, "_broadcast_tensor", lambda value, **kwargs: value)
-    monkeypatch.setattr(module, "load_video_frames", lambda path: f"frames:{path}")
-    images = [Image.new("RGB", (16, 16)), Image.new("RGB", (32, 16))]
-    prepared_videos = [{"prepared_path": "reference.mp4"}]
-
-    rows, shapes = pipeline._encode_visual_conditions(
-        images,
-        prepared_videos,
-        video_count=1,
+    result = _encode_media(
+        pipeline,
+        images=(torch.zeros(16, 16, 3, dtype=torch.uint8), torch.zeros(16, 32, 3, dtype=torch.uint8)),
+        videos=(torch.zeros(12, 32, 32, 3, dtype=torch.uint8),),
+        video_audios=(None,),
     )
 
-    assert rows.shape == (5, 4)
-    assert shapes == [(1, 1, 1), (1, 1, 2), (3, 2, 2)]
+    assert result.visual_condition.shape == (5, 4)
+    assert result.visual_condition_shapes == ((1, 1, 1), (1, 1, 2), (3, 2, 2))
     assert events == [
         ("activate", pipeline.video_vae),
         ("image", (16, 16)),
         ("image", (32, 16)),
-        ("video", "frames:reference.mp4"),
+        ("video", (12, 32, 32, 3)),
         ("offload", pipeline.video_vae),
     ]
 
@@ -325,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: list[tuple[Any, ...]] = []
+    events: list[tuple] = []
 
     @contextmanager
     def record_component(value):
@@ -335,26 +543,20 @@ def test_h3_model_cpu_offload_shares_embedded_and_standalone_audio_scope(monkeyp
         finally:
             events.append(("offload", value))
 
-    def encode_embedded(*args, **kwargs):
-        events.append(("embedded",))
+    def encode_waveform(waveform, sample_rate):
+        events.append(("audio", int(waveform[0]), sample_rate))
         if encode_fails:
             raise RuntimeError("audio encode failed")
-        return torch.ones(1, 2), [1]
+        return torch.ones(80, 32), 80
 
-    def encode_standalone(*args, **kwargs):
-        events.append(("standalone",))
-        return torch.ones(1, 2), [1]
-
-    pipeline._encode_video_audio_conditions_resident = encode_embedded
-    pipeline._encode_audio_conditions_resident = encode_standalone
+    pipeline.audio_vae.encode_waveform.side_effect = encode_waveform
     monkeypatch.setattr(module, "sequential_offload_component", record_component)
 
     def call():
-        return pipeline._encode_reference_audio_conditions(
-            [{"input_has_audio": True}],
-            has_audio=[True],
-            standalone_audios=[(torch.ones(1), 16_000)],
-            max_duration_seconds=1.0,
+        return _encode_media(
+            pipeline,
+            video_audios=(),
+            audios=((torch.ones(32_000), 16_000),),
         )
 
     if encode_fails:
@@ -362,10 +564,61 @@ def test_h3_model_cpu_offload_shares_embedded_and_standalone_audio_scope(monkeyp
             call()
     else:
         result = call()
-        assert result[0].shape == (1, 2)
-        assert result[2].shape == (1, 2)
+        assert result.audio_condition.shape == (80, 32)
+        assert result.audio_condition_lengths == (80,)
+        assert events[1:-1] == [("audio", 1, 16_000)]
 
     assert events[0] == ("activate", pipeline.audio_vae)
     assert events[-1] == ("offload", pipeline.audio_vae)
     assert events.count(("activate", pipeline.audio_vae)) == 1
     assert events.count(("offload", pipeline.audio_vae)) == 1
+
+
+@pytest.mark.parametrize("distributed", [False, True])
+def test_manual_component_offload_wins_over_requested_model_offload(distributed):
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.od_config = SimpleNamespace(
+        enable_cpu_offload=True,
+        enable_layerwise_offload=not distributed,
+        enable_distributed_layerwise_offload=distributed,
+    )
+    pipeline._model_cpu_offload_modules = []
+    pipeline.text_encoder = Mock()
+    expected = torch.ones(2, 3)
+    pipeline.text_encoder.encode_ids.return_value = expected
+    component = Mock()
+
+    actual = pipeline._encode_text_hidden(torch.tensor([1, 2]), {})
+    with pipeline._component_on_device(component):
+        component.load_to_device.assert_called_once_with()
+        component.offload_to_cpu.assert_not_called()
+
+    assert actual is expected
+    pipeline.text_encoder.load_to_device.assert_called_once_with()
+    pipeline.text_encoder.offload_to_cpu.assert_called_once_with()
+    component.offload_to_cpu.assert_called_once_with()
+
+
+def test_requested_model_offload_without_backend_uses_resident_components():
+    from vllm_omni.diffusion.models.minimax_h3 import MiniMaxH3Pipeline
+
+    pipeline = object.__new__(MiniMaxH3Pipeline)
+    torch.nn.Module.__init__(pipeline)
+    pipeline.od_config = SimpleNamespace(
+        enable_cpu_offload=True,
+        enable_layerwise_offload=False,
+        enable_distributed_layerwise_offload=False,
+    )
+    pipeline._model_cpu_offload_modules = []
+    pipeline.text_encoder = Mock()
+    expected = torch.ones(2, 3)
+    pipeline.text_encoder.encode_ids.return_value = expected
+
+    actual = pipeline._encode_text_hidden(torch.tensor([1, 2]), {})
+
+    assert actual is expected
+    pipeline.text_encoder.load_to_device.assert_called_once_with()
+    pipeline.text_encoder.encode_ids.assert_called_once()
diff --git a/tests/diffusion/models/minimax_h3/test_minimax_h3_packing.py b/tests/diffusion/models/minimax_h3/test_minimax_h3_packing.py
index 53348f579..4340e093f 100644
--- a/tests/diffusion/models/minimax_h3/test_minimax_h3_packing.py
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_packing.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 pytest
 import torch
@@ -190,3 +190,90 @@ def test_condition_noise_accepts_a_reference_video_longer_than_the_target():
         noise_aug=0.5,
     )
     assert result.shape == rows.shape
+
+
+def test_explicit_seq_len_pins_one_shape_across_prompt_lengths():
+    """Prompts of different token counts must land on the same packed length.
+
+    Without the pin they fall into different 64-row buckets, and each bucket is
+    a packed shape the compiled transformer has not seen before.
+    """
+    from vllm_omni.diffusion.models.minimax_h3.packed_sequence import (
+        minimax_h3_packed_sequence,
+    )
+
+    common = dict(
+        latent_t=2,
+        latent_h=4,
+        latent_w=6,
+        audio_t=3,
+        include_keyframe_cond=False,
+    )
+    # used = text_len + 18 rows: 22 -> bucket 64; 118 -> bucket 128.
+    short = minimax_h3_packed_sequence(text_len=4, **common)
+    long = minimax_h3_packed_sequence(text_len=100, **common)
+    assert int(short["seq_len"]) == 64
+    assert int(long["seq_len"]) == 128
+
+    short_pinned = minimax_h3_packed_sequence(text_len=4, seq_len=192, **common)
+    long_pinned = minimax_h3_packed_sequence(text_len=100, seq_len=192, **common)
+    assert int(short_pinned["seq_len"]) == int(long_pinned["seq_len"]) == 192
+    # The pin only adds padding rows; the used prefix is untouched.
+    assert int(short_pinned["cu_seqlens"][1]) == int(short["cu_seqlens"][1]) == 22
+    assert int(long_pinned["cu_seqlens"][1]) == int(long["cu_seqlens"][1]) == 118
+    assert short_pinned["img_pos"].tolist() == short["img_pos"].tolist()
+
+
+def test_the_ref2va_packer_pins_one_shape_across_prompt_lengths_too():
+    """Both packers share one resolver, so both honour the pin."""
+    from vllm_omni.diffusion.models.minimax_h3.packed_sequence import (
+        minimax_h3_packed_sequence_ref2va_blocks,
+    )
+
+    common = dict(
+        latent_t=2,
+        latent_h=4,
+        latent_w=6,
+        audio_t=3,
+        ref_blocks=[{"kind": "audio", "ref_audio_t": 1}],
+    )
+    short = minimax_h3_packed_sequence_ref2va_blocks(text_len=4, **common)
+    long = minimax_h3_packed_sequence_ref2va_blocks(text_len=100, **common)
+    assert int(short["seq_len"]) != int(long["seq_len"])
+
+    short_pinned = minimax_h3_packed_sequence_ref2va_blocks(text_len=4, seq_len=192, **common)
+    long_pinned = minimax_h3_packed_sequence_ref2va_blocks(text_len=100, seq_len=192, **common)
+    assert int(short_pinned["seq_len"]) == int(long_pinned["seq_len"]) == 192
+    assert int(short_pinned["cu_seqlens"][1]) == int(short["cu_seqlens"][1])
+    assert int(long_pinned["cu_seqlens"][1]) == int(long["cu_seqlens"][1])
+
+
+def test_explicit_seq_len_below_used_rows_is_a_client_error():
+    """Both packers reject an under-sized pin as a 4xx, not a server error."""
+    from vllm_omni.diffusion.models.minimax_h3.packed_sequence import (
+        minimax_h3_packed_sequence,
+        minimax_h3_packed_sequence_ref2va_blocks,
+    )
+    from vllm_omni.errors import OmniClientError
+
+    with pytest.raises(OmniClientError, match="used rows"):
+        minimax_h3_packed_sequence(
+            text_len=4,
+            latent_t=2,
+            latent_h=4,
+            latent_w=6,
+            audio_t=3,
+            include_keyframe_cond=False,
+            seq_len=8,
+        )
+
+    with pytest.raises(OmniClientError, match="used rows"):
+        minimax_h3_packed_sequence_ref2va_blocks(
+            text_len=4,
+            latent_t=2,
+            latent_h=4,
+            latent_w=6,
+            audio_t=3,
+            ref_blocks=[{"kind": "audio", "ref_audio_t": 1}],
+            seq_len=8,
+        )
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 a45631f7d..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
@@ -175,7 +175,7 @@ def _generate_joint_output(omni, config: QualityTestConfig):
         pytest.param(
             _QUALITY_CONFIG,
             id=_QUALITY_CONFIG.id,
-            marks=hardware_marks(res={"cuda": _QUALITY_CONFIG.gpu}, num_cards=2),
+            marks=hardware_marks(res={"cuda": ["H100", "B200"]}, num_cards=2),
         )
     ],
 )
@@ -186,10 +186,15 @@ def test_minimax_h3_quantization_quality(config: QualityTestConfig):
     common_kwargs = {
         "model": model_ref,
         "enforce_eager": True,
-        "tensor_parallel_size": 2,
         # The fused BF16 baseline only fits on H100-80GB with encoder TP.
+        # 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 63c3a42f1..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):
@@ -110,6 +121,8 @@ def _step_pipeline(model, *, packed_batch_supported: bool = True):
     from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import MiniMaxH3Pipeline
 
     pipeline = object.__new__(MiniMaxH3Pipeline)
+    pipeline.load_text_encoder = False
+    pipeline.load_vae_encoder = False
     pipeline.transformer = model
     pipeline.device = torch.device("cpu")
     pipeline._transformer_for_task = lambda task: model
@@ -154,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 = [
@@ -169,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:
@@ -284,15 +385,20 @@ def test_mixed_step_batch_leaves_gated_attention_dense():
     assert recorder.denoise_timestep is None
 
 
-def test_prepare_encode_seeds_runner_visible_state(monkeypatch):
+@pytest.mark.parametrize("batch_frames", [1, 33])
+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 = {
         "height": 96,
         "width": 64,
+        "preencode_mp4": True,
+        "preencode_batch_frames": batch_frames,
         "latent_t": 2,
         "latent_h": 4,
         "latent_w": 6,
@@ -301,8 +407,17 @@ def test_prepare_encode_seeds_runner_visible_state(monkeypatch):
     }
 
     pipeline = _step_pipeline(_SegmentMeanModel())
-    monkeypatch.setattr(mod.MiniMaxH3Pipeline, "_extract_prompt", staticmethod(lambda _: ("a prompt", {})))
-    monkeypatch.setattr(mod.MiniMaxH3Pipeline, "_prepare_request_inputs", lambda self, **_: context)
+    conditioning = object()
+    monkeypatch.setattr(
+        mod.MiniMaxH3Pipeline,
+        "_extract_encoder_conditioning",
+        staticmethod(lambda _: conditioning),
+    )
+    monkeypatch.setattr(
+        mod.MiniMaxH3Pipeline,
+        "_prepare_encoder_conditioning_inputs",
+        lambda self, value, sampling: context,
+    )
     monkeypatch.setattr(
         mod.MiniMaxH3Pipeline,
         "_build_denoise_inputs",
@@ -312,6 +427,8 @@ def test_prepare_encode_seeds_runner_visible_state(monkeypatch):
             "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,
         },
@@ -333,8 +450,22 @@ def test_prepare_encode_seeds_runner_visible_state(monkeypatch):
     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()
+    monkeypatch.setattr(pipeline, "_unpack_denoised_rows", lambda *args, **kwargs: (torch.zeros(1), torch.zeros(1)))
+    calls = []
+
+    def decode_to_mp4(*args, **kwargs):
+        calls.append(kwargs)
+        return b"mp4"
+
+    monkeypatch.setattr(pipeline, "decode_to_mp4", decode_to_mp4)
+    assert pipeline.post_decode(state).output == (b"mp4", None)
+    assert calls[0]["batch_frames"] == batch_frames
+
 
 def test_prepare_encode_rejects_request_mode_only_features():
     """Multi-output and DLO have no representation in the step contract."""
@@ -426,48 +557,31 @@ def test_packed_batch_rejects_backends_that_cannot_isolate_requests(attention):
     assert MiniMaxH3Pipeline._packed_batch_supported(_FakeTransformer([attention])) is False
 
 
-def test_broadcast_rank0_exception_single_rank_reraises():
-    """Single-rank execution has no group; the helper just reraises."""
-    from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
-        _broadcast_rank0_exception,
+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"),
     )
-    from vllm_omni.errors import OmniClientError
-
-    _broadcast_rank0_exception(None)
-    with pytest.raises(OmniClientError, match="bad ref"):
-        _broadcast_rank0_exception(OmniClientError("bad ref"))
-
-
-def test_broadcast_rank0_exception_propagates_to_non_zero_ranks(monkeypatch):
-    """A rank-0 error becomes a matching client error on every other DiT rank."""
-    from vllm_omni.diffusion.models.minimax_h3 import pipeline_minimax_h3 as mod
-    from vllm_omni.errors import OmniClientError
-
-    def fake_rank_world(rank):
-        return lambda: (object(), rank, 4)
-
-    def make_broadcast(rank0_payload):
-        def fake_broadcast(payload_list, *, src, group):
-            payload_list[0] = rank0_payload
-
-        return fake_broadcast
-
-    monkeypatch.setattr(mod, "_dit_rank_world", fake_rank_world(0))
-    err = OmniClientError("invalid reference-video file", status_code=422, error_type="UnprocessableEntityError")
-    rank0_payload = {
-        "type": type(err).__name__,
-        "message": str(err),
-        "status_code": err.status_code,
-        "error_type": err.error_type,
-    }
-    monkeypatch.setattr(mod.dist, "broadcast_object_list", make_broadcast(rank0_payload))
-    with pytest.raises(OmniClientError) as rank0_info:
-        mod._broadcast_rank0_exception(err)
-    assert rank0_info.value is err
-
-    monkeypatch.setattr(mod, "_dit_rank_world", fake_rank_world(2))
-    with pytest.raises(OmniClientError) as rank2_info:
-        mod._broadcast_rank0_exception(None)
-    assert rank2_info.value.status_code == 422
-    assert rank2_info.value.error_type == "UnprocessableEntityError"
-    assert "invalid reference-video file" in str(rank2_info.value)
+    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_gather_reuse.py b/tests/diffusion/models/minimax_h3/test_minimax_h3_vae_gather_reuse.py
new file mode 100644
index 000000000..116f44ef9
--- /dev/null
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_vae_gather_reuse.py
@@ -0,0 +1,473 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""CPU tests for the pinned tiled-VAE gather buffer in the MiniMax-H3 video VAE.
+
+The checkpoint's ``_all_gather_tiled_results`` allocates its gather output on
+every call, so with a per-request ``empty_cache()`` the collective lands on a
+new device address every request and XCCL's per-address registrations pile up.
+On XPU the adapter replaces that method with an equal-shape gather into a
+buffer it keeps alive. These tests pin the properties that make it a fix
+rather than a rewrite: the address is stable, the tiles come back
+bit-identical and in the same order, the caller owns what it gets back, and no
+other device is touched.
+"""
+
+import logging
+import sys
+import types
+from typing import Any
+
+import pytest
+import torch
+import torch.distributed as dist
+
+from vllm_omni.diffusion.models.minimax_h3 import vae as vae_module
+from vllm_omni.diffusion.models.minimax_h3.vae import MiniMaxH3VideoVAE
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+TILE = (1, 3, 2, 4, 4)
+
+
+class _CheckpointGatherSentinel:
+    """Stands in for the checkpoint's own bound method.
+
+    Identity is the point: a test asserts this exact object is still installed
+    on the devices the adapter must leave alone.
+    """
+
+    def __call__(self, tasks, num_tiles):  # pragma: no cover - never invoked
+        raise AssertionError("the checkpoint gather must not run in these tests")
+
+
+class _FakeCheckpointModel:
+    def __init__(self):
+        self._all_gather_tiled_results = _CheckpointGatherSentinel()
+
+
+def _local_tiles(all_tiles, num_tiles, rank, sp_size):
+    """One rank's round-robin share, as ``klvae.py:275`` computes it."""
+    return [all_tiles[index] for index in range(rank, num_tiles, sp_size)]
+
+
+def _reference_gather(all_tiles, num_tiles, sp_size):
+    """The checkpoint's variable-shape list gather, reimplemented verbatim.
+
+    Written from the control flow of ``_all_gather_tiled_results`` in the
+    checkpoint's ``klvae.py`` (lines 252-273) -- stack each rank's share, gather
+    the list, walk it back into global tile order -- so that it is an
+    independent oracle rather than a restatement of the code under test.
+    """
+    gathered = [torch.stack(_local_tiles(all_tiles, num_tiles, rank, sp_size), dim=0) for rank in range(sp_size)]
+    results = [None] * num_tiles
+    for rank, rank_tensors in enumerate(gathered):
+        for k in range(rank_tensors.shape[0]):
+            global_index = k * sp_size + rank
+            if global_index >= num_tiles:
+                break
+            results[global_index] = rank_tensors[k]
+    return results
+
+
+def _peer_stacks(all_tiles, num_tiles, sp_size):
+    """What every rank hands to the collective, padded the way the adapter pads."""
+    max_tasks = -(-num_tiles // sp_size)
+    stacks = []
+    for rank in range(sp_size):
+        share = _local_tiles(all_tiles, num_tiles, rank, sp_size)
+        stacked = share[0].new_zeros((max_tasks, *share[0].shape))
+        stacked[: len(share)] = torch.stack(share, dim=0)
+        stacks.append(stacked)
+    return stacks
+
+
+def _tiles(num_tiles, seed=0, dtype=torch.float32):
+    generator = torch.Generator().manual_seed(seed)
+    return [torch.rand(TILE, generator=generator).to(dtype) for _ in range(num_tiles)]
+
+
+def _workspace_bytes(num_tiles, sp_size, dtype=torch.float32):
+    """Bytes one gather needs: ``sp_size`` copies of the padded local stack."""
+    max_tasks = -(-num_tiles // sp_size)
+    element_size = torch.empty(0, dtype=dtype).element_size()
+    numel = 1
+    for dim in TILE:
+        numel *= dim
+    return sp_size * max_tasks * numel * element_size
+
+
+@pytest.fixture
+def fake_collective(monkeypatch):
+    """Replace the collective with a single-process stand-in.
+
+    ``all_gather_into_tensor`` is the only distributed call on this path, so
+    filling the output buffer from a caller-supplied peer list exercises the
+    real padding, keying, addressing and unpacking code without a process
+    group.
+    """
+    calls: list[dict[str, Any]] = []
+
+    def fake_all_gather_into_tensor(output, input_tensor, group=None, async_op=False):
+        peers = calls[-1]["peers"]
+        assert output.shape == (len(peers), *input_tensor.shape)
+        calls[-1]["sent"] = input_tensor.clone()
+        calls[-1]["buf_ptr"] = output.data_ptr()
+        for rank, peer in enumerate(peers):
+            output[rank].copy_(peer)
+
+    monkeypatch.setattr(dist, "all_gather_into_tensor", fake_all_gather_into_tensor)
+    return calls
+
+
+class _Records(logging.Handler):
+    """vllm's logger sets ``propagate=False``, so caplog never sees these."""
+
+    def __init__(self):
+        super().__init__(level=logging.DEBUG)
+        self.messages = []
+        self.records = []
+
+    def emit(self, record):
+        self.messages.append(record.getMessage())
+        self.records.append((record.levelno, record.getMessage()))
+
+
+@pytest.fixture
+def gather_log():
+    handler = _Records()
+    logger = vae_module.logger
+    previous = logger.level
+    logger.addHandler(handler)
+    logger.setLevel(logging.DEBUG)
+    try:
+        yield handler
+    finally:
+        logger.removeHandler(handler)
+        logger.setLevel(previous)
+
+
+def _vae(sp_size, sp_rank=0):
+    """An adapter instance with the override installed, no checkpoint needed."""
+    state = {
+        "sp_size": sp_size,
+        "sp_rank": sp_rank,
+        "sp_enabled": sp_size > 1,
+        "sp_process_group": object(),
+    }
+    module = types.ModuleType("fake_gather_ckpt.parallel")
+    module.get_parallel_state = lambda: state  # type: ignore[attr-defined]
+    sys.modules.setdefault("fake_gather_ckpt", types.ModuleType("fake_gather_ckpt"))
+    sys.modules["fake_gather_ckpt.parallel"] = module
+
+    vae = object.__new__(MiniMaxH3VideoVAE)
+    vae.remote = type("Remote", (), {"__module__": "fake_gather_ckpt.klvae"})()
+    vae.model = _FakeCheckpointModel()
+    vae._device_target = torch.device("xpu")
+    vae._tile_gather_workspace = None
+    vae._tile_gather_stats = {"hits": 0, "allocs": 0, "workspace_bytes": 0}
+    vae._checkpoint_tile_gather = None
+    vae._install_persistent_tile_gather()
+    return vae
+
+
+def _run(vae, calls, all_tiles, num_tiles, sp_size, sp_rank):
+    calls.append({"peers": _peer_stacks(all_tiles, num_tiles, sp_size)})
+    return vae.model._all_gather_tiled_results(_local_tiles(all_tiles, num_tiles, sp_rank, sp_size), num_tiles)
+
+
+# --------------------------------------------------------------------------
+# The address is stable across calls. This is what the accumulation is about:
+# drop the workspace and every call registers a new receive address. And the
+# workspace is one grow-only block, so varying request geometries cannot keep
+# adding resident buffers the way a per-geometry cache would.
+# --------------------------------------------------------------------------
+
+
+def test_the_landing_buffer_address_is_stable_across_calls(fake_collective):
+    vae = _vae(4)
+    pointers = []
+    for request in range(3):
+        _run(vae, fake_collective, _tiles(8, seed=request), 8, 4, 0)
+        pointers.append(fake_collective[-1]["buf_ptr"])
+
+    assert len(set(pointers)) == 1, f"gather buffer moved across calls: {pointers}"
+    assert vae._tile_gather_stats == {
+        "hits": 2,
+        "allocs": 1,
+        "workspace_bytes": _workspace_bytes(8, 4),
+    }
+    assert vae._tile_gather_workspace.numel() == _workspace_bytes(8, 4)
+    assert vae._tile_gather_workspace.dtype is torch.uint8
+
+
+def test_distinct_shapes_share_the_one_workspace(fake_collective):
+    """One decode gathers several temporal clips, and the head/tail clips differ."""
+    vae = _vae(4)
+    _run(vae, fake_collective, _tiles(8), 8, 4, 0)
+    first = fake_collective[-1]["buf_ptr"]
+    _run(vae, fake_collective, _tiles(12), 12, 4, 0)
+    second = fake_collective[-1]["buf_ptr"]
+    _run(vae, fake_collective, _tiles(8, seed=5), 8, 4, 0)
+    third = fake_collective[-1]["buf_ptr"]
+
+    # The larger geometry did not fit, so the block was replaced -- not added to.
+    assert second == third
+    assert vae._tile_gather_stats["allocs"] == 2
+    assert vae._tile_gather_stats["hits"] == 1
+    assert vae._tile_gather_stats["workspace_bytes"] == _workspace_bytes(12, 4)
+    # ``first`` is deliberately not compared: the replaced block is freed, so
+    # the allocator is free to hand its address back for the larger one.
+    assert isinstance(first, int)
+
+
+def test_workspace_is_bounded_across_geometries(fake_collective):
+    """Alternating geometries must not each retain a buffer of their own."""
+    sp_size = 4
+    large, small, largest = 12, 8, 20
+    vae = _vae(sp_size)
+
+    pointers = []
+    for round_index in range(3):
+        for num_tiles in (large, small):
+            _run(vae, fake_collective, _tiles(num_tiles, seed=round_index), num_tiles, sp_size, 0)
+            pointers.append(fake_collective[-1]["buf_ptr"])
+
+    assert len(pointers) == 6
+    assert len(set(pointers)) == 1, f"workspace moved across geometries: {pointers}"
+    assert vae._tile_gather_stats["allocs"] == 1
+    assert vae._tile_gather_stats["workspace_bytes"] == _workspace_bytes(large, sp_size)
+    assert vae._tile_gather_workspace.numel() == _workspace_bytes(large, sp_size)
+
+    # A geometry that does not fit grows the single block; it does not add one.
+    _run(vae, fake_collective, _tiles(largest), largest, sp_size, 0)
+    grown = fake_collective[-1]["buf_ptr"]
+    assert vae._tile_gather_stats["allocs"] == 2
+    assert vae._tile_gather_stats["workspace_bytes"] == _workspace_bytes(largest, sp_size)
+    assert vae._tile_gather_workspace.numel() == _workspace_bytes(largest, sp_size)
+
+    # ...and the geometries seen before it now fit, so nothing reallocates again.
+    for num_tiles in (large, small):
+        _run(vae, fake_collective, _tiles(num_tiles, seed=7), num_tiles, sp_size, 0)
+        assert fake_collective[-1]["buf_ptr"] == grown
+    assert vae._tile_gather_stats["allocs"] == 2
+    assert vae._tile_gather_stats["workspace_bytes"] == _workspace_bytes(largest, sp_size)
+
+
+def test_workspace_grows_only_upward(fake_collective):
+    """Resident bytes track the largest geometry seen, not the sum of them."""
+    sp_size = 4
+    small, large = 8, 12
+    vae = _vae(sp_size)
+
+    _run(vae, fake_collective, _tiles(small), small, sp_size, 0)
+    assert vae._tile_gather_stats["workspace_bytes"] == _workspace_bytes(small, sp_size)
+
+    _run(vae, fake_collective, _tiles(large), large, sp_size, 0)
+
+    assert vae._tile_gather_stats["allocs"] == 2
+    assert vae._tile_gather_stats["hits"] == 0
+    assert vae._tile_gather_stats["workspace_bytes"] == _workspace_bytes(large, sp_size)
+    assert vae._tile_gather_stats["workspace_bytes"] < _workspace_bytes(small, sp_size) + _workspace_bytes(
+        large, sp_size
+    )
+    assert vae._tile_gather_workspace.numel() == _workspace_bytes(large, sp_size)
+
+
+def test_mixed_dtype_shares_one_workspace(fake_collective):
+    """The workspace is bytes, so a narrower dtype reuses it instead of adding one."""
+    sp_size, num_tiles = 4, 8
+    vae = _vae(sp_size)
+    fp32_bytes = _workspace_bytes(num_tiles, sp_size, dtype=torch.float32)
+
+    pointers = []
+    for round_index in range(2):
+        for dtype in (torch.float32, torch.bfloat16):
+            tiles = _tiles(num_tiles, seed=round_index, dtype=dtype)
+            produced = _run(vae, fake_collective, tiles, num_tiles, sp_size, 0)
+            pointers.append(fake_collective[-1]["buf_ptr"])
+            assert all(tile.dtype is dtype for tile in produced)
+            for index, tile in enumerate(produced):
+                assert torch.equal(tile, tiles[index])
+
+    assert len(set(pointers)) == 1, f"workspace moved across dtypes: {pointers}"
+    assert vae._tile_gather_stats["allocs"] == 1
+    assert vae._tile_gather_stats["hits"] == 3
+    assert vae._tile_gather_stats["workspace_bytes"] == fp32_bytes
+    assert vae._tile_gather_workspace.numel() == fp32_bytes
+
+
+# --------------------------------------------------------------------------
+# Equivalence with the checkpoint's own gather, padded branch included. A
+# reordered tile grid is silent at runtime, so order is asserted as well.
+# --------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize("num_tiles", [5, 8, 9, 28])
+@pytest.mark.parametrize("sp_rank", [0, 3])
+def test_gathered_tiles_match_the_checkpoint_gather(fake_collective, num_tiles, sp_rank):
+    sp_size = 4
+    all_tiles = _tiles(num_tiles, seed=num_tiles)
+    vae = _vae(sp_size, sp_rank=sp_rank)
+
+    produced = _run(vae, fake_collective, all_tiles, num_tiles, sp_size, sp_rank)
+    expected = _reference_gather(all_tiles, num_tiles, sp_size)
+
+    assert len(produced) == num_tiles
+    assert all(tile is not None for tile in produced)
+    for index, (got, want) in enumerate(zip(produced, expected)):
+        assert torch.equal(got, want), f"tile {index} differs from the checkpoint gather"
+    # ...and it is the tile that belongs at that index, not a permutation that
+    # happens to agree with an equally permuted oracle.
+    for index, tile in enumerate(produced):
+        assert torch.equal(tile, all_tiles[index])
+
+
+def test_the_padded_branch_is_actually_exercised(fake_collective):
+    """9 tiles over 4 ranks: ranks 1-3 are one short, so the padding runs."""
+    sp_size, num_tiles = 4, 9
+    all_tiles = _tiles(num_tiles, seed=9)
+    assert len(_local_tiles(all_tiles, num_tiles, 1, sp_size)) < -(-num_tiles // sp_size)
+
+    vae = _vae(sp_size, sp_rank=1)
+    produced = _run(vae, fake_collective, all_tiles, num_tiles, sp_size, 1)
+
+    sent = fake_collective[-1]["sent"]
+    assert sent.shape[0] == 3
+    assert torch.equal(sent[2], torch.zeros_like(sent[2]))
+    for index, tile in enumerate(produced):
+        assert torch.equal(tile, all_tiles[index])
+
+
+def test_an_empty_local_share_still_raises(fake_collective):
+    """A rank with no tiles fails loudly, exactly as the checkpoint does."""
+    vae = _vae(4)
+    with pytest.raises(ValueError, match="empty tasks on sp rank"):
+        vae.model._all_gather_tiled_results([], 8)
+
+
+def test_more_tiles_than_round_robin_allows_is_refused(fake_collective):
+    """The unpacking arithmetic is only valid for the checkpoint's ownership."""
+    vae = _vae(4)
+    with pytest.raises(ValueError, match="round-robin"):
+        vae.model._all_gather_tiled_results(_tiles(5), 8)
+
+
+# --------------------------------------------------------------------------
+# Ownership: the buffer is overwritten by the next gather, so returned tiles
+# must not alias it.
+# --------------------------------------------------------------------------
+
+
+def test_returned_tiles_do_not_alias_the_pinned_buffer(fake_collective):
+    sp_size, num_tiles = 4, 8
+    first_tiles = _tiles(num_tiles, seed=1)
+    vae = _vae(sp_size)
+    produced = _run(vae, fake_collective, first_tiles, num_tiles, sp_size, 0)
+
+    buffer_storage = vae._tile_gather_workspace.untyped_storage().data_ptr()
+    for tile in produced:
+        assert tile.untyped_storage().data_ptr() != buffer_storage
+
+    # The next gather reuses that memory; the first call's tiles must survive it.
+    _run(vae, fake_collective, _tiles(num_tiles, seed=2), num_tiles, sp_size, 0)
+    for index, tile in enumerate(produced):
+        assert torch.equal(tile, first_tiles[index])
+
+
+# --------------------------------------------------------------------------
+# Non-XPU behaviour is unchanged: the checkpoint's own method stays installed.
+# --------------------------------------------------------------------------
+
+
+def _construct(monkeypatch, device, model):
+    """Run the real ``__init__`` against a stub checkpoint component."""
+
+    class _Remote(torch.nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.weight = torch.nn.Parameter(torch.zeros(1))
+            self.model = model
+
+    monkeypatch.setattr(
+        vae_module,
+        "_load_component_config",
+        lambda path: {"latent_channels": 1, "latents_mean": [0.0], "latents_std": [1.0]},
+    )
+    # **kwargs: the loader gained a trust_remote_code argument at some point,
+    # and this stub does not care either way.
+    monkeypatch.setattr(vae_module, "_load_remote_component", lambda path, config, **kwargs: _Remote())
+    # The adapter only stores this handle; resolving it for real needs an
+    # accelerator, which a CPU test runner does not have.
+    monkeypatch.setattr(torch, "get_device_module", lambda *args, **kwargs: types.SimpleNamespace())
+    return MiniMaxH3VideoVAE("unused", device=torch.device(device))
+
+
+@pytest.mark.parametrize("device", ["cpu", "meta"])
+def test_non_xpu_devices_keep_the_checkpoint_gather(monkeypatch, device):
+    model = _FakeCheckpointModel()
+    original = model._all_gather_tiled_results
+
+    vae = _construct(monkeypatch, device, model)
+
+    assert vae._tile_gather_reuse_enabled() is False
+    assert vae.model._all_gather_tiled_results is original
+    assert vae._checkpoint_tile_gather is None
+
+
+@pytest.mark.parametrize(
+    ("device", "enabled"),
+    [("xpu", True), ("cpu", False), ("cuda", False), ("meta", False)],
+)
+def test_only_xpu_asks_for_the_pinned_buffer(device, enabled):
+    vae = object.__new__(MiniMaxH3VideoVAE)
+    vae._device_target = torch.device(device)
+    assert vae._tile_gather_reuse_enabled() is enabled
+
+
+def test_construction_installs_the_override_when_the_device_asks_for_it(monkeypatch):
+    """Close the loop: ``__init__`` must consult the predicate, not ignore it."""
+    monkeypatch.setattr(MiniMaxH3VideoVAE, "_tile_gather_reuse_enabled", lambda self: True)
+    model = _FakeCheckpointModel()
+    original = model._all_gather_tiled_results
+
+    vae = _construct(monkeypatch, "cpu", model)
+
+    assert vae.model._all_gather_tiled_results is not original
+    assert vae._checkpoint_tile_gather is original
+
+
+# --------------------------------------------------------------------------
+# The decision-point receipt carries quantities, not just presence: a line
+# that only says "installed" cannot tell reuse from reallocation.
+# --------------------------------------------------------------------------
+
+
+def test_the_receipt_line_reports_hits_allocs_and_the_address(fake_collective, gather_log):
+    vae = _vae(4)
+    install = [
+        (level, line) for level, line in gather_log.records if "persistent tile gather installed device=xpu" in line
+    ]
+    # The one-shot install line is what an operator needs at info level.
+    assert install and all(level == logging.INFO for level, _ in install)
+    gather_log.messages.clear()
+    gather_log.records.clear()
+
+    _run(vae, fake_collective, _tiles(8), 8, 4, 0)
+    first_ptr = fake_collective[-1]["buf_ptr"]
+    _run(vae, fake_collective, _tiles(8, seed=3), 8, 4, 0)
+
+    records = [(level, line) for level, line in gather_log.records if "[H3_VAE_GATHER] reuse=" in line]
+    # The per-gather line fires once per decoder tile batch, so it is debug.
+    assert all(level == logging.DEBUG for level, _ in records)
+    lines = [line for _, line in records]
+    assert len(lines) == 2
+    assert "reuse=alloc" in lines[0] and "hits=0 allocs=1" in lines[0]
+    assert "reuse=hit" in lines[1] and "hits=1 allocs=1" in lines[1]
+    # Resident bytes are reported, not just the bytes this one gather needed.
+    needed = _workspace_bytes(8, 4) / (1024.0 * 1024.0)
+    for line in lines:
+        assert f"need_mib={needed:.2f}" in line
+        assert f"workspace_mib={needed:.2f}" in line
+    assert f"buf_ptr=0x{first_ptr:x}" in lines[0]
+    assert f"buf_ptr=0x{first_ptr:x}" in lines[1]
diff --git a/tests/diffusion/models/minimax_h3/test_minimax_h3_vae_ops.py b/tests/diffusion/models/minimax_h3/test_minimax_h3_vae_ops.py
index 7a1c54f7b..86ccaa27b 100644
--- a/tests/diffusion/models/minimax_h3/test_minimax_h3_vae_ops.py
+++ b/tests/diffusion/models/minimax_h3/test_minimax_h3_vae_ops.py
@@ -198,7 +198,7 @@ def test_video_vae_installs_exact_optimizations(monkeypatch):
     monkeypatch.setattr(
         vae_module,
         "_load_remote_component",
-        lambda _path, _config: FakeRemote(),
+        lambda _path, _config, **_kwargs: FakeRemote(),
     )
     install = Mock(return_value=True)
     monkeypatch.setattr(vae_module, "install_h3_vae_optimizations", install)
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/minimax_h3/test_vsa_layout.py b/tests/diffusion/models/minimax_h3/test_vsa_layout.py
new file mode 100644
index 000000000..c556543d0
--- /dev/null
+++ b/tests/diffusion/models/minimax_h3/test_vsa_layout.py
@@ -0,0 +1,221 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import math
+import sys
+import types
+from typing import Any
+
+import pytest
+import torch
+
+from vllm_omni.diffusion.attention.backends.abstract import (
+    AttentionMetadata,
+    PackedPaddingMetadata,
+    VideoTokenLayout,
+    VideoTokenSpan,
+)
+from vllm_omni.diffusion.models.minimax_h3.attention.fastvideo_h3 import (
+    MiniMaxH3VSAImpl,
+    _get_h3_tile_metadata,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+
+def _h3_metadata(prefix_segments, video_shape, *, gate=None, packed_padding=None):
+    extra: dict[str, Any] = {
+        "vsa_h3_prefix_segments": prefix_segments,
+    }
+    if gate is not None:
+        extra["gate_compress"] = gate
+    return AttentionMetadata(
+        packed_padding=packed_padding,
+        video_layout=VideoTokenLayout(
+            used_len=sum(prefix_segments) + math.prod(video_shape),
+            video_spans=(VideoTokenSpan(start=sum(prefix_segments), latent_grid=video_shape, role="target"),),
+        ),
+        extra=extra,
+    )
+
+
+def _fake_block_sparse_kernel(monkeypatch, calls):
+    """Stand in for fastvideo_kernel.block_sparse_attn with a mask-obeying SDPA."""
+
+    def block_sparse_attn(q, k, v, block_map, variable_block_sizes):
+        calls["block_map"] = block_map.clone()
+        calls["variable_block_sizes"] = variable_block_sizes.tolist()
+        calls["q_shape"] = tuple(q.shape)
+        blocks = block_map.shape[-1]
+        assert blocks * 64 == q.shape[2]
+        # Expand the per-block map to a per-token mask so the stand-in honours
+        # the sparsity contract the real kernel implements, and drop the rows
+        # each partial block pads with, which the real kernel skips through
+        # variable_block_sizes.
+        token_mask = block_map.repeat_interleave(64, dim=-1).repeat_interleave(64, dim=-2)
+        within = torch.arange(64, device=q.device)[None, :] < variable_block_sizes[:, None]
+        token_mask = token_mask & within.reshape(1, 1, 1, -1)
+        out = torch.nn.functional.scaled_dot_product_attention(q.float(), k.float(), v.float(), attn_mask=token_mask)
+        return out.to(q.dtype), None
+
+    module = types.ModuleType("fastvideo_kernel.block_sparse_attn")
+    setattr(module, "block_sparse_attn", block_sparse_attn)
+    monkeypatch.setitem(sys.modules, "fastvideo_kernel", types.ModuleType("fastvideo_kernel"))
+    monkeypatch.setitem(sys.modules, "fastvideo_kernel.block_sparse_attn", module)
+
+
+def _h3_impl(**backend_kwargs):
+    kwargs = {"topk": 1, "min_seq_len": 1, "disable_when_sp_active": False}
+    kwargs.update(backend_kwargs)
+    return MiniMaxH3VSAImpl(num_heads=2, head_size=8, softmax_scale=8**-0.5, backend_kwargs=kwargs)
+
+
+def test_h3_forward_tiles_untiles_and_restores_the_original_row_order(monkeypatch):
+    calls: dict[str, Any] = {}
+    _fake_block_sparse_kernel(monkeypatch, calls)
+    impl = _h3_impl(topk=64)
+    prefix_segments, video_shape = (5, 70), (2, 4, 4)
+    seq_len = sum(prefix_segments) + 2 * 4 * 4
+    torch.manual_seed(0)
+    query = torch.randn(1, seq_len, 2, 8, dtype=torch.bfloat16)
+
+    output = impl.forward_cuda(query, query, query, _h3_metadata(prefix_segments, video_shape))
+
+    assert output.shape == query.shape
+    # topk covers every video block, so the block map is dense and the tiled
+    # kernel must reproduce plain attention over the same rows.
+    reference = torch.nn.functional.scaled_dot_product_attention(
+        *(x.float().transpose(1, 2) for x in (query, query, query))
+    ).transpose(1, 2)
+    torch.testing.assert_close(output.float(), reference, atol=2e-2, rtol=2e-2)
+    # 5 + 70 splits into segment-pure 5 | 64 | 6, then one (2, 4, 4) video tile.
+    assert calls["variable_block_sizes"] == [5, 64, 6, 32]
+
+
+def test_h3_forward_keeps_prefix_dense_and_selects_top_k_video_tiles(monkeypatch):
+    calls: dict[str, Any] = {}
+    _fake_block_sparse_kernel(monkeypatch, calls)
+    impl = _h3_impl(topk=1)
+    prefix_segments, video_shape = (5,), (8, 4, 4)
+    seq_len = 5 + 8 * 4 * 4
+    torch.manual_seed(0)
+    query = torch.randn(1, seq_len, 2, 8, dtype=torch.bfloat16)
+
+    impl.forward_cuda(query, query, query, _h3_metadata(prefix_segments, video_shape))
+
+    # 1 prefix block + 2 video blocks. The odd count is padded to an even one
+    # for the paired-CTA kernel contract, and the Triton route slices that
+    # transport-only partner off again before launching.
+    block_map = calls["block_map"]
+    assert block_map.shape[-1] == 3
+    assert calls["variable_block_sizes"] == [5, 64, 64]
+    assert block_map[:, :, :1, :].all(), "prefix queries stay dense"
+    assert block_map[..., :1].all(), "prefix keys are exempt from selection"
+    assert (block_map[:, :, 1:, 1:].sum(dim=-1) == 1).all(), "one video tile per video query"
+
+    # The same odd geometry must still untile back onto the original rows.
+    dense = _h3_impl(topk=64).forward_cuda(query, query, query, _h3_metadata(prefix_segments, video_shape))
+    reference = torch.nn.functional.scaled_dot_product_attention(
+        *(x.float().transpose(1, 2) for x in (query, query, query))
+    ).transpose(1, 2)
+    torch.testing.assert_close(dense.float(), reference, atol=2e-2, rtol=2e-2)
+
+
+def test_h3_forward_applies_the_learned_compression_gate(monkeypatch):
+    _fake_block_sparse_kernel(monkeypatch, {})
+    impl = _h3_impl(topk=64)
+    prefix_segments, video_shape = (5,), (2, 4, 4)
+    seq_len = 5 + 2 * 4 * 4
+    torch.manual_seed(0)
+    query = torch.randn(1, seq_len, 2, 8, dtype=torch.bfloat16)
+
+    without_gate = impl.forward_cuda(query, query, query, _h3_metadata(prefix_segments, video_shape))
+    zero_gate = torch.zeros_like(query)
+    with_zero_gate = impl.forward_cuda(query, query, query, _h3_metadata(prefix_segments, video_shape, gate=zero_gate))
+    live_gate = torch.full_like(query, 0.5)
+    with_live_gate = impl.forward_cuda(query, query, query, _h3_metadata(prefix_segments, video_shape, gate=live_gate))
+
+    torch.testing.assert_close(with_zero_gate.float(), without_gate.float())
+    assert not torch.allclose(with_live_gate.float(), without_gate.float())
+
+
+def test_h3_forward_restores_rows_the_packed_padding_excludes(monkeypatch):
+    _fake_block_sparse_kernel(monkeypatch, {})
+    impl = _h3_impl(topk=64)
+    prefix_segments, video_shape = (5,), (2, 4, 4)
+    valid = 5 + 2 * 4 * 4
+    torch.manual_seed(0)
+    query = torch.randn(1, valid + 24, 2, 8, dtype=torch.bfloat16)
+    padding = PackedPaddingMetadata(
+        q_length=valid,
+        kv_length=valid,
+        cu_seqlens_q=torch.tensor([0, valid], dtype=torch.int32),
+        cu_seqlens_k=torch.tensor([0, valid], dtype=torch.int32),
+    )
+
+    output = impl.forward_cuda(query, query, query, _h3_metadata(prefix_segments, video_shape, packed_padding=padding))
+
+    assert output.shape == query.shape
+    assert torch.count_nonzero(output[:, valid:]) == 0
+
+
+def test_h3_geometry_keeps_prefix_segments_pure_and_tiles_video_3d():
+    partition, sizes, non_pad, untile, prefix_blocks, video_blocks = _get_h3_tile_metadata(
+        (5, 70, 9), (5, 6, 6), torch.device("cpu")
+    )
+    assert sizes[:4].tolist() == [5, 64, 6, 9]
+    assert prefix_blocks == 4
+    assert video_blocks == 8
+    assert int(sizes.sum()) == 5 + 70 + 9 + 5 * 6 * 6
+    assert partition.numel() == non_pad.numel() == untile.numel() == int(sizes.sum())
+
+
+@pytest.mark.parametrize("fallback_on_error", [False, True])
+def test_h3_kernel_failure_preserves_fallback_policy(monkeypatch, fallback_on_error):
+    impl = _h3_impl(fallback_on_error=fallback_on_error)
+    query = torch.randn(1, 37, 2, 8)
+    metadata = _h3_metadata((5,), (2, 4, 4))
+
+    def fail(*args, **kwargs):
+        raise RuntimeError("kernel failure")
+
+    monkeypatch.setattr(impl, "_forward_h3", fail)
+    monkeypatch.setattr(impl.sdpa_fallback, "forward", impl.sdpa_fallback.forward_cuda)
+    if fallback_on_error:
+        output = impl.forward_cuda(query, query, query, metadata)
+        expected = impl.sdpa_fallback.forward_cuda(query, query, query, metadata)
+        torch.testing.assert_close(output, expected, rtol=0, atol=0)
+    else:
+        with pytest.raises(RuntimeError, match="kernel failure"):
+            impl.forward_cuda(query, query, query, metadata)
+
+
+def test_h3_accelerator_failure_is_not_swallowed(monkeypatch):
+    impl = _h3_impl(fallback_on_error=True)
+    query = torch.randn(1, 37, 2, 8)
+
+    def fail(*args, **kwargs):
+        raise torch.AcceleratorError("device failure")
+
+    monkeypatch.setattr(impl, "_forward_h3", fail)
+    with pytest.raises(torch.AcceleratorError, match="device failure"):
+        impl.forward_cuda(query, query, query, _h3_metadata((5,), (2, 4, 4)))
+
+
+def test_h3_without_layout_delegates_to_shared_backend(monkeypatch):
+    from vllm_omni.diffusion.attention.backends.fastvideo_vsa import FastVideoVSAImpl
+
+    impl = _h3_impl()
+    query = torch.randn(1, 37, 2, 8)
+    metadata = AttentionMetadata()
+    expected = torch.empty_like(query)
+    calls = []
+
+    def forward(self, q, k, v, attn_metadata):
+        calls.append((self, q, k, v, attn_metadata))
+        return expected
+
+    monkeypatch.setattr(FastVideoVSAImpl, "forward_cuda", forward)
+    assert impl.forward_cuda(query, query, query, metadata) is expected
+    assert len(calls) == 1
+    assert all(actual is wanted for actual, wanted in zip(calls[0], (impl, query, query, query, metadata)))
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
new file mode 100644
index 000000000..16dc85115
--- /dev/null
+++ b/tests/diffusion/models/qwen_image/test_qwen_image_fused_qk_norm_rope.py
@@ -0,0 +1,196 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import pytest
+import torch
+import torch.nn as nn
+
+from vllm_omni.diffusion.layers.rope import RotaryEmbedding
+from vllm_omni.diffusion.models.qwen_image.qwen_image_transformer import (
+    _qwen_image_qk_norm_rope,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion]
+
+BATCH = 2
+Q_HEADS = 24
+K_HEADS = 24
+HEAD_DIM = 128
+EPS = 1e-6
+SEED = 2026
+
+
+@dataclass(frozen=True)
+class QwenImageQKInput:
+    q: torch.Tensor
+    k: torch.Tensor
+    norm_q: nn.RMSNorm
+    norm_k: nn.RMSNorm
+    freqs: torch.Tensor
+
+
+def _make_input(
+    *,
+    seq_len: int,
+    dtype: torch.dtype,
+    device: torch.device,
+    packed_qkv_view: bool,
+) -> QwenImageQKInput:
+    gen = torch.Generator(device=device)
+    gen.manual_seed(SEED + seq_len)
+
+    if packed_qkv_view:
+        qkv_dim = (Q_HEADS + K_HEADS + K_HEADS) * HEAD_DIM
+        qkv = torch.randn(BATCH, seq_len, qkv_dim, device=device, dtype=dtype, generator=gen)
+        q, k, _ = qkv.split(
+            [
+                Q_HEADS * HEAD_DIM,
+                K_HEADS * HEAD_DIM,
+                K_HEADS * HEAD_DIM,
+            ],
+            dim=-1,
+        )
+        q = q.unflatten(-1, (Q_HEADS, HEAD_DIM))
+        k = k.unflatten(-1, (K_HEADS, HEAD_DIM))
+    else:
+        q = torch.randn(BATCH, seq_len, Q_HEADS, HEAD_DIM, device=device, dtype=dtype, generator=gen)
+        k = torch.randn(BATCH, seq_len, K_HEADS, HEAD_DIM, device=device, dtype=dtype, generator=gen)
+
+    norm_q = nn.RMSNorm(HEAD_DIM, eps=EPS, device=device, dtype=dtype)
+    norm_k = nn.RMSNorm(HEAD_DIM, eps=EPS, device=device, dtype=dtype)
+    norm_q.requires_grad_(False)
+    norm_k.requires_grad_(False)
+    with torch.no_grad():
+        norm_q.weight.copy_(torch.randn(HEAD_DIM, device=device, dtype=dtype, generator=gen))
+        norm_k.weight.copy_(torch.randn(HEAD_DIM, device=device, dtype=dtype, generator=gen))
+    angles = torch.randn(seq_len, HEAD_DIM // 2, device=device, dtype=torch.float32, generator=gen)
+    freqs = torch.polar(torch.ones_like(angles), angles)
+    return QwenImageQKInput(q=q, k=k, norm_q=norm_q, norm_k=norm_k, freqs=freqs)
+
+
+def _eager_rotary(data: QwenImageQKInput) -> tuple[torch.Tensor, torch.Tensor]:
+    q = data.norm_q(data.q)
+    k = data.norm_k(data.k)
+    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 _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,
+        data.norm_q,
+        data.norm_k,
+        data.freqs,
+        RotaryEmbedding(is_neox_style=False),
+        EPS,
+        use_fused=use_fused,
+    )
+
+
+@pytest.mark.cuda
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA required")
+def test_qwen_image_qk_norm_rope_cuda_fp32_fallback_matches_reference():
+    data = _make_input(
+        seq_len=7,
+        dtype=torch.float32,
+        device=torch.device("cuda:0"),
+        packed_qkv_view=True,
+    )
+
+    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)
+
+
+@pytest.mark.cuda
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA required")
+def test_qwen_image_qk_norm_rope_cuda_fp16_fallback_matches_reference():
+    data = _make_input(
+        seq_len=7,
+        dtype=torch.float16,
+        device=torch.device("cuda:0"),
+        packed_qkv_view=True,
+    )
+
+    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)
+
+
+@pytest.mark.cuda
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA required")
+@pytest.mark.parametrize("seq_len", [1, 7, 257, 1024])
+@pytest.mark.parametrize("packed_qkv_view", [False, True])
+def test_qwen_image_fused_qk_norm_rope_cuda_matches_fp32_rope_reference(
+    seq_len: int,
+    packed_qkv_view: bool,
+):
+    data = _make_input(
+        seq_len=seq_len,
+        dtype=torch.bfloat16,
+        device=torch.device("cuda:0"),
+        packed_qkv_view=packed_qkv_view,
+    )
+
+    actual_q, actual_k = _run(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)
+
+
+@pytest.mark.cuda
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA required")
+def test_qwen_image_fused_qk_norm_rope_torch_compile_fullgraph_capture():
+    data = _make_input(
+        seq_len=257,
+        dtype=torch.bfloat16,
+        device=torch.device("cuda:0"),
+        packed_qkv_view=True,
+    )
+    rope = RotaryEmbedding(is_neox_style=False)
+
+    def fn(
+        q: torch.Tensor,
+        k: torch.Tensor,
+        freqs: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        return _qwen_image_qk_norm_rope(
+            q,
+            k,
+            data.norm_q,
+            data.norm_k,
+            freqs,
+            rope,
+            EPS,
+        )
+
+    compiled_fn = torch.compile(fn, dynamic=True, fullgraph=True)
+    expected_q, expected_k = fn(data.q, data.k, data.freqs)
+    actual_q, actual_k = compiled_fn(data.q, data.k, data.freqs)
+
+    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/qwen_image/test_qwen_image_select01_routing.py b/tests/diffusion/models/qwen_image/test_qwen_image_select01_routing.py
new file mode 100644
index 000000000..1a3acbb48
--- /dev/null
+++ b/tests/diffusion/models/qwen_image/test_qwen_image_select01_routing.py
@@ -0,0 +1,87 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import pytest
+import torch
+import torch.nn as nn
+
+from vllm_omni.diffusion.models.qwen_image import qwen_image_transformer
+from vllm_omni.diffusion.models.qwen_image.qwen_image_transformer import QwenImageTransformerBlock
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+
+class _StaticOutput(nn.Module):
+    def __init__(self, output: torch.Tensor):
+        super().__init__()
+        self.output = output
+
+    def forward(self, _: torch.Tensor) -> torch.Tensor:
+        return self.output
+
+
+class _RecordingNorm(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.calls: list[tuple[torch.Tensor, torch.Tensor, torch.Tensor]] = []
+
+    def forward(self, x: torch.Tensor, scale: torch.Tensor, shift: torch.Tensor) -> torch.Tensor:
+        self.calls.append((x, scale, shift))
+        return x
+
+
+class _ZeroAttention(nn.Module):
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        encoder_hidden_states: torch.Tensor,
+        **_: object,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        return torch.zeros_like(hidden_states), torch.zeros_like(encoder_hidden_states)
+
+
+class _ZeroMLP(nn.Module):
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return torch.zeros_like(x)
+
+
+def test_non_cuda_select01_uses_adalayernorm_dispatch(monkeypatch):
+    hidden_size = 4
+    block = QwenImageTransformerBlock.__new__(QwenImageTransformerBlock)
+    nn.Module.__init__(block)
+    block.zero_cond_t = True
+    block.img_mod = _StaticOutput(torch.zeros(2, 6 * hidden_size))
+    block.txt_mod = _StaticOutput(torch.zeros(1, 6 * hidden_size))
+    block.img_norm1 = _RecordingNorm()
+    block.img_norm2 = _RecordingNorm()
+    block.txt_norm1 = _RecordingNorm()
+    block.txt_norm2 = _RecordingNorm()
+    block.attn = _ZeroAttention()
+    block.img_mlp = _ZeroMLP()
+    block.txt_mlp = _ZeroMLP()
+
+    monkeypatch.setattr(qwen_image_transformer, "can_use_qwen_select01_triton", lambda _: False)
+
+    def fail_if_called(*args, **kwargs):
+        pytest.fail("non-CUDA select01 must preserve the AdaLayerNorm dispatch")
+
+    monkeypatch.setattr(qwen_image_transformer, "fused_layernorm_select01", fail_if_called)
+    monkeypatch.setattr(qwen_image_transformer, "fused_residual_layernorm_select01", fail_if_called)
+
+    hidden_states = torch.randn(1, 3, hidden_size)
+    encoder_hidden_states = torch.randn(1, 2, hidden_size)
+    modulate_index = torch.tensor([[0, 1, 0]])
+    block(
+        hidden_states,
+        encoder_hidden_states,
+        torch.ones(1, 2),
+        torch.zeros(2, hidden_size),
+        (torch.empty(0), torch.empty(0)),
+        modulate_index=modulate_index,
+    )
+
+    assert len(block.img_norm1.calls) == 1
+    assert len(block.img_norm2.calls) == 1
+    for _, scale, shift in (*block.img_norm1.calls, *block.img_norm2.calls):
+        assert scale.shape == hidden_states.shape
+        assert shift.shape == hidden_states.shape
diff --git a/tests/diffusion/models/wan2_2/conftest.py b/tests/diffusion/models/wan2_2/conftest.py
index f836fa545..cc95914c0 100644
--- a/tests/diffusion/models/wan2_2/conftest.py
+++ b/tests/diffusion/models/wan2_2/conftest.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 contextlib import contextmanager
@@ -33,7 +36,7 @@ class StubScheduler:
         self.config = SimpleNamespace(num_train_timesteps=1000)
         self.set_timesteps_calls: list[tuple[int, torch.device]] = []
 
-    def set_timesteps(self, num_steps: int, device: torch.device) -> None:
+    def set_timesteps(self, num_steps: int, device: torch.device, shift: float | None = None) -> None:
         self.set_timesteps_calls.append((num_steps, device))
 
 
diff --git a/tests/diffusion/models/wan2_2/fixtures/native_unipc_shift12.json b/tests/diffusion/models/wan2_2/fixtures/native_unipc_shift12.json
new file mode 100644
index 000000000..9b6fd2433
--- /dev/null
+++ b/tests/diffusion/models/wan2_2/fixtures/native_unipc_shift12.json
@@ -0,0 +1,97 @@
+{
+  "source_url": "https://github.com/Wan-Video/Wan2.2/blob/42bf4cfaa384bc21833865abc2f9e6c0e67233dc/wan/utils/fm_solvers_unipc.py",
+  "source_sha256": "0dec8c7ed17f6f2049275c6848113314da6ccec1c8db5bdc89df43c05c6038d9",
+  "git_head": "42bf4cfaa384bc21833865abc2f9e6c0e67233dc",
+  "num_train_timesteps": 1000,
+  "use_dynamic_shifting": false,
+  "reproduction": "Load FlowUniPCMultistepScheduler from source_url; construct with num_train_timesteps=1000, shift=1.0, use_dynamic_shifting=False; call set_timesteps(40, device='cpu', shift=12.0); record timesteps.tolist() and sigmas.tolist().",
+  "constructor_shift": 1.0,
+  "runtime_shift": 12.0,
+  "steps": 40,
+  "timesteps": [
+    999,
+    997,
+    995,
+    993,
+    990,
+    988,
+    985,
+    982,
+    979,
+    976,
+    972,
+    969,
+    965,
+    961,
+    956,
+    952,
+    947,
+    941,
+    936,
+    929,
+    922,
+    915,
+    907,
+    898,
+    888,
+    877,
+    865,
+    852,
+    837,
+    819,
+    799,
+    776,
+    749,
+    717,
+    678,
+    631,
+    571,
+    492,
+    386,
+    235
+  ],
+  "sigmas": [
+    0.9999166131019592,
+    0.9977826476097107,
+    0.9955461621284485,
+    0.9931996464729309,
+    0.9907346963882446,
+    0.988142192363739,
+    0.9854119420051575,
+    0.9825326800346375,
+    0.9794917702674866,
+    0.9762753844261169,
+    0.9728676676750183,
+    0.9692512154579163,
+    0.9654061794281006,
+    0.961310088634491,
+    0.9569376707077026,
+    0.95225989818573,
+    0.9472436308860779,
+    0.9418508410453796,
+    0.9360373020172119,
+    0.9297519326210022,
+    0.9229347705841064,
+    0.9155154228210449,
+    0.9074103832244873,
+    0.8985199332237244,
+    0.888724148273468,
+    0.8778772950172424,
+    0.865800678730011,
+    0.8522725701332092,
+    0.8370144367218018,
+    0.8196719288825989,
+    0.7997865080833435,
+    0.7767546772956848,
+    0.7497654557228088,
+    0.717703104019165,
+    0.6789888143539429,
+    0.6313128471374512,
+    0.5711563229560852,
+    0.49288034439086914,
+    0.38684695959091187,
+    0.23510953783988953,
+    0.0
+  ],
+  "implementation": "Wan-Video/Wan2.2 wan/utils/fm_solvers_unipc.py"
+}
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_i2v_pipeline.py b/tests/diffusion/models/wan2_2/test_wan22_i2v_pipeline.py
index 26e78ddab..70bb146ab 100644
--- a/tests/diffusion/models/wan2_2/test_wan22_i2v_pipeline.py
+++ b/tests/diffusion/models/wan2_2/test_wan22_i2v_pipeline.py
@@ -1,15 +1,16 @@
 # 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
 
+import numpy as np
 import pytest
 import torch
 from PIL import Image
 from torch import nn
 
 from tests.diffusion.models.wan2_2.conftest import StubScheduler, StubTransformer, StubVAE, noop_progress_bar
-from vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2 import _WAN_TEXT_ENCODER_OFFLOAD_PLAN
+from vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2 import _WAN_TEXT_ENCODER_OFFLOAD_PLAN, build_wan_scheduler
 from vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2_i2v import (
     Wan22I2VPipeline,
     get_wan22_i2v_post_process_func,
@@ -50,7 +51,7 @@ def _make_i2v_pipeline(*, expand_timesteps: bool) -> Wan22I2VPipeline:
 
 
 def _make_i2v_sampling(**overrides):
-    values = {
+    values: dict[str, object] = {
         "height": 16,
         "width": 16,
         "num_frames": 5,
@@ -275,16 +276,18 @@ def test_i2v_prepare_latents_preserves_batched_image_conditions() -> None:
     assert first_frame_mask.shape == (2, 1, 2, 2, 2)
 
 
-def test_i2v_forward_batches_conditions_random_inputs_and_outputs(monkeypatch) -> None:
+@pytest.mark.parametrize("solver", ["unipc", "euler"])
+@pytest.mark.parametrize("shift", [3.0, 5.0, 12.0])
+def test_i2v_forward_batches_conditions_random_inputs_and_outputs(monkeypatch, solver: str, shift: float) -> None:
     monkeypatch.setattr(
         "vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2_i2v.current_omni_platform",
         SimpleNamespace(is_available=lambda: False),
     )
     pipeline = _make_i2v_pipeline(expand_timesteps=True)
-    pipeline.scheduler = StubScheduler([9])
-    pipeline.od_config = SimpleNamespace(flow_shift=5.0)
-    pipeline._sample_solver = "unipc"
-    pipeline._flow_shift = 5.0
+    pipeline.scheduler = build_wan_scheduler(solver, shift)
+    pipeline.od_config = SimpleNamespace(flow_shift=shift)
+    pipeline._sample_solver = solver
+    pipeline._flow_shift = shift
     pipeline.boundary_ratio = 0.875
     pipeline.has_image_encoder = False
     pipeline._guidance_scale = None
@@ -327,6 +330,8 @@ def test_i2v_forward_batches_conditions_random_inputs_and_outputs(monkeypatch) -
                     generator=gen_a,
                     latents=latents_a,
                     num_outputs_per_prompt=2,
+                    num_inference_steps=50,
+                    extra_args={"sample_solver": solver, "flow_shift": shift},
                 ),
             ),
             SimpleNamespace(
@@ -336,12 +341,25 @@ def test_i2v_forward_batches_conditions_random_inputs_and_outputs(monkeypatch) -
                     generator=gen_b,
                     latents=latents_b,
                     num_outputs_per_prompt=2,
+                    num_inference_steps=50,
+                    extra_args={"sample_solver": solver, "flow_shift": shift},
                 ),
             ),
         ]
     )
 
     outputs = pipeline.forward(batch)
+    if solver == "unipc":
+        sigmas = np.linspace(float(np.float32(0.999)), 0.0, 51)[:-1]
+        sigmas = shift * sigmas / (1.0 + (shift - 1.0) * sigmas)
+        torch.testing.assert_close(
+            pipeline.scheduler.sigmas, torch.tensor(np.append(sigmas, 0.0), dtype=torch.float32), rtol=0, atol=0
+        )
+        assert pipeline.scheduler.timesteps.tolist() == (sigmas * 1000).astype(np.int64).tolist()
+    else:
+        reference = build_wan_scheduler("euler", shift)
+        reference.set_timesteps(50, device="cpu")
+        torch.testing.assert_close(pipeline.scheduler.sigmas, reference.sigmas, rtol=0, atol=0)
 
     assert prepare_call["batch_size"] == 4
     assert prepare_call["generator"] == [gen_a, gen_a, gen_b, gen_b]
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 de5abeab0..58a5e961b 100644
--- a/tests/diffusion/models/wan2_2/test_wan22_pipeline_diffuse.py
+++ b/tests/diffusion/models/wan2_2/test_wan22_pipeline_diffuse.py
@@ -9,7 +9,8 @@ import pytest
 import torch
 from torch import nn
 
-from vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2 import Wan22Pipeline
+from vllm_omni.diffusion.media import VideoTensorEncoding, VideoTensorLayout, VideoValueRange
+from vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2 import Wan22Pipeline, build_wan_scheduler
 from vllm_omni.diffusion.models.wan2_2.wan2_2_transformer import WanSelfAttention
 from vllm_omni.diffusion.request import OmniDiffusionRequest
 from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
@@ -18,6 +19,14 @@ from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
 
 
+@pytest.fixture(autouse=True)
+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):
     @property
     def dtype(self) -> torch.dtype:
@@ -30,14 +39,30 @@ class _StubTextEncoder(nn.Module):
         return torch.float32
 
 
+class _StubVaeConfig:
+    latents_mean = [0.0, 0.0, 0.0, 0.0]
+    latents_std = [1.0, 1.0, 1.0, 1.0]
+    z_dim = 4
+
+
+class _StubVae(nn.Module):
+    dtype = torch.float32
+    config = _StubVaeConfig()
+
+    def decode(self, latents, return_dict=False):
+        del return_dict
+        batch, _, frames, height, width = latents.shape
+        return (torch.zeros(batch, 3, frames, height, width),)
+
+
 class _StubScheduler:
     def __init__(self, timesteps: list[int]) -> None:
         self.timesteps = torch.tensor(timesteps, dtype=torch.int64)
         self.config = SimpleNamespace(num_train_timesteps=1000)
-        self.set_timesteps_calls: list[tuple[int, torch.device]] = []
+        self.set_timesteps_calls: list[tuple[int, torch.device, float | None]] = []
 
-    def set_timesteps(self, num_steps: int, device: torch.device) -> None:
-        self.set_timesteps_calls.append((num_steps, device))
+    def set_timesteps(self, num_steps: int, device: torch.device, shift: float | None = None) -> None:
+        self.set_timesteps_calls.append((num_steps, device, shift))
 
 
 @contextmanager
@@ -75,6 +100,7 @@ def _make_pipeline() -> Wan22Pipeline:
     pipeline.transformer = _StubTransformer()
     pipeline.transformer_2 = None
     pipeline.text_encoder = _StubTextEncoder()
+    pipeline.vae = _StubVae()
     pipeline.transformer_config = SimpleNamespace(patch_size=(1, 2, 2), in_channels=4, out_channels=4)
     pipeline.scheduler = _StubScheduler([9, 5])
     pipeline.od_config = SimpleNamespace(flow_shift=5.0)
@@ -166,7 +192,24 @@ def test_forward_delegates_denoising_to_diffuse(
     assert captured["boundary_timestep"] == pytest.approx(875.0)
     assert captured["latent_condition"] is None
     assert captured["first_frame_mask"] is None
-    assert pipeline.scheduler.set_timesteps_calls == [(2, torch.device("cpu"))]
+    assert pipeline.scheduler.set_timesteps_calls == [(2, torch.device("cpu"), 5.0)]
+
+
+@pytest.mark.parametrize("solver", ["unipc", "euler"])
+def test_forward_passes_request_shift_without_mutating_scheduler_config(solver: str) -> None:
+    pipeline = _make_pipeline()
+    pipeline.diffuse = lambda **kwargs: kwargs["latents"]
+    for shift in (3.0, 12.0, 5.0):
+        sampling = _make_sampling(num_inference_steps=5, extra_args={"sample_solver": solver, "flow_shift": shift})
+        request = OmniDiffusionRequest(prompt="prompt", request_id="schedule", sampling_params=sampling)
+        pipeline.forward(DiffusionRequestBatch(requests=[request]))
+        reference = build_wan_scheduler(solver, shift)
+        if solver == "unipc":
+            reference.set_timesteps(5, device="cpu", shift=shift)
+            assert pipeline.scheduler.config.shift == pipeline.scheduler.config["shift"] == 1.0
+        else:
+            reference.set_timesteps(5, device="cpu")
+        torch.testing.assert_close(pipeline.scheduler.sigmas, reference.sigmas, rtol=0, atol=0)
 
 
 def test_forward_batches_text_generators_latents_and_splits_outputs() -> None:
@@ -227,6 +270,99 @@ def test_forward_batches_text_generators_latents_and_splits_outputs() -> None:
     torch.testing.assert_close(outputs[1].output, latents_b)
 
 
+def test_forward_emits_request_local_typed_media_after_vae_decode() -> None:
+    pipeline = _make_pipeline()
+
+    def _fake_diffuse(
+        *,
+        latents,
+        timesteps,
+        prompt_embeds,
+        negative_prompt_embeds,
+        guidance_low,
+        guidance_high,
+        boundary_timestep,
+        dtype,
+        attention_kwargs,
+        latent_condition,
+        first_frame_mask,
+        generator,
+    ):
+        del (
+            timesteps,
+            prompt_embeds,
+            negative_prompt_embeds,
+            guidance_low,
+            guidance_high,
+            boundary_timestep,
+            dtype,
+            attention_kwargs,
+            latent_condition,
+            first_frame_mask,
+            generator,
+        )
+        return torch.zeros_like(latents)
+
+    pipeline.diffuse = _fake_diffuse  # type: ignore[method-assign]
+    batch = DiffusionRequestBatch(
+        requests=[
+            OmniDiffusionRequest(
+                prompt="prompt",
+                request_id="request-0",
+                sampling_params=OmniDiffusionSamplingParams(
+                    num_frames=1,
+                    num_inference_steps=2,
+                    max_sequence_length=32,
+                    output_type="np",
+                ),
+            )
+        ]
+    )
+
+    outputs = pipeline.forward(batch)
+
+    assert len(outputs) == 1
+    assert outputs[0].output is None
+    assert outputs[0].media is not None
+    assert outputs[0].media.prepared_for_transport is False
+    assert outputs[0].media.video.tensor.shape == (1, 3, 1, 8, 8)
+    assert outputs[0].media.video.spec.layout is VideoTensorLayout.BCTHW
+    assert outputs[0].media.video.spec.encoding is VideoTensorEncoding.NORMALIZED_FLOAT
+    assert outputs[0].media.video.spec.value_range is VideoValueRange.NEGATIVE_ONE_TO_ONE
+
+
+def test_forward_keeps_legacy_output_on_non_owner_vae_rank() -> None:
+    # Distributed VAE decode uses broadcast_result=False, so non-owner ranks get
+    # an empty placeholder instead of the full video. Wrapping that as typed media
+    # would fail split_diffusion_output_by_request's batch check on every non-owner
+    # rank, so the pipeline must keep the placeholder on the legacy output field.
+    pipeline = _make_pipeline()
+    pipeline.vae.decode = lambda latents, return_dict=False: (torch.empty(0),)  # type: ignore[assignment]
+    pipeline.diffuse = lambda **kwargs: torch.zeros_like(kwargs["latents"])  # type: ignore[method-assign]
+
+    batch = DiffusionRequestBatch(
+        requests=[
+            OmniDiffusionRequest(
+                prompt="prompt",
+                request_id="request-0",
+                sampling_params=OmniDiffusionSamplingParams(
+                    num_frames=1,
+                    num_inference_steps=2,
+                    max_sequence_length=32,
+                    output_type="np",
+                ),
+            )
+        ]
+    )
+
+    outputs = pipeline.forward(batch)
+
+    assert len(outputs) == 1
+    assert outputs[0].media is None
+    assert outputs[0].output is not None
+    assert outputs[0].output.numel() == 0
+
+
 def test_forward_batches_precomputed_prompt_embeddings() -> None:
     pipeline = _make_pipeline()
     diffuse_call = {}
@@ -343,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 3b49d7edb..a36f3a6a5 100644
--- a/tests/diffusion/models/wan2_2/test_wan22_s2v_pipeline.py
+++ b/tests/diffusion/models/wan2_2/test_wan22_s2v_pipeline.py
@@ -1,4 +1,8 @@
+# SPDX-License-Identifier: Apache-2.0
+# 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
@@ -7,6 +11,7 @@ import pytest
 import torch
 import torch.nn as nn
 
+from vllm_omni.diffusion.models.schedulers import FlowUniPCMultistepScheduler
 from vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2_s2v import (
     Wan22S2VPipeline,
     _make_clip_generators,
@@ -14,11 +19,32 @@ from vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2_s2v import (
 from vllm_omni.diffusion.models.wan2_2.wan2_2_s2v_transformer import WanS2VTransformer3DModel
 from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
 
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+
+@pytest.mark.parametrize("configured_shift", [None, 12.0])
+def test_s2v_constructor_preserves_unshifted_endpoints(configured_shift: float | None) -> None:
+    module = "vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2_s2v"
+    config = SimpleNamespace(model="unused", flow_shift=configured_shift, enable_diffusion_pipeline_profiler=False)
+
+    def init_components(pipeline, *args):
+        pipeline.vae = SimpleNamespace(config=SimpleNamespace(scale_factor_temporal=4, scale_factor_spatial=8))
+
+    with (
+        patch(f"{module}.get_local_device", return_value=torch.device("cpu")),
+        patch(f"{module}._resolve_model_path", return_value="unused"),
+        patch(f"{module}._is_diffusers_format", return_value=True),
+        patch.object(Wan22S2VPipeline, "_init_diffusers_format", init_components),
+        patch.object(Wan22S2VPipeline, "setup_diffusion_pipeline_profiler"),
+    ):
+        pipeline = Wan22S2VPipeline(od_config=config)
+    assert pipeline._flow_shift == (3.0 if configured_shift is None else configured_shift)
+    assert pipeline.scheduler.config.shift == pipeline.scheduler.config["shift"] == 1.0
+    assert pipeline.scheduler.sigma_max == float(np.float32(0.999))
 
 
 def _make_s2v_sampling(**overrides):
-    values = {
+    values: dict[str, Any] = {
         "height": 16,
         "width": 16,
         "num_frames": 8,
@@ -211,7 +237,8 @@ def test_s2v_forward_rejects_different_raw_audio_shapes() -> None:
         pipeline.forward(batch)
 
 
-def test_s2v_forward_batches_request_local_inputs_and_splits_outputs() -> None:
+@pytest.mark.parametrize("shift", [3.0, 12.0])
+def test_s2v_forward_batches_request_local_inputs_and_splits_outputs(shift: float) -> None:
     pipeline = object.__new__(Wan22S2VPipeline)
     nn.Module.__init__(pipeline)
     pipeline.device = torch.device("cpu")
@@ -227,7 +254,8 @@ def test_s2v_forward_batches_request_local_inputs_and_splits_outputs() -> None:
         enable_cpu_offload=False,
         parallel_config=SimpleNamespace(use_hsdp=False),
     )
-    pipeline.scheduler = MagicMock(timesteps=torch.tensor([1.0]))
+    pipeline._flow_shift = shift
+    pipeline.scheduler = FlowUniPCMultistepScheduler(shift=1.0)
     pipeline.vae_scale_factor_spatial = 8
     pipeline.resolution_divisor = 16
     pipeline.motion_frames = 7
@@ -262,6 +290,7 @@ def test_s2v_forward_batches_request_local_inputs_and_splits_outputs() -> None:
                     "multi_modal_data": {"image": image, "audio": audio_a},
                 },
                 sampling_params=_make_s2v_sampling(
+                    num_inference_steps=5,
                     num_outputs_per_prompt=2,
                     generator=generators_a,
                     latents=latents_a,
@@ -275,6 +304,7 @@ def test_s2v_forward_batches_request_local_inputs_and_splits_outputs() -> None:
                     "multi_modal_data": {"image": image, "audio": audio_b},
                 },
                 sampling_params=_make_s2v_sampling(
+                    num_inference_steps=5,
                     num_outputs_per_prompt=2,
                     generator=generators_b,
                     latents=latents_b,
@@ -287,6 +317,12 @@ def test_s2v_forward_batches_request_local_inputs_and_splits_outputs() -> None:
         platform.is_available.return_value = False
         outputs = pipeline.forward(batch)
 
+    expected = np.linspace(float(np.float32(0.999)), 0.0, 6)[:-1]
+    expected = shift * expected / (1.0 + (shift - 1.0) * expected)
+    torch.testing.assert_close(
+        pipeline.scheduler.sigmas, torch.tensor(np.append(expected, 0.0), dtype=torch.float32), rtol=0, atol=0
+    )
+    assert pipeline.scheduler.config.shift == pipeline.scheduler.config["shift"] == 1.0
     assert len(outputs) == 2
     assert outputs[0].output[0].shape[0] == 2
     assert outputs[1].output[0].shape[0] == 2
@@ -519,6 +555,7 @@ def test_s2v_pipeline_hsdp_forward_complete_process():
     mock_scheduler.timesteps = torch.linspace(999, 0, 5)
     mock_scheduler.step = MagicMock(return_value=(torch.zeros(1, 16, 20, 88, 128),))
     pipeline.scheduler = mock_scheduler
+    pipeline._flow_shift = 3.0
 
     # -- Bind methods from the real class --
     pipeline.encode_prompt = Wan22S2VPipeline.encode_prompt.__get__(pipeline)
@@ -611,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/models/wan2_2/test_wan22_scheduler.py b/tests/diffusion/models/wan2_2/test_wan22_scheduler.py
new file mode 100644
index 000000000..87cc24670
--- /dev/null
+++ b/tests/diffusion/models/wan2_2/test_wan22_scheduler.py
@@ -0,0 +1,54 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Compare actual Wan schedules to native Wan outputs and independent sigma arithmetic."""
+
+import json
+from pathlib import Path
+
+import numpy as np
+import numpy.typing as npt
+import pytest
+import torch
+
+from vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2 import (
+    FASTWAN_DMD_SCHEDULER_SHIFT,
+    build_wan_scheduler,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+
+def test_wan_unipc_matches_captured_native_full_schedule() -> None:
+    # The fixture pins the official Wan source and records how to regenerate it.
+    golden = json.loads((Path(__file__).parent / "fixtures/native_unipc_shift12.json").read_text())
+    scheduler = build_wan_scheduler("unipc", golden["runtime_shift"])
+    for steps in (golden["steps"], 20, golden["steps"]):
+        scheduler.set_timesteps(steps, device="cpu", shift=golden["runtime_shift"])
+        if steps == golden["steps"]:
+            assert scheduler.timesteps.tolist() == golden["timesteps"]
+            torch.testing.assert_close(scheduler.sigmas, torch.tensor(golden["sigmas"]), rtol=0, atol=0)
+
+
+@pytest.mark.parametrize("shift", [1.0, 3.0, 5.0, 12.0])
+@pytest.mark.parametrize("steps", [20, 40])
+def test_wan_unipc_shifts_unmodified_training_endpoints(shift: float, steps: int) -> None:
+    # Native Wan: float32 training sigma_max=(1-1/1000), sigma_min=0;
+    # interpolate in float64, apply the runtime shift, then cast sigma to FP32.
+    unshifted = np.linspace(float(np.float32(0.999)), 0.0, steps + 1)[:-1]
+    shifted = shift * unshifted / (1.0 + (shift - 1.0) * unshifted)
+    expected_timesteps = (shifted * 1000).astype(np.int64)
+    expected_sigmas: npt.NDArray[np.float32] = np.append(shifted, 0.0).astype(np.float32)
+    scheduler = build_wan_scheduler("unipc", shift)
+    scheduler.set_timesteps(steps, device="cpu", shift=shift)
+    assert scheduler.config.shift == scheduler.config["shift"] == 1.0
+    torch.testing.assert_close(scheduler.timesteps, torch.from_numpy(expected_timesteps), rtol=0, atol=0)
+    torch.testing.assert_close(scheduler.sigmas, torch.from_numpy(expected_sigmas), rtol=0, atol=0)
+
+
+def test_wan_euler_keeps_dmd_shift_semantics() -> None:
+    scheduler = build_wan_scheduler("euler", FASTWAN_DMD_SCHEDULER_SHIFT)
+    scheduler.set_timesteps(3, device="cpu")
+    # The unchanged Euler branch starts at sigma=1, with shift=8 for DMD.
+    expected = torch.tensor([1.0, 16.0 / 17.0, 0.8, 0.0])
+    torch.testing.assert_close(scheduler.sigmas, expected, rtol=0, atol=1e-7)
+    torch.testing.assert_close(scheduler.timesteps, expected[:-1] * 1000, rtol=0, atol=1e-4)
diff --git a/tests/diffusion/models/wan2_2/test_wan22_vace_pipeline.py b/tests/diffusion/models/wan2_2/test_wan22_vace_pipeline.py
index 5f712bc8a..75cf868ce 100644
--- a/tests/diffusion/models/wan2_2/test_wan22_vace_pipeline.py
+++ b/tests/diffusion/models/wan2_2/test_wan22_vace_pipeline.py
@@ -1,15 +1,17 @@
 # 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 types import SimpleNamespace
 
+import numpy as np
 import pytest
 import torch
 from PIL import Image
 from torch import nn
 
 from tests.diffusion.models.wan2_2.conftest import StubScheduler, StubTransformer, StubVAE, noop_progress_bar
+from vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2 import build_wan_scheduler
 from vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2_vace import (
     Wan22VACEPipeline,
     create_vace_transformer_from_config,
@@ -33,6 +35,8 @@ def test_vace_default_flow_shift_preserves_compact_offload_runtime_state(monkeyp
         )
         enable_layerwise_offload: bool = True
         post_init_calls: int = 0
+        _resolved_diffusion_offload: object = None
+        _diffusion_offload_flags_materialized: bool = False
 
         def __post_init__(self) -> None:
             self.post_init_calls += 1
@@ -41,7 +45,7 @@ def test_vace_default_flow_shift_preserves_compact_offload_runtime_state(monkeyp
     resolved_offload = object()
     config._resolved_diffusion_offload = resolved_offload
     config._diffusion_offload_flags_materialized = True
-    captured = {}
+    captured: dict[str, object] = {}
 
     def capture_base_init(self, *, od_config, prefix="") -> None:
         captured.update(od_config=od_config, prefix=prefix)
@@ -51,6 +55,7 @@ def test_vace_default_flow_shift_preserves_compact_offload_runtime_state(monkeyp
     Wan22VACEPipeline(od_config=config, prefix="stage")
 
     forwarded = captured["od_config"]
+    assert isinstance(forwarded, RuntimeConfig)
     assert forwarded is not config
     assert config.flow_shift is None
     assert forwarded.flow_shift == 3.0
@@ -75,7 +80,7 @@ def _make_vace_pipeline() -> Wan22VACEPipeline:
 
 
 def _make_vace_sampling(**overrides):
-    values = {
+    values: dict[str, object] = {
         "height": 16,
         "width": 16,
         "num_frames": 5,
@@ -123,7 +128,7 @@ def test_vace_preprocess_collects_reference_video_and_mask_inputs() -> None:
 
 
 def test_create_vace_transformer_from_config_maps_vace_specific_keys(monkeypatch) -> None:
-    captured = {}
+    captured: dict[str, object] = {}
 
     class FakeVACETransformer:
         def __init__(self, **kwargs) -> None:
@@ -203,7 +208,9 @@ def test_vace_diffuse_passes_context_and_scale_to_cfg_branches() -> None:
     torch.testing.assert_close(result, torch.ones_like(latents))
 
 
-def test_vace_forward_batches_random_inputs_and_splits_outputs(monkeypatch) -> None:
+@pytest.mark.parametrize("solver", ["unipc", "euler"])
+@pytest.mark.parametrize("shift", [3.0, 5.0, 12.0])
+def test_vace_forward_batches_random_inputs_and_splits_outputs(monkeypatch, solver: str, shift: float) -> None:
     monkeypatch.setattr(
         "vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2_vace.current_omni_platform",
         SimpleNamespace(is_available=lambda: False),
@@ -211,10 +218,10 @@ def test_vace_forward_batches_random_inputs_and_splits_outputs(monkeypatch) -> N
     pipeline = _make_vace_pipeline()
     pipeline.transformer.vace_patch_embedding = None
     pipeline.transformer_2 = None
-    pipeline.scheduler = StubScheduler([9])
-    pipeline.od_config = SimpleNamespace(flow_shift=3.0)
-    pipeline._sample_solver = "unipc"
-    pipeline._flow_shift = 3.0
+    pipeline.scheduler = build_wan_scheduler(solver, shift)
+    pipeline.od_config = SimpleNamespace(flow_shift=shift)
+    pipeline._sample_solver = solver
+    pipeline._flow_shift = shift
     pipeline.boundary_ratio = None
     pipeline._guidance_scale = None
     pipeline._num_timesteps = None
@@ -247,6 +254,8 @@ def test_vace_forward_batches_random_inputs_and_splits_outputs(monkeypatch) -> N
                     generator=gen_a,
                     latents=latents_a,
                     num_outputs_per_prompt=2,
+                    num_inference_steps=50,
+                    extra_args={"sample_solver": solver, "flow_shift": shift},
                 ),
             ),
             SimpleNamespace(
@@ -256,12 +265,25 @@ def test_vace_forward_batches_random_inputs_and_splits_outputs(monkeypatch) -> N
                     generator=gen_b,
                     latents=latents_b,
                     num_outputs_per_prompt=2,
+                    num_inference_steps=50,
+                    extra_args={"sample_solver": solver, "flow_shift": shift},
                 ),
             ),
         ]
     )
 
     outputs = pipeline.forward(batch)
+    if solver == "unipc":
+        sigmas = np.linspace(float(np.float32(0.999)), 0.0, 51)[:-1]
+        sigmas = shift * sigmas / (1.0 + (shift - 1.0) * sigmas)
+        torch.testing.assert_close(
+            pipeline.scheduler.sigmas, torch.tensor(np.append(sigmas, 0.0), dtype=torch.float32), rtol=0, atol=0
+        )
+        assert pipeline.scheduler.timesteps.tolist() == (sigmas * 1000).astype(np.int64).tolist()
+    else:
+        reference = build_wan_scheduler("euler", shift)
+        reference.set_timesteps(50, device="cpu")
+        torch.testing.assert_close(pipeline.scheduler.sigmas, reference.sigmas, rtol=0, atol=0)
 
     assert prepare_call["batch_size"] == 4
     assert prepare_call["generator"] == [gen_a, gen_a, gen_b, gen_b]
diff --git a/tests/diffusion/offloader/test_backend_plan_contract.py b/tests/diffusion/offloader/test_backend_plan_contract.py
new file mode 100644
index 000000000..3c406f5d5
--- /dev/null
+++ b/tests/diffusion/offloader/test_backend_plan_contract.py
@@ -0,0 +1,163 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Executable contracts for the two behaviors the generic cutover changed.
+
+Placement now follows resolved block identity, and the backends run on the
+resolved plan alone. Declaration parsing, selection errors, rollback,
+residency and enable/disable cycles are covered by ``test_plan_resolver.py``,
+``test_layerwise_backend.py`` and ``test_sequential_backend.py``.
+"""
+
+from typing import ClassVar
+
+import pytest
+import torch
+from torch import nn
+
+from tests.diffusion.offloader.helpers import patch_offload_runtime
+from vllm_omni.diffusion.offloader import layerwise_backend, sequential_backend
+from vllm_omni.diffusion.offloader.base import OffloadConfig, OffloadStrategy
+from vllm_omni.diffusion.offloader.layerwise_backend import LayerWiseOffloadBackend
+from vllm_omni.diffusion.offloader.offload_plan import OffloadPlan
+from vllm_omni.diffusion.offloader.plan_resolver import resolve_offload_plan
+from vllm_omni.diffusion.offloader.sequential_backend import ModelLevelOffloadBackend
+from vllm_omni.platforms import current_omni_platform
+
+pytestmark = [pytest.mark.diffusion, pytest.mark.core_model]
+
+STRATEGIES = [OffloadStrategy.MODEL_LEVEL, OffloadStrategy.LAYER_WISE]
+CPU = torch.device("cpu")
+
+
+class _Block(nn.Linear):
+    def __init__(self):
+        super().__init__(4, 4)
+        self.register_buffer("scale", torch.tensor(0.5))
+
+    def forward(self, x):
+        return super().forward(x).tanh() * self.scale
+
+
+class _Stack(nn.Module):
+    """Two block containers plus non-block state that must stay resident."""
+
+    def __init__(self):
+        super().__init__()
+        self.blocks = nn.ModuleList([_Block() for _ in range(3)])
+        self.tail = nn.ModuleList([_Block() for _ in range(2)])
+        self.bias = nn.Parameter(torch.ones(4))
+        self.register_buffer("scale", torch.tensor(0.25))
+        self.proj = nn.Linear(4, 4)
+
+    def forward(self, x):
+        for block in (*self.blocks, *self.tail):
+            x = block(x)
+        return self.proj(x) * self.scale + self.bias
+
+
+class _Pipeline(nn.Module):
+    _dit_modules: ClassVar[list[str]] = ["transformer"]
+    _encoder_modules: ClassVar[list[str]] = ["text_encoder", "image_encoder"]
+    _vae_modules: ClassVar[list[str]] = ["vae"]
+    _resident_modules: ClassVar[list[str]] = ["resident"]
+    _offload_plan = OffloadPlan(
+        block_attrs={"transformer": ("blocks", "tail")},
+        encoder_block_attrs={"text_encoder": ("blocks", "tail")},
+    )
+
+    def __init__(self):
+        super().__init__()
+        self.transformer = _Stack()
+        self.text_encoder = _Stack()
+        self.image_encoder = nn.Linear(4, 4)
+        self.vae = nn.Linear(4, 4)
+        self.resident = nn.Linear(4, 4)
+
+    def forward(self, x):
+        return self.resident(self.vae(self.transformer(self.text_encoder(self.image_encoder(x)))))
+
+
+@pytest.fixture(params=[pytest.param("cpu", marks=pytest.mark.cpu), pytest.param("cuda", marks=pytest.mark.cuda)])
+def execution_device(request, monkeypatch):
+    if request.param == "cuda":
+        if not torch.cuda.is_available():
+            pytest.skip("CUDA required for real transfer/residency coverage")
+        return torch.device("cuda:0")
+    patch_offload_runtime(monkeypatch, current_omni_platform, synchronize=True)
+    monkeypatch.setattr(current_omni_platform, "get_free_memory", lambda: 0)
+    return CPU
+
+
+def _config(strategy, components):
+    return OffloadConfig(strategy=strategy, components=components, pin_cpu_memory=False)
+
+
+def _backend(config, device):
+    kind = ModelLevelOffloadBackend if config.strategy is OffloadStrategy.MODEL_LEVEL else LayerWiseOffloadBackend
+    return kind(config, device)
+
+
+def _assert_no_offload_hooks(pipeline):
+    for module in pipeline.modules():
+        registry = getattr(module, "_hook_registry", None)
+        if registry is not None:
+            assert registry.get_hook("sequential_offload") is None
+            assert registry.get_hook("layerwise_offload") is None
+        assert not getattr(module, "_omni_layerwise_enabled", False)
+
+
+@torch.inference_mode()
+def test_alias_of_a_streamed_block_is_not_placed(execution_device):
+    """Placement moves DiT state by resolved block identity, not by attribute.
+
+    An attribute aliasing a streamed block must stay with its ring: copying it
+    to the device makes the ring record the device as that block's home and
+    strands those weights there after teardown.
+    """
+    pipeline = _Pipeline()
+    pipeline.transformer.proj.weight = pipeline.transformer.blocks[1].weight
+    original = pipeline.transformer.proj.weight.clone()
+    backend = _backend(_config(OffloadStrategy.LAYER_WISE, frozenset({"dit"})), execution_device)
+
+    backend.enable(pipeline)
+    try:
+        assert pipeline.transformer.proj.weight is pipeline.transformer.blocks[1].weight
+        assert pipeline.transformer.proj.weight.device == CPU
+        # Non-block state around the alias is still placed.
+        assert pipeline.transformer.proj.bias.device == execution_device
+        assert pipeline.transformer.bias.device == execution_device
+    finally:
+        backend.disable()
+
+    assert pipeline.transformer.proj.weight.device == CPU
+    torch.testing.assert_close(pipeline.transformer.proj.weight, original)
+
+
+@pytest.mark.parametrize("strategy", STRATEGIES)
+@torch.inference_mode()
+def test_backends_execute_the_resolved_plan_alone(execution_device, strategy, monkeypatch):
+    pipeline = _Pipeline().to(execution_device)
+    x = torch.randn(2, 4, device=execution_device)
+    expected = pipeline(x)
+    config = _config(strategy, frozenset({"dit", "text_encoder"}))
+    resolved = resolve_offload_plan(pipeline, config)
+
+    def forbidden_read(*args, **kwargs):
+        pytest.fail("Backend reinterpreted topology after plan resolution")
+
+    # Once resolved, neither declarations nor selector helpers are an input to
+    # backend execution. Transport options stay readable.
+    monkeypatch.setattr(config, "offloads", forbidden_read)
+    monkeypatch.setattr(config, "should_offload_encoder", forbidden_read)
+    monkeypatch.setattr(pipeline, "_offload_plan", None)
+    backend_module = sequential_backend if strategy is OffloadStrategy.MODEL_LEVEL else layerwise_backend
+    monkeypatch.setattr(backend_module, "resolve_offload_plan", lambda *_: resolved)
+
+    backend = _backend(config, execution_device)
+    try:
+        backend.enable(pipeline)
+        torch.testing.assert_close(pipeline(x), expected)
+    finally:
+        backend.disable()
+    _assert_no_offload_hooks(pipeline)
diff --git a/tests/diffusion/offloader/test_diffusion_cpu_offload.py b/tests/diffusion/offloader/test_diffusion_cpu_offload.py
index 80a03180f..873f355c9 100644
--- a/tests/diffusion/offloader/test_diffusion_cpu_offload.py
+++ b/tests/diffusion/offloader/test_diffusion_cpu_offload.py
@@ -9,14 +9,14 @@ import pytest
 import torch
 from vllm.distributed.parallel_state import cleanup_dist_env_and_memory
 
-from tests.helpers.mark import hardware_test
+from tests.helpers.mark import hardware_marks, hardware_test
 from tests.helpers.monitor import DeviceMemoryMonitor
 from tests.helpers.runtime import OmniRunner
 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]] = {
@@ -27,11 +27,19 @@ MODELS: dict[str, dict[str, int | None]] = {**AUDIO_MODEL, **IMAGE_MODELS}
 
 MODEL_MARKS = {
     "riverclouds/qwen_image_random": pytest.mark.core_model,
-    "stabilityai/stable-audio-open-1.0": pytest.mark.full_model,
+    "stabilityai/stable-audio-open-1.0": [
+        pytest.mark.full_model,
+        *hardware_marks(res={"cuda": ["L4", "B200"], "rocm": "MI325"}),
+    ],
 }
 
 _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": {},
@@ -47,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()
@@ -78,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):
@@ -109,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):
@@ -122,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]
@@ -139,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_diffusion_layerwise_offload.py b/tests/diffusion/offloader/test_diffusion_layerwise_offload.py
index 8e083605f..c579affe9 100644
--- a/tests/diffusion/offloader/test_diffusion_layerwise_offload.py
+++ b/tests/diffusion/offloader/test_diffusion_layerwise_offload.py
@@ -1,7 +1,10 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
+import concurrent.futures
 import gc
+import multiprocessing as mp
+import os
 from typing import Any
 
 import numpy as np
@@ -9,7 +12,7 @@ import pytest
 import torch
 from vllm.distributed.parallel_state import cleanup_dist_env_and_memory
 
-from tests.helpers.mark import hardware_test
+from tests.helpers.mark import hardware_marks
 from tests.helpers.monitor import DeviceMemoryMonitor
 from tests.helpers.runtime import OmniRunner
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
@@ -31,8 +34,14 @@ IMAGE_VIDEO_MODELS: dict[str, dict[str, int | None]] = {
 MODELS: dict[str, dict[str, int | None]] = {**AUDIO_MODEL, **IMAGE_VIDEO_MODELS}
 
 MODEL_MARKS = {
-    "riverclouds/qwen_image_random": pytest.mark.core_model,
-    "stabilityai/stable-audio-open-1.0": pytest.mark.full_model,
+    "riverclouds/qwen_image_random": [
+        pytest.mark.core_model,
+        *hardware_marks(res={"cuda": "L4", "rocm": "MI325"}),
+    ],
+    "stabilityai/stable-audio-open-1.0": [
+        pytest.mark.full_model,
+        *hardware_marks(res={"cuda": ["L4", "B200"], "rocm": "MI325"}),
+    ],
 }
 
 AUDIO_MODEL_PARAMS: dict[str, dict[str, Any]] = {
@@ -45,32 +54,98 @@ IMAGE_VIDEO_MODELS_PARAMS: dict[str, dict[str, Any]] = {
     "sampler_params": {"height": 480, "width": 640, "num_frames": 5},
 }
 
+_OFFLOAD_STATE_PROBE = "vllm_omni_layerwise_offload_test"
+# A second CI build can reverse the same exact-head measurement without a
+# source edit; the default keeps the existing baseline-first workload.
+_MEASUREMENT_ORDER_ENV = "VLLM_OMNI_OFFLOAD_TEST_ORDER"
+_MEASUREMENT_ORDERS: dict[str, tuple[bool, bool]] = {
+    "baseline-first": (False, True),
+    "offload-first": (True, False),
+}
 
-def check_audio_determinism(audio1, audio2, atol=1e-2):
-    device = current_omni_platform.device_type
-    if isinstance(audio1, np.ndarray):
-        audio1 = torch.from_numpy(audio1).to(device)
-    if isinstance(audio2, np.ndarray):
-        audio2 = torch.from_numpy(audio2).to(device)
 
-    if not torch.allclose(audio1, audio2, atol=atol):
-        diff = torch.abs(audio1 - audio2)
-        print(f"Max difference: {diff.max().item()}")
-        print(f"Mean difference: {diff.mean().item()}")
+class OffloadStateProbe:
+    """Test-only worker extension exposing the configured offloader state."""
+
+    model_runner: Any
+
+    def get_offload_state_for_test(self) -> dict[str, Any]:
+        backend = getattr(self.model_runner, "offload_backend", None)
+        block_groups = getattr(backend, "_blocks", ())
+        group_sizes = [len(group) for group in block_groups] if isinstance(block_groups, (list, tuple)) else []
+
+        return {
+            "probe": _OFFLOAD_STATE_PROBE,
+            "backend_type": (
+                None if backend is None else f"{backend.__class__.__module__}.{backend.__class__.__qualname__}"
+            ),
+            "requested": bool(getattr(self.model_runner.od_config, "enable_layerwise_offload", False)),
+            "enabled": bool(backend is not None and backend.is_enabled()),
+            "block_group_count": len(group_sizes),
+            "block_group_sizes": group_sizes,
+            "block_count": sum(group_sizes),
+        }
+
+
+def check_audio_determinism(audio1: np.ndarray, audio2: np.ndarray, atol: float = 1e-2) -> bool:
+    if not np.allclose(audio1, audio2, atol=atol):
+        diff = np.abs(audio1 - audio2)
+        print(f"Max difference: {diff.max()}")
+        print(f"Mean difference: {diff.mean()}")
         raise AssertionError(f"Audio outputs differ beyond tolerance atol={atol}")
     return True
 
 
+def _device_used_mb(device_index: int) -> float:
+    current_omni_platform.synchronize()
+    with current_omni_platform.device(device_index):
+        free_bytes, total_bytes = current_omni_platform.mem_get_info()
+    return (total_bytes - free_bytes) / (1024**2)
+
+
+def _extract_audio(output: Any) -> np.ndarray | None:
+    if not output:
+        return None
+    multimodal_output = getattr(output[0], "multimodal_output", None)
+    if not isinstance(multimodal_output, dict):
+        return None
+    audio = multimodal_output.get("audio")
+    if audio is None:
+        return None
+    if isinstance(audio, torch.Tensor):
+        return audio.detach().cpu().numpy()
+    return np.asarray(audio)
+
+
+def _collect_offload_states(value: Any) -> list[dict[str, Any]]:
+    if isinstance(value, dict):
+        return [value] if value.get("probe") == _OFFLOAD_STATE_PROBE else []
+    if isinstance(value, (list, tuple)):
+        states: list[dict[str, Any]] = []
+        for item in value:
+            states.extend(_collect_offload_states(item))
+        return states
+    return []
+
+
+def _measurement_order() -> tuple[bool, bool]:
+    """Return the requested order without changing the default CI workload."""
+    configured = os.environ.get(_MEASUREMENT_ORDER_ENV, "baseline-first")
+    try:
+        return _MEASUREMENT_ORDERS[configured]
+    except KeyError as exc:
+        allowed = ", ".join(_MEASUREMENT_ORDERS)
+        raise ValueError(f"{_MEASUREMENT_ORDER_ENV} must be one of: {allowed}; got {configured!r}") from exc
+
+
 def run_inference(
     model_name: str,
     layerwise_offload: bool = False,
     num_inference_steps: int = 3,
-) -> tuple[float, Any]:
+) -> dict[str, Any]:
     current_omni_platform.empty_cache()
     device_index = current_omni_platform.current_device()
-    with current_omni_platform.device(device_index):
-        free_bytes, total_bytes = current_omni_platform.mem_get_info()
-    initial_used_mb = (total_bytes - free_bytes) / (1024**2)
+    initial_used_mb = _device_used_mb(device_index)
 
     if model_name in AUDIO_MODEL:
         params = AUDIO_MODEL_PARAMS
@@ -80,10 +155,17 @@ def run_inference(
     with OmniRunner(
         model_name,
         enable_layerwise_offload=layerwise_offload,
+        worker_extension_cls=f"{OffloadStateProbe.__module__}.{OffloadStateProbe.__qualname__}",
         # TODO: we might want to add overlapped feature e2e tests
         # cache_backend="cache_dit",
         **params["runner_params"],
     ) as runner:
+        offload_states = _collect_offload_states(
+            runner.omni.engine.collective_rpc(method="get_offload_state_for_test", timeout=60)
+        )
+        if not offload_states:
+            raise AssertionError("The offload-state worker probe returned no diffusion worker results")
+
         # Measure steady-state inference memory, not model construction. Enabling
         # layerwise offload first loads the model and then replaces each block's
         # device storage with CPU-backed weights.  Monitoring that transition
@@ -108,20 +190,135 @@ def run_inference(
         finally:
             monitor.stop()
 
+        audio = _extract_audio(output)
+        del output
+
     # DeviceMemoryMonitor reports absolute device usage. Subtract this run's
-    # starting usage so process-wide compiler/workspace caches retained from a
-    # previous run do not make the second measurement order-dependent.
-    peak = max(0.0, monitor.peak_used_mb - initial_used_mb)
+    # starting usage. Each mode runs in its own spawned process below, so model
+    # objects and process-local allocator/compiler/backend workspace state cannot
+    # carry into the other measurement. Shared filesystem caches can persist;
+    # _MEASUREMENT_ORDER_ENV enables a reversed-order validation run for that.
+    peak_used_mb = monitor.peak_used_mb
+    incremental_peak_mb = max(0.0, peak_used_mb - initial_used_mb)
 
+    del runner
     gc.collect()
+    cleanup_dist_env_and_memory()
     current_omni_platform.empty_cache()
+    post_cleanup_used_mb = _device_used_mb(device_index)
 
-    return peak, output
+    return {
+        "initial_used_mb": initial_used_mb,
+        "peak_used_mb": peak_used_mb,
+        "incremental_peak_mb": incremental_peak_mb,
+        "post_cleanup_used_mb": post_cleanup_used_mb,
+        "audio": audio,
+        "offload_states": offload_states,
+    }
+
+
+def run_inference_isolated(
+    model_name: str,
+    layerwise_offload: bool = False,
+    num_inference_steps: int = 3,
+) -> dict[str, Any]:
+    """Run one measurement in a fresh interpreter and accelerator context."""
+    with concurrent.futures.ProcessPoolExecutor(max_workers=1, mp_context=mp.get_context("spawn")) as executor:
+        return executor.submit(run_inference, model_name, layerwise_offload, num_inference_steps).result()
+
+
+def _assert_offload_state(measurement: dict[str, Any], *, expected_enabled: bool) -> None:
+    states = measurement["offload_states"]
+    assert states, "Expected at least one offload-state result"
+    for state in states:
+        assert state["requested"] is expected_enabled, f"Unexpected offload request state: {state}"
+        assert state["enabled"] is expected_enabled, f"Unexpected offload state: {state}"
+        if expected_enabled:
+            assert state["backend_type"], f"Enabled offloader has no backend type: {state}"
+            assert state["block_group_count"] > 0, f"Enabled offloader has no block groups: {state}"
+            assert state["block_count"] > 0, f"Enabled offloader has no managed blocks: {state}"
+        else:
+            assert state["block_group_count"] == 0, f"Disabled offloader retained block groups: {state}"
+            assert state["block_count"] == 0, f"Disabled offloader retained managed blocks: {state}"
+
+
+def _assert_audio_outputs(
+    model_name: str,
+    audio_no_offload: np.ndarray | None,
+    audio_offload: np.ndarray | None,
+) -> None:
+    if model_name not in AUDIO_MODEL:
+        return
+
+    assert audio_no_offload is not None, "Baseline Stable Audio inference returned no audio"
+    assert audio_offload is not None, "Layerwise-offloaded Stable Audio inference returned no audio"
+    # Match the sibling cpu-offload test's tolerance: layerwise offload moves
+    # blocks across the PCIe bus on a side stream, which can perturb cuBLAS
+    # algorithm selection and produce ~ULP-level drift larger than 1e-3.
+    check_audio_determinism(audio_offload, audio_no_offload, atol=1e-2)
+
+
+def _print_measurement(label: str, measurement: dict[str, Any]) -> None:
+    print(
+        f"{label}: initial={measurement['initial_used_mb']:.1f} MB, "
+        f"peak={measurement['peak_used_mb']:.1f} MB, "
+        f"incremental_peak={measurement['incremental_peak_mb']:.1f} MB, "
+        f"post_cleanup={measurement['post_cleanup_used_mb']:.1f} MB"
+    )
+    print(f"{label} offload state: {measurement['offload_states']}")
 
 
 @pytest.mark.diffusion
-@hardware_test(res={"cuda": "L4", "rocm": "MI325"})
-@pytest.mark.parametrize("model_name", list(MODELS.keys()))
+@pytest.mark.core_model
+@pytest.mark.cpu
+@pytest.mark.parametrize(
+    ("configured", "expected"),
+    [
+        (None, (False, True)),
+        ("baseline-first", (False, True)),
+        ("offload-first", (True, False)),
+    ],
+)
+def test_measurement_order(monkeypatch, configured: str | None, expected: tuple[bool, bool]) -> None:
+    if configured is None:
+        monkeypatch.delenv(_MEASUREMENT_ORDER_ENV, raising=False)
+    else:
+        monkeypatch.setenv(_MEASUREMENT_ORDER_ENV, configured)
+
+    assert _measurement_order() == expected
+
+
+@pytest.mark.diffusion
+@pytest.mark.core_model
+@pytest.mark.cpu
+def test_measurement_order_rejects_unknown_value(monkeypatch) -> None:
+    monkeypatch.setenv(_MEASUREMENT_ORDER_ENV, "unknown")
+
+    with pytest.raises(ValueError, match=_MEASUREMENT_ORDER_ENV):
+        _measurement_order()
+
+
+@pytest.mark.diffusion
+@pytest.mark.core_model
+@pytest.mark.cpu
+@pytest.mark.parametrize(
+    ("audio_no_offload", "audio_offload", "message"),
+    [
+        (None, None, "Baseline Stable Audio inference returned no audio"),
+        (None, np.zeros(1), "Baseline Stable Audio inference returned no audio"),
+        (np.zeros(1), None, "Layerwise-offloaded Stable Audio inference returned no audio"),
+    ],
+)
+def test_stable_audio_requires_both_outputs(audio_no_offload, audio_offload, message) -> None:
+    with pytest.raises(AssertionError, match=message):
+        _assert_audio_outputs("stabilityai/stable-audio-open-1.0", audio_no_offload, audio_offload)
+
+
+@pytest.mark.diffusion
+@pytest.mark.parametrize(
+    "model_name",
+    [pytest.param(name, marks=MODEL_MARKS[name]) for name in MODELS],
+)
 def test_layerwise_offload_diffusion_model(model_name: str):
     """Test that layerwise offloading reduces GPU memory usage.
 
@@ -130,14 +327,15 @@ def test_layerwise_offload_diffusion_model(model_name: str):
     offloader keeps only a single transformer block on GPU at a time, with
     prefetching for compute-memory overlap.
     """
+    measurements: dict[bool, dict[str, Any]] = {}
     try:
-        # Run without layerwise offloading (baseline)
-        no_offload_peak_memory, output_no_offload = run_inference(model_name, layerwise_offload=False)
-        cleanup_dist_env_and_memory()
-
-        # Run with layerwise offloading (1 layer on device)
-        layerwise_offload_peak_memory, output_offload = run_inference(model_name, layerwise_offload=True)
-        cleanup_dist_env_and_memory()
+        measurement_order = _measurement_order()
+        print(
+            "Measurement order: "
+            + " -> ".join("layerwise-offload" if enabled else "baseline" for enabled in measurement_order)
+        )
+        for enabled in measurement_order:
+            measurements[enabled] = run_inference_isolated(model_name, layerwise_offload=enabled)
     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):
@@ -145,20 +343,18 @@ def test_layerwise_offload_diffusion_model(model_name: str):
                 f"Skipping: gated HF repo {model_name!r} inaccessible "
                 f"({exc}). See docs/contributing/ci/hf_credentials.md."
             )
-        pytest.fail(f"Inference failed: {exc}")
-    except Exception:
-        pytest.fail("Inference failed")
+        raise
 
-    print(f"Layerwise offload peak memory (1 GPU layer): {layerwise_offload_peak_memory} MB")
-    print(f"No offload peak memory: {no_offload_peak_memory} MB")
+    no_offload = measurements[False]
+    layerwise_offload = measurements[True]
+    _assert_offload_state(no_offload, expected_enabled=False)
+    _assert_offload_state(layerwise_offload, expected_enabled=True)
+    _print_measurement("No offload", no_offload)
+    _print_measurement("Layerwise offload", layerwise_offload)
 
-    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")
-        # Match the sibling cpu-offload test's tolerance: layerwise offload moves
-        # blocks across the PCIe bus on a side stream, which can perturb cuBLAS
-        # algorithm selection and produce ~ULP-level drift larger than 1e-3.
-        check_audio_determinism(audio_offload, audio_no_offload, atol=1e-2)
+    audio_no_offload = no_offload["audio"]
+    audio_offload = layerwise_offload["audio"]
+    _assert_audio_outputs(model_name, audio_no_offload, audio_offload)
 
     is_rocm = torch.version.hip is not None
     platform = "rocm" if is_rocm else "cuda"
@@ -170,6 +366,8 @@ def test_layerwise_offload_diffusion_model(model_name: str):
 
     # Verify that layerwise offloading significantly reduces memory usage
     # Passes only if the actual savings meets the expected savings
+    no_offload_peak_memory = no_offload["incremental_peak_mb"]
+    layerwise_offload_peak_memory = layerwise_offload["incremental_peak_mb"]
     actual_saved_memory = no_offload_peak_memory - layerwise_offload_peak_memory
     assert layerwise_offload_peak_memory + expected_saved_memory <= no_offload_peak_memory, (
         f"Layerwise offload peak memory {layerwise_offload_peak_memory} 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/offloader/test_layerwise_backend.py b/tests/diffusion/offloader/test_layerwise_backend.py
index 099e93f79..4c965adaa 100644
--- a/tests/diffusion/offloader/test_layerwise_backend.py
+++ b/tests/diffusion/offloader/test_layerwise_backend.py
@@ -24,6 +24,11 @@ from tests.diffusion.offloader.helpers import (
     patch_offload_runtime,
 )
 from vllm_omni.diffusion.offloader.base import OffloadConfig, OffloadStrategy
+from vllm_omni.diffusion.offloader.block_discovery import (
+    get_blocks_attr_names,
+    get_blocks_from_dit,
+    set_blocks_attr_names,
+)
 from vllm_omni.diffusion.offloader.layerwise_backend import (
     LayerWiseOffloadBackend,
     LayerwiseOffloadHook,
@@ -209,21 +214,21 @@ class _NoAttrsModel(nn.Module):
 class TestGetBlocksFromDit:
     def test_get_blocks_from_dit_single_block_attr(self):
         model = _SingleBlockModel(num_blocks=3)
-        attr_names, blocks = LayerWiseOffloadBackend.get_blocks_from_dit(model)
+        attr_names, blocks = get_blocks_from_dit(model)
         assert attr_names == ["blocks"]
         assert len(blocks) == 3
         assert all(isinstance(b, _DummyBlock) for b in blocks)
 
     def test_get_blocks_from_dit_multi_block_attrs(self):
         model = _MultiBlockModel(num_transformer=2, num_single=3)
-        attr_names, blocks = LayerWiseOffloadBackend.get_blocks_from_dit(model)
+        attr_names, blocks = get_blocks_from_dit(model)
         assert set(attr_names) == {"transformer_blocks", "single_transformer_blocks"}
         assert len(blocks) == 5
         assert all(isinstance(b, _DummyBlock) for b in blocks)
 
     def test_get_blocks_from_dit_empty_blocks(self):
         model = _EmptyBlocksModel()
-        attr_names, blocks = LayerWiseOffloadBackend.get_blocks_from_dit(model)
+        attr_names, blocks = get_blocks_from_dit(model)
         assert attr_names == []
         assert blocks == []
 
@@ -233,17 +238,17 @@ class TestGetBlocksFromDit:
             AttributeError,
             match="Attribute 'nonexistent_blocks' declared in _layerwise_offload_blocks_attrs does not exist",
         ):
-            LayerWiseOffloadBackend.get_blocks_from_dit(model)
+            get_blocks_from_dit(model)
 
     def test_get_blocks_from_dit_no_attrs_defined(self):
         model = _NoAttrsModel(num_blocks=3)
-        attr_names, blocks = LayerWiseOffloadBackend.get_blocks_from_dit(model)
+        attr_names, blocks = get_blocks_from_dit(model)
         assert attr_names == []
         assert blocks == []
 
     def test_get_blocks_from_dit_deprecated_single_attr(self):
         model = _DeprecatedSingleAttrModel(num_blocks=2)
-        attr_names, blocks = LayerWiseOffloadBackend.get_blocks_from_dit(model)
+        attr_names, blocks = get_blocks_from_dit(model)
         assert attr_names == ["blocks"]
         assert len(blocks) == 2
 
@@ -251,17 +256,17 @@ class TestGetBlocksFromDit:
 class TestGetBlocksAttrNames:
     def test_get_blocks_attr_names_new_format(self):
         model = _MultiBlockModel()
-        attrs = LayerWiseOffloadBackend.get_blocks_attr_names(model)
+        attrs = get_blocks_attr_names(model)
         assert attrs == ["transformer_blocks", "single_transformer_blocks"]
 
     def test_get_blocks_attr_names_no_attrs(self):
         model = _NoAttrsModel()
-        attrs = LayerWiseOffloadBackend.get_blocks_attr_names(model)
+        attrs = get_blocks_attr_names(model)
         assert attrs == []
 
     def test_set_blocks_attr_names(self):
         model = _NoAttrsModel()
-        LayerWiseOffloadBackend.set_blocks_attr_names(model, ["new_blocks"])
+        set_blocks_attr_names(model, ["new_blocks"])
         assert hasattr(model.__class__, "_layerwise_offload_blocks_attrs")
         assert model.__class__._layerwise_offload_blocks_attrs == ["new_blocks"]
 
diff --git a/tests/diffusion/quantization/test_cosmos3_mixed_precision.py b/tests/diffusion/quantization/test_cosmos3_mixed_precision.py
new file mode 100644
index 000000000..026090fe9
--- /dev/null
+++ b/tests/diffusion/quantization/test_cosmos3_mixed_precision.py
@@ -0,0 +1,690 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+import pytest
+import torch
+
+from vllm_omni.diffusion.models.cosmos3.mixed_precision import (
+    Cosmos3MixedPrecisionConfig,
+    Cosmos3MixedPrecisionRuntime,
+    resolve_mixed_precision_config,
+)
+from vllm_omni.diffusion.models.cosmos3.mixed_precision import runtime as runtime_impl
+from vllm_omni.diffusion.models.cosmos3.mixed_precision.checkpoint import read_checkpoint_policy
+from vllm_omni.diffusion.models.cosmos3.mixed_precision.runtime import (
+    Cosmos3MixedPrecisionLinearMethod,
+)
+from vllm_omni.diffusion.models.cosmos3.mixed_precision.strategy import (
+    Fp8W8A8W8A16Strategy,
+    Nvfp4W4A4W4A16Strategy,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+
+def _policy(
+    *,
+    first_steps: int = 3,
+    last_steps: int = 3,
+    reasoner: str = "a16",
+    scope: list[str] | None = None,
+) -> dict[str, object]:
+    return {
+        "schema_version": 1,
+        "type": "first_last_n",
+        "index_space": "denoising_loop_iteration",
+        "scope": scope or ["transformer"],
+        "default_mode": "native",
+        "first_steps": {"count": first_steps, "mode": "a16"},
+        "last_steps": {"count": last_steps, "mode": "a16"},
+        "overlap": "a16",
+        "reasoner": reasoner,
+    }
+
+
+def _fake_quant_config(name: str, *, serialized: bool = True):
+    if name == "modelopt":
+        return SimpleNamespace(
+            get_name=lambda: name,
+            is_checkpoint_fp8_serialized=serialized,
+        )
+    if name == "modelopt_fp4":
+        return SimpleNamespace(
+            get_name=lambda: name,
+            quant_method="NVFP4",
+            is_checkpoint_nvfp4_serialized=serialized,
+        )
+    return SimpleNamespace(get_name=lambda: name)
+
+
+def _checkpoint_od_config(
+    quant_config,
+    *,
+    policy: object | None = None,
+    additional_config: dict[str, object] | None = None,
+):
+    quant_config_name = quant_config.get_name()
+    quant_algo = {
+        "modelopt": "FP8",
+        "modelopt_fp4": "NVFP4",
+    }.get(quant_config_name, "FP8")
+    disk_quant_config: dict[str, object] = {
+        "quant_method": quant_config_name,
+        "quant_algo": quant_algo,
+    }
+    if policy is not None:
+        disk_quant_config["runtime"] = {"diffusion_step_policy": policy}
+    return SimpleNamespace(
+        quantization_config=quant_config,
+        tf_model_config=SimpleNamespace(
+            params={"quantization_config": disk_quant_config},
+            quant_config=quant_config,
+        ),
+        additional_config=additional_config,
+    )
+
+
+def _swizzle_blockscale_cpu(scale: torch.Tensor) -> torch.Tensor:
+    rows, cols = scale.shape
+    padded_rows = ((rows + 127) // 128) * 128
+    padded_cols = ((cols + 3) // 4) * 4
+    padded = torch.zeros(
+        (1, padded_rows, padded_cols),
+        dtype=scale.dtype,
+        device=scale.device,
+    )
+    padded[0, :rows, :cols] = scale
+    padded = padded.reshape(1, padded_rows // 128, 4, 32, padded_cols // 4, 4)
+    return (
+        padded.permute(0, 1, 4, 3, 2, 5)
+        .contiguous()
+        .reshape(
+            padded_rows,
+            padded_cols,
+        )
+    )
+
+
+def test_config_parses_nested_schedule_and_reasoner_policy() -> None:
+    config = Cosmos3MixedPrecisionConfig.from_additional_config(
+        {
+            "cosmos3_mixed_precision": {
+                "first_steps": 2,
+                "last_steps": 4,
+                "reasoner": "native",
+            }
+        }
+    )
+
+    assert config is not None
+    assert config.reasoner == "native"
+    assert [index for index in range(10) if config.use_high_precision(index, 10)] == [0, 1, 6, 7, 8, 9]
+
+
+@pytest.mark.parametrize(
+    ("first_steps", "last_steps", "selected"),
+    [
+        (0, 2, [5, 6]),
+        (2, 0, [0, 1]),
+        (0, 0, []),
+        (4, 4, list(range(7))),
+    ],
+)
+def test_schedule_boundaries_and_overlap(
+    first_steps: int,
+    last_steps: int,
+    selected: list[int],
+) -> None:
+    config = Cosmos3MixedPrecisionConfig(
+        first_steps=first_steps,
+        last_steps=last_steps,
+    )
+    assert [index for index in range(7) if config.use_high_precision(index, 7)] == selected
+
+
+def test_one_step_request_honors_boundary_precision() -> None:
+    config = Cosmos3MixedPrecisionConfig(first_steps=1, last_steps=1)
+    assert config.use_high_precision(0, 1)
+
+
+@pytest.mark.parametrize(
+    ("values", "message"),
+    [
+        ({"cosmos3_mixed_precision": True}, "must be a mapping"),
+        ({"cosmos3_mixed_precision": {"first_steps": -1}}, "non-negative"),
+        ({"cosmos3_mixed_precision": {"reasoner": "fp16"}}, "must be one of"),
+        ({"cosmos3_mixed_precision": {"enabled": 0}}, "must be a boolean"),
+        (
+            {"cosmos3_mixed_precision": {"enabled": False, "first_steps": 1}},
+            "cannot be combined",
+        ),
+        ({"cosmos3_mixed_precision": {"unknown": 1}}, "Unknown"),
+    ],
+)
+def test_config_rejects_invalid_values(values: dict, message: str) -> None:
+    with pytest.raises((TypeError, ValueError), match=message):
+        Cosmos3MixedPrecisionConfig.from_additional_config(values)
+
+
+def test_config_presence_enables_defaults() -> None:
+    assert Cosmos3MixedPrecisionConfig.from_additional_config({}) is None
+    config = Cosmos3MixedPrecisionConfig.from_additional_config({"cosmos3_mixed_precision": {}})
+    assert config == Cosmos3MixedPrecisionConfig()
+
+
+def test_noop_config_does_not_install_runtime() -> None:
+    assert (
+        Cosmos3MixedPrecisionConfig.from_additional_config(
+            {
+                "cosmos3_mixed_precision": {
+                    "first_steps": 0,
+                    "last_steps": 0,
+                    "reasoner": "native",
+                }
+            }
+        )
+        is None
+    )
+
+
+def test_additional_config_distinguishes_absent_and_disabled() -> None:
+    assert Cosmos3MixedPrecisionConfig.resolve_additional_config({}) == (False, None)
+    assert Cosmos3MixedPrecisionConfig.resolve_additional_config({"cosmos3_mixed_precision": {"enabled": False}}) == (
+        True,
+        None,
+    )
+    assert Cosmos3MixedPrecisionConfig.resolve_additional_config(
+        {
+            "cosmos3_mixed_precision": {
+                "first_steps": 0,
+                "last_steps": 0,
+                "reasoner": "native",
+            }
+        }
+    ) == (True, None)
+
+
+def test_checkpoint_policy_round_trip_through_transformer_config() -> None:
+    from vllm_omni.diffusion.data import TransformerConfig
+
+    disk = {
+        "_class_name": "Cosmos3VFMTransformer",
+        "quantization_config": {
+            "quant_method": "modelopt",
+            "quant_algo": "FP8",
+            "runtime": {"diffusion_step_policy": _policy(first_steps=2, last_steps=4)},
+        },
+    }
+
+    tf_config = TransformerConfig.from_dict(disk)
+    assert tf_config.quant_config is not None
+    assert tf_config.quant_config.get_name() == "modelopt"
+    assert tf_config.to_dict()["quantization_config"]["runtime"] == disk["quantization_config"]["runtime"]
+    assert read_checkpoint_policy(SimpleNamespace(tf_model_config=tf_config)) == Cosmos3MixedPrecisionConfig(
+        first_steps=2,
+        last_steps=4,
+        reasoner="a16",
+    )
+
+
+@pytest.mark.parametrize("name", ["modelopt", "modelopt_fp4"])
+def test_checkpoint_policy_supports_serialized_modelopt_formats(name: str) -> None:
+    od_config = _checkpoint_od_config(_fake_quant_config(name), policy=_policy())
+    assert read_checkpoint_policy(od_config) == Cosmos3MixedPrecisionConfig()
+
+
+@pytest.mark.parametrize("name", ["modelopt", "modelopt_fp4"])
+def test_checkpoint_policy_rejects_nonserialized_modelopt_formats(name: str) -> None:
+    od_config = _checkpoint_od_config(
+        _fake_quant_config(name, serialized=False),
+        policy=_policy(),
+    )
+    with pytest.raises(ValueError, match="serialized ModelOpt"):
+        read_checkpoint_policy(od_config)
+
+
+def test_checkpoint_policy_rejects_mixed_modelopt_format() -> None:
+    with pytest.raises(ValueError, match="serialized ModelOpt FP8 or NVFP4"):
+        read_checkpoint_policy(_checkpoint_od_config(_fake_quant_config("modelopt_mixed"), policy=_policy()))
+
+
+def test_checkpoint_policy_missing_metadata_preserves_ordinary_path() -> None:
+    assert read_checkpoint_policy(_checkpoint_od_config(_fake_quant_config("modelopt"))) is None
+
+
+def test_checkpoint_policy_rejects_malformed_runtime_container() -> None:
+    od_config = _checkpoint_od_config(_fake_quant_config("modelopt"))
+    od_config.tf_model_config.params["quantization_config"]["runtime"] = True
+    with pytest.raises(TypeError, match="runtime must be a mapping"):
+        read_checkpoint_policy(od_config)
+
+
+@pytest.mark.parametrize(
+    ("field", "value", "message"),
+    [
+        ("schema_version", 2, "schema_version"),
+        ("type", "sigma_ranges", "type"),
+        ("index_space", "scheduler_timestep", "index_space"),
+        ("default_mode", "a16", "default_mode"),
+        ("overlap", "native", "overlap"),
+        ("reasoner", "fp16", "reasoner"),
+    ],
+)
+def test_checkpoint_policy_rejects_invalid_schema(field: str, value: object, message: str) -> None:
+    policy = _policy()
+    policy[field] = value
+    with pytest.raises(ValueError, match=message):
+        read_checkpoint_policy(_checkpoint_od_config(_fake_quant_config("modelopt"), policy=policy))
+
+
+@pytest.mark.parametrize(
+    ("step_range", "message"),
+    [
+        ({"count": -1, "mode": "a16"}, "non-negative"),
+        ({"count": True, "mode": "a16"}, "non-negative"),
+        ({"count": 1, "mode": "native"}, "mode"),
+        ({"mode": "a16"}, "Missing"),
+        ({"count": 1, "mode": "a16", "sigma": 1.0}, "Unknown"),
+    ],
+)
+def test_checkpoint_policy_rejects_invalid_step_range(step_range: object, message: str) -> None:
+    policy = _policy()
+    policy["first_steps"] = step_range
+    with pytest.raises((TypeError, ValueError), match=message):
+        read_checkpoint_policy(_checkpoint_od_config(_fake_quant_config("modelopt"), policy=policy))
+
+
+def test_checkpoint_policy_rejects_unsupported_quantization_config() -> None:
+    with pytest.raises(ValueError, match="serialized ModelOpt FP8 or NVFP4"):
+        read_checkpoint_policy(_checkpoint_od_config(_fake_quant_config("compressed-tensors"), policy=_policy()))
+
+
+def test_checkpoint_policy_for_other_scope_is_not_applied() -> None:
+    od_config = _checkpoint_od_config(
+        _fake_quant_config("modelopt"),
+        policy=_policy(scope=["vae"]),
+    )
+    assert read_checkpoint_policy(od_config) is None
+
+
+def test_additional_config_overrides_and_disables_checkpoint_policy() -> None:
+    checkpoint = _checkpoint_od_config(
+        _fake_quant_config("modelopt"),
+        policy=_policy(first_steps=1, last_steps=1),
+    )
+    assert resolve_mixed_precision_config(checkpoint) == (
+        Cosmos3MixedPrecisionConfig(first_steps=1, last_steps=1),
+        "checkpoint",
+    )
+
+    checkpoint.additional_config = {
+        "cosmos3_mixed_precision": {
+            "first_steps": 2,
+            "last_steps": 0,
+            "reasoner": "native",
+        }
+    }
+    assert resolve_mixed_precision_config(checkpoint) == (
+        Cosmos3MixedPrecisionConfig(first_steps=2, last_steps=0, reasoner="native"),
+        "additional_config",
+    )
+
+    checkpoint.additional_config = {"cosmos3_mixed_precision": {"enabled": False}}
+    assert resolve_mixed_precision_config(checkpoint) == (None, "additional_config_disabled")
+
+
+@pytest.mark.parametrize("name", ["modelopt", "modelopt_fp4"])
+def test_additional_config_supports_serialized_modelopt_formats_without_checkpoint_policy(name: str) -> None:
+    od_config = _checkpoint_od_config(
+        _fake_quant_config(name),
+        additional_config={"cosmos3_mixed_precision": {}},
+    )
+    assert resolve_mixed_precision_config(od_config) == (Cosmos3MixedPrecisionConfig(), "additional_config")
+
+
+@pytest.mark.parametrize("has_checkpoint_policy", [False, True])
+@pytest.mark.parametrize(
+    ("name", "serialized"),
+    [
+        ("modelopt_mixed", True),
+        ("mxfp8", True),
+        ("compressed-tensors", True),
+        ("modelopt", False),
+        ("modelopt_fp4", False),
+    ],
+)
+def test_additional_config_rejects_incompatible_quantization(
+    name: str, serialized: bool, has_checkpoint_policy: bool
+) -> None:
+    od_config = _checkpoint_od_config(
+        _fake_quant_config(name, serialized=serialized),
+        policy=_policy() if has_checkpoint_policy else None,
+        additional_config={"cosmos3_mixed_precision": {}},
+    )
+    with pytest.raises(ValueError, match="serialized ModelOpt"):
+        resolve_mixed_precision_config(od_config)
+
+
+@pytest.mark.parametrize("additional_config", [None, {"cosmos3_mixed_precision": {}}])
+def test_policy_validates_effective_quantization_config(additional_config: dict[str, object] | None) -> None:
+    od_config = _checkpoint_od_config(
+        _fake_quant_config("modelopt"),
+        policy=_policy(),
+        additional_config=additional_config,
+    )
+    od_config.quantization_config = _fake_quant_config("modelopt_mixed")
+    with pytest.raises(ValueError, match="serialized ModelOpt FP8 or NVFP4"):
+        resolve_mixed_precision_config(od_config)
+
+
+def test_additional_config_rejects_missing_quantization_config() -> None:
+    od_config = SimpleNamespace(additional_config={"cosmos3_mixed_precision": {}})
+    with pytest.raises(ValueError, match="serialized ModelOpt FP8 or NVFP4"):
+        resolve_mixed_precision_config(od_config)
+
+
+@pytest.mark.parametrize("policy", [_policy(), True])
+def test_additional_config_disable_bypasses_incompatible_checkpoint(policy: object) -> None:
+    od_config = _checkpoint_od_config(
+        _fake_quant_config("modelopt_mixed"),
+        policy=policy,
+        additional_config={"cosmos3_mixed_precision": {"enabled": False}},
+    )
+    od_config.quantization_config = _fake_quant_config("modelopt_mixed")
+    assert resolve_mixed_precision_config(od_config) == (None, "additional_config_disabled")
+
+
+def test_runtime_allows_standard_offload_and_rejects_distributed(monkeypatch) -> None:
+    from vllm_omni.diffusion.models.cosmos3 import transformer_cosmos3
+
+    monkeypatch.setattr(
+        transformer_cosmos3,
+        "get_tensor_model_parallel_world_size",
+        lambda: 1,
+    )
+    od_config = SimpleNamespace(
+        enable_cpu_offload=True,
+        enable_layerwise_offload=True,
+        enable_distributed_layerwise_offload=False,
+        parallel_config=SimpleNamespace(use_hsdp=False),
+    )
+    transformer_cosmos3._validate_mixed_precision_runtime(
+        Cosmos3MixedPrecisionConfig(),
+        od_config,
+    )
+    od_config.enable_distributed_layerwise_offload = True
+    with pytest.raises(ValueError, match="distributed layer-wise offload"):
+        transformer_cosmos3._validate_mixed_precision_runtime(
+            Cosmos3MixedPrecisionConfig(),
+            od_config,
+        )
+    od_config.enable_distributed_layerwise_offload = False
+    od_config.max_num_seqs = 2
+    with pytest.raises(ValueError, match="one active request"):
+        transformer_cosmos3._validate_mixed_precision_runtime(
+            Cosmos3MixedPrecisionConfig(),
+            od_config,
+        )
+
+
+class _Layer(torch.nn.Module):
+    def __init__(self, output_size: int, input_size: int) -> None:
+        super().__init__()
+        self.output_size_per_partition = output_size
+        self.input_size_per_partition = input_size
+
+
+class _BaseMethod:
+    def __init__(self, *, nvfp4: bool = False) -> None:
+        self.processed = False
+        self.apply_calls = 0
+        self.fp8_linear = object()
+        if nvfp4:
+            from vllm.model_executor.kernels.linear.nvfp4.cutlass import (
+                CutlassNvFp4LinearKernel,
+            )
+
+            self.kernel = object.__new__(CutlassNvFp4LinearKernel)
+        else:
+            self.kernel = None
+
+    def create_weights(self, *args, **kwargs) -> None:
+        pass
+
+    def process_weights_after_loading(self, layer) -> None:
+        self.processed = True
+        if layer.weight.dtype == torch.float8_e4m3fn:
+            layer.weight = layer.weight.t().contiguous()
+            layer.weight_scale = layer.weight_scale.max().reshape(1)
+        elif layer.weight.dtype == torch.uint8:
+            layer.weight_scale = _swizzle_blockscale_cpu(layer.weight_scale)
+            layer.weight_global_scale = layer.weight_scale_2.max().float().reshape(1)
+            del layer.weight_scale_2
+
+    def apply(self, layer, x, bias=None):
+        del bias
+        self.apply_calls += 1
+        return torch.full(
+            (*x.shape[:-1], layer.output_size_per_partition),
+            17,
+            dtype=x.dtype,
+            device=x.device,
+        )
+
+
+def _fp8_layer(output_size: int = 2, input_size: int = 4) -> _Layer:
+    layer = _Layer(output_size, input_size)
+    layer.weight = torch.ones(output_size, input_size, dtype=torch.float8_e4m3fn)
+    layer.weight_scale = torch.tensor([0.5], dtype=torch.float32)
+    return layer
+
+
+def _nvfp4_layer(output_size: int = 128, input_size: int = 64) -> _Layer:
+    layer = _Layer(output_size, input_size)
+    layer.weight = torch.full((output_size, input_size // 2), 0x22, dtype=torch.uint8)
+    layer.weight_scale = torch.ones(output_size, input_size // 16, dtype=torch.float8_e4m3fn)
+    layer.weight_scale_2 = torch.ones(1)
+    return layer
+
+
+def _runtime_and_method(
+    strategy,
+    layer: _Layer,
+    *,
+    path: str = "generation",
+    reasoner: str = "native",
+):
+    config = Cosmos3MixedPrecisionConfig(
+        first_steps=1,
+        last_steps=1,
+        reasoner=reasoner,
+    )
+    runtime = Cosmos3MixedPrecisionRuntime(config)
+    base = _BaseMethod(nvfp4=isinstance(strategy, Nvfp4W4A4W4A16Strategy))
+    method = Cosmos3MixedPrecisionLinearMethod(
+        base,
+        strategy,
+        runtime,
+        f"{path}.linear",
+        path,
+    )
+    method.process_weights_after_loading(layer)
+    return runtime, base, method
+
+
+@pytest.mark.parametrize(
+    ("strategy", "layer"),
+    [
+        (Fp8W8A8W8A16Strategy(), _fp8_layer()),
+        (Nvfp4W4A4W4A16Strategy(), _nvfp4_layer()),
+    ],
+)
+def test_generation_dispatches_native_middle_and_a16_edges(strategy, layer) -> None:
+    runtime, base, method = _runtime_and_method(strategy, layer)
+    x = torch.ones(1, layer.input_size_per_partition, dtype=torch.bfloat16)
+
+    runtime.set_step(1, 3)
+    assert torch.equal(
+        method.apply(layer, x),
+        torch.full((1, layer.output_size_per_partition), 17, dtype=x.dtype),
+    )
+    runtime.set_step(0, 3)
+    assert torch.equal(
+        method.apply(layer, x),
+        torch.nn.functional.linear(x, strategy.materialize(layer)),
+    )
+    assert base.apply_calls == 1
+
+
+@pytest.mark.parametrize(
+    ("strategy", "layer"),
+    [
+        (Fp8W8A8W8A16Strategy(), _fp8_layer()),
+        (Nvfp4W4A4W4A16Strategy(), _nvfp4_layer()),
+    ],
+)
+def test_a16_uses_only_live_native_weights(strategy, layer) -> None:
+    runtime, base, method = _runtime_and_method(strategy, layer)
+    assert base.processed
+    assert not hasattr(layer, "_cosmos3_precision_weight")
+    assert not hasattr(layer, "_cosmos3_precision_weight_scale")
+
+    runtime.set_step(0, 3)
+    output = method.apply(
+        layer,
+        torch.ones(1, layer.input_size_per_partition, dtype=torch.bfloat16),
+    )
+    assert output.shape == (1, layer.output_size_per_partition)
+
+
+def test_a16_follows_live_weight_storage_after_offload_rebinding() -> None:
+    layer = _fp8_layer()
+    strategy = Fp8W8A8W8A16Strategy()
+    runtime, _, method = _runtime_and_method(strategy, layer)
+    runtime.set_step(0, 3)
+    x = torch.ones(1, 4, dtype=torch.bfloat16)
+    before = method.apply(layer, x)
+
+    layer.weight = torch.zeros_like(layer.weight)
+    after = method.apply(layer, x)
+    assert not torch.equal(before, after)
+    assert torch.count_nonzero(after) == 0
+
+
+def test_fp8_rejects_smoothquant() -> None:
+    layer = _fp8_layer()
+    layer.pre_quant_scale = torch.ones(1)
+    with pytest.raises(ValueError, match="SmoothQuant"):
+        Fp8W8A8W8A16Strategy().validate_before_processing(
+            _BaseMethod(),
+            layer,
+            "gen.linear",
+        )
+
+
+def test_fp8_rejects_non_tensorwise_scales() -> None:
+    layer = _fp8_layer(output_size=3, input_size=2)
+    layer.weight_scale = torch.tensor([[1.0], [2.0], [3.0]])
+    with pytest.raises(ValueError, match="tensorwise FP8"):
+        Fp8W8A8W8A16Strategy().validate_before_processing(
+            _BaseMethod(),
+            layer,
+            "gen.linear",
+        )
+
+
+def test_nvfp4_reference_materializes_live_cutlass_weights() -> None:
+    layer = _nvfp4_layer()
+    strategy = Nvfp4W4A4W4A16Strategy()
+    _runtime_and_method(strategy, layer)
+    output = strategy.materialize(layer)
+    assert output.shape == (128, 64)
+    assert torch.equal(output, torch.ones_like(output))
+
+
+def test_nvfp4_rejects_fused_global_scales() -> None:
+    layer = _nvfp4_layer()
+    layer.weight_scale_2 = torch.tensor([1.0, 2.0])
+    strategy = Nvfp4W4A4W4A16Strategy()
+    with pytest.raises(ValueError, match="NVFP4 scales"):
+        strategy.validate_before_processing(
+            _BaseMethod(nvfp4=True),
+            layer,
+            "gen.qkv",
+        )
+
+
+@pytest.mark.parametrize(
+    ("policy", "uses_native"),
+    [("a16", False), ("native", True)],
+)
+def test_reasoner_policy_is_independent_of_generation_step(
+    policy: str,
+    uses_native: bool,
+) -> None:
+    layer = _fp8_layer()
+    runtime, base, method = _runtime_and_method(
+        Fp8W8A8W8A16Strategy(),
+        layer,
+        path="reasoner",
+        reasoner=policy,
+    )
+    runtime.set_step(1, 3)
+    method.apply(layer, torch.ones(1, 4, dtype=torch.bfloat16))
+    assert (base.apply_calls == 1) is uses_native
+
+
+def test_reset_clears_generation_state() -> None:
+    runtime = Cosmos3MixedPrecisionRuntime(Cosmos3MixedPrecisionConfig(first_steps=1, last_steps=1))
+    runtime.set_step(0, 5)
+    assert runtime.use_high_precision("generation")
+    runtime.reset()
+    assert not runtime.use_high_precision("generation")
+
+
+def test_install_discovers_generation_and_opt_in_reasoner(monkeypatch) -> None:
+    class _FakeLinear(torch.nn.Module):
+        def __init__(self, prefix: str) -> None:
+            super().__init__()
+            self.prefix = prefix
+            self.input_size_per_partition = 4
+            self.output_size_per_partition = 2
+            self.quant_method = SimpleNamespace(name="fp8")
+
+    monkeypatch.setattr(runtime_impl, "LinearBase", _FakeLinear)
+    strategy = Fp8W8A8W8A16Strategy()
+    monkeypatch.setattr(strategy, "accepts", lambda method: getattr(method, "name", None) == "fp8")
+    monkeypatch.setattr(runtime_impl, "_STRATEGIES", (strategy,))
+    runtime = Cosmos3MixedPrecisionRuntime(Cosmos3MixedPrecisionConfig(reasoner="a16"))
+    reasoner = _FakeLinear("reasoner.q_proj")
+    generation = [
+        _FakeLinear("generation.q_proj"),
+        _FakeLinear("generation.out_proj"),
+    ]
+    transformer = SimpleNamespace(
+        language_model=SimpleNamespace(layers=torch.nn.Sequential(reasoner)),
+        gen_layers=torch.nn.Sequential(*generation),
+    )
+    runtime.install(transformer)
+    assert isinstance(reasoner.quant_method, Cosmos3MixedPrecisionLinearMethod)
+    assert all(isinstance(layer.quant_method, Cosmos3MixedPrecisionLinearMethod) for layer in generation)
+
+
+def test_pipeline_helpers_forward_and_reset_schedule() -> None:
+    from vllm_omni.diffusion.models.cosmos3.pipeline_cosmos3 import (
+        Cosmos3OmniDiffusersPipeline,
+    )
+
+    calls = []
+    pipeline = object.__new__(Cosmos3OmniDiffusersPipeline)
+    pipeline.transformer = SimpleNamespace(
+        set_mixed_precision_step=lambda step, count: calls.append((step, count)),
+        reset_mixed_precision=lambda: calls.append("reset"),
+    )
+    pipeline._set_mixed_precision_step(2, 7)
+    pipeline._reset_mixed_precision()
+    assert calls == [(2, 7), "reset"]
diff --git a/tests/diffusion/quantization/test_gguf_diffusion.py b/tests/diffusion/quantization/test_gguf_diffusion.py
index ad2e72edc..dc91a1e40 100644
--- a/tests/diffusion/quantization/test_gguf_diffusion.py
+++ b/tests/diffusion/quantization/test_gguf_diffusion.py
@@ -109,7 +109,7 @@ def _generate_single_stage_image(
     return images, peak_mem
 
 
-@hardware_test(res={"cuda": "L4"})
+@hardware_test(res={"cuda": ["L4", "B200"]})
 @pytest.mark.full_model
 @pytest.mark.diffusion
 @pytest.mark.parametrize("model", [Z_IMAGE_CONFIG, FLUX_CONFIG], ids=["Z-Image-Turbo", "FLUX.2-klein"])
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 5793ad95c..9f41a6a89 100644
--- a/tests/diffusion/quantization/test_quantization_fp8.py
+++ b/tests/diffusion/quantization/test_quantization_fp8.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
 """
 End-to-end tests for the unified quantization framework (PR #1764).
 
@@ -270,7 +270,7 @@ def _generate_bagel_image(
 # ─── Single-stage diffusion model tests ──────────────────────────────────────
 
 
-@hardware_test(res={"cuda": "L4"})
+@hardware_test(res={"cuda": ["L4", "B200"]})
 def test_single_stage_zimage_fp8():
     """Z-Image-Turbo with FP8 generates valid images."""
     images, _ = _generate_single_stage_image(
@@ -281,7 +281,7 @@ def test_single_stage_zimage_fp8():
     images[0].save("test_zimage_fp8.png")
 
 
-@hardware_test(res={"cuda": "L4"})
+@hardware_test(res={"cuda": ["L4", "B200"]})
 def test_single_stage_zimage_fp8_uses_less_memory():
     """FP8 should use less peak memory than BF16 for Z-Image-Turbo."""
     _, mem_bf16 = _generate_single_stage_image(
@@ -300,7 +300,7 @@ def test_single_stage_zimage_fp8_uses_less_memory():
     assert mem_fp8 < mem_bf16, f"FP8 ({mem_fp8:.2f} GiB) should use less memory than BF16 ({mem_bf16:.2f} GiB)"
 
 
-@hardware_test(res={"cuda": "L4", "xpu": "B60"})
+@hardware_test(res={"cuda": ["L4", "B200"], "xpu": "B60"})
 @pytest.mark.advanced_model
 def test_single_stage_qwen_image_fp8():
     """Qwen-Image (random weights) with FP8 generates valid images."""
@@ -316,7 +316,7 @@ def test_single_stage_qwen_image_fp8():
     images[0].save("test_qwen_image_fp8.png")
 
 
-@hardware_test(res={"cuda": "H100"})
+@hardware_test(res={"cuda": ["H100", "B200"]})
 @pytest.mark.skip(reason="This model is not authorized on Hugging Face Hub yet")
 def test_single_stage_flux_fp8():
     """FLUX.1-dev with FP8 generates valid images."""
@@ -331,7 +331,7 @@ def test_single_stage_flux_fp8():
     images[0].save("test_flux_fp8.png")
 
 
-@hardware_test(res={"cuda": "H100"})
+@hardware_test(res={"cuda": ["H100", "B200"]})
 @pytest.mark.skip(reason="This model is not authorized on Hugging Face Hub yet")
 def test_single_stage_flux_fp8_uses_less_memory():
     """FP8 should use less peak memory than BF16 for FLUX.1-dev."""
@@ -357,7 +357,7 @@ def test_single_stage_flux_fp8_uses_less_memory():
     assert mem_fp8 < mem_bf16, f"FP8 ({mem_fp8:.2f} GiB) should use less memory than BF16 ({mem_bf16:.2f} GiB)"
 
 
-@hardware_test(res={"cuda": "H100"})
+@hardware_test(res={"cuda": ["H100", "B200"]})
 def test_single_stage_ltx2_fp8_uses_less_memory():
     """FP8 should use less peak memory than BF16 for LTX-2."""
     _, mem_bf16 = _generate_single_stage_video(
@@ -379,7 +379,7 @@ def test_single_stage_ltx2_fp8_uses_less_memory():
 # ─── Multi-stage model tests (BAGEL) ─────────────────────────────────────────
 
 
-@hardware_test(res={"cuda": "H100"})
+@hardware_test(res={"cuda": ["H100", "B200"]})
 def test_bagel_fp8_generates_image():
     """BAGEL with diffusion-stage FP8 generates a valid image.
 
@@ -392,7 +392,7 @@ def test_bagel_fp8_generates_image():
     image.save("test_bagel_fp8.png")
 
 
-@hardware_test(res={"cuda": "H100"})
+@hardware_test(res={"cuda": ["H100", "B200"]})
 def test_bagel_bf16_generates_image():
     """BAGEL without quantization generates a valid image (baseline)."""
     image, _ = _generate_bagel_image(diffusion_quantization_config=None)
@@ -402,7 +402,7 @@ def test_bagel_bf16_generates_image():
 # ─── Quantization config routing tests ────────────────────────────────────────
 
 
-@hardware_test(res={"cuda": "L4"})
+@hardware_test(res={"cuda": ["L4", "B200"]})
 def test_quantization_key_maps_to_quantization_config():
     """The old 'quantization' kwarg should map to 'quantization_config'
     in OmniDiffusionConfig.from_kwargs for backwards compatibility."""
@@ -413,22 +413,20 @@ def test_quantization_key_maps_to_quantization_config():
     assert config.quantization_config.get_name() == "fp8"
 
 
-@hardware_test(res={"cuda": "L4"})
-def test_quantization_config_key_takes_priority():
-    """When both 'quantization' and 'quantization_config' are set,
-    'quantization_config' takes priority."""
+@hardware_test(res={"cuda": ["L4", "B200"]})
+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"})
+@hardware_test(res={"cuda": ["L4", "B200"]})
 def test_single_stage_quantization_config_key():
     """Single-stage model using quantization_config (dict) key generates images."""
     images, _ = _generate_single_stage_image(
diff --git a/tests/diffusion/quantization/test_quantization_quality.py b/tests/diffusion/quantization/test_quantization_quality.py
index 47908daa0..4bace0da5 100644
--- a/tests/diffusion/quantization/test_quantization_quality.py
+++ b/tests/diffusion/quantization/test_quantization_quality.py
@@ -45,6 +45,7 @@ import pytest
 import torch
 from PIL import Image
 
+from tests.e2e.accuracy.helpers import resolve_device_threshold
 from tests.helpers.mark import hardware_marks
 
 _REPO_ROOT = Path(__file__).resolve().parents[3]
@@ -70,7 +71,7 @@ class QualityTestConfig:
     id: str  # pytest ID, e.g. "fp8_z_image"
     task: str  # "t2i" or "t2v"
     prompt: str  # generation prompt
-    max_lpips: float  # fail threshold — higher = more lenient
+    max_lpips: float | dict[str, float]  # threshold, or {"H100": 0.15, "B200": 0.17}
     model: str | None = None  # HF model name
     quantization: str | dict[str, object] | None = None  # quantization method/config, e.g. "fp8"
     baseline_model: str | None = None  # explicit BF16/local baseline path
@@ -80,7 +81,6 @@ class QualityTestConfig:
     num_inference_steps: int = 20  # keep low for CI speed
     num_frames: int = 5  # only for t2v
     seed: int = 42
-    gpu: str = "H100"  # minimum GPU requirement
     negative_prompt: str | None = ""
     guidance_scale: float | None = None
     sigmas: list[float] | None = None
@@ -190,7 +190,7 @@ QUALITY_CONFIGS = [
         quantization={"text_encoder": "fp8", "transformer": None, "vae": None},
         task="t2i",
         prompt="a cup of coffee on a wooden table, morning light",
-        max_lpips=0.15,
+        max_lpips={"H100": 0.15, "B200": 0.17},
         num_inference_steps=10,
         enable_cpu_offload=True,
         height=1024,
@@ -528,7 +528,7 @@ def test_ltx_quality_gate_uses_official_eager_defaults(monkeypatch):
     assert captured.sampling.guidance_scale is None
 
 
-_marks = hardware_marks(res={"cuda": "H100"})
+_marks = hardware_marks(res={"cuda": ["H100", "B200"]})
 _OUTPUT_DIR = Path(os.environ["VLLM_OMNI_QUALITY_OUTPUT_DIR"]) if "VLLM_OMNI_QUALITY_OUTPUT_DIR" in os.environ else None
 
 
@@ -588,8 +588,9 @@ def test_quantization_quality(config: QualityTestConfig):
     # --- Similarity metrics ---
     lpips_score = _compute_lpips(baseline_out, quant_out, config.task)
     psnr_score, mae_score = _compute_psnr_and_mae(baseline_out, quant_out, config.task)
-    assert lpips_score <= config.max_lpips, (
-        f"LPIPS {lpips_score:.4f} exceeds threshold {config.max_lpips} "
+    gpu_key, max_lpips = resolve_device_threshold(config.max_lpips, label=f"{config.id} max_lpips")
+    assert lpips_score <= max_lpips, (
+        f"LPIPS {lpips_score:.4f} exceeds threshold {max_lpips} ({gpu_key}) "
         f"for {config.quantization_ref() or 'pre-quantized checkpoint'} on {config.quantized_ref()}"
     )
 
@@ -601,12 +602,12 @@ def test_quantization_quality(config: QualityTestConfig):
     print(f"  Baseline:      {config.baseline_ref()}")
     print(f"  Quantized:     {config.quantized_ref()}")
     print(f"  Method:        {config.quantization_ref() or 'pre-quantized checkpoint'}")
-    print(f"  LPIPS:         {lpips_score:.4f}  (threshold: {config.max_lpips})")
+    print(f"  LPIPS:         {lpips_score:.4f}  (threshold: {max_lpips}, gpu: {gpu_key})")
     print(f"  PSNR:          {psnr_score:.4f} dB  (higher is better)")
     print(f"  MAE:           {mae_score:.6f}  (lower is better)")
     print(f"  BF16 memory:   {bl_mem:.2f} GiB")
     print(f"  Quant memory:  {qt_mem:.2f} GiB  ({mem_reduction:.0f}% reduction)")
-    print(f"  Result:        {'PASS' if lpips_score <= config.max_lpips else 'FAIL'}")
+    print(f"  Result:        {'PASS' if lpips_score <= max_lpips else 'FAIL'}")
     print(f"{'=' * 60}\n")
 
     assert np.isfinite(psnr_score) or np.isinf(psnr_score), f"PSNR is invalid for {config.id}: {psnr_score}"
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_diffusion_streaming_output.py b/tests/diffusion/streaming_interactive_generation/test_diffusion_streaming_output.py
index c833ae7a1..e0b0a6c53 100644
--- a/tests/diffusion/streaming_interactive_generation/test_diffusion_streaming_output.py
+++ b/tests/diffusion/streaming_interactive_generation/test_diffusion_streaming_output.py
@@ -39,7 +39,8 @@ from vllm_omni.distributed.omni_connectors.utils.serialization import (
 from vllm_omni.engine.async_omni_engine import StageRuntimeInfo
 from vllm_omni.engine.messages import ShutdownRequestMessage, StageSubmissionMessage
 from vllm_omni.engine.stage_init_utils import StageMetadata
-from vllm_omni.entrypoints.async_omni import AsyncEventResolver, AsyncOmni
+from vllm_omni.entrypoints.async_omni import AsyncOmni
+from vllm_omni.entrypoints.async_omni_base import AsyncEventResolver
 from vllm_omni.entrypoints.openai.serving_video_output_stream import OmniStreamingVideoOutputHandler
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 from vllm_omni.outputs import OmniRequestOutput
diff --git a/tests/diffusion/streaming_interactive_generation/test_prompt_interaction.py b/tests/diffusion/streaming_interactive_generation/test_prompt_interaction.py
index 2e5ceb8e2..d3b46a00d 100644
--- a/tests/diffusion/streaming_interactive_generation/test_prompt_interaction.py
+++ b/tests/diffusion/streaming_interactive_generation/test_prompt_interaction.py
@@ -42,7 +42,8 @@ from vllm_omni.engine.orchestrator import Orchestrator, OrchestratorRequestState
 from vllm_omni.engine.stage_client import StagePoolClient
 from vllm_omni.engine.stage_init_utils import StageMetadata
 from vllm_omni.engine.stage_pool import StagePool
-from vllm_omni.entrypoints.async_omni import AsyncEventResolver, AsyncOmni
+from vllm_omni.entrypoints.async_omni import AsyncOmni
+from vllm_omni.entrypoints.async_omni_base import AsyncEventResolver
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams, OmniInteractionPrompt
 from vllm_omni.outputs import OmniRequestOutput
 
@@ -77,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
 
 
@@ -108,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
 
 
@@ -154,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())
 
@@ -167,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,
@@ -366,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_async_output_worker.py b/tests/diffusion/test_async_output_worker.py
index a4bff4625..8a81f30d4 100644
--- a/tests/diffusion/test_async_output_worker.py
+++ b/tests/diffusion/test_async_output_worker.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 WorkerProc async output logic."""
 
 import queue
@@ -8,13 +8,23 @@ import time
 from unittest.mock import MagicMock
 
 import pytest
+import torch
 
+import vllm_omni.diffusion.ipc as diffusion_ipc
 from vllm_omni.diffusion.data import (
     AsyncDiffusionOutput,
     AsyncOutputKind,
     DiffusionOutput,
     OmniACK,
 )
+from vllm_omni.diffusion.media import (
+    DiffusionMediaOutput,
+    VideoMediaOutput,
+    VideoTensorEncoding,
+    VideoTensorLayout,
+    VideoTensorSpec,
+    VideoValueRange,
+)
 from vllm_omni.diffusion.worker.diffusion_worker import WorkerProc
 from vllm_omni.diffusion.worker.utils import BatchRunnerOutput, RunnerOutput
 
@@ -182,6 +192,66 @@ class TestReturnResultSyncPath:
         mock_pack.assert_called_once_with(output)
         proc.result_mq.enqueue.assert_called_once_with(output)
 
+    def test_media_contract_error_is_not_sent_as_an_unpacked_result(self, mocker):
+        proc = _make_worker_proc(step_execution=True)
+        proc._async_output_queue = None
+        mocker.patch(
+            "vllm_omni.diffusion.worker.diffusion_worker.pack_diffusion_output_shm",
+            side_effect=ValueError("media was not prepared"),
+        )
+
+        with pytest.raises(ValueError, match="media was not prepared"):
+            proc._return_result(DiffusionOutput())
+
+        proc.result_mq.enqueue.assert_not_called()
+
+    def test_media_packing_memory_failure_is_reraised_for_typed_media(self, mocker):
+        """A non-ValueError packing failure on typed media must re-raise, not
+        swallow it and enqueue a half-packed payload."""
+        proc = _make_worker_proc(step_execution=True)
+        proc._async_output_queue = None
+        mocker.patch(
+            "vllm_omni.diffusion.worker.diffusion_worker.pack_diffusion_output_shm",
+            side_effect=RuntimeError("SHM pack out of memory"),
+        )
+
+        output = DiffusionOutput(media=MagicMock(spec=DiffusionMediaOutput))
+        with pytest.raises(RuntimeError, match="SHM pack out of memory"):
+            proc._return_result(output)
+
+        proc.result_mq.enqueue.assert_not_called()
+
+    def test_media_packing_failure_is_reraised_for_dp_container(self, mocker):
+        """Container dispatch and typed-media failure detection share a walker."""
+        proc = _make_worker_proc(step_execution=True)
+        proc._async_output_queue = None
+        mocker.patch(
+            "vllm_omni.diffusion.worker.diffusion_worker.pack_diffusion_output_shm",
+            side_effect=RuntimeError("SHM pack out of memory"),
+        )
+
+        output = DiffusionOutput(media=MagicMock(spec=DiffusionMediaOutput))
+        tagged_output = {"dp_rank": 0, "output": output}
+        with pytest.raises(RuntimeError, match="SHM pack out of memory"):
+            proc._return_result(tagged_output)
+
+        proc.result_mq.enqueue.assert_not_called()
+
+    def test_legacy_output_packing_failure_is_still_swallowed(self, mocker):
+        """Non-typed (legacy output) failures keep the historic swallow-and-
+        enqueue behavior; only typed media re-raises."""
+        proc = _make_worker_proc(step_execution=True)
+        proc._async_output_queue = None
+        mocker.patch(
+            "vllm_omni.diffusion.worker.diffusion_worker.pack_diffusion_output_shm",
+            side_effect=RuntimeError("SHM pack out of memory"),
+        )
+
+        proc._return_result(DiffusionOutput(output="data"))
+
+        # Legacy path: warning logged, output still enqueued once.
+        proc.result_mq.enqueue.assert_called_once_with(DiffusionOutput(output="data"))
+
     def test_non_diffusion_output_skips_async_in_request_mode(self, mocker):
         """Non-DiffusionOutput/BatchRunnerOutput in request mode uses sync path."""
         proc = _make_worker_proc(step_execution=False)
@@ -243,6 +313,70 @@ class TestAsyncOutputLoopLogic:
         )
         assert output_ready_enqueued, "Expected OUTPUT_READY with async_output_id='abc123' in enqueue calls"
 
+    def test_late_field_failure_sends_error_without_partial_payload_or_shm_leak(
+        self,
+        mocker,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        from multiprocessing import shared_memory
+
+        proc = _make_worker_proc(step_execution=False)
+        media = DiffusionMediaOutput(
+            video=VideoMediaOutput(
+                tensor=torch.zeros(1, 3, 2, 4, 5),
+                spec=VideoTensorSpec(
+                    layout=VideoTensorLayout.BCTHW,
+                    encoding=VideoTensorEncoding.NORMALIZED_FLOAT,
+                    value_range=VideoValueRange.NEGATIVE_ONE_TO_ONE,
+                ),
+            ),
+            prepared_for_transport=True,
+        )
+        output = DiffusionOutput(media=media, trajectory_latents=torch.ones(30))
+        original_latents = output.trajectory_latents
+
+        real_array_to_shm = diffusion_ipc._array_to_shm
+        created_handles: list[dict[str, object]] = []
+
+        def _fail_on_second(array):
+            if created_handles:
+                raise RuntimeError("late-field packing failure")
+            handle = real_array_to_shm(array)
+            created_handles.append(handle)
+            return handle
+
+        monkeypatch.setattr(diffusion_ipc, "_SHM_TENSOR_THRESHOLD", 1)
+        monkeypatch.setattr(diffusion_ipc, "_array_to_shm", _fail_on_second)
+
+        def _pack_without_stream(value, d2h_stream=None):
+            # The worker loop behavior is under test here. CPU tensors avoid
+            # introducing a device dependency into this unit test.
+            del d2h_stream
+            return diffusion_ipc.pack_diffusion_output_shm(value)
+
+        mocker.patch(
+            "vllm_omni.diffusion.worker.diffusion_worker.pack_diffusion_output_shm",
+            side_effect=_pack_without_stream,
+        )
+        mock_torch = mocker.MagicMock()
+        mock_torch.accelerator.current_accelerator.return_value.type = "cpu"
+        mocker.patch("vllm_omni.diffusion.worker.diffusion_worker.torch", mock_torch)
+
+        proc._async_output_queue.put((output, "late-failure", None))
+        proc._async_output_queue.put(None)
+        proc._async_output_loop()
+
+        messages = [call.args[0] for call in proc.result_mq.enqueue.call_args_list]
+        assert len(messages) == 1
+        assert messages[0].kind is AsyncOutputKind.OUTPUT_READY
+        assert messages[0].async_output_id == "late-failure"
+        assert messages[0].error == "Background D2H/SHM packing failed"
+        assert messages[0].output is None
+        assert output.media is media
+        assert output.trajectory_latents is original_latents
+        with pytest.raises(FileNotFoundError):
+            shared_memory.SharedMemory(name=str(created_handles[0]["name"]))
+
 
 class TestDrainAsyncOutputs:
     """Async outputs must finish packing before device memory is released."""
diff --git a/tests/diffusion/test_device_output_preparation.py b/tests/diffusion/test_device_output_preparation.py
new file mode 100644
index 000000000..0a6f1ab90
--- /dev/null
+++ b/tests/diffusion/test_device_output_preparation.py
@@ -0,0 +1,460 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from __future__ import annotations
+
+from dataclasses import FrozenInstanceError
+
+import numpy as np
+import pytest
+import torch
+
+import vllm_omni.diffusion.ipc as diffusion_ipc
+import vllm_omni.diffusion.postprocess.device_reduction as device_reduction
+from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig, VideoOutputTransportConfig
+from vllm_omni.diffusion.ipc import pack_diffusion_output_shm, unpack_diffusion_output_shm
+from vllm_omni.diffusion.media import (
+    DiffusionMediaOutput,
+    FloatVideoConsumer,
+    VideoMediaOutput,
+    VideoTensorEncoding,
+    VideoTensorLayout,
+    VideoTensorSpec,
+    VideoTransportConstraints,
+    VideoValueRange,
+    ensure_request_owned_tensor,
+    slice_diffusion_media_output,
+)
+from vllm_omni.diffusion.postprocess.device_reduction import prepare_diffusion_media_for_transport
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+
+def _config(*, enabled: bool) -> OmniDiffusionConfig:
+    return OmniDiffusionConfig(
+        model=None,
+        video_output_transport=VideoOutputTransportConfig(enable_device_postprocess=enabled),
+    )
+
+
+def _sampling(*, output_type: str | None = "np", interpolate: bool = False) -> OmniDiffusionSamplingParams:
+    return OmniDiffusionSamplingParams(
+        output_type=output_type,
+        enable_frame_interpolation=interpolate,
+    )
+
+
+def _media(
+    tensor: torch.Tensor,
+    *,
+    value_range: VideoValueRange = VideoValueRange.NEGATIVE_ONE_TO_ONE,
+    consumers: frozenset[FloatVideoConsumer] = frozenset(),
+) -> DiffusionMediaOutput:
+    return DiffusionMediaOutput(
+        video=VideoMediaOutput(
+            tensor=tensor,
+            spec=VideoTensorSpec(
+                layout=VideoTensorLayout.BCTHW,
+                encoding=VideoTensorEncoding.NORMALIZED_FLOAT,
+                value_range=value_range,
+            ),
+            constraints=VideoTransportConstraints(pending_float_consumers=consumers),
+        )
+    )
+
+
+def test_runtime_prepares_request_local_video_as_uint8() -> None:
+    video = torch.linspace(-1.0, 1.0, 2 * 3 * 2 * 4 * 5).reshape(2, 3, 2, 4, 5)
+
+    prepared = prepare_diffusion_media_for_transport(
+        _media(video),
+        od_config=_config(enabled=True),
+        sampling_params=_sampling(),
+    )
+
+    assert prepared.prepared_for_transport is True
+    assert prepared.video.tensor.dtype == torch.uint8
+    assert prepared.video.tensor.shape == (2, 2, 4, 5, 3)
+    assert prepared.video.spec == VideoTensorSpec(
+        layout=VideoTensorLayout.BTHWC,
+        encoding=VideoTensorEncoding.UINT8_FRAMES,
+        value_range=VideoValueRange.ZERO_TO_255,
+    )
+    assert prepared.video.constraints.pending_float_consumers == frozenset()
+
+
+def test_disabled_runtime_preserves_float_but_marks_media_prepared() -> None:
+    video = torch.randn(1, 3, 2, 4, 5)
+
+    prepared = prepare_diffusion_media_for_transport(
+        _media(video),
+        od_config=_config(enabled=False),
+        sampling_params=_sampling(),
+    )
+
+    assert prepared.prepared_for_transport is True
+    assert prepared.video.tensor is video
+    assert prepared.video.spec.encoding is VideoTensorEncoding.NORMALIZED_FLOAT
+
+
+def test_device_oom_falls_back_to_request_owned_float_media(monkeypatch: pytest.MonkeyPatch) -> None:
+    source = torch.randn(2, 3, 2, 4, 5)
+    sliced = slice_diffusion_media_output(_media(source), 0, 1)
+
+    def raise_oom(video: torch.Tensor, *, do_denormalize: bool) -> torch.Tensor:
+        raise torch.OutOfMemoryError("injected")
+
+    monkeypatch.setattr(device_reduction, "reduce_video_to_uint8_frames", raise_oom)
+
+    prepared = prepare_diffusion_media_for_transport(
+        sliced,
+        od_config=_config(enabled=True),
+        sampling_params=_sampling(),
+    )
+
+    assert prepared.prepared_for_transport is True
+    assert prepared.video.spec.encoding is VideoTensorEncoding.NORMALIZED_FLOAT
+    assert prepared.video.tensor.dtype == source.dtype
+    assert prepared.video.tensor.shape == (1, 3, 2, 4, 5)
+    assert prepared.video.tensor.is_contiguous()
+    assert prepared.video.tensor._base is None
+
+
+def test_device_non_oom_error_is_not_swallowed(monkeypatch: pytest.MonkeyPatch) -> None:
+    def raise_runtime_error(video: torch.Tensor, *, do_denormalize: bool) -> torch.Tensor:
+        raise RuntimeError("injected")
+
+    monkeypatch.setattr(device_reduction, "reduce_video_to_uint8_frames", raise_runtime_error)
+
+    with pytest.raises(RuntimeError, match="injected"):
+        prepare_diffusion_media_for_transport(
+            _media(torch.randn(1, 3, 2, 4, 5)),
+            od_config=_config(enabled=True),
+            sampling_params=_sampling(),
+        )
+
+
+def test_declared_and_request_float_consumers_are_unioned() -> None:
+    video = torch.randn(1, 3, 2, 4, 5)
+    media = _media(
+        video,
+        consumers=frozenset({FloatVideoConsumer.VIDEO_GUARDRAILS}),
+    )
+
+    prepared = prepare_diffusion_media_for_transport(
+        media,
+        od_config=_config(enabled=True),
+        sampling_params=_sampling(interpolate=True),
+    )
+
+    assert prepared.video.tensor is video
+    assert prepared.video.constraints.pending_float_consumers == frozenset(
+        {
+            FloatVideoConsumer.FRAME_INTERPOLATION,
+            FloatVideoConsumer.VIDEO_GUARDRAILS,
+        }
+    )
+
+
+def test_non_numpy_presentation_preserves_float() -> None:
+    prepared = prepare_diffusion_media_for_transport(
+        _media(torch.randn(1, 3, 2, 4, 5)),
+        od_config=_config(enabled=True),
+        sampling_params=_sampling(output_type="pil"),
+    )
+
+    assert prepared.prepared_for_transport is True
+    assert prepared.video.spec.encoding is VideoTensorEncoding.NORMALIZED_FLOAT
+
+
+def test_zero_to_one_video_is_not_denormalized() -> None:
+    video = torch.tensor([[[[[0.0, 0.5, 1.0]]]]]).expand(1, 3, 1, 1, 3)
+
+    prepared = prepare_diffusion_media_for_transport(
+        _media(video, value_range=VideoValueRange.ZERO_TO_ONE),
+        od_config=_config(enabled=True),
+        sampling_params=_sampling(),
+    )
+
+    expected = np.rint(video.permute(0, 2, 3, 4, 1).numpy() * 255.0).astype(np.uint8)
+    np.testing.assert_array_equal(prepared.video.tensor.numpy(), expected)
+
+
+def test_invalid_contract_raises_even_when_feature_is_off() -> None:
+    media = _media(torch.randn(3, 2, 4, 5))
+
+    with pytest.raises(ValueError, match="rank 5"):
+        prepare_diffusion_media_for_transport(
+            media,
+            od_config=_config(enabled=False),
+            sampling_params=_sampling(),
+        )
+
+
+@pytest.mark.parametrize(
+    ("tensor", "spec", "message"),
+    [
+        (
+            torch.randn(1, 2, 4, 5, 3),
+            VideoTensorSpec(
+                layout=VideoTensorLayout.BTHWC,
+                encoding=VideoTensorEncoding.UINT8_FRAMES,
+                value_range=VideoValueRange.ZERO_TO_255,
+            ),
+            "torch.uint8",
+        ),
+        (
+            torch.zeros(1, 2, 4, 5, 3, dtype=torch.uint8),
+            VideoTensorSpec(
+                layout=VideoTensorLayout.BTHWC,
+                encoding=VideoTensorEncoding.UINT8_FRAMES,
+                value_range=VideoValueRange.ZERO_TO_ONE,
+            ),
+            "incompatible value range",
+        ),
+        (
+            torch.randn(1, 4, 2, 4, 5),
+            VideoTensorSpec(
+                layout=VideoTensorLayout.BCTHW,
+                encoding=VideoTensorEncoding.NORMALIZED_FLOAT,
+                value_range=VideoValueRange.NEGATIVE_ONE_TO_ONE,
+            ),
+            "3 channels",
+        ),
+    ],
+)
+def test_invalid_spec_tensor_combinations_are_contract_errors(
+    tensor: torch.Tensor,
+    spec: VideoTensorSpec,
+    message: str,
+) -> None:
+    media = DiffusionMediaOutput(video=VideoMediaOutput(tensor=tensor, spec=spec))
+
+    with pytest.raises(ValueError, match=message):
+        media.validate()
+
+
+def test_pipeline_cannot_emit_unprepared_uint8_media() -> None:
+    media = DiffusionMediaOutput(
+        video=VideoMediaOutput(
+            tensor=torch.zeros(1, 2, 4, 5, 3, dtype=torch.uint8),
+            spec=VideoTensorSpec(
+                layout=VideoTensorLayout.BTHWC,
+                encoding=VideoTensorEncoding.UINT8_FRAMES,
+                value_range=VideoValueRange.ZERO_TO_255,
+            ),
+        )
+    )
+
+    with pytest.raises(ValueError, match="must emit unprepared media as NORMALIZED_FLOAT"):
+        prepare_diffusion_media_for_transport(
+            media,
+            od_config=_config(enabled=True),
+            sampling_params=_sampling(),
+        )
+
+
+def test_descriptors_are_immutable() -> None:
+    media = _media(torch.randn(1, 3, 2, 4, 5))
+
+    with pytest.raises(FrozenInstanceError):
+        media.prepared_for_transport = True  # type: ignore[misc]
+    with pytest.raises(FrozenInstanceError):
+        media.video.spec.layout = VideoTensorLayout.BTHWC  # type: ignore[misc]
+
+
+def test_float_fallback_detaches_a_request_view_before_transport() -> None:
+    source = torch.randn(4, 3, 2, 4, 5)
+    sliced = slice_diffusion_media_output(_media(source), 1, 3)
+
+    prepared = prepare_diffusion_media_for_transport(
+        sliced,
+        od_config=_config(enabled=False),
+        sampling_params=_sampling(),
+    )
+
+    tensor = prepared.video.tensor
+    assert tensor.shape == (2, 3, 2, 4, 5)
+    assert tensor.is_contiguous()
+    assert tensor._base is None
+    assert tensor.untyped_storage().nbytes() == tensor.numel() * tensor.element_size()
+    assert tensor.untyped_storage().data_ptr() != source.untyped_storage().data_ptr()
+
+
+def test_full_batch_slice_does_not_duplicate_owned_storage() -> None:
+    source = torch.randn(2, 3, 2, 4, 5)
+
+    sliced = slice_diffusion_media_output(_media(source), 0, 2)
+
+    assert sliced.video.tensor.untyped_storage().data_ptr() == source.untyped_storage().data_ptr()
+
+
+def test_diffusion_output_to_cpu_moves_prepared_typed_media() -> None:
+    prepared = prepare_diffusion_media_for_transport(
+        _media(torch.randn(1, 3, 2, 4, 5)),
+        od_config=_config(enabled=False),
+        sampling_params=_sampling(),
+    )
+    output = DiffusionOutput(media=prepared, to_cpu=True)
+
+    assert output.media is not None
+    assert output.media.video.tensor.device.type == "cpu"
+
+
+def test_diffusion_output_to_cpu_rejects_unprepared_media() -> None:
+    with pytest.raises(ValueError, match="prepared before to_cpu"):
+        DiffusionOutput(media=_media(torch.randn(1, 3, 2, 4, 5)), to_cpu=True)
+
+
+def test_prepared_media_round_trips_through_typed_ipc(monkeypatch: pytest.MonkeyPatch) -> None:
+    expected = prepare_diffusion_media_for_transport(
+        _media(torch.randn(1, 3, 2, 256, 256)),
+        od_config=_config(enabled=True),
+        sampling_params=_sampling(),
+    )
+    output = DiffusionOutput(media=expected)
+
+    monkeypatch.setattr(diffusion_ipc, "_SHM_TENSOR_THRESHOLD", 1)
+    pack_diffusion_output_shm(output)
+
+    assert isinstance(output.media, dict)
+    assert output.media["__type__"] == "diffusion_media_v1"
+    assert output.media["video"]["tensor"]["__tensor_shm__"] is True
+
+    unpack_diffusion_output_shm(output)
+
+    assert isinstance(output.media, DiffusionMediaOutput)
+    assert output.media.prepared_for_transport is True
+    assert output.media.video.spec == expected.video.spec
+    torch.testing.assert_close(output.media.video.tensor, expected.video.tensor)
+
+
+def test_float_media_constraints_round_trip_through_typed_ipc(monkeypatch: pytest.MonkeyPatch) -> None:
+    expected = prepare_diffusion_media_for_transport(
+        _media(torch.randn(1, 3, 2, 256, 256, dtype=torch.bfloat16)),
+        od_config=_config(enabled=True),
+        sampling_params=_sampling(interpolate=True),
+    )
+    output = DiffusionOutput(media=expected)
+
+    monkeypatch.setattr(diffusion_ipc, "_SHM_TENSOR_THRESHOLD", 1)
+    pack_diffusion_output_shm(output)
+    unpack_diffusion_output_shm(output)
+
+    assert isinstance(output.media, DiffusionMediaOutput)
+    assert output.media.video.tensor.dtype is torch.bfloat16
+    assert output.media.video.constraints.pending_float_consumers == frozenset({FloatVideoConsumer.FRAME_INTERPOLATION})
+    torch.testing.assert_close(output.media.video.tensor, expected.video.tensor)
+
+
+def test_ipc_rejects_media_that_skipped_runner_preparation() -> None:
+    output = DiffusionOutput(media=_media(torch.randn(1, 3, 2, 4, 5)))
+
+    with pytest.raises(ValueError, match="must be prepared"):
+        pack_diffusion_output_shm(output)
+
+
+def test_ipc_rejects_unknown_media_schema_version() -> None:
+    prepared = prepare_diffusion_media_for_transport(
+        _media(torch.randn(1, 3, 2, 4, 5)),
+        od_config=_config(enabled=False),
+        sampling_params=_sampling(),
+    )
+    output = DiffusionOutput(media=prepared)
+    pack_diffusion_output_shm(output)
+    assert isinstance(output.media, dict)
+    output.media["schema_version"] = 2
+
+    with pytest.raises(ValueError, match="schema version"):
+        unpack_diffusion_output_shm(output)
+
+
+def test_prepare_rejects_media_a_pipeline_already_prepared(monkeypatch: pytest.MonkeyPatch) -> None:
+    # A pipeline must emit unprepared media so the runner applies request policy
+    # (e.g. frame interpolation). Accepting a forged prepared uint8 payload would
+    # skip the interpolation constraint; interpolator never runs and gets dropped.
+    forged = DiffusionMediaOutput(
+        video=VideoMediaOutput(
+            tensor=torch.zeros(1, 2, 4, 5, 3, dtype=torch.uint8),
+            spec=VideoTensorSpec(
+                layout=VideoTensorLayout.BTHWC,
+                encoding=VideoTensorEncoding.UINT8_FRAMES,
+                value_range=VideoValueRange.ZERO_TO_255,
+            ),
+        ),
+        prepared_for_transport=True,
+    )
+
+    with pytest.raises(ValueError, match="already prepared"):
+        prepare_diffusion_media_for_transport(
+            forged,
+            od_config=_config(enabled=True),
+            sampling_params=_sampling(interpolate=True),
+        )
+
+
+def test_prepare_rejects_prepared_media_despite_pending_interpolation(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    # The forged payload is the exact case the reviewer described: device
+    # postprocessing enabled plus frame_interpolation, but the media already being
+    # prepared. It must be rejected, not silently returned with interpolation dropped.
+    forged = DiffusionMediaOutput(
+        video=VideoMediaOutput(
+            tensor=torch.zeros(1, 3, 2, 2, 3, dtype=torch.float32),
+            spec=VideoTensorSpec(
+                layout=VideoTensorLayout.BCTHW,
+                encoding=VideoTensorEncoding.NORMALIZED_FLOAT,
+                value_range=VideoValueRange.NEGATIVE_ONE_TO_ONE,
+            ),
+        ),
+        prepared_for_transport=True,
+    )
+
+    with pytest.raises(ValueError, match="already prepared"):
+        prepare_diffusion_media_for_transport(
+            forged,
+            od_config=_config(enabled=True),
+            sampling_params=_sampling(interpolate=True),
+        )
+
+
+def test_request_owned_tensor_rejects_a_detached_storage_view() -> None:
+    # ``tensor._base is None`` is not proof of ownership: a detached slice keeps a
+    # nonzero storage offset and the whole source storage. Serializing it would
+    # leak every other request's pixels, so it must be cloned before transport.
+    source = torch.randn(4, 3, 2, 4, 5)
+    detached_slice = source[1:2].detach()
+    assert detached_slice.is_contiguous()
+    assert detached_slice._base is None
+    assert detached_slice.storage_offset() != 0
+
+    owned = ensure_request_owned_tensor(detached_slice)
+
+    assert owned.shape == detached_slice.shape
+    assert owned.storage_offset() == 0
+    assert owned.untyped_storage().nbytes() == owned.numel() * owned.element_size()
+    assert owned.untyped_storage().data_ptr() != source.untyped_storage().data_ptr()
+    torch.testing.assert_close(owned, detached_slice)
+
+
+def test_prepared_media_rejects_non_compact_request_storage() -> None:
+    # A zero-offset view of a bigger buffer is contiguous but not compact, so
+    # prepared transport must refuse it just as it refuses a storage view.
+    source = torch.randn(2, 3, 2, 4, 5)
+    zero_offset_view = source[0:1]
+    media = DiffusionMediaOutput(
+        video=VideoMediaOutput(
+            tensor=zero_offset_view,
+            spec=VideoTensorSpec(
+                layout=VideoTensorLayout.BCTHW,
+                encoding=VideoTensorEncoding.NORMALIZED_FLOAT,
+                value_range=VideoValueRange.NEGATIVE_ONE_TO_ONE,
+            ),
+        ),
+        prepared_for_transport=True,
+    )
+
+    with pytest.raises(ValueError, match="request-local storage"):
+        media.validate()
diff --git a/tests/diffusion/test_device_reduction.py b/tests/diffusion/test_device_reduction.py
new file mode 100644
index 000000000..f69bb5eb5
--- /dev/null
+++ b/tests/diffusion/test_device_reduction.py
@@ -0,0 +1,125 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""GPU correctness/size tests for device-side video reduction.
+
+The reduction must be byte-identical to the current production output (SHM
+widens bf16->f32, then diffusers postprocess, then the API server's ``*255``
+rounding), otherwise enabling it would silently change pixels.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+import torch
+
+from tests.helpers.mark import hardware_marks
+from vllm_omni.diffusion.postprocess.device_reduction import reduce_video_to_uint8_frames
+
+pytestmark = [
+    pytest.mark.core_model,
+    pytest.mark.diffusion,
+    *hardware_marks(res={"cuda": "L4"}, num_cards=1),
+]
+
+_GPU = torch.accelerator.is_available() if hasattr(torch, "accelerator") else torch.cuda.is_available()
+requires_gpu = pytest.mark.skipif(not _GPU, reason="device reduction is a GPU path")
+
+
+def _device() -> str:
+    return "cuda:0"
+
+
+def _reference_uint8(video: torch.Tensor, *, compute_dtype: torch.dtype | None = torch.float32) -> np.ndarray:
+    """The diffusers postprocess plus the API server's rounding, for the same input.
+
+    ``compute_dtype`` selects the precision the denormalize runs at.
+    ``torch.float32`` is the precision the device reduction uses; ``None`` keeps
+    the input's own dtype, which is what the engine's postprocess actually does.
+    """
+    from diffusers.video_processor import VideoProcessor
+
+    source = video if compute_dtype is None else video.to(compute_dtype)
+    processed = VideoProcessor(vae_scale_factor=8).postprocess_video(source, output_type="np")
+    scaled = np.clip(processed.astype(np.float32), 0.0, 1.0) * 255.0
+    np.rint(scaled, out=scaled)
+    return scaled.astype(np.uint8)
+
+
+@requires_gpu
+@pytest.mark.parametrize("dtype", [torch.bfloat16, torch.float16, torch.float32])
+def test_device_reduction_matches_a_float32_reference(dtype: torch.dtype) -> None:
+    """The reduction must be the float32 computation, exactly, for every input dtype."""
+    torch.manual_seed(0)
+    # Values slightly outside [-1, 1] so the clamp is actually exercised.
+    video = (torch.rand(1, 3, 8, 64, 96, device=_device()) * 2.4 - 1.2).to(dtype)
+
+    reference = _reference_uint8(video)
+    produced = reduce_video_to_uint8_frames(video).cpu().numpy()
+
+    assert produced.shape == reference.shape == (1, 8, 64, 96, 3)
+    assert produced.dtype == np.uint8
+    np.testing.assert_array_equal(produced, reference)
+
+
+@requires_gpu
+@pytest.mark.parametrize("dtype", [torch.bfloat16, torch.float16])
+def test_device_reduction_deviates_from_a_narrow_postprocess_by_at_most_one(dtype: torch.dtype) -> None:
+    """Pin the cost of computing in float32: at most one 255th.
+
+    A postprocess that denormalizes in the VAE's own dtype (WAN, HunyuanVideo,
+    LTX-2, Cosmos3) does not match this reduction bit for bit; ~20% of pixels
+    differ by one on a real 480x832x81 WAN generation. Keep that a bound rather
+    than a surprise, so a regression widening it fails here.
+    """
+    torch.manual_seed(0)
+    video = (torch.rand(1, 3, 8, 64, 96, device=_device()) * 2.4 - 1.2).to(dtype)
+
+    narrow = _reference_uint8(video, compute_dtype=None)
+    produced = reduce_video_to_uint8_frames(video).cpu().numpy()
+
+    deviation = np.abs(produced.astype(np.int16) - narrow.astype(np.int16))
+    assert deviation.max() <= 1
+    # The narrow path really is different, so the bound above is not vacuous.
+    assert deviation.any()
+
+
+@requires_gpu
+def test_device_reduction_shrinks_hop1_payload_4x() -> None:
+    """The whole point: the D2H payload drops from float32 to uint8 (4x)."""
+    video = torch.rand(1, 3, 8, 704, 1280, device=_device(), dtype=torch.bfloat16) * 2 - 1
+
+    # Production transports bf16 widened to float32 over SHM.
+    widened_f32_bytes = video.numel() * 4
+    reduced = reduce_video_to_uint8_frames(video)
+    reduced_bytes = reduced.numel() * reduced.element_size()
+
+    assert reduced.dtype == torch.uint8
+    assert widened_f32_bytes / reduced_bytes == pytest.approx(4.0, rel=1e-6)
+
+
+@requires_gpu
+def test_device_reduction_stays_on_device() -> None:
+    """Reduction must happen before D2H, so the result is still on the GPU."""
+    video = torch.rand(1, 3, 4, 32, 48, device=_device(), dtype=torch.bfloat16) * 2 - 1
+    reduced = reduce_video_to_uint8_frames(video)
+    assert reduced.device.type == "cuda"
+    assert reduced.is_contiguous()
+
+
+@requires_gpu
+def test_device_reduction_without_denormalize_matches_already_unit_range() -> None:
+    """Pipelines with do_normalize=False emit [0,1]; skip the denorm step."""
+    video = torch.rand(1, 3, 4, 16, 16, device=_device(), dtype=torch.float32)  # already [0,1]
+
+    produced = reduce_video_to_uint8_frames(video, do_denormalize=False).cpu().numpy()
+
+    expected = video.permute(0, 2, 3, 4, 1).cpu().numpy()
+    expected = np.rint(np.clip(expected, 0, 1) * 255.0).astype(np.uint8)
+    np.testing.assert_array_equal(produced, expected)
+
+
+def test_device_reduction_rejects_non_5d() -> None:
+    """A wrong-rank tensor is a programming error, not a silent reshape."""
+    with pytest.raises(ValueError, match=r"\[B, C, F, H, W\]"):
+        reduce_video_to_uint8_frames(torch.rand(3, 8, 64, 64))
diff --git a/tests/diffusion/test_diffusion_config_propagation.py b/tests/diffusion/test_diffusion_config_propagation.py
index 51b3154a1..c85c2b1ac 100644
--- a/tests/diffusion/test_diffusion_config_propagation.py
+++ b/tests/diffusion/test_diffusion_config_propagation.py
@@ -11,12 +11,14 @@ 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,
 )
 from vllm_omni.diffusion.diffusion_kv.config import DiffusionKVCacheMode
 from vllm_omni.diffusion.model_metadata import (
+    FLUX2_KLEIN_MAX_INPUT_IMAGES,
     HUNYUAN_IMAGE3_MAX_INPUT_IMAGES,
     QWEN_IMAGE_EDIT_PLUS_MAX_INPUT_IMAGES,
 )
@@ -24,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.
 
@@ -33,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})
 
 
 def test_direct_config_extras_are_independent_dicts():
@@ -65,9 +74,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
 
@@ -201,6 +208,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")
@@ -211,6 +229,18 @@ def test_qwen_image_edit_plus_sets_generic_multimodal_limit():
     assert od_config.max_multimodal_image_inputs == QWEN_IMAGE_EDIT_PLUS_MAX_INPUT_IMAGES
 
 
+def test_flux2_klein_sets_generic_multimodal_limit():
+    od_config = OmniDiffusionConfig(
+        model="black-forest-labs/FLUX.2-klein-9B",
+        model_class_name="Flux2KleinPipeline",
+    )
+
+    od_config.update_multimodal_support()
+
+    assert od_config.supports_multimodal_inputs is True
+    assert od_config.max_multimodal_image_inputs == FLUX2_KLEIN_MAX_INPUT_IMAGES
+
+
 def test_task_type_roundtrip():
     od = _roundtrip_diffusion_config(model="x", task_type="model-defined-task")
     assert od.task_type == "model-defined-task"
diff --git a/tests/diffusion/test_diffusion_engine.py b/tests/diffusion/test_diffusion_engine.py
index 1ee7424e9..77a6da5db 100644
--- a/tests/diffusion/test_diffusion_engine.py
+++ b/tests/diffusion/test_diffusion_engine.py
@@ -15,7 +15,12 @@ from pytest_mock import MockerFixture
 
 import vllm_omni.diffusion.diffusion_engine as diffusion_engine_module
 from tests.helpers.mark import hardware_test
-from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
+from vllm_omni.diffusion.data import (
+    DIFFUSION_REQUEST_LIFECYCLE_KEY,
+    DIFFUSION_REQUEST_STARTED,
+    DiffusionOutput,
+    OmniDiffusionConfig,
+)
 from vllm_omni.diffusion.diffusion_engine import (
     DiffusionEngine,
     DiffusionExecutionMode,
@@ -183,6 +188,28 @@ def _make_request_mode_sched_output(*request_ids: str) -> RealDiffusionScheduler
     )
 
 
+@pytest.mark.cpu
+def test_request_started_output_is_emitted_only_for_opted_in_requests() -> None:
+    sched_output = _make_request_mode_sched_output("tracked", "untracked")
+    sched_output.scheduled_new_reqs[0].req.sampling_params.emit_request_lifecycle = True
+    engine = object.__new__(DiffusionEngine)
+    emitted = []
+    engine._put_output = lambda request_id, output: emitted.append((request_id, output))
+
+    engine._emit_request_started_outputs(sched_output)
+
+    assert len(emitted) == 1
+    request_id, output = emitted[0]
+    assert request_id == "tracked"
+    assert output.request_started is True
+    assert output.finished is False
+    [formatted] = engine.postprocess_output(sched_output.scheduled_new_reqs[0].req, output)
+    assert formatted.custom_output == {
+        DIFFUSION_REQUEST_LIFECYCLE_KEY: DIFFUSION_REQUEST_STARTED,
+    }
+    assert formatted.finished is False
+
+
 class TestRequestBatchCapability:
     pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
 
diff --git a/tests/diffusion/test_diffusion_engine_dummy_run.py b/tests/diffusion/test_diffusion_engine_dummy_run.py
index 8d524c572..1f1e8cbab 100644
--- a/tests/diffusion/test_diffusion_engine_dummy_run.py
+++ b/tests/diffusion/test_diffusion_engine_dummy_run.py
@@ -7,6 +7,7 @@ from unittest.mock import Mock
 import pytest
 
 from vllm_omni.diffusion import io_support
+from vllm_omni.diffusion.data import OmniDiffusionConfig
 from vllm_omni.diffusion.diffusion_engine import DiffusionEngine, DiffusionExecutionMode
 from vllm_omni.diffusion.diffusion_kv.config import DiffusionKVCacheMode
 from vllm_omni.diffusion.diffusion_kv.request import DiffusionKVRequest
@@ -16,6 +17,22 @@ from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
 
 
+@pytest.mark.parametrize("model_class_name", ["DreamZeroPipeline", "LingBotWorldCausalDMDPipeline"])
+def test_observation_conditioned_startup_skips_generic_warmup(model_class_name: str) -> None:
+    """Observation-conditioned pipelines must not receive generic text requests."""
+    engine = DiffusionEngine.__new__(DiffusionEngine)
+    engine.od_config = OmniDiffusionConfig.__new__(OmniDiffusionConfig)
+    engine.od_config.model_class_name = model_class_name
+    engine.od_config.diffusion_load_format = "default"
+    engine.add_req_and_wait_for_response = Mock(side_effect=AssertionError("generic text warmup submitted"))
+    engine.close = Mock()
+
+    engine.run_startup_warmup()
+
+    engine.add_req_and_wait_for_response.assert_not_called()
+    engine.close.assert_not_called()
+
+
 @pytest.mark.parametrize("step_execution", [False, True])
 def test_dummy_run_uses_enough_steps_for_execution_mode(
     monkeypatch: pytest.MonkeyPatch,
diff --git a/tests/diffusion/test_diffusion_engine_metrics.py b/tests/diffusion/test_diffusion_engine_metrics.py
index 1dad9face..ec222bcd3 100644
--- a/tests/diffusion/test_diffusion_engine_metrics.py
+++ b/tests/diffusion/test_diffusion_engine_metrics.py
@@ -90,6 +90,7 @@ def _get_function_source(source: str, class_name: str | None, func_name: str) ->
     Args:
         source: Full file source code.
         class_name: Enclosing class name, or None for module-level functions.
+            The method may be inherited from a base class defined in the same file.
         func_name: Function/method name.
 
     Returns:
@@ -97,13 +98,24 @@ def _get_function_source(source: str, class_name: str | None, func_name: str) ->
     """
     tree = ast.parse(source)
     if class_name is not None:
-        for node in ast.walk(tree):
-            if isinstance(node, ast.ClassDef) and node.name == class_name:
-                for item in node.body:
-                    if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)) and item.name == func_name:
-                        result = ast.get_source_segment(source, item)
-                        assert result is not None, f"{class_name}.{func_name} source not found"
-                        return result
+        # Follow the bases: ``Orchestrator`` inherits its loops and helpers from
+        # ``OrchestratorBase`` in the same module, and the lookup stays anchored
+        # on the public class rather than on where the split happens to fall.
+        classes = {node.name: node for node in ast.walk(tree) if isinstance(node, ast.ClassDef)}
+        pending = [class_name]
+        seen: set[str] = set()
+        while pending:
+            name = pending.pop(0)
+            if name in seen or name not in classes:
+                continue
+            seen.add(name)
+            node = classes[name]
+            for item in node.body:
+                if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)) and item.name == func_name:
+                    result = ast.get_source_segment(source, item)
+                    assert result is not None, f"{class_name}.{func_name} source not found"
+                    return result
+            pending.extend(base.id for base in node.bases if isinstance(base, ast.Name))
     else:
         for node in ast.walk(tree):
             if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and node.name == func_name:
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 9f8d4dec6..f5e4aaa2c 100644
--- a/tests/diffusion/test_diffusion_model_runner.py
+++ b/tests/diffusion/test_diffusion_model_runner.py
@@ -10,9 +10,19 @@ import torch
 
 import vllm_omni.diffusion.worker.diffusion_model_runner as model_runner_module
 from tests.helpers.mark import hardware_test
-from vllm_omni.diffusion.data import DiffusionOutput
+from vllm_omni.diffusion.data import DiffusionOutput, VideoOutputTransportConfig
 from vllm_omni.diffusion.diffusion_kv.config import DiffusionKVCacheMode
 from vllm_omni.diffusion.diffusion_kv.model_runner_backend import DiffusionKVModelRunnerBackend
+from vllm_omni.diffusion.media import (
+    DiffusionMediaOutput,
+    VideoMediaOutput,
+    VideoTensorEncoding,
+    VideoTensorLayout,
+    VideoTensorSpec,
+    VideoValueRange,
+)
+from vllm_omni.diffusion.request import OmniDiffusionRequest
+from vllm_omni.diffusion.sched.interface import CachedRequestData, DiffusionSchedulerOutput, NewRequestData
 from vllm_omni.diffusion.worker.diffusion_model_runner import DiffusionModelRunner
 from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch, split_diffusion_output_by_request
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
@@ -144,6 +154,19 @@ def _make_request():
     )
 
 
+def _raw_video_media(batch_size: int = 1, tensor: torch.Tensor | None = None) -> DiffusionMediaOutput:
+    return DiffusionMediaOutput(
+        video=VideoMediaOutput(
+            tensor=tensor if tensor is not None else torch.randn(batch_size, 3, 2, 4, 5),
+            spec=VideoTensorSpec(
+                layout=VideoTensorLayout.BCTHW,
+                encoding=VideoTensorEncoding.NORMALIZED_FLOAT,
+                value_range=VideoValueRange.NEGATIVE_ONE_TO_ONE,
+            ),
+        )
+    )
+
+
 def _make_request_with_params(req_id: str, sampling_params):
     return SimpleNamespace(
         request_id=req_id,
@@ -214,6 +237,7 @@ def _make_runner(cache_backend, cache_backend_name: str, enable_cache_dit_summar
         enable_cache_dit_summary=enable_cache_dit_summary,
         parallel_config=SimpleNamespace(use_hsdp=False),
         streaming_output=False,
+        video_output_transport=VideoOutputTransportConfig(),
     )
     runner.diffusion_kv_backend = DiffusionKVModelRunnerBackend(
         vllm_config=runner.vllm_config,
@@ -407,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=[]),
     )
 
@@ -546,6 +576,48 @@ def test_execute_stepwise_streaming_returns_chunks_at_boundaries(monkeypatch):
     assert fourth.get_request_output("req").finished is True
 
 
+@pytest.mark.core_model
+@pytest.mark.cpu
+def test_execute_stepwise_prepares_typed_media(monkeypatch):
+    runner = _make_runner(cache_backend=None, cache_backend_name=None)
+    runner.pipeline = _ChunkStepPipeline([DiffusionOutput(media=_raw_video_media())])
+    runner.od_config.streaming_output = True
+    runner.od_config.step_execution = True
+    runner.od_config.video_output_transport = VideoOutputTransportConfig(enable_device_postprocess=True)
+    req = OmniDiffusionRequest(
+        prompt="a prompt",
+        sampling_params=OmniDiffusionSamplingParams(num_inference_steps=4),
+        request_id="req",
+    )
+
+    monkeypatch.setattr(model_runner_module, "set_forward_context", _noop_forward_context)
+    monkeypatch.setattr(model_runner_module.current_omni_platform, "reset_peak_memory_stats", lambda: None)
+    monkeypatch.setattr(model_runner_module.current_omni_platform, "max_memory_reserved", lambda: 0)
+    monkeypatch.setattr(model_runner_module.current_omni_platform, "max_memory_allocated", lambda: 0)
+    scheduler_output = DiffusionSchedulerOutput(
+        step_id=0,
+        scheduled_new_reqs=[NewRequestData(request_id="req", req=req)],
+        scheduled_cached_reqs=CachedRequestData.make_empty(),
+        finished_req_ids=set(),
+        num_running_reqs=1,
+        num_waiting_reqs=0,
+    )
+
+    DiffusionModelRunner.execute_stepwise(runner, scheduler_output)
+    scheduler_output = DiffusionSchedulerOutput(
+        step_id=1,
+        scheduled_new_reqs=[],
+        scheduled_cached_reqs=CachedRequestData(request_ids=["req"]),
+        finished_req_ids=set(),
+        num_running_reqs=1,
+        num_waiting_reqs=0,
+    )
+    result = DiffusionModelRunner.execute_stepwise(runner, scheduler_output).get_request_output("req").result
+
+    assert result.media.prepared_for_transport is True
+    assert result.media.video.spec.encoding is VideoTensorEncoding.UINT8_FRAMES
+
+
 @pytest.mark.core_model
 @pytest.mark.cpu
 def test_execute_stepwise_streaming_decodes_final_only_pipeline(monkeypatch):
@@ -819,6 +891,7 @@ def _make_batch_runner(pipeline):
         cache_backend="none",
         enable_cache_dit_summary=False,
         parallel_config=SimpleNamespace(use_hsdp=False),
+        video_output_transport=VideoOutputTransportConfig(),
     )
     runner.kv_transfer_manager = SimpleNamespace(
         receive_multi_kv_cache_distributed=lambda req, cfg_kv_collect_func=None, target_device=None: None,
@@ -938,6 +1011,21 @@ def test_execute_model_batch_uses_runner_output_helper(monkeypatch):
     assert helper_calls == [(["req-0", "req-1"], ["a", "b"])]
 
 
+@pytest.mark.core_model
+@pytest.mark.cpu
+def test_execute_model_batch_prepares_typed_media_before_return(monkeypatch):
+    monkeypatch.setattr(model_runner_module, "set_forward_context", _noop_forward_context)
+    monkeypatch.setattr(model_runner_module, "current_omni_platform", _fake_platform_for_peak_memory())
+    runner = _make_batch_runner(_BatchPipeline(outputs=[DiffusionOutput(media=_raw_video_media())]))
+    runner.od_config.video_output_transport = VideoOutputTransportConfig(enable_device_postprocess=True)
+
+    result = DiffusionModelRunner.execute_model_batch(runner, _make_scheduler_output(num_reqs=1), runner.od_config)
+
+    prepared = result.runner_outputs[0].result.media
+    assert prepared.prepared_for_transport is True
+    assert prepared.video.spec.encoding is VideoTensorEncoding.UINT8_FRAMES
+
+
 @pytest.mark.core_model
 @pytest.mark.cpu
 def test_split_diffusion_output_by_request_slices_single_and_multi_request_outputs():
@@ -959,6 +1047,36 @@ def test_split_diffusion_output_by_request_slices_single_and_multi_request_outpu
     assert single[0].output == ["img-0a", "img-0b"]
 
 
+@pytest.mark.core_model
+@pytest.mark.cpu
+def test_split_diffusion_output_by_request_preserves_typed_media():
+    reqs = [_make_request(), _make_request()]
+    batch = DiffusionRequestBatch(requests=reqs)
+    source = torch.randn(4, 3, 2, 4, 5)
+    result = DiffusionOutput(media=_raw_video_media(tensor=source))
+
+    outputs = split_diffusion_output_by_request(result, batch, num_outputs_per_prompt=2)
+
+    assert [output.media.video.tensor.shape for output in outputs] == [
+        torch.Size([2, 3, 2, 4, 5]),
+        torch.Size([2, 3, 2, 4, 5]),
+    ]
+    assert all(output.media.prepared_for_transport is False for output in outputs)
+    torch.testing.assert_close(outputs[0].media.video.tensor, source[:2])
+    torch.testing.assert_close(outputs[1].media.video.tensor, source[2:])
+
+
+@pytest.mark.core_model
+@pytest.mark.cpu
+def test_split_diffusion_output_by_request_validates_media_batch_dimension():
+    reqs = [_make_request(), _make_request()]
+    batch = DiffusionRequestBatch(requests=reqs)
+    result = DiffusionOutput(media=_raw_video_media(batch_size=3))
+
+    with pytest.raises(ValueError, match=r"request_count \* num_outputs_per_prompt \(4\), got 3"):
+        split_diffusion_output_by_request(result, batch, num_outputs_per_prompt=2)
+
+
 @pytest.mark.core_model
 @pytest.mark.cpu
 def test_split_diffusion_output_by_request_slices_tuple_outputs():
diff --git a/tests/diffusion/test_diffusion_output_formatter.py b/tests/diffusion/test_diffusion_output_formatter.py
index 4578d8368..a1dfec637 100644
--- a/tests/diffusion/test_diffusion_output_formatter.py
+++ b/tests/diffusion/test_diffusion_output_formatter.py
@@ -443,3 +443,14 @@ def test_format_empty_diffusion_outputs_preserves_empty_response_shape() -> None
     assert [result.prompt for result in results] == ["prompt-0"]
     assert [result.images for result in results] == [[]]
     assert [result.metrics for result in results] == [{}]
+
+
+def test_format_empty_diffusion_outputs_preserves_custom_output() -> None:
+    [result] = format_empty_diffusion_outputs(
+        _request("prompt-0"),
+        finished=False,
+        custom_output={"lifecycle": "started"},
+    )
+
+    assert result.custom_output == {"lifecycle": "started"}
+    assert result.finished is False
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_inline_stage_diffusion_client.py b/tests/diffusion/test_inline_stage_diffusion_client.py
index e39c18ff4..3eadc53c1 100644
--- a/tests/diffusion/test_inline_stage_diffusion_client.py
+++ b/tests/diffusion/test_inline_stage_diffusion_client.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 from __future__ import annotations
 
 import asyncio
@@ -7,7 +10,11 @@ from unittest.mock import MagicMock, patch
 import pytest
 from vllm.v1.engine.exceptions import EngineDeadError
 
-from vllm_omni.diffusion.data import OmniDiffusionConfig
+from vllm_omni.diffusion.data import (
+    DIFFUSION_REQUEST_LIFECYCLE_KEY,
+    DIFFUSION_REQUEST_STARTED,
+    OmniDiffusionConfig,
+)
 from vllm_omni.diffusion.inline_stage_diffusion_client import InlineStageDiffusionClient
 from vllm_omni.engine.stage_init_utils import StageMetadata
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
@@ -80,6 +87,43 @@ async def test_inline_dispatch_request_success(client, mock_engine):
     assert output.request_id == "req-1"
 
 
+@pytest.mark.asyncio
+async def test_inline_non_streaming_dispatches_lifecycle_before_final(client, mock_engine):
+    lifecycle = OmniRequestOutput.from_diffusion(
+        request_id="req-lifecycle",
+        images=[],
+        custom_output={DIFFUSION_REQUEST_LIFECYCLE_KEY: DIFFUSION_REQUEST_STARTED},
+        finished=False,
+    )
+    intermediate = OmniRequestOutput.from_diffusion(
+        request_id="req-lifecycle",
+        images=[],
+        custom_output={"chunk": 0},
+        finished=False,
+    )
+    final = OmniRequestOutput.from_diffusion(request_id="req-lifecycle", images=[MagicMock()])
+
+    async def _step_streaming(_request):
+        yield [lifecycle]
+        yield [intermediate]
+        yield [final]
+
+    mock_engine.step_streaming = _step_streaming
+
+    await client.add_request_async("req-lifecycle", "A test prompt", OmniDiffusionSamplingParams())
+
+    outputs = []
+    for _ in range(20):
+        output = client.get_diffusion_output_nowait()
+        if output is not None:
+            outputs.append(output)
+            if output.finished:
+                break
+        await asyncio.sleep(0.01)
+
+    assert outputs == [lifecycle, final]
+
+
 @pytest.mark.asyncio
 async def test_inline_requests_clone_shared_sampling_params(client, mock_engine):
     requests = []
diff --git a/tests/diffusion/test_ipc_async.py b/tests/diffusion/test_ipc_async.py
index 03919095b..43650c581 100644
--- a/tests/diffusion/test_ipc_async.py
+++ b/tests/diffusion/test_ipc_async.py
@@ -1,7 +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
 """Unit tests for IPC async D2H stream packing."""
 
+from unittest.mock import ANY
+
 import pytest
 import torch
 
@@ -43,7 +45,7 @@ class TestPackTensorIfLargeWithD2hStream:
         tensor = torch.zeros(1)
         d2h = mocker.MagicMock()
         _pack_value_if_large(tensor, d2h_stream=d2h)
-        mock_pack.assert_called_once_with(tensor, d2h_stream=d2h)
+        mock_pack.assert_called_once_with(tensor, d2h_stream=d2h, created=None)
 
     def test_pack_value_if_large_passes_stream_through_dict(self, mocker):
         """d2h_stream propagates through dict container packing."""
@@ -93,7 +95,7 @@ class TestPackDiffusionFieldsWithD2hStream:
         d2h = mocker.MagicMock()
         out = DiffusionOutput(output=torch.zeros(1))
         _pack_diffusion_fields(out, d2h_stream=d2h)
-        mock_pack_value.assert_called_once_with(torch.zeros(1), d2h_stream=d2h)
+        mock_pack_value.assert_called_once_with(torch.zeros(1), d2h_stream=d2h, created=None)
 
     def test_trajectory_fields_packed_with_stream(self, mocker):
         mock_pack_tensor = mocker.patch(
@@ -120,7 +122,12 @@ class TestPackDiffusionOutputShmWithD2hStream:
         d2h = mocker.MagicMock()
         out = DiffusionOutput()
         pack_diffusion_output_shm(out, d2h_stream=d2h)
-        mock_pack_fields.assert_called_once_with(out, d2h_stream=d2h)
+        mock_pack_fields.assert_called_once_with(
+            out,
+            d2h_stream=d2h,
+            created=ANY,
+            pending_updates=ANY,
+        )
 
     def test_rpc_envelope_path_with_stream(self, mocker):
         mock_pack_fields = mocker.patch(
@@ -130,11 +137,11 @@ class TestPackDiffusionOutputShmWithD2hStream:
         result = DiffusionOutput()
         envelope = {"type": "diffusion_rpc_result", "result": result}
         pack_diffusion_output_shm(envelope, d2h_stream=d2h)
-        # envelope["result"] is replaced in-place by pack_diffusion_output_shm;
-        # assert with the original reference, not the replaced one.
         mock_pack_fields.assert_called_once_with(
             result,
             d2h_stream=d2h,
+            created=ANY,
+            pending_updates=ANY,
         )
 
     @pytest.mark.parametrize("wrapped_in_rpc_envelope", [False, True])
@@ -147,7 +154,12 @@ class TestPackDiffusionOutputShmWithD2hStream:
         tagged = {"dp_rank": 1, "output": result}
         value = {"type": "diffusion_rpc_result", "result": tagged} if wrapped_in_rpc_envelope else tagged
         pack_diffusion_output_shm(value, d2h_stream=d2h)
-        mock_pack_fields.assert_called_once_with(result, d2h_stream=d2h)
+        mock_pack_fields.assert_called_once_with(
+            result,
+            d2h_stream=d2h,
+            created=ANY,
+            pending_updates=ANY,
+        )
 
     def test_runner_output_path_with_stream(self, mocker):
         mock_pack_fields = mocker.patch(
@@ -163,9 +175,9 @@ class TestPackDiffusionOutputShmWithD2hStream:
             result=result,
         )
         pack_diffusion_output_shm(runner_out, d2h_stream=d2h)
-        # runner_out.result is replaced in-place by pack_diffusion_output_shm;
-        # assert with the original reference, not the replaced one.
         mock_pack_fields.assert_called_once_with(
             result,
             d2h_stream=d2h,
+            created=ANY,
+            pending_updates=ANY,
         )
diff --git a/tests/diffusion/test_media_output_contract.py b/tests/diffusion/test_media_output_contract.py
new file mode 100644
index 000000000..ae5c2fdbf
--- /dev/null
+++ b/tests/diffusion/test_media_output_contract.py
@@ -0,0 +1,546 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+import torch
+
+import vllm_omni.diffusion.diffusion_engine as diffusion_engine_module
+import vllm_omni.diffusion.ipc as diffusion_ipc
+import vllm_omni.diffusion.postprocess.media as media_postprocess
+from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig, VideoOutputTransportConfig
+from vllm_omni.diffusion.diffusion_engine import DiffusionEngine
+from vllm_omni.diffusion.ipc import pack_diffusion_output_shm, unpack_diffusion_output_shm
+from vllm_omni.diffusion.media import (
+    DiffusionMediaOutput,
+    FloatVideoConsumer,
+    VideoMediaOutput,
+    VideoTensorEncoding,
+    VideoTensorLayout,
+    VideoTensorSpec,
+    VideoTransportConstraints,
+    VideoValueRange,
+)
+from vllm_omni.diffusion.postprocess.device_reduction import prepare_diffusion_media_for_transport
+from vllm_omni.diffusion.postprocess.media import finalize_diffusion_media
+from vllm_omni.diffusion.request import OmniDiffusionRequest
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+
+def _video(
+    tensor: torch.Tensor,
+    *,
+    encoding: VideoTensorEncoding,
+    value_range: VideoValueRange,
+    consumers: frozenset[FloatVideoConsumer] = frozenset(),
+) -> VideoMediaOutput:
+    layout = VideoTensorLayout.BTHWC if encoding is VideoTensorEncoding.UINT8_FRAMES else VideoTensorLayout.BCTHW
+    return VideoMediaOutput(
+        tensor=tensor,
+        spec=VideoTensorSpec(
+            layout=layout,
+            encoding=encoding,
+            value_range=value_range,
+        ),
+        constraints=VideoTransportConstraints(pending_float_consumers=consumers),
+    )
+
+
+def _prepared_media(video: VideoMediaOutput) -> DiffusionMediaOutput:
+    return DiffusionMediaOutput(video=video, prepared_for_transport=True)
+
+
+def _od_config(*, enabled: bool = False) -> OmniDiffusionConfig:
+    config = OmniDiffusionConfig(
+        model=None,
+        video_output_transport=VideoOutputTransportConfig(enable_device_postprocess=enabled),
+    )
+    config.model_class_name = "WanPipeline"
+    return config
+
+
+def test_finalizer_rejects_media_that_skipped_runner_preparation() -> None:
+    media = DiffusionMediaOutput(
+        video=_video(
+            torch.randn(1, 3, 2, 4, 5),
+            encoding=VideoTensorEncoding.NORMALIZED_FLOAT,
+            value_range=VideoValueRange.NEGATIVE_ONE_TO_ONE,
+        )
+    )
+
+    with pytest.raises(ValueError, match="before transport preparation"):
+        finalize_diffusion_media(media, sampling_params=OmniDiffusionSamplingParams(output_type="np"))
+
+
+def test_uint8_media_finalization_preserves_frames() -> None:
+    frames = torch.randint(0, 256, (1, 4, 8, 8, 3), dtype=torch.uint8)
+
+    output = finalize_diffusion_media(
+        _prepared_media(
+            _video(
+                frames,
+                encoding=VideoTensorEncoding.UINT8_FRAMES,
+                value_range=VideoValueRange.ZERO_TO_255,
+            )
+        ),
+        sampling_params=OmniDiffusionSamplingParams(output_type="np"),
+    )
+
+    np.testing.assert_array_equal(output["payload"]["video"], frames.numpy())
+    assert output["metadata"] == {}
+
+
+def test_float_media_finalization_uses_the_declared_range() -> None:
+    video = torch.tensor([[[[[-1.0, 0.0, 1.0]]]]]).expand(1, 3, 1, 1, 3).contiguous()
+
+    output = finalize_diffusion_media(
+        _prepared_media(
+            _video(
+                video,
+                encoding=VideoTensorEncoding.NORMALIZED_FLOAT,
+                value_range=VideoValueRange.NEGATIVE_ONE_TO_ONE,
+            )
+        ),
+        sampling_params=OmniDiffusionSamplingParams(output_type="np"),
+    )
+
+    expected = (video.permute(0, 2, 3, 4, 1).numpy() * 0.5 + 0.5).clip(0.0, 1.0)
+    np.testing.assert_array_equal(output["payload"]["video"], expected)
+
+
+def test_zero_to_one_float_media_is_not_denormalized() -> None:
+    video = torch.tensor([[[[[0.0, 0.5, 1.0]]]]]).expand(1, 3, 1, 1, 3).contiguous()
+    media = _prepared_media(
+        _video(
+            video,
+            encoding=VideoTensorEncoding.NORMALIZED_FLOAT,
+            value_range=VideoValueRange.ZERO_TO_ONE,
+        )
+    )
+
+    output = finalize_diffusion_media(media, sampling_params=OmniDiffusionSamplingParams(output_type="np"))
+
+    expected = video.permute(0, 2, 3, 4, 1).numpy()
+    np.testing.assert_array_equal(output["payload"]["video"], expected)
+
+
+def test_presentation_is_resolved_outside_the_tensor_descriptor() -> None:
+    video = torch.zeros(1, 3, 2, 4, 5)
+    media = _prepared_media(
+        _video(
+            video,
+            encoding=VideoTensorEncoding.NORMALIZED_FLOAT,
+            value_range=VideoValueRange.NEGATIVE_ONE_TO_ONE,
+        )
+    )
+
+    output = finalize_diffusion_media(media, sampling_params=OmniDiffusionSamplingParams(output_type="pil"))
+
+    assert "presentation" not in media.video.__dataclass_fields__
+    assert len(output["payload"]["video"]) == 1
+    assert len(output["payload"]["video"][0]) == 2
+
+
+def test_frame_interpolation_consumes_its_constraint(monkeypatch: pytest.MonkeyPatch) -> None:
+    video = torch.randn(1, 3, 2, 4, 5)
+    interpolated = torch.randn(1, 3, 3, 4, 5)
+    monkeypatch.setattr(
+        media_postprocess,
+        "interpolate_video_tensor",
+        lambda *args, **kwargs: (interpolated, 2.0),
+    )
+
+    output = finalize_diffusion_media(
+        _prepared_media(
+            _video(
+                video,
+                encoding=VideoTensorEncoding.NORMALIZED_FLOAT,
+                value_range=VideoValueRange.NEGATIVE_ONE_TO_ONE,
+                consumers=frozenset({FloatVideoConsumer.FRAME_INTERPOLATION}),
+            )
+        ),
+        sampling_params=OmniDiffusionSamplingParams(output_type="np", enable_frame_interpolation=True),
+    )
+
+    assert output["payload"]["video"].shape == (1, 3, 4, 5, 3)
+    assert output["metadata"] == {"video": {"video_fps_multiplier": 2.0}}
+
+
+def test_uint8_media_rejects_a_pending_float_consumer() -> None:
+    media = _prepared_media(
+        _video(
+            torch.zeros(1, 2, 4, 5, 3, dtype=torch.uint8),
+            encoding=VideoTensorEncoding.UINT8_FRAMES,
+            value_range=VideoValueRange.ZERO_TO_255,
+            consumers=frozenset({FloatVideoConsumer.FRAME_INTERPOLATION}),
+        )
+    )
+
+    with pytest.raises(ValueError, match="cannot have pending float consumers"):
+        media.validate()
+
+
+def test_unconsumed_float_constraint_fails_before_public_formatting() -> None:
+    media = _prepared_media(
+        _video(
+            torch.randn(1, 3, 2, 4, 5),
+            encoding=VideoTensorEncoding.NORMALIZED_FLOAT,
+            value_range=VideoValueRange.NEGATIVE_ONE_TO_ONE,
+            consumers=frozenset({FloatVideoConsumer.VIDEO_GUARDRAILS}),
+        )
+    )
+
+    with pytest.raises(ValueError, match="pending float consumers"):
+        finalize_diffusion_media(media, sampling_params=OmniDiffusionSamplingParams(output_type="np"))
+
+
+def test_engine_routes_typed_media_exclusively(monkeypatch: pytest.MonkeyPatch) -> None:
+    media = _prepared_media(
+        _video(
+            torch.zeros(1, 1, 2, 2, 3, dtype=torch.uint8),
+            encoding=VideoTensorEncoding.UINT8_FRAMES,
+            value_range=VideoValueRange.ZERO_TO_255,
+        )
+    )
+    request = OmniDiffusionRequest(
+        prompt="test",
+        sampling_params=OmniDiffusionSamplingParams(output_type="np"),
+        request_id="request-0",
+    )
+    engine = object.__new__(DiffusionEngine)
+    engine.od_config = _od_config()
+    engine.post_process_func = lambda _: pytest.fail("legacy postprocessor was called")
+    engine._post_process_accepts_sampling_params = False
+
+    finalized = {"payload": {"video": np.zeros((1, 1, 2, 2, 3), dtype=np.uint8)}, "metadata": {}}
+
+    def _format_outputs(
+        *,
+        request: object,
+        od_config: object,
+        diffusion_output: object,
+        output_data: object,
+        postprocess_output: object,
+    ) -> list[object]:
+        del request, od_config, diffusion_output, output_data
+        return [postprocess_output]
+
+    monkeypatch.setattr(diffusion_engine_module, "finalize_diffusion_media", lambda *args, **kwargs: finalized)
+    monkeypatch.setattr(diffusion_engine_module, "normalize_diffusion_postprocess_output", lambda value: value)
+    monkeypatch.setattr(diffusion_engine_module, "format_diffusion_outputs", _format_outputs)
+
+    result = engine.postprocess_output(request, DiffusionOutput(media=media))
+
+    assert result == [finalized]
+
+
+def test_typed_media_crosses_runner_ipc_and_engine_without_legacy_postprocess(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    sampling_params = OmniDiffusionSamplingParams(output_type="np", num_outputs_per_prompt=1)
+    raw_media = DiffusionMediaOutput(
+        video=_video(
+            torch.linspace(-1.0, 1.0, 1 * 3 * 2 * 4 * 5).reshape(1, 3, 2, 4, 5),
+            encoding=VideoTensorEncoding.NORMALIZED_FLOAT,
+            value_range=VideoValueRange.NEGATIVE_ONE_TO_ONE,
+        )
+    )
+    prepared = prepare_diffusion_media_for_transport(
+        raw_media,
+        od_config=_od_config(enabled=True),
+        sampling_params=sampling_params,
+    )
+    diffusion_output = DiffusionOutput(media=prepared)
+    monkeypatch.setattr(diffusion_ipc, "_SHM_TENSOR_THRESHOLD", 1)
+    pack_diffusion_output_shm(diffusion_output)
+    unpack_diffusion_output_shm(diffusion_output)
+
+    engine = object.__new__(DiffusionEngine)
+    engine.od_config = _od_config()
+    engine.post_process_func = lambda _: pytest.fail("legacy postprocessor was called")
+    engine._post_process_accepts_sampling_params = False
+    request = OmniDiffusionRequest(prompt="test", sampling_params=sampling_params, request_id="request-0")
+
+    outputs = engine.postprocess_output(request, diffusion_output)
+
+    assert len(outputs) == 1
+    assert outputs[0].images[0].dtype == np.uint8
+    assert outputs[0].images[0].shape == (1, 2, 4, 5, 3)
+
+
+def test_diffusion_output_rejects_typed_and_legacy_output_together() -> None:
+    media = _prepared_media(
+        _video(
+            torch.zeros(1, 1, 2, 2, 3, dtype=torch.uint8),
+            encoding=VideoTensorEncoding.UINT8_FRAMES,
+            value_range=VideoValueRange.ZERO_TO_255,
+        )
+    )
+    with pytest.raises(ValueError, match="both media and legacy output"):
+        DiffusionOutput(output=torch.zeros(1), media=media)
+
+
+def test_diffusion_output_rejects_postprocessor_on_typed_media() -> None:
+    media = _prepared_media(
+        _video(
+            torch.zeros(1, 1, 2, 2, 3, dtype=torch.uint8),
+            encoding=VideoTensorEncoding.UINT8_FRAMES,
+            value_range=VideoValueRange.ZERO_TO_255,
+        )
+    )
+
+    with pytest.raises(ValueError, match="model-specific post_process_func"):
+        DiffusionOutput(media=media, post_process_func=lambda value: value)
+
+
+def test_diffusion_output_preserves_the_legacy_positional_constructor() -> None:
+    # ``media`` was originally declared right after ``output``, which broke
+    # ``DiffusionOutput(output, trajectory_timesteps)`` by binding the second
+    # argument to media. It must stay last so out-of-tree positional callers keep
+    # the pre-existing field order.
+    output_tensor = torch.randn(1)
+    timesteps = torch.tensor([1, 2, 3])
+
+    output = DiffusionOutput(output_tensor, timesteps)
+
+    assert output.output is output_tensor
+    assert output.trajectory_timesteps is timesteps
+    assert output.media is None
+
+
+def test_frame_interpolation_uses_the_declared_range_negative_one_to_one(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    # RIFE infers [0,1] vs [-1,1] from the tensor min/max, so an all-nonnegative
+    # [-1,1] clip is misread as [0,1] and interpolated in the wrong space. The
+    # interpolator must receive the unit-range form per the declared spec.
+    video = torch.full((1, 3, 2, 3, 3), 0.25)
+    media = DiffusionMediaOutput(
+        video=VideoMediaOutput(
+            tensor=video,
+            spec=VideoTensorSpec(
+                layout=VideoTensorLayout.BCTHW,
+                encoding=VideoTensorEncoding.NORMALIZED_FLOAT,
+                value_range=VideoValueRange.NEGATIVE_ONE_TO_ONE,
+            ),
+            constraints=VideoTransportConstraints(
+                pending_float_consumers=frozenset({FloatVideoConsumer.FRAME_INTERPOLATION})
+            ),
+        ),
+        prepared_for_transport=True,
+    )
+
+    seen: list[torch.Tensor] = []
+
+    def _square_interpolator(tensor: torch.Tensor, **_kwargs: object) -> tuple[torch.Tensor, float]:
+        seen.append(tensor)
+        return tensor * tensor, 2.0
+
+    monkeypatch.setattr(media_postprocess, "interpolate_video_tensor", _square_interpolator)
+
+    output = finalize_diffusion_media(
+        media,
+        sampling_params=OmniDiffusionSamplingParams(output_type="np", enable_frame_interpolation=True),
+    )
+
+    # The interpolator is fed the unit-range form 0.25→0.625, not raw 0.25.
+    assert len(seen) == 1
+    assert seen[0].shape == video.shape
+    assert float(seen[0][0, 0, 0, 0, 0]) == pytest.approx(0.625, abs=1e-6)
+    # Squaring gives 0.390625; restored to [-1,1] (-0.21875) by the fix, then the
+    # existing denormalize maps it back to [0,1] as 0.390625 in the public frames.
+    frames = output["payload"]["video"]
+    assert np.allclose(np.asarray(frames), 0.390625, atol=1e-6)
+
+
+def test_frame_interpolation_uses_the_declared_range_zero_to_one(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    # With a declared [0,1] range, the all-0.25 clip is already in unit space, so
+    # squaring gives 0.390625 and there is no restore step.
+    video = torch.full((1, 3, 2, 3, 3), 0.25)
+    media = DiffusionMediaOutput(
+        video=VideoMediaOutput(
+            tensor=video,
+            spec=VideoTensorSpec(
+                layout=VideoTensorLayout.BCTHW,
+                encoding=VideoTensorEncoding.NORMALIZED_FLOAT,
+                value_range=VideoValueRange.ZERO_TO_ONE,
+            ),
+            constraints=VideoTransportConstraints(
+                pending_float_consumers=frozenset({FloatVideoConsumer.FRAME_INTERPOLATION})
+            ),
+        ),
+        prepared_for_transport=True,
+    )
+
+    def _square_interpolator(tensor: torch.Tensor, **_kwargs: object) -> tuple[torch.Tensor, float]:
+        return tensor * tensor, 2.0
+
+    monkeypatch.setattr(media_postprocess, "interpolate_video_tensor", _square_interpolator)
+
+    output = finalize_diffusion_media(
+        media,
+        sampling_params=OmniDiffusionSamplingParams(output_type="np", enable_frame_interpolation=True),
+    )
+
+    # 0.25 is already [0,1]; squaring gives 0.0625, and no denormalize is applied.
+    frames = output["payload"]["video"]
+    assert np.allclose(np.asarray(frames), 0.0625, atol=1e-6)
+
+
+def test_frame_interpolation_clamps_zero_to_one_overshoot(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    # A declared [0,1] clip whose sample is almost entirely inside [0,1] — but
+    # with one bf16 value overshooting 1 — is still in unit space, so it must be
+    # clamped to [0,1] before RIFE and interpolated as [0,1]. Without the clamp
+    # the interpolator classifies it as [-1,1] (amax > 1) and returns the wrong
+    # space, which is then written back with no *2-1 restore.
+    video = torch.full((1, 3, 2, 3, 3), 0.25, dtype=torch.bfloat16)
+    video[0, 0, 0, 0, 0] = 1.25  # single overshoot > 1 -> amax > 1
+    media = DiffusionMediaOutput(
+        video=VideoMediaOutput(
+            tensor=video,
+            spec=VideoTensorSpec(
+                layout=VideoTensorLayout.BCTHW,
+                encoding=VideoTensorEncoding.NORMALIZED_FLOAT,
+                value_range=VideoValueRange.ZERO_TO_ONE,
+            ),
+            constraints=VideoTransportConstraints(
+                pending_float_consumers=frozenset({FloatVideoConsumer.FRAME_INTERPOLATION})
+            ),
+        ),
+        prepared_for_transport=True,
+    )
+
+    seen: list[torch.Tensor] = []
+
+    def _square_interpolator(tensor: torch.Tensor, **_kwargs: object) -> tuple[torch.Tensor, float]:
+        seen.append(tensor)
+        return tensor.float().square(), 2.0
+
+    monkeypatch.setattr(media_postprocess, "interpolate_video_tensor", _square_interpolator)
+
+    output = finalize_diffusion_media(
+        media,
+        sampling_params=OmniDiffusionSamplingParams(output_type="np", enable_frame_interpolation=True),
+    )
+
+    # The interpolator is fed the clamped bf16 unit-range tensor (max now 1.0),
+    # not the raw 1.25 overshoot that would be misread as [-1,1].
+    assert len(seen) == 1
+    assert seen[0].dtype is torch.bfloat16
+    assert float(seen[0].min()) == pytest.approx(0.25, abs=1e-6)
+    assert float(seen[0].max()) == pytest.approx(1.0, abs=1e-6)
+    # Squaring the clamped values gives 0.0625 at the 0.25 samples and 1.0 at the
+    # overshoot; the overall shape is unchanged (no *2-1 for ZERO_TO_ONE).
+    frames = output["payload"]["video"]
+    assert np.allclose(np.asarray(frames).reshape(-1)[1:], 0.0625, atol=1e-6)
+    assert np.isclose(float(np.asarray(frames).reshape(-1)[0]), 1.0, atol=1e-6)
+
+
+def test_packing_failure_unlinks_created_segments_and_leaves_output_untouched(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    # Packing a late field can fail after an SHM segment is already created;
+    # the segment must be unlinked and ``output`` left unmutated so a partial
+    # object is never enqueued.
+    prepared = prepare_diffusion_media_for_transport(
+        DiffusionMediaOutput(
+            video=_video(
+                torch.linspace(-1.0, 1.0, 2 * 3 * 2 * 4 * 5).reshape(2, 3, 2, 4, 5),
+                encoding=VideoTensorEncoding.NORMALIZED_FLOAT,
+                value_range=VideoValueRange.NEGATIVE_ONE_TO_ONE,
+            )
+        ),
+        od_config=_od_config(enabled=False),
+        sampling_params=OmniDiffusionSamplingParams(output_type="np"),
+    )
+    output = DiffusionOutput(media=prepared, trajectory_latents=torch.randn(30))
+    original_media = prepared
+    original_latents = output.trajectory_latents
+
+    real_array_to_shm = diffusion_ipc._array_to_shm
+    created_handles: list[dict[str, object]] = []
+
+    def _fail_on_second(array: np.ndarray) -> dict[str, object]:
+        if created_handles:
+            raise RuntimeError("injected packing failure")
+        handle = real_array_to_shm(array)
+        created_handles.append(handle)
+        return handle
+
+    monkeypatch.setattr(diffusion_ipc, "_SHM_TENSOR_THRESHOLD", 1)
+    monkeypatch.setattr(diffusion_ipc, "_array_to_shm", _fail_on_second)
+
+    with pytest.raises(RuntimeError, match="injected packing failure"):
+        pack_diffusion_output_shm(output)
+
+    assert created_handles, "no SHM segment was created before the injected failure"
+    # Output was not mutated despite the media segment being created first.
+    assert output.media is original_media
+    assert isinstance(output.media, DiffusionMediaOutput)
+    assert output.trajectory_latents is original_latents
+
+    from multiprocessing import shared_memory
+
+    with pytest.raises(FileNotFoundError):
+        shared_memory.SharedMemory(name=str(created_handles[0]["name"]))
+
+
+def test_second_batch_entry_failure_leaves_the_whole_batch_untouched(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    from multiprocessing import shared_memory
+
+    from vllm_omni.diffusion.worker.utils import BatchRunnerOutput, RunnerOutput
+
+    first_media = _prepared_media(
+        _video(
+            torch.zeros(1, 3, 2, 4, 5),
+            encoding=VideoTensorEncoding.NORMALIZED_FLOAT,
+            value_range=VideoValueRange.NEGATIVE_ONE_TO_ONE,
+        )
+    )
+    second_media = _prepared_media(
+        _video(
+            torch.ones(1, 3, 2, 4, 5),
+            encoding=VideoTensorEncoding.NORMALIZED_FLOAT,
+            value_range=VideoValueRange.NEGATIVE_ONE_TO_ONE,
+        )
+    )
+    first = DiffusionOutput(media=first_media)
+    second = DiffusionOutput(media=second_media)
+    batch = BatchRunnerOutput(
+        runner_outputs=[
+            RunnerOutput(request_id="first", result=first),
+            RunnerOutput(request_id="second", result=second),
+        ]
+    )
+
+    real_array_to_shm = diffusion_ipc._array_to_shm
+    created_handles: list[dict[str, object]] = []
+
+    def _fail_on_second(array: np.ndarray) -> dict[str, object]:
+        if created_handles:
+            raise RuntimeError("second batch entry failed")
+        handle = real_array_to_shm(array)
+        created_handles.append(handle)
+        return handle
+
+    monkeypatch.setattr(diffusion_ipc, "_SHM_TENSOR_THRESHOLD", 1)
+    monkeypatch.setattr(diffusion_ipc, "_array_to_shm", _fail_on_second)
+
+    with pytest.raises(RuntimeError, match="second batch entry failed"):
+        pack_diffusion_output_shm(batch)
+
+    # No per-entry assignment is committed until every entry has packed.
+    assert first.media is first_media
+    assert second.media is second_media
+    with pytest.raises(FileNotFoundError):
+        shared_memory.SharedMemory(name=str(created_handles[0]["name"]))
diff --git a/tests/diffusion/test_multiproc_engine_concurrency.py b/tests/diffusion/test_multiproc_engine_concurrency.py
index 5577a34a3..dcb7fdc72 100644
--- a/tests/diffusion/test_multiproc_engine_concurrency.py
+++ b/tests/diffusion/test_multiproc_engine_concurrency.py
@@ -4,8 +4,10 @@
 import asyncio
 import multiprocessing as mp
 import queue
+import signal
 import threading
 import time
+import weakref
 from types import SimpleNamespace
 from unittest.mock import MagicMock, Mock
 
@@ -865,11 +867,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,
@@ -1362,6 +1371,7 @@ class TestExecutorShutdownCleaner:
         class FakeProcess:
             def __init__(self, name):
                 self.name = name
+                self.pid = 123
                 self.alive = True
                 self.terminated = False
                 self.join_timeouts = []
@@ -1390,6 +1400,132 @@ class TestExecutorShutdownCleaner:
         assert first.terminated and second.terminated
         assert not first.is_alive() and not second.is_alive()
 
+    @pytest.mark.parametrize("cooperative", [False, True])
+    def test_real_workers_exit_and_are_reaped(self, monkeypatch, cooperative):
+        from vllm_omni.diffusion.executor import multiproc_executor as executor_module
+
+        ctx = mp.get_context("fork")
+        ready, stop = ctx.Event(), ctx.Event()
+
+        def run_worker():
+            signal.signal(signal.SIGTERM, signal.SIG_IGN)
+            ready.set()
+            stop.wait()
+
+        dead = ctx.Process(target=lambda: None)
+        worker = ctx.Process(target=run_worker)
+        monkeypatch.setattr(executor_module, "_WORKER_SHUTDOWN_GRACE_S", 0.2)
+        monkeypatch.setattr(executor_module, "_WORKER_TERMINATE_GRACE_S", 0.1)
+        monkeypatch.setattr(executor_module, "_WORKER_KILL_GRACE_S", 5.0, raising=False)
+        dead.start()
+        worker.start()
+        try:
+            dead.join(5)
+            assert not dead.is_alive()
+            assert ready.wait(5), "worker did not install its signal handler"
+            mq = Mock()
+            if cooperative:
+                mq.enqueue.side_effect = lambda *args, **kwargs: stop.set()
+            else:
+                mq.enqueue.side_effect = OSError("shutdown queue unavailable")
+            cleaner = executor_module._ExecutorShutdownCleaner(mq, 2, [dead, worker])
+
+            cleaner()
+
+            assert not worker.is_alive()
+            assert worker.exitcode == (0 if cooperative else -signal.SIGKILL)
+            assert cleaner.processes == []
+            assert cleaner.broadcast_mq is None
+            cleaner()
+        finally:
+            for proc in (dead, worker):
+                if proc.is_alive():
+                    proc.kill()
+                proc.join(5)
+                proc.close()
+
+    @pytest.mark.parametrize("failed_action", ["terminate", "kill"])
+    def test_kill_phase_shares_deadline_and_continues_after_os_errors(self, monkeypatch, failed_action):
+        from vllm_omni.diffusion.executor import multiproc_executor as executor_module
+
+        first, second = Mock(pid=101), Mock(pid=102)
+        first.name, second.name = "first", "second"
+        for proc in (first, second):
+            proc.is_alive.side_effect = [True, True, True, False]
+        getattr(first, failed_action).side_effect = OSError("signal failed")
+        first.join.side_effect = [OSError("join failed"), None, None]
+        monotonic = Mock(side_effect=[100, 100, 110, 120, 120, 124, 130, 130, 134])
+        monkeypatch.setattr(executor_module, "time", SimpleNamespace(monotonic=monotonic))
+        cleaner = executor_module._ExecutorShutdownCleaner(processes=[first, second])
+
+        cleaner()
+
+        first.kill.assert_called_once()
+        second.kill.assert_called_once()
+        assert [call.args[0] for call in first.join.call_args_list] == [15, 5, 5]
+        assert [call.args[0] for call in second.join.call_args_list] == [5, 1, 1]
+        assert cleaner.processes == []
+
+    def test_executor_retains_survivor_for_explicit_shutdown_retry(self, monkeypatch):
+        from vllm_omni.diffusion.executor import multiproc_executor as executor_module
+
+        survivor = Mock(pid=123)
+        survivor.name = "surviving-worker"
+        survivor.is_alive.return_value = True
+        cleaner = executor_module._ExecutorShutdownCleaner(processes=[survivor])
+        executor, _, _ = _make_executor()
+        executor._shutdown_cleaner = cleaner
+        executor._processes = [survivor]
+        executor._finalizer = weakref.finalize(executor, cleaner)
+        executor._pump_stop = threading.Event()
+        executor._futures_lock = threading.RLock()
+        executor._rpc_futures = {}
+        executor._output_futures = {}
+        executor._batch_split_map = {}
+        log_error = Mock()
+        monkeypatch.setattr(executor_module.logger, "error", log_error)
+
+        executor.shutdown()
+
+        assert not executor._finalizer.alive
+        assert executor._shutdown_cleaner is cleaner
+        assert executor._processes == [survivor]
+        log_error.assert_called_once()
+        assert log_error.call_args.args[1] == [("surviving-worker", 123)]
+        survivor.is_alive.return_value = False
+
+        executor.shutdown()
+        executor.shutdown()
+
+        assert executor._shutdown_cleaner is None
+        assert executor._processes == []
+
+    def test_concurrent_cleanup_does_not_repeat_process_operations(self):
+        from vllm_omni.diffusion.executor import multiproc_executor as executor_module
+
+        joining, release = threading.Event(), threading.Event()
+        proc = Mock(pid=123)
+        proc.is_alive.return_value = True
+
+        def join(timeout):
+            joining.set()
+            assert release.wait(5)
+            proc.is_alive.return_value = False
+
+        proc.join.side_effect = join
+        cleaner = executor_module._ExecutorShutdownCleaner(processes=[proc])
+        thread = threading.Thread(target=cleaner)
+        thread.start()
+        try:
+            assert joining.wait(5)
+            cleaner()
+            proc.join.assert_called_once()
+        finally:
+            release.set()
+            thread.join(5)
+        assert not thread.is_alive()
+        assert cleaner.processes == []
+
 
 # ───────── monitor thread & death sentinel integration tests ─────────
 
@@ -1438,7 +1574,7 @@ class TestMultiprocExecutorWorkerMonitor:
         executor._result_mq = None
         executor._shutdown_cleaner = None
         # Use a no-op so shutdown() doesn't crash on None resources.
-        executor._finalizer = lambda: None
+        executor._finalizer = weakref.finalize(executor, lambda: None)
         # ------------------------------------------------------------------
         # Attributes added by remove_bubble_v2 (async D2H); shutdown() iterates
         # over them, so they need to exist even when constructed via __new__.
@@ -1473,7 +1609,7 @@ class TestMultiprocExecutorWorkerMonitor:
         executor._broadcast_mq = None
         executor._result_mq = None
         executor._shutdown_cleaner = None
-        executor._finalizer = lambda: None
+        executor._finalizer = weakref.finalize(executor, lambda: None)
 
         proc = _make_short_lived_process()
         executor._processes = [proc]
diff --git a/tests/diffusion/test_stage_diffusion_proc.py b/tests/diffusion/test_stage_diffusion_proc.py
index 90e753c9b..c6b5761d9 100644
--- a/tests/diffusion/test_stage_diffusion_proc.py
+++ b/tests/diffusion/test_stage_diffusion_proc.py
@@ -9,6 +9,7 @@ import pytest
 
 import vllm_omni.diffusion.stage_diffusion_proc as stage_diffusion_proc
 import vllm_omni.plugins as omni_plugins
+from vllm_omni.diffusion.data import DIFFUSION_REQUEST_LIFECYCLE_KEY, DIFFUSION_REQUEST_STARTED
 from vllm_omni.diffusion.stage_diffusion_proc import StageDiffusionProc
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 from vllm_omni.outputs import OmniRequestOutput
@@ -103,6 +104,49 @@ async def test_proc_streaming_request_yields_each_engine_chunk():
     assert captured["request"].kv_sender_info == {0: {"host": "127.0.0.1"}}
 
 
+@pytest.mark.asyncio
+async def test_proc_non_streaming_forwards_lifecycle_before_final_output():
+    lifecycle = OmniRequestOutput.from_diffusion(
+        request_id="",
+        images=[],
+        custom_output={DIFFUSION_REQUEST_LIFECYCLE_KEY: DIFFUSION_REQUEST_STARTED},
+        finished=False,
+    )
+    intermediate = OmniRequestOutput.from_diffusion(
+        request_id="",
+        images=[],
+        custom_output={"chunk": 0},
+        finished=False,
+    )
+    final = OmniRequestOutput.from_diffusion(request_id="", images=[], finished=True)
+
+    class _LifecycleEngine:
+        async def step_streaming(self, request):
+            del request
+            yield [lifecycle]
+            yield [intermediate]
+            yield [final]
+
+    stage_proc = object.__new__(StageDiffusionProc)
+    stage_proc._engine = _LifecycleEngine()
+    intermediate_outputs = []
+
+    async def _capture(output):
+        intermediate_outputs.append(output)
+
+    result = await stage_proc._process_request(
+        request_id="req-lifecycle",
+        prompt="prompt",
+        sampling_params_dict=asdict(OmniDiffusionSamplingParams()),
+        on_request_started=_capture,
+    )
+
+    assert intermediate_outputs == [lifecycle]
+    assert lifecycle.request_id == "req-lifecycle"
+    assert result is final
+    assert result.request_id == "req-lifecycle"
+
+
 @pytest.mark.asyncio
 async def test_proc_process_request_with_batching_async_output():
     stage_proc = object.__new__(StageDiffusionProc)
diff --git a/tests/diffusion/test_video_transport_defaults_are_inert.py b/tests/diffusion/test_video_transport_defaults_are_inert.py
new file mode 100644
index 000000000..fd7346e76
--- /dev/null
+++ b/tests/diffusion/test_video_transport_defaults_are_inert.py
@@ -0,0 +1,61 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Pin the default behavior and the WAN reference integration boundary."""
+
+from __future__ import annotations
+
+import inspect
+from pathlib import Path
+
+import pytest
+
+from vllm_omni.diffusion.data import OmniDiffusionConfig, VideoOutputTransportConfig
+from vllm_omni.diffusion.registry import _DIFFUSION_POST_PROCESS_FUNCS
+
+pytestmark = [pytest.mark.core_model, pytest.mark.diffusion, pytest.mark.cpu]
+
+
+def test_transport_defaults() -> None:
+    transport = VideoOutputTransportConfig()
+
+    assert transport.enable_device_postprocess is False
+
+
+def test_a_default_diffusion_config_carries_a_default_transport() -> None:
+    config = OmniDiffusionConfig(model=None)
+
+    assert isinstance(config.video_output_transport, VideoOutputTransportConfig)
+    assert config.video_output_transport.enable_device_postprocess is False
+
+
+def test_wan_uses_the_typed_media_contract() -> None:
+    import vllm_omni.diffusion.models as models_pkg
+
+    source = (Path(inspect.getfile(models_pkg)).parent / "wan2_2/pipeline_wan2_2.py").read_text()
+    assert "DiffusionMediaOutput(" in source
+    assert "reduce_video_to_uint8_frames(" not in source
+    # The migrated built-in WAN pipeline emits typed media, so it never invokes
+    # the legacy postprocess hook. The mappings are intentionally retained so
+    # legacy/out-of-tree WAN replacements (registered with
+    # post_process_func_name=None) keep the built-in hook instead of exposing raw
+    # BCTHW tensors.
+    assert _DIFFUSION_POST_PROCESS_FUNCS["WanPipeline"] == "get_wan22_post_process_func"
+    assert _DIFFUSION_POST_PROCESS_FUNCS["WanDMDPipeline"] == "get_wan22_post_process_func"
+    assert _DIFFUSION_POST_PROCESS_FUNCS["WanT2VDMD2Pipeline"] == "get_wan22_post_process_func"
+
+
+def test_non_reference_models_do_not_use_the_runtime_reducer() -> None:
+    import vllm_omni.diffusion.models as models_pkg
+
+    root = Path(inspect.getfile(models_pkg)).parent
+    paths = (
+        "cosmos3/pipeline_cosmos3.py",
+        "hunyuan_video/pipeline_hunyuan_video_1_5.py",
+        "lingbot_video/pipeline_lingbot_video.py",
+        "ltx2/ltx2_runtime.py",
+        "minimax_h3/pipeline_minimax_h3.py",
+    )
+    for relative in paths:
+        source = (root / relative).read_text()
+        assert "prepare_diffusion_media_for_transport(" not in source
+        assert "reduce_video_to_uint8_frames(" not in source
diff --git a/tests/diffusion/test_wan_device_reduction.py b/tests/diffusion/test_wan_device_reduction.py
new file mode 100644
index 000000000..492aec7a5
--- /dev/null
+++ b/tests/diffusion/test_wan_device_reduction.py
@@ -0,0 +1,348 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""WAN reference coverage for the typed pre-D2H media contract."""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+import torch
+
+from tests.helpers.mark import hardware_marks
+from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig, VideoOutputTransportConfig
+from vllm_omni.diffusion.ipc import pack_diffusion_output_shm, unpack_diffusion_output_shm
+from vllm_omni.diffusion.media import (
+    DiffusionMediaOutput,
+    VideoMediaOutput,
+    VideoTensorEncoding,
+    VideoTensorLayout,
+    VideoTensorSpec,
+    VideoValueRange,
+)
+from vllm_omni.diffusion.models.wan2_2.pipeline_wan2_2 import get_wan22_post_process_func
+from vllm_omni.diffusion.postprocess.device_reduction import prepare_diffusion_media_for_transport
+from vllm_omni.diffusion.postprocess.media import finalize_diffusion_media
+from vllm_omni.entrypoints.openai.video_api_utils import _coerce_video_to_uint8_frames
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+pytestmark = [
+    pytest.mark.core_model,
+    pytest.mark.diffusion,
+    *hardware_marks(res={"cuda": "L4"}, num_cards=1),
+]
+
+_GPU = torch.accelerator.is_available() if hasattr(torch, "accelerator") else torch.cuda.is_available()
+requires_gpu = pytest.mark.skipif(not _GPU, reason="device reduction is a GPU path")
+
+
+def _decoded_wan_video(tensor: torch.Tensor) -> DiffusionMediaOutput:
+    return DiffusionMediaOutput(
+        video=VideoMediaOutput(
+            tensor=tensor,
+            spec=VideoTensorSpec(
+                layout=VideoTensorLayout.BCTHW,
+                encoding=VideoTensorEncoding.NORMALIZED_FLOAT,
+                value_range=VideoValueRange.NEGATIVE_ONE_TO_ONE,
+            ),
+        )
+    )
+
+
+def _config(*, enabled: bool) -> OmniDiffusionConfig:
+    return OmniDiffusionConfig(
+        model=None,
+        video_output_transport=VideoOutputTransportConfig(enable_device_postprocess=enabled),
+    )
+
+
+def _encoder_frames(video_payload: np.ndarray) -> list[np.ndarray]:
+    return [_coerce_video_to_uint8_frames(video_payload[i]) for i in range(video_payload.shape[0])]
+
+
+@requires_gpu
+def test_wan_media_reduction_matches_float32_reference_and_bounds_native_path() -> None:
+    torch.manual_seed(0)
+    vae_out = torch.rand(2, 3, 8, 64, 96, device="cuda:0", dtype=torch.bfloat16) * 2.4 - 1.2
+    sampling = OmniDiffusionSamplingParams(output_type=None, enable_frame_interpolation=False)
+
+    legacy_postprocess = get_wan22_post_process_func(_config(enabled=False))
+    widened_out = legacy_postprocess(vae_out.float(), output_type="np", sampling_params=sampling)
+    widened_frames = _encoder_frames(widened_out["payload"]["video"])
+    native_out = legacy_postprocess(vae_out, output_type="np", sampling_params=sampling)
+    native_frames = _encoder_frames(native_out["payload"]["video"])
+
+    prepared = prepare_diffusion_media_for_transport(
+        _decoded_wan_video(vae_out),
+        od_config=_config(enabled=True),
+        sampling_params=sampling,
+    )
+    reduced_out = finalize_diffusion_media(prepared, sampling_params=sampling)
+    assert prepared.video.spec.encoding is VideoTensorEncoding.UINT8_FRAMES
+    assert reduced_out["payload"]["video"].dtype == np.uint8
+    reduced_frames = _encoder_frames(reduced_out["payload"]["video"])
+
+    assert len(widened_frames) == len(reduced_frames) == 2
+    for expected, native, produced in zip(widened_frames, native_frames, reduced_frames, strict=True):
+        assert produced.shape == expected.shape == (8, 64, 96, 3)
+        np.testing.assert_array_equal(produced, expected)
+        deviation = np.abs(produced.astype(np.int16) - native.astype(np.int16))
+        assert deviation.max() <= 1
+
+
+@requires_gpu
+def test_wan_uint8_media_finalization_does_not_rescale() -> None:
+    frames = torch.randint(0, 256, (1, 4, 16, 16, 3), dtype=torch.uint8, device="cuda:0")
+    media = DiffusionMediaOutput(
+        video=VideoMediaOutput(
+            tensor=frames,
+            spec=VideoTensorSpec(
+                layout=VideoTensorLayout.BTHWC,
+                encoding=VideoTensorEncoding.UINT8_FRAMES,
+                value_range=VideoValueRange.ZERO_TO_255,
+            ),
+        ),
+        prepared_for_transport=True,
+    )
+
+    out = finalize_diffusion_media(media, sampling_params=OmniDiffusionSamplingParams(output_type="np"))
+
+    np.testing.assert_array_equal(out["payload"]["video"], frames.cpu().numpy())
+
+
+@requires_gpu
+def test_diffusion_output_to_cpu_moves_wan_media_off_device() -> None:
+    prepared = prepare_diffusion_media_for_transport(
+        _decoded_wan_video(torch.randn(1, 3, 2, 4, 5, device="cuda:0")),
+        od_config=_config(enabled=False),
+        sampling_params=OmniDiffusionSamplingParams(output_type="np"),
+    )
+    output = DiffusionOutput(media=prepared, to_cpu=True)
+
+    assert output.media is not None
+    assert output.media.video.tensor.device.type == "cpu"
+
+
+@requires_gpu
+def test_small_typed_media_is_on_cpu_before_ipc() -> None:
+    sampling = OmniDiffusionSamplingParams(output_type="np")
+    prepared = prepare_diffusion_media_for_transport(
+        _decoded_wan_video(torch.randn(1, 3, 2, 4, 5, device="cuda:0")),
+        od_config=_config(enabled=True),
+        sampling_params=sampling,
+    )
+    output = DiffusionOutput(media=prepared)
+
+    pack_diffusion_output_shm(output)
+
+    assert isinstance(output.media, dict)
+    packed_tensor = output.media["video"]["tensor"]
+    assert isinstance(packed_tensor, torch.Tensor)
+    assert packed_tensor.device.type == "cpu"
+    unpack_diffusion_output_shm(output)
+
+
+@requires_gpu
+def test_wan_float_media_finalization_matches_the_legacy_path() -> None:
+    video = torch.rand(1, 3, 4, 16, 16, device="cuda:0", dtype=torch.bfloat16) * 2 - 1
+    sampling = OmniDiffusionSamplingParams(output_type="np")
+    prepared = prepare_diffusion_media_for_transport(
+        _decoded_wan_video(video),
+        od_config=_config(enabled=False),
+        sampling_params=sampling,
+    )
+
+    produced = finalize_diffusion_media(prepared, sampling_params=sampling)
+    expected = get_wan22_post_process_func(_config(enabled=False))(
+        video,
+        output_type="np",
+        sampling_params=sampling,
+    )
+
+    assert prepared.video.spec.encoding is VideoTensorEncoding.NORMALIZED_FLOAT
+    np.testing.assert_array_equal(produced["payload"]["video"], expected["payload"]["video"])
+
+
+@requires_gpu
+def test_oom_fallback_media_packs_without_device_widening(monkeypatch: pytest.MonkeyPatch) -> None:
+    # Regression: when the fp32 reduction OOMs, the fallback keeps the bf16 float
+    # payload. Async IPC must copy it to the host in bf16 and widen on the CPU;
+    # a second device-side fp32 conversion would OOM again and drop the payload.
+    from vllm_omni.diffusion.postprocess import device_reduction
+
+    # Large enough (> 1 MB in bf16) that packing routes the tensor through the
+    # shared-memory D2H path rather than the small-tensor CPU copy.
+    video = torch.rand(1, 3, 16, 128, 128, device="cuda:0", dtype=torch.bfloat16) * 2 - 1
+
+    def _raise_oom(*_args: object, **_kwargs: object) -> torch.Tensor:
+        raise torch.OutOfMemoryError("forced fp32 reduction OOM")
+
+    monkeypatch.setattr(device_reduction, "reduce_video_to_uint8_frames", _raise_oom)
+
+    prepared = prepare_diffusion_media_for_transport(
+        _decoded_wan_video(video),
+        od_config=_config(enabled=True),
+        sampling_params=OmniDiffusionSamplingParams(output_type="np"),
+    )
+    assert prepared.video.spec.encoding is VideoTensorEncoding.NORMALIZED_FLOAT
+    assert prepared.video.tensor.dtype == torch.bfloat16
+
+    output = DiffusionOutput(media=prepared)
+
+    pinned_dtypes: list[torch.dtype] = []
+    real_empty = torch.empty
+
+    def _spy_empty(*args: object, **kwargs: object) -> torch.Tensor:
+        tensor = real_empty(*args, **kwargs)
+        if kwargs.get("pin_memory"):
+            pinned_dtypes.append(tensor.dtype)
+        return tensor
+
+    monkeypatch.setattr(torch, "empty", _spy_empty)
+
+    d2h_stream = torch.Stream(device=torch.device("cuda", 0))
+    pack_diffusion_output_shm(output, d2h_stream=d2h_stream)
+    d2h_stream.synchronize()
+
+    assert pinned_dtypes == [torch.bfloat16], (
+        "async packing must D2H in the original dtype and widen on the CPU, "
+        "never widen bf16 to fp32 on the accelerator before the copy"
+    )
+
+    unpack_diffusion_output_shm(output)
+    assert isinstance(output.media, DiffusionMediaOutput)
+    assert output.media.video.tensor.dtype == torch.bfloat16
+    torch.testing.assert_close(output.media.video.tensor, video.cpu())
+
+
+@requires_gpu
+def test_oom_fallback_recovers_the_allocator(monkeypatch: pytest.MonkeyPatch) -> None:
+    # A real float32 OOM leaves the CUDA caching allocator in a failed state;
+    # the fallback must empty the cache and drain the device before marking the
+    # float representation transport-ready, so the worker D2H of the same tensor
+    # can actually run. Use a genuine allocation failure (per-process cap) rather
+    # than injecting the exception, which never poisons the allocator.
+    from vllm_omni.platforms import current_omni_platform
+
+    video = torch.empty(1, 3, 16, 128, 128, device="cuda:0", dtype=torch.bfloat16)
+    video.uniform_(-1.0, 1.0)
+    expected = video.cpu()
+    d2h_stream = torch.Stream(device=video.device)
+    base_bytes = video.numel() * video.element_size()
+    _free, total = current_omni_platform.get_device_memory()
+
+    # Cap the process so the fp32 conversion (2x base bytes) cannot fit, while
+    # retaining the original bf16 tensor. This forces a real allocator OOM at
+    # the .to(fp32), rather than injecting an exception from a monkeypatch.
+    torch.cuda.set_per_process_memory_fraction(min(0.99, (1.2 * base_bytes) / total))
+    real_empty_cache = current_omni_platform.empty_cache
+    real_synchronize = current_omni_platform.synchronize
+    try:
+        empty_calls: list[int] = []
+        sync_calls: list[bool] = []
+
+        def _empty_cache() -> None:
+            real_empty_cache()
+            empty_calls.append(torch.accelerator.current_device_index())
+
+        def _synchronize() -> None:
+            real_synchronize()
+            sync_calls.append(True)
+
+        monkeypatch.setattr(current_omni_platform, "empty_cache", _empty_cache)
+        monkeypatch.setattr(current_omni_platform, "synchronize", _synchronize)
+
+        prepared = prepare_diffusion_media_for_transport(
+            _decoded_wan_video(video),
+            od_config=_config(enabled=True),
+            sampling_params=OmniDiffusionSamplingParams(output_type="np"),
+        )
+
+        # The fallback ran past a genuine OOM and kept the bf16 float payload.
+        assert prepared.video.spec.encoding is VideoTensorEncoding.NORMALIZED_FLOAT
+        assert prepared.video.tensor.dtype == torch.bfloat16
+        assert empty_calls, "fallback must empty the CUDA allocator cache after a real OOM"
+        assert sync_calls, "fallback must drain the device after a real OOM"
+
+        # Exercise the next production step: async D2H/SHM packing of the same
+        # tensor must succeed after allocator recovery and preserve its values.
+        output = DiffusionOutput(media=prepared)
+        pack_diffusion_output_shm(output, d2h_stream=d2h_stream)
+        d2h_stream.synchronize()
+        unpack_diffusion_output_shm(output)
+        assert isinstance(output.media, DiffusionMediaOutput)
+        torch.testing.assert_close(output.media.video.tensor, expected)
+    finally:
+        torch.cuda.set_per_process_memory_fraction(1.0)
+        real_empty_cache()
+        real_synchronize()
+
+
+@requires_gpu
+def test_oom_fallback_releases_late_uint8_traceback_before_clone(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """A final uint8 allocation OOM must release float intermediates first."""
+    from vllm_omni.diffusion.postprocess import device_reduction
+    from vllm_omni.platforms import current_omni_platform
+
+    # A split request is a non-compact view, so float fallback must allocate a
+    # request-owned clone after reduction fails.
+    backing = torch.empty(2, 3, 16, 128, 128, device="cuda:0", dtype=torch.bfloat16)
+    backing.uniform_(-1.0, 1.0)
+    video = backing[1:2].detach()
+    expected = video.cpu()
+    _, total = current_omni_platform.get_device_memory()
+    real_to = torch.Tensor.to
+    real_empty_cache = current_omni_platform.empty_cache
+    real_synchronize = current_omni_platform.synchronize
+    real_ensure_request_owned = device_reduction.ensure_request_owned_tensor
+    uint8_attempts: list[int] = []
+    fallback_allocations: list[int] = []
+
+    def _record_fallback_allocation(tensor: torch.Tensor) -> torch.Tensor:
+        fallback_allocations.append(torch.accelerator.memory_allocated(tensor.device))
+        return real_ensure_request_owned(tensor)
+
+    def _fail_real_uint8_allocation(
+        tensor: torch.Tensor,
+        *args: object,
+        **kwargs: object,
+    ) -> torch.Tensor:
+        dtype = kwargs.get("dtype")
+        if dtype is None and args and isinstance(args[0], torch.dtype):
+            dtype = args[0]
+        if tensor.is_cuda and dtype is torch.uint8:
+            # Earlier float32 work runs without a cap. Immediately before the
+            # real final uint8 allocation, cap the allocator below that request
+            # but above the post-unwind request-owned bf16 clone requirement.
+            real_empty_cache()
+            allocated = torch.accelerator.memory_allocated(tensor.device)
+            uint8_bytes = tensor.numel()
+            limit_bytes = allocated + max(1, uint8_bytes // 2)
+            torch.cuda.set_per_process_memory_fraction(min(0.99, limit_bytes / total))
+            uint8_attempts.append(allocated)
+        return real_to(tensor, *args, **kwargs)
+
+    monkeypatch.setattr(device_reduction, "ensure_request_owned_tensor", _record_fallback_allocation)
+    monkeypatch.setattr(torch.Tensor, "to", _fail_real_uint8_allocation)
+    try:
+        prepared = prepare_diffusion_media_for_transport(
+            _decoded_wan_video(video),
+            od_config=_config(enabled=True),
+            sampling_params=OmniDiffusionSamplingParams(output_type="np"),
+        )
+
+        assert uint8_attempts, "the real final .to(uint8) allocation was not attempted"
+        assert fallback_allocations, "float fallback did not request compact storage"
+        assert fallback_allocations[0] < uint8_attempts[0], (
+            "the failed reduction's float intermediates remained live during fallback"
+        )
+        assert prepared.video.spec.encoding is VideoTensorEncoding.NORMALIZED_FLOAT
+        assert prepared.video.tensor.dtype is torch.bfloat16
+        assert prepared.video.tensor.storage_offset() == 0
+        assert prepared.video.tensor.untyped_storage().data_ptr() != video.untyped_storage().data_ptr()
+        torch.testing.assert_close(prepared.video.tensor.cpu(), expected)
+    finally:
+        torch.cuda.set_per_process_memory_fraction(1.0)
+        real_empty_cache()
+        real_synchronize()
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_basic_connectors.py b/tests/distributed/omni_connectors/test_basic_connectors.py
index 787d5594b..2cd0fcea3 100644
--- a/tests/distributed/omni_connectors/test_basic_connectors.py
+++ b/tests/distributed/omni_connectors/test_basic_connectors.py
@@ -33,6 +33,18 @@ def test_tensor_serialization():
     assert torch.equal(tensor, deserialized)
 
 
+def test_bfloat16_tensor_serialization():
+    """The raw tensor serializer preserves the Mammoth BF16 wire dtype."""
+    import torch
+
+    tensor = torch.tensor([[1.0, -2.5], [3.25, 4.5]], dtype=torch.bfloat16)
+    serialized = OmniSerializer.serialize({"text_prompt_embeds": tensor})
+    deserialized = OmniSerializer.deserialize(serialized)
+
+    assert deserialized["text_prompt_embeds"].dtype == torch.bfloat16
+    assert torch.equal(deserialized["text_prompt_embeds"], tensor)
+
+
 def test_noncontiguous_tensor_serialization():
     """Test torch.Tensor serialization for strided views."""
     import torch
diff --git a/tests/distributed/omni_connectors/test_chunk_transfer_adapter.py b/tests/distributed/omni_connectors/test_chunk_transfer_adapter.py
index 40d29e969..92c2a7343 100644
--- a/tests/distributed/omni_connectors/test_chunk_transfer_adapter.py
+++ b/tests/distributed/omni_connectors/test_chunk_transfer_adapter.py
@@ -4,7 +4,7 @@
 import threading
 from collections import deque
 from types import MethodType, SimpleNamespace
-from unittest.mock import Mock, patch
+from unittest.mock import Mock, call, patch
 
 import pytest
 import torch
@@ -543,7 +543,7 @@ def test_create_connector_config_parsing(monkeypatch, raw_cfg, expected_name, ex
     assert connector == "ok"
     assert isinstance(captured["spec"], ConnectorSpec)
     assert captured["spec"].name == expected_name
-    assert captured["spec"].extra == expected_extra
+    assert captured["spec"].extra == {**expected_extra, "stage_id": 0}
 
 
 def test_load_poll(build_adapter):
@@ -570,8 +570,51 @@ def test_load_poll(build_adapter):
     assert request.additional_information == payload
     assert adapter.get_req_chunk["req-1"] == 1
     assert "req-1" not in adapter._finished_load_reqs
-    assert "req-1" in adapter.upstream_exhausted_requests
-    assert "req-1" not in adapter._pending_load_reqs
+
+
+def test_load_poll_uses_request_scoped_payload_sender_endpoint(build_adapter):
+    adapter, connector = build_adapter(stage_id=2, model_mode="ar")
+    request = _req("req-1", RequestStatus.WAITING, external_req_id="external-1")
+    request.payload_sender_info = {"host": "10.0.0.1", "zmq_port": 50051}
+    connector.get.return_value = None
+
+    adapter._poll_single_request(_dequeue_load_entry(adapter, request))
+
+    connector.get.assert_called_once_with(
+        "1",
+        "2",
+        "req-1_1_0",
+        {"source_host": "10.0.0.1", "source_port": 50051},
+    )
+
+
+def test_load_poll_keeps_concurrent_payload_sender_endpoints_distinct(build_adapter):
+    adapter, connector = build_adapter(stage_id=2, model_mode="ar")
+    first = _req("req-1", RequestStatus.WAITING)
+    first.payload_sender_info = {"host": "10.0.0.1", "zmq_port": 50051}
+    second = _req("req-2", RequestStatus.WAITING)
+    second.payload_sender_info = {"host": "10.0.0.2", "zmq_port": 51051}
+    connector.get.return_value = None
+
+    second_entry = _dequeue_load_entry(adapter, second)
+    first_entry = _dequeue_load_entry(adapter, first)
+    adapter._poll_single_request(second_entry)
+    adapter._poll_single_request(first_entry)
+
+    assert connector.get.call_args_list == [
+        call(
+            "1",
+            "2",
+            "req-2_1_0",
+            {"source_host": "10.0.0.2", "source_port": 51051},
+        ),
+        call(
+            "1",
+            "2",
+            "req-1_1_0",
+            {"source_host": "10.0.0.1", "source_port": 50051},
+        ),
+    ]
 
 
 def test_load_async_does_not_requeue_registered_inflight_request(build_adapter):
@@ -2526,6 +2569,357 @@ def test_omni_ar_scheduler_finish_requests(mocker: MockerFixture):
     assert order == ["adapter", "super"]
 
 
+def _parked_sender_scheduler(adapter, session):
+    """A minimal OmniARScheduler holding one parked streaming session."""
+    scheduler = OmniARScheduler.__new__(OmniARScheduler)
+    scheduler.chunk_transfer_adapter = adapter
+    scheduler.input_coordinator = None
+    scheduler.requests = {session.request_id: session}
+    scheduler.running = []
+    scheduler.waiting = DummyWaitingQueue()
+    scheduler.skipped_waiting = DummyWaitingQueue([session])
+    scheduler.num_waiting_for_streaming_input = 1
+    scheduler.finished_req_ids_dict = {}
+
+    def _free_request(self, request, delay_free_blocks=False):
+        del delay_free_blocks
+        self.requests.pop(request.request_id, None)
+        return None, None
+
+    scheduler._free_request = MethodType(_free_request, scheduler)
+    return scheduler
+
+
+@pytest.mark.parametrize("send_first_chunk", [False, True])
+def test_parked_streaming_final_update_emits_downstream_terminal(build_adapter, send_first_chunk):
+    """#6670: a final update on a parked sender must terminate the receiver.
+
+    Upstream turns "final update while parked in WAITING_FOR_STREAMING_REQ"
+    into a silent local abort. The downstream stage only learns a stream ended
+    from a chunk carrying ``finished``, so the abort used to leave it in
+    WAITING_FOR_CHUNK until the 600s input deadline.
+    """
+    adapter, connector = build_adapter(stage_id=1, model_mode="ar")
+    session = _req(
+        "req-parked-final",
+        RequestStatus.WAITING_FOR_STREAMING_REQ,
+        external_req_id="ext-parked-final",
+    )
+    session.resumable = True
+    session._omni_segment_generation = 0
+    # A segment stop queues its boundary before the final update arrives.
+    # The downstream request is already prewarmed even if the sender has not
+    # dequeued this first task, so it still needs a terminal in both cases.
+    adapter.save_async(None, session, is_segment_finished=True)
+    assert session.external_req_id not in adapter.put_req_chunk
+    if send_first_chunk:
+        adapter._send_single_request(adapter._pending_save_reqs.popleft())
+        connector.put.reset_mock()
+
+    scheduler = _parked_sender_scheduler(adapter, session)
+
+    final_update = _req(session.request_id, RequestStatus.WAITING)
+    final_update.resumable = False
+    OmniARScheduler.add_request(scheduler, final_update)
+
+    # Local teardown happened...
+    assert session.request_id not in scheduler.requests
+    # ...but only after a terminal chunk was queued for the next stage.
+    assert session.status == RequestStatus.FINISHED_STOPPED
+    assert any(task["is_finished"] for task in adapter._pending_save_reqs)
+    while adapter._pending_save_reqs:
+        adapter._send_single_request(adapter._pending_save_reqs.popleft())
+
+    connector.put.assert_called_once()
+    assert connector.put.call_args.kwargs["put_key"] == f"ext-parked-final_1_{int(send_first_chunk)}"
+    payload = connector.put.call_args.kwargs["data"]
+    assert bool(payload.meta.finished.item()) is True
+    assert bool(payload.meta.is_segment_finished.item()) is False
+
+
+def test_queued_terminal_chunk_survives_sender_cleanup(build_adapter):
+    """#6670: ``cleanup_sender`` must not discard an already-queued terminal."""
+    adapter, connector = build_adapter(stage_id=1, model_mode="ar")
+    request = _req("req-terminal", RequestStatus.FINISHED_STOPPED, external_req_id="ext-terminal")
+    request.resumable = False
+
+    adapter.save_async(None, request, is_segment_finished=False)
+    assert len(adapter._pending_save_reqs) == 1
+
+    # The scheduler tears the request down before the save_loop drains.
+    adapter.cleanup_sender("ext-terminal")
+
+    adapter._send_single_request(adapter._pending_save_reqs.popleft())
+    connector.put.assert_called_once()
+    assert bool(connector.put.call_args.kwargs["data"].meta.finished.item()) is True
+    # The terminal put reclaims the generation it kept alive.
+    assert "ext-terminal" not in adapter._sender_tokens
+
+
+def test_non_terminal_chunk_is_still_dropped_by_sender_cleanup(build_adapter):
+    """The #6670 fence is terminal-only: ordinary queued chunks still drop."""
+    adapter, connector = build_adapter(stage_id=1, model_mode="ar")
+    request = _req("req-mid", RequestStatus.RUNNING, external_req_id="ext-mid")
+    request.resumable = True
+
+    adapter.save_async(None, request, is_segment_finished=False)
+    adapter.cleanup_sender("ext-mid")
+
+    adapter._send_single_request(adapter._pending_save_reqs.popleft())
+    connector.put.assert_not_called()
+
+
+def test_final_update_on_non_sender_stage_keeps_upstream_abort(build_adapter):
+    """A final stage never put a chunk, so it must keep the upstream path."""
+    adapter, _connector = build_adapter(stage_id=2, model_mode="generation")
+    session = _req(
+        "req-final-stage",
+        RequestStatus.WAITING_FOR_STREAMING_REQ,
+        external_req_id="ext-final-stage",
+    )
+    session.resumable = True
+    scheduler = _parked_sender_scheduler(adapter, session)
+
+    final_update = _req(session.request_id, RequestStatus.WAITING)
+    final_update.resumable = False
+
+    with patch.object(VLLMScheduler, "add_request") as base_add:
+        OmniARScheduler.add_request(scheduler, final_update)
+
+    base_add.assert_called_once()
+    assert not adapter._pending_save_reqs
+
+
+def _queue_terminal(
+    adapter,
+    external_req_id: str,
+    req_id: str = "req-terminal",
+    segment_generation: int = 0,
+) -> None:
+    """Queue one request-terminal chunk on the adapter's save queue.
+
+    ``segment_generation`` must match the adapter's dedup watermark, which a
+    preceding segment stop advances; otherwise ``save_async`` drops the chunk
+    as a late duplicate.
+    """
+    request = _req(req_id, RequestStatus.FINISHED_STOPPED, external_req_id=external_req_id)
+    request.resumable = False
+    request._omni_segment_generation = segment_generation
+    adapter.save_async(None, request, is_segment_finished=False)
+
+
+def _assert_terminal_put(connector) -> None:
+    connector.put.assert_called_once()
+    assert bool(connector.put.call_args.kwargs["data"].meta.finished.item()) is True
+
+
+def test_terminal_chunk_survives_cleanup_after_dequeue(build_adapter):
+    """#6670: the fence must hold across the connector handoff, not just the queue.
+
+    ``_finish_parked_streaming_session`` queues the terminal and then calls
+    ``finish_requests``, so ``cleanup_sender`` can land *after* the save_loop
+    has already dequeued the terminal. Releasing the fence at dequeue left
+    that interleaving cancelling the chunk before ``put`` -- the same lost
+    terminal, and the same downstream WAITING_FOR_CHUNK hang.
+    """
+    adapter, connector = build_adapter(stage_id=1, model_mode="ar")
+    _queue_terminal(adapter, "ext-late-cleanup")
+    task = adapter._pending_save_reqs.popleft()
+
+    real_send = adapter._send_single_request_for_generation
+
+    def send_with_cleanup_in_flight(inner_task, sender_token=None):
+        # The scheduler thread reaches cleanup_sender here: the save_loop owns
+        # the terminal but has not handed it to the connector yet.
+        adapter.cleanup_sender("ext-late-cleanup")
+        return real_send(inner_task, sender_token)
+
+    adapter._send_single_request_for_generation = send_with_cleanup_in_flight
+    adapter._send_single_request(task)
+
+    _assert_terminal_put(connector)
+    # The generation the fence kept alive is reclaimed, not leaked.
+    assert "ext-late-cleanup" not in adapter._sender_tokens
+    assert "ext-late-cleanup" not in adapter.put_req_chunk
+
+
+def test_terminal_chunk_survives_cleanup_racing_an_inflight_sibling(build_adapter):
+    """#6670: an in-flight ordinary chunk must not reclaim a fenced generation.
+
+    ``_send_single_request``'s ``finally`` also tears a cancelled generation
+    down. If the stop and the abort both land while an earlier chunk is on the
+    wire, that teardown would unregister the token and the queued terminal
+    would then fail the identity check.
+    """
+    adapter, connector = build_adapter(stage_id=1, model_mode="ar")
+    running = _req("req-sibling", RequestStatus.RUNNING, external_req_id="ext-sibling")
+    running.resumable = True
+    adapter.save_async(None, running, is_segment_finished=True)
+    ordinary_task = adapter._pending_save_reqs.popleft()
+
+    real_send = adapter._send_single_request_for_generation
+
+    def send_then_stop_and_abort(inner_task, sender_token=None):
+        result = real_send(inner_task, sender_token)
+        # Terminal stop and abort both land while this chunk is on the wire.
+        # The segment stop above already armed the next segment's watermark.
+        _queue_terminal(adapter, "ext-sibling", req_id="req-sibling", segment_generation=1)
+        adapter.cleanup_sender("ext-sibling")
+        return result
+
+    adapter._send_single_request_for_generation = send_then_stop_and_abort
+    adapter._send_single_request(ordinary_task)
+    adapter._send_single_request_for_generation = real_send
+
+    assert len(adapter._pending_save_reqs) == 1
+    connector.put.reset_mock()
+    adapter._send_single_request(adapter._pending_save_reqs.popleft())
+
+    _assert_terminal_put(connector)
+    assert "ext-sibling" not in adapter._sender_tokens
+
+
+@pytest.mark.parametrize("finish_inside_put", [False, True])
+def test_successful_put_keeps_terminal_chunk_sequence(build_adapter, finish_inside_put):
+    """A cleanup during put must not reuse a key already consumed downstream."""
+    adapter, connector = build_adapter(stage_id=1, model_mode="ar")
+    receiver, receiver_connector = build_adapter(stage_id=2, model_mode="generation")
+    session = _req("req-sequence", RequestStatus.WAITING_FOR_STREAMING_REQ, external_req_id="ext-sequence")
+    session.resumable = True
+    session._omni_segment_generation = 0
+    scheduler = _parked_sender_scheduler(adapter, session)
+    final_update = _req(session.request_id, RequestStatus.WAITING)
+    final_update.resumable = False
+    downstream = _req("req-downstream", RequestStatus.WAITING, external_req_id=session.external_req_id)
+    receiver.request_ids_mapping[downstream.request_id] = session.external_req_id
+    payloads = {}
+
+    def receive_next():
+        entry = _dequeue_load_entry(receiver, downstream)
+        return receiver._poll_single_request(entry)
+
+    def put_then_finish(**kwargs):
+        payload = kwargs["data"]
+        payloads[kwargs["put_key"]] = {
+            "meta": {
+                "finished": bool(payload.meta.finished.item()),
+                "is_segment_finished": bool(payload.meta.is_segment_finished.item()),
+            }
+        }
+        if not payload.meta.finished.item():
+            # Consume the ordinary boundary while put is still in flight.
+            assert receive_next()
+            if finish_inside_put:
+                scheduler.add_request(final_update)
+        return True, 1, {}
+
+    def get_by_key(_from_stage, _to_stage, key, metadata=None):
+        assert metadata is None
+        payload = payloads.pop(key, None)
+        return (payload, 1) if payload is not None else None
+
+    connector.put.side_effect = put_then_finish
+    receiver_connector.get.side_effect = get_by_key
+    adapter.save_async(None, session, is_segment_finished=True)
+    adapter._send_single_request(adapter._pending_save_reqs.popleft())
+    if not finish_inside_put:
+        scheduler.add_request(final_update)
+    while adapter._pending_save_reqs:
+        adapter._send_single_request(adapter._pending_save_reqs.popleft())
+
+    assert [call.kwargs["put_key"] for call in connector.put.call_args_list] == ["ext-sequence_1_0", "ext-sequence_1_1"]
+    assert receive_next()
+    assert downstream.request_id in receiver.upstream_exhausted_requests
+    assert not payloads
+    assert session.external_req_id not in adapter._sender_tokens
+
+
+def test_late_successful_put_cannot_advance_replacement_generation(build_adapter):
+    """The post-put guard must retain identity checks while relaxing cancellation."""
+    adapter, connector = build_adapter(stage_id=1, model_mode="ar")
+    request = _req("req-old", RequestStatus.RUNNING, external_req_id="ext-replaced")
+    request.resumable = True
+    adapter.save_async(None, request, is_segment_finished=True)
+    task = adapter._pending_save_reqs.popleft()
+    old_token = task["sender_token"]
+    replacement_token = type(old_token)()
+
+    def replace_during_put(**kwargs):
+        # Model a completion that no longer owns its external id. The old
+        # terminal fence must never authorize writes to the successor's state.
+        with adapter._sender_state_lock:
+            old_token.cancelled = True
+            old_token.terminal_pending = True
+            adapter._sender_tokens[request.external_req_id] = replacement_token
+            adapter.put_req_chunk[request.external_req_id] = 4
+            adapter.ramp_chunk_count[request.external_req_id] = 2
+        return True, 1, {}
+
+    connector.put.side_effect = replace_during_put
+    adapter._send_single_request(task)
+    assert adapter._sender_tokens[request.external_req_id] is replacement_token
+    assert adapter.put_req_chunk[request.external_req_id] == 4
+    assert adapter.ramp_chunk_count[request.external_req_id] == 2
+
+
+def test_new_request_cannot_join_a_generation_with_a_queued_terminal(build_adapter):
+    """#6670: the fence must not readmit a request reusing the external id.
+
+    ``save_async`` rejects chunks whose generation is ``cancelled``; that is
+    what stops a new request from inheriting a retiring generation's token and
+    chunk counters. Deferring the reclaim must not also defer that retirement.
+    """
+    adapter, connector = build_adapter(stage_id=1, model_mode="ar")
+    _queue_terminal(adapter, "ext-shared", req_id="req-old")
+    adapter.cleanup_sender("ext-shared")
+
+    newcomer = _req("req-new", RequestStatus.RUNNING, external_req_id="ext-shared")
+    newcomer.resumable = True
+    adapter.save_async(None, newcomer, is_segment_finished=True)
+
+    # Rejected loudly, so the scheduler fails the newcomer now instead of its
+    # chunks being silently discarded at send time.
+    assert len(adapter._pending_save_reqs) == 1
+    assert adapter.collect_failed_send_request_ids() == {"req-new": "previous sender generation is still draining"}
+
+    adapter._send_single_request(adapter._pending_save_reqs.popleft())
+    _assert_terminal_put(connector)
+    assert "ext-shared" not in adapter._sender_tokens
+
+
+def test_failed_terminal_put_runs_the_deferred_cleanup(build_adapter):
+    """#6670: a silent connector drop must not strand the deferred cleanup.
+
+    ``connector.put`` returning False skips the success path that would have
+    called ``cleanup``. The reclaim ``cleanup_sender`` handed over is owed on
+    that path too, or the whole per-request sender state leaks for good.
+    """
+    adapter, connector = build_adapter(stage_id=1, model_mode="ar")
+    _queue_terminal(adapter, "ext-put-failed")
+    adapter.cleanup_sender("ext-put-failed")
+    connector.put.return_value = (False, 0, {})
+
+    adapter._send_single_request(adapter._pending_save_reqs.popleft())
+
+    assert "ext-put-failed" not in adapter._sender_tokens
+    assert "ext-put-failed" not in adapter.put_req_chunk
+
+
+def test_raising_terminal_put_runs_the_deferred_cleanup(build_adapter):
+    """#6670: the same reclaim is owed when the connector raises."""
+    adapter, connector = build_adapter(stage_id=1, model_mode="ar")
+    _queue_terminal(adapter, "ext-put-raised")
+    adapter.cleanup_sender("ext-put-raised")
+    connector.put.side_effect = RuntimeError("connector down")
+
+    # ``save_loop`` catches this and records a send failure.
+    with pytest.raises(RuntimeError):
+        adapter._send_single_request(adapter._pending_save_reqs.popleft())
+
+    assert "ext-put-raised" not in adapter._sender_tokens
+    assert "ext-put-raised" not in adapter.put_req_chunk
+
+
 def test_wire_round_trip_struct_to_dict_contract():
     """Pin the wire contract: encoding ``OmniPayloadStruct`` and decoding it
     yields a dict equivalent to ``to_dict(struct)``.
diff --git a/tests/distributed/omni_connectors/test_nixl_connector.py b/tests/distributed/omni_connectors/test_nixl_connector.py
new file mode 100644
index 000000000..5e5fc3ed6
--- /dev/null
+++ b/tests/distributed/omni_connectors/test_nixl_connector.py
@@ -0,0 +1,893 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""
+Unit tests for the NixlConnector metadata handshake.
+
+NIXL itself is stubbed out, so these tests exercise the ZMQ control plane and
+the payload normalisation rather than any actual RDMA transfer.
+"""
+
+import ctypes
+import sys
+import time
+import types
+
+import msgspec
+import pytest
+import torch
+import zmq
+
+from vllm_omni.data_entry_keys import HiddenStatesStruct, MetaStruct, OmniPayloadStruct
+
+pytestmark = [pytest.mark.cpu, pytest.mark.parallel, pytest.mark.core_model]
+
+PORT = 47431
+
+
+def _wait_for_metadata(consumer, key, metadata=None, *, timeout=2.0):
+    """Retry outside the connector's deliberately bounded metadata query."""
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        resolved = consumer._resolve_metadata(key, metadata)
+        if resolved is not None:
+            return resolved
+        time.sleep(0.01)
+    pytest.fail(f"Timed out waiting for metadata for {key!r}")
+
+
+@pytest.mark.parametrize("misses", [0, 2])
+def test_wait_for_metadata_retries_until_success(monkeypatch, misses):
+    expected = {"claim_id": "claim"}
+    forwarded = {"source_host": "127.0.0.1", "source_port": PORT}
+    calls = []
+
+    def resolve(key, metadata):
+        calls.append((key, metadata))
+        return None if len(calls) <= misses else expected
+
+    ticks = iter(range(10))
+    monkeypatch.setattr(time, "monotonic", lambda: next(ticks))
+    monkeypatch.setattr(time, "sleep", lambda _: None)
+    consumer = types.SimpleNamespace(_resolve_metadata=resolve)
+    assert _wait_for_metadata(consumer, "retry", forwarded, timeout=5) is expected
+    assert calls == [("retry", forwarded)] * (misses + 1)
+
+
+def test_wait_for_metadata_stops_at_deadline(monkeypatch):
+    calls = []
+    ticks = iter([0.0, 0.0, 1.0, 2.0])
+    monkeypatch.setattr(time, "monotonic", lambda: next(ticks))
+    monkeypatch.setattr(time, "sleep", lambda _: None)
+    consumer = types.SimpleNamespace(_resolve_metadata=lambda *args: calls.append(args))
+    with pytest.raises(pytest.fail.Exception, match="Timed out waiting for metadata for 'missing'"):
+        _wait_for_metadata(consumer, "missing")
+    assert calls == [("missing", None)] * 2
+
+
+@pytest.mark.parametrize("async_chunk", [False, True])
+def test_three_stage_incoming_and_outgoing_endpoints(nixl_connector_cls, async_chunk):
+    from vllm_omni.distributed.omni_connectors.utils.config import ConnectorSpec, OmniTransferConfig
+    from vllm_omni.distributed.omni_connectors.utils.initialization import resolve_connector_spec
+    from vllm_omni.engine.stage_init_utils import get_stage_connector_spec
+
+    config = OmniTransferConfig(
+        connectors={
+            ("0", "1"): ConnectorSpec(name="NixlConnector", extra={"host": "127.0.0.1", "zmq_port": PORT}),
+            ("1", "2"): ConnectorSpec(name="NixlConnector", extra={"host": "127.0.0.1", "zmq_port": PORT + 10}),
+        }
+    )
+    connectors = []
+    try:
+        for stage in range(3):
+            spec = get_stage_connector_spec(config, stage, async_chunk)
+            resolved = resolve_connector_spec(ConnectorSpec(**spec), stage_id=stage, role=spec["extra"]["role"])
+            connectors.append(nixl_connector_cls(resolved.extra))
+        first, middle, last = connectors
+        assert middle._sender_zmq_port == PORT
+        assert middle._serving_handshake
+        assert middle._zmq_port == PORT + 11
+        first.put("0", "1", "incoming", torch.ones(1))
+        incoming = _wait_for_metadata(middle, "incoming")
+        assert incoming["sender_zmq_port"] == PORT
+        assert incoming["generation"] == first._published["incoming"]["generation"]
+        middle.put("1", "2", "outgoing", torch.ones(1))
+        outgoing = _wait_for_metadata(last, "outgoing")
+        assert outgoing["sender_zmq_port"] == PORT + 11
+        assert outgoing["generation"] == middle._published["outgoing"]["generation"]
+    finally:
+        for connector in reversed(connectors):
+            for pending in connector._pending.values():
+                pending.claims.clear()  # No DMA in this metadata-only probe.
+            connector.close()
+
+
+@pytest.mark.parametrize("name", ["NixlConnector", "MooncakeTransferEngineConnector"])
+def test_explicit_sender_port_is_not_derived(name):
+    from vllm_omni.distributed.omni_connectors.utils.config import ConnectorSpec
+    from vllm_omni.distributed.omni_connectors.utils.initialization import resolve_connector_spec
+
+    spec = ConnectorSpec(name=name, extra={"sender_zmq_port": 55000, "from_stage": 0})
+    resolved = resolve_connector_spec(spec, stage_id=1, role="receiver", replica_id=3, local_rank=2)
+    assert resolved.extra["sender_zmq_port"] == 55000
+    assert spec.extra == {"sender_zmq_port": 55000, "from_stage": 0}
+    spec.extra["zmq_port"] = "${UNUSED_NIXL_BASE_PORT}"
+    assert resolve_connector_spec(spec, stage_id=1, role="receiver").extra["sender_zmq_port"] == 55000
+
+
+@pytest.mark.parametrize("need_recv_cache", [False, True])
+@pytest.mark.parametrize("update_before_init", [False, True])
+def test_manager_receiver_does_not_bind_shared_producer_port(producer, need_recv_cache, update_before_init):
+    """Payload-only and KV receivers must dial, not bind, the incoming edge."""
+    from vllm_omni.distributed.omni_connectors.kv_transfer_manager import (
+        OmniKVCacheConfig,
+        OmniKVTransferManager,
+    )
+
+    manager = OmniKVTransferManager(
+        OmniKVCacheConfig(
+            connector_config={
+                "type": "NixlConnector",
+                "role": "receiver",
+                "host": "127.0.0.1",
+                "zmq_port": PORT,
+                "backends": ["UCX"],
+            },
+            from_stage="0",
+            to_stage="1",
+            stage_id=1,
+            need_recv_cache=need_recv_cache,
+        )
+    )
+    sender_info = {"host": producer.host, "zmq_port": producer._zmq_port}
+    if update_before_init:
+        manager.update_sender_info(sender_info)
+    receiver = manager.connector
+    try:
+        assert receiver is not None, "Receiver incorrectly tried to bind the producer's occupied port"
+        assert receiver._zmq_port is None
+        assert not receiver._serving_handshake
+        if not update_before_init:
+            assert receiver._sender_zmq_port is None
+            manager.update_sender_info(sender_info)
+        assert receiver._sender_zmq_port == producer._zmq_port
+        assert manager.config.connector_config["zmq_port"] == PORT  # Do not mutate the shared specification.
+        success, _, _ = producer.put("0", "1", "manager-receive", torch.ones(1))
+        assert success
+        metadata = _wait_for_metadata(receiver, "manager-receive")
+        assert metadata["generation"] == producer._published["manager-receive"]["generation"]
+        receiver._notify_transfer_done("manager-receive", metadata)
+        assert not producer._pending
+    finally:
+        if receiver is not None:
+            receiver.close()
+
+
+@pytest.mark.parametrize("need_recv_cache", [False, True])
+def test_manager_receiver_preserves_explicit_standalone_sender(producer, need_recv_cache):
+    from vllm_omni.distributed.omni_connectors.kv_transfer_manager import (
+        OmniKVCacheConfig,
+        OmniKVTransferManager,
+    )
+
+    manager = OmniKVTransferManager(
+        OmniKVCacheConfig(
+            connector_config={
+                "type": "NixlConnector",
+                "role": "receiver",
+                "zmq_port": PORT,
+                "sender_host": producer.host,
+                "sender_zmq_port": producer._zmq_port,
+            },
+            need_recv_cache=need_recv_cache,
+        )
+    )
+    receiver = manager.connector
+    try:
+        assert receiver is not None
+        assert receiver._zmq_port is None and not receiver._serving_handshake
+        assert (receiver._sender_host, receiver._sender_zmq_port) == (producer.host, producer._zmq_port)
+        success, _, _ = producer.put("0", "1", "standalone-receive", torch.ones(1))
+        assert success
+        metadata = _wait_for_metadata(receiver, "standalone-receive")
+        assert metadata["generation"] == producer._published["standalone-receive"]["generation"]
+        receiver._notify_transfer_done("standalone-receive", metadata)
+        assert not producer._pending
+    finally:
+        if receiver is not None:
+            receiver.close()
+
+
+def test_middle_stage_advertises_its_outgoing_replica_endpoint():
+    from vllm_omni.engine.stage_engine_core_client import StageEngineCoreClient
+
+    client = object.__new__(StageEngineCoreClient)
+    client.stage_id = 1
+    client.replica_id = 3
+    client.vllm_config = types.SimpleNamespace(
+        model_config=types.SimpleNamespace(
+            stage_connector_config={
+                "name": "NixlConnector",
+                "extra": {
+                    "role": "receiver",
+                    "host": "10.0.0.1",
+                    "zmq_port": 47000,
+                    "from_stage": 0,
+                    "outgoing": {"host": "10.0.0.2", "zmq_port": 48000, "from_stage": 1},
+                },
+            }
+        )
+    )
+    assert client._build_payload_sender_info() == {"host": "10.0.0.2", "zmq_port": 51073}
+
+
+@pytest.mark.parametrize("direct", [False, True])
+@pytest.mark.usefixtures("reliable_claim_queries")
+def test_claimed_source_survives_expiry_and_cleanup(producer, consumer, direct):
+    _, _, metadata = producer.put("0", "1", "claimed", torch.ones(1))
+    resolved = consumer._resolve_metadata("claimed", metadata if direct else None)
+    pending = producer._pending["claimed"]
+    pending.deadline = 0
+    producer._cleanup_expired_pending()
+    assert producer._pending.get("claimed") is pending
+    producer.cleanup("claimed")
+    assert producer._pending.get("claimed") is pending
+    assert producer._agent.registered
+    consumer._notify_transfer_done("claimed", resolved)
+    consumer._notify_transfer_done("claimed", resolved)
+    assert producer._pending == {}
+    assert producer._agent.registered == []
+
+
+@pytest.mark.usefixtures("reliable_claim_queries")
+def test_claims_are_generation_scoped_and_duplicate_ack_cannot_release_sibling(producer, consumer):
+    _, _, original = producer.put("0", "1", "owners", torch.ones(1))
+    first = consumer._resolve_metadata("owners", original)
+    second = consumer._resolve_metadata("owners", original)
+    assert first["claim_id"] != second["claim_id"]
+    assert not producer.put("0", "1", "owners", torch.zeros(1))[0]
+    consumer._notify_transfer_done("owners", first)
+    consumer._notify_transfer_done("owners", first)
+    assert len(producer._pending["owners"].claims) == 1
+    consumer._notify_transfer_done("owners", second)
+    assert not producer._pending
+    producer.put("0", "1", "owners", torch.zeros(1))
+    consumer._notify_transfer_done("owners", second)
+    assert "owners" in producer._pending
+    assert consumer._resolve_metadata("owners", original) is None
+
+
+@pytest.mark.parametrize("get_metadata", [None, {"schema_version": 1, "tensor_specs": [], "descriptor_groups": []}])
+@pytest.mark.usefixtures("reliable_claim_queries")
+def test_abandoned_claim_survives_close_and_late_completion(producer, consumer, get_metadata):
+    _, _, metadata = producer.put("0", "1", "abandoned", torch.ones(1))
+    claimed = consumer._resolve_metadata("abandoned", metadata)
+    producer._pending["abandoned"].deadline = 0
+    producer.close()
+    assert producer._closing and not producer._closed
+    assert producer._agent.registered
+    assert producer._listener_thread.is_alive()
+    with pytest.raises(RuntimeError, match="closed"):
+        producer.put("0", "1", "new", torch.ones(1))
+    metrics = dict(producer._metrics)
+    with pytest.raises(RuntimeError, match="Cannot get data: NixlConnector is closed"):
+        producer.get("0", "1", "new", get_metadata)
+    assert producer._metrics == metrics
+    assert producer._pending["abandoned"].claims == {claimed["claim_id"]}
+    assert consumer._resolve_metadata("abandoned", metadata) is None
+    consumer._notify_transfer_done("abandoned", claimed)
+    assert not producer._pending
+    assert not producer._agent.registered
+    assert producer._listener_thread.is_alive()
+    producer.close()
+    assert not producer._agent.registered
+    assert producer._closed
+
+
+@pytest.fixture
+def copying_native_agent(consumer, monkeypatch):
+    """Strict fake descriptors and actual CPU copies; not native NIXL evidence."""
+    calls = []
+
+    def descriptors(regions, memory_type):
+        assert regions and all(region[0] > 0 and region[1] > 0 for region in regions)
+        return regions
+
+    def prepare(operation, local, local_ids, remote, remote_ids):
+        assert operation == "READ"
+        assert local_ids == remote_ids == list(range(len(local)))
+        return list(zip(local, remote, strict=True))
+
+    def transfer(pairs):
+        calls.append(pairs)
+        for destination, source in pairs:
+            assert destination[1] == source[1] > 0
+            ctypes.memmove(destination[0], source[0], source[1])
+
+    agent = consumer._agent
+    monkeypatch.setattr(agent, "add_remote_agent", lambda metadata: "producer", raising=False)
+    monkeypatch.setattr(agent, "get_xfer_descs", descriptors, raising=False)
+    monkeypatch.setattr(agent, "prep_xfer_dlist", lambda agent, descs: descs, raising=False)
+    monkeypatch.setattr(agent, "make_prepped_xfer", prepare, raising=False)
+    monkeypatch.setattr(agent, "transfer", transfer, raising=False)
+    monkeypatch.setattr(agent, "check_xfer_state", lambda handle: "DONE", raising=False)
+    for method in ("release_xfer_handle", "release_dlist_handle", "remove_remote_agent"):
+        monkeypatch.setattr(agent, method, lambda handle: None, raising=False)
+    return calls
+
+
+@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)
+    scalar = torch.tensor(7)
+    vector = torch.arange(6, dtype=torch.float32)
+    payload = {
+        "empty": empty,
+        "all_empty": [empty, other],
+        "mixed": [empty, scalar, other, vector],
+        "scalar": scalar,
+        "structured_empty": {"leaves": (empty, [other]), "label": "empty"},
+        "structured_mixed": {"leaves": (empty, [scalar, other, vector]), "label": "mixed"},
+    }[case]
+    ok, size, metadata = producer.put("0", "1", "empty-slots", payload)
+    assert ok
+    indices = [index for group in metadata["descriptor_groups"] for index in group["tensor_indices"]]
+    assert sorted(indices) == [i for i, spec in enumerate(metadata["tensor_specs"]) if spec["size"]]
+    actual, received_size = consumer.get("0", "1", "empty-slots", metadata)
+    if isinstance(payload, dict):
+        assert actual["label"] == payload["label"]
+        torch.testing.assert_close(actual["leaves"], payload["leaves"], rtol=0, atol=0)
+    else:
+        torch.testing.assert_close(actual, payload, rtol=0, atol=0)
+    assert size == received_size
+    if case in ("empty", "all_empty"):
+        assert not copying_native_agent
+    assert not producer._pending and not producer._agent.registered
+    assert not consumer._agent.registered
+
+
+@pytest.mark.parametrize("direct", [False, True])
+@pytest.mark.parametrize("outcome", ["done", "error", "timeout", "unknown"])
+@pytest.mark.usefixtures("reliable_claim_queries")
+def test_read_ownership_through_terminal_and_deferred_paths(
+    producer, consumer, copying_native_agent, monkeypatch, direct, outcome
+):
+    import threading
+
+    _, _, metadata = producer.put("0", "1", "active-read", torch.ones(2))
+    entered, proceed = threading.Event(), threading.Event()
+    state = ["PROC"]
+    monkeypatch.setattr(consumer._agent, "check_xfer_state", lambda handle: state[0])
+
+    def wait(handle, key):
+        entered.set()
+        assert proceed.wait(5)
+        if outcome == "done":
+            state[0] = "DONE"
+        elif outcome == "error":
+            state[0] = "ERR"
+            raise RuntimeError("terminal error")
+        else:
+            if outcome == "unknown":
+                state[0] = "UNKNOWN"
+            raise TimeoutError("still owned")
+
+    monkeypatch.setattr(consumer, "_wait_for_transfer", wait)
+    worker = threading.Thread(target=consumer.get, args=("0", "1", "active-read", metadata if direct else None))
+    worker.start()
+    try:
+        assert entered.wait(5)
+        pending = producer._pending["active-read"]
+        pending.deadline = 0
+        producer._cleanup_expired_pending()
+        producer.cleanup("active-read")
+        assert producer._pending["active-read"] is pending
+        assert producer._agent.registered
+    finally:
+        proceed.set()
+        worker.join(5)
+    assert not worker.is_alive()
+    if outcome in ("timeout", "unknown"):
+        assert producer._agent.registered
+        assert consumer._deferred_transfers
+        consumer._reap_deferred_transfers()
+        assert producer._agent.registered
+        state[0] = "DONE"
+        deadline = time.monotonic() + 5
+        while producer._pending and time.monotonic() < deadline:
+            time.sleep(0.01)
+    assert not producer._pending
+    assert not producer._agent.registered
+
+
+class _FakeNixlAgent:
+    def __init__(self, name, config=None):
+        self.name = name
+        self.config = config
+        self.registered = []
+
+    def get_reg_descs(self, regions, memory_type):
+        return ("reg", tuple(regions), memory_type)
+
+    def register_memory(self, descs, backends=None):
+        self.registered.append(descs)
+
+    def deregister_memory(self, descs):
+        if descs in self.registered:
+            self.registered.remove(descs)
+
+    def get_agent_metadata(self):
+        return f"agent-metadata-{self.name}".encode()
+
+
+@pytest.fixture
+def nixl_connector_cls(monkeypatch):
+    """Import NixlConnector with vLLM's optional NIXL dependency stubbed out."""
+    stub = types.ModuleType("vllm.distributed.nixl_utils")
+    stub.NixlWrapper = _FakeNixlAgent  # type: ignore[attr-defined]
+    config_module = types.ModuleType("test_nixl_config_api")
+    config_sync_type = types.SimpleNamespace(NIXL_THREAD_SYNC_STRICT="strict")
+    config_module.nixl_thread_sync_t = config_sync_type  # type: ignore[attr-defined]
+
+    def agent_config(**kwargs):
+        return kwargs
+
+    agent_config.__module__ = config_module.__name__
+    config_module.nixl_agent_config = agent_config  # type: ignore[attr-defined]
+    stub.nixl_agent_config = agent_config  # type: ignore[attr-defined]
+    monkeypatch.setitem(sys.modules, "vllm.distributed.nixl_utils", stub)
+    monkeypatch.setitem(sys.modules, config_module.__name__, config_module)
+    sync_type = types.SimpleNamespace(NIXL_THREAD_SYNC_STRICT="wrong-public-enum")
+    nixl_module = types.ModuleType("nixl")
+    nixl_module.nixl_thread_sync_t = sync_type  # type: ignore[attr-defined]
+    monkeypatch.setitem(sys.modules, "nixl", nixl_module)
+
+    from vllm_omni.distributed.omni_connectors.connectors.nixl_connector import NixlConnector
+
+    return NixlConnector
+
+
+@pytest.fixture
+def producer(nixl_connector_cls):
+    connector = nixl_connector_cls({"role": "sender", "host": "127.0.0.1", "zmq_port": PORT})
+    yield connector
+    # These control-plane tests do not submit DMA. Explicitly complete claims
+    # made by metadata-only probes before tearing down the shared port.
+    for key, pending in list(connector._pending.items()):
+        for claim in list(pending.claims):
+            from vllm_omni.distributed.omni_connectors.connectors.nixl_connector import _XFER_DONE_MSG
+
+            connector._handle_handshake_message(
+                _XFER_DONE_MSG
+                + msgspec.msgpack.encode({"key": key, "generation": pending.generation, "claim_id": claim})
+            )
+    connector.close()
+
+
+@pytest.fixture
+def consumer(nixl_connector_cls):
+    connector = nixl_connector_cls({"role": "receiver", "sender_host": "127.0.0.1", "sender_zmq_port": PORT})
+    yield connector
+    connector.close()
+
+
+@pytest.fixture
+def reliable_claim_queries(producer, consumer, monkeypatch):
+    """Ownership probes need exact claims, not claims retained after lost replies.
+
+    Exercise the real resolver, wire encoding and producer handler synchronously;
+    discovery tests separately cover bounded queries over real ZMQ sockets.
+    """
+    import uuid
+
+    from vllm_omni.distributed.omni_connectors.connectors.nixl_connector import _GET_META_MSG, _META_NOT_FOUND
+
+    def query(key, host, port, *, generation=None):
+        assert (host, port) == (producer.host, producer._zmq_port)
+        request = {"key": key, "generation": generation, "claim_id": uuid.uuid4().hex}
+        reply = producer._handle_handshake_message(_GET_META_MSG + msgspec.msgpack.encode(request))
+        return None if reply == _META_NOT_FOUND else msgspec.msgpack.decode(reply)
+
+    monkeypatch.setattr(consumer, "_query_metadata_at", query)
+
+
+def test_put_publishes_its_handshake_endpoint(producer):
+    ok, size, metadata = producer.put("0", "1", "req-0", torch.arange(8, dtype=torch.float32))
+
+    assert ok is True
+    assert size == 32
+    assert metadata["sender_host"] == "127.0.0.1"
+    assert metadata["sender_zmq_port"] == PORT
+
+
+def test_agent_uses_strict_thread_synchronization(producer):
+    assert producer._agent.config["sync_mode"] == "strict"
+
+
+def test_handshake_serves_metadata_when_caller_has_none(producer, consumer):
+    _, _, published = producer.put("0", "1", "req-1", torch.arange(4, dtype=torch.float32))
+
+    resolved = _wait_for_metadata(consumer, "req-1")
+
+    # msgpack has no tuple type, so region descriptors arrive as lists; get()
+    # re-tuples them before handing them to NIXL.
+    assert resolved.pop("claim_id")
+    assert resolved == msgspec.msgpack.decode(msgspec.msgpack.encode(published))
+    assert [tuple(region) for group in resolved["descriptor_groups"] for region in group["regions"]] == [
+        region for group in published["descriptor_groups"] for region in group["regions"]
+    ]
+
+
+def test_legacy_metadata_without_generation_skips_the_handshake(consumer):
+    """Externally owned metadata without a generation needs no ownership claim."""
+    direct = {"schema_version": 1, "kind": "tensors", "tensor_specs": []}
+
+    assert consumer._resolve_metadata("req-2", direct) is direct
+
+
+def test_source_endpoint_metadata_overrides_configured_sender(consumer, monkeypatch):
+    queried = []
+    expected = {"schema_version": 1, "kind": "tensors", "tensor_specs": []}
+
+    def query(get_key, host, port):
+        queried.append((get_key, host, port))
+        return expected
+
+    monkeypatch.setattr(consumer, "_query_metadata_at", query)
+
+    resolved = consumer._resolve_metadata(
+        "req-tp4-rank3",
+        {"source_host": "10.0.0.3", "source_port": PORT + 3 * 16},
+    )
+
+    assert resolved is expected
+    assert queried == [("req-tp4-rank3", "10.0.0.3", PORT + 3 * 16)]
+
+
+def test_unknown_key_is_queried_once(producer, consumer, monkeypatch):
+    socket = consumer._get_req_socket(f"tcp://127.0.0.1:{PORT}")
+    send_count = 0
+    original_send = socket.send
+
+    def count_send(message):
+        nonlocal send_count
+        send_count += 1
+        return original_send(message)
+
+    monkeypatch.setattr(socket, "send", count_send)
+
+    assert consumer._resolve_metadata("never-published", None) is None
+    assert send_count == 1
+    assert socket.getsockopt(zmq.RCVTIMEO) == 10
+
+
+@pytest.mark.usefixtures("reliable_claim_queries")
+def test_transfer_done_releases_the_producer_buffer(producer, consumer):
+    _, _, metadata = producer.put("0", "1", "req-3", torch.arange(4, dtype=torch.float32))
+    assert producer._pending and producer._agent.registered
+
+    metadata = consumer._resolve_metadata("req-3", metadata)
+    consumer._notify_transfer_done("req-3", metadata)
+
+    assert producer._pending == {}
+    assert producer._published == {}
+    assert producer._agent.registered == []
+
+
+def test_direct_metadata_has_ephemeral_ownership_endpoint(nixl_connector_cls):
+    connector = nixl_connector_cls({})
+    try:
+        assert connector._zmq_ctx is not None
+        assert connector._listener_thread is not None
+        _, _, metadata = connector.put("0", "1", "req-4", torch.zeros(2))
+        assert metadata["sender_host"]
+        assert metadata["sender_zmq_port"] > 0
+    finally:
+        connector.close()
+
+
+def test_idle_producer_lease_expires_without_another_put(nixl_connector_cls):
+    connector = nixl_connector_cls({"role": "sender", "lease_seconds": 0.01})
+    try:
+        connector.put("0", "1", "req-expire", torch.zeros(2))
+
+        deadline = time.monotonic() + 1.0
+        while connector._pending and time.monotonic() < deadline:
+            time.sleep(0.01)
+
+        assert connector._pending == {}
+        assert connector._published == {}
+        assert connector._agent.registered == []
+        assert connector._registered_descs == []
+    finally:
+        connector.close()
+
+
+def test_close_stops_lease_reaper(nixl_connector_cls):
+    connector = nixl_connector_cls({"role": "sender"})
+    lease_thread = connector._lease_thread
+
+    connector.close()
+
+    assert lease_thread is not None
+    assert not lease_thread.is_alive()
+    assert connector._lease_thread is None
+
+
+def test_deferred_transfer_is_retained_while_active(nixl_connector_cls):
+    from vllm_omni.distributed.omni_connectors.connectors.nixl_connector import _DeferredTransfer
+
+    connector = nixl_connector_cls({"role": "receiver"})
+    released = []
+    connector._agent.check_xfer_state = lambda handle: "PROC"
+    connector._agent.release_xfer_handle = lambda handle: released.append(("handle", handle))
+    connector._agent.release_dlist_handle = lambda handle: released.append(("dlist", handle))
+    connector._agent.remove_remote_agent = lambda agent: released.append(("agent", agent))
+    transfer = _DeferredTransfer(
+        tensors=[torch.zeros(1)],
+        registrations=["registration"],
+        dlists=["local", "remote"],
+        handles=["transfer"],
+        remote_agent="producer",
+    )
+    connector._defer_transfer(transfer)
+    try:
+        connector._reap_deferred_transfers()
+
+        assert released == []
+        assert transfer in connector._deferred_transfers
+        assert transfer.tensors
+    finally:
+        connector._agent.check_xfer_state = lambda handle: "DONE"
+        connector.close()
+
+
+def test_deferred_transfer_releases_exactly_once_after_done(nixl_connector_cls):
+    from vllm_omni.distributed.omni_connectors.connectors.nixl_connector import _DeferredTransfer
+
+    connector = nixl_connector_cls({"role": "receiver"})
+    released = []
+    connector._agent.check_xfer_state = lambda handle: "DONE"
+    connector._agent.release_xfer_handle = lambda handle: released.append(("handle", handle))
+    connector._agent.release_dlist_handle = lambda handle: released.append(("dlist", handle))
+    connector._agent.remove_remote_agent = lambda agent: released.append(("agent", agent))
+    connector._agent.deregister_memory = lambda descs: released.append(("registration", descs))
+    transfer = _DeferredTransfer(
+        tensors=[torch.zeros(1)],
+        registrations=["registration"],
+        dlists=["local", "remote"],
+        handles=["transfer"],
+        remote_agent="producer",
+    )
+    connector._defer_transfer(transfer)
+    try:
+        connector._reap_deferred_transfers()
+        connector._reap_deferred_transfers()
+
+        assert released == [
+            ("handle", "transfer"),
+            ("dlist", "local"),
+            ("dlist", "remote"),
+            ("agent", "producer"),
+            ("registration", "registration"),
+        ]
+        assert connector._deferred_transfers == []
+        assert transfer.tensors == []
+    finally:
+        connector.close()
+
+
+def test_active_sibling_transfer_requires_deferred_ownership(nixl_connector_cls):
+    connector = nixl_connector_cls({"role": "receiver"})
+    connector._agent.check_xfer_state = lambda handle: {"failed": "ERR", "active": "PROC"}[handle]
+    try:
+        assert connector._transfers_may_be_active(["failed", "active"]) is True
+        assert connector._transfers_may_be_active(["failed"]) is False
+    finally:
+        connector.close()
+
+
+def test_get_defers_complete_ownership_when_sibling_transfer_is_active(nixl_connector_cls):
+    connector = nixl_connector_cls({"role": "receiver"})
+    connector._agent.add_remote_agent = lambda metadata: "producer"
+    connector._agent.get_xfer_descs = lambda regions, memory_type: (regions, memory_type)
+    connector._agent.prep_xfer_dlist = lambda agent, descs: (agent, tuple(descs[0]))
+    handles = iter(["failed", "active"])
+    connector._agent.make_prepped_xfer = lambda *_args: next(handles)
+    connector._agent.transfer = lambda handle: None
+    connector._agent.check_xfer_state = lambda handle: {"failed": "ERR", "active": "PROC"}[handle]
+    released = []
+    connector._agent.release_xfer_handle = lambda handle: released.append(("handle", handle))
+    connector._agent.release_dlist_handle = lambda handle: released.append(("dlist", handle))
+    connector._agent.remove_remote_agent = lambda agent: released.append(("agent", agent))
+    connector._agent.deregister_memory = lambda descs: released.append(("registration", descs))
+    metadata = {
+        "schema_version": 1,
+        "kind": "tensors",
+        "agent_metadata": b"producer-metadata",
+        "tensor_specs": [
+            {"shape": [1], "dtype": "torch.float32", "device": "cpu", "size": 4},
+            {"shape": [1], "dtype": "torch.float32", "device": "cpu", "size": 4},
+        ],
+        "descriptor_groups": [
+            {"memory_type": "DRAM", "tensor_indices": [0], "regions": [(1, 4, 0, "")]},
+            {"memory_type": "DRAM", "tensor_indices": [1], "regions": [(2, 4, 0, "")]},
+        ],
+        "size": 8,
+    }
+
+    try:
+        assert connector.get("0", "1", "req-active-sibling", metadata) is None
+        assert released == []
+        assert len(connector._deferred_transfers) == 1
+        deferred = connector._deferred_transfers[0]
+        assert deferred.handles == ["failed", "active"]
+        assert len(deferred.registrations) == 2
+        assert len(deferred.dlists) == 4
+        assert deferred.remote_agent == "producer"
+        assert len(deferred.tensors) == 2
+    finally:
+        connector._agent.check_xfer_state = lambda handle: "DONE"
+        connector.close()
+
+
+@pytest.mark.parametrize(
+    "payload,expected_kind",
+    [
+        (torch.zeros(4), "tensors"),
+        ([torch.zeros(2), torch.ones(3)], "tensors"),
+        ({"hidden": torch.zeros(4), "meta": {"token_role_ids": [1, 2]}}, "structured"),
+        ({"prompt": "a cat", "steps": 8}, "object"),
+    ],
+)
+def test_payload_kinds_round_trip_through_the_handshake(producer, consumer, payload, expected_kind):
+    _, _, published = producer.put("0", "1", "req-kind", payload)
+    assert published["kind"] == expected_kind
+
+    resolved = _wait_for_metadata(consumer, "req-kind")
+
+    assert resolved["kind"] == expected_kind
+    assert resolved["tensor_specs"] == published["tensor_specs"]
+
+
+def test_structured_payload_groups_descriptors_by_memory_type(producer, monkeypatch):
+    monkeypatch.setattr(
+        producer,
+        "_resolve_memory_type",
+        lambda tensor: "DRAM" if tensor.dtype == torch.uint8 else "VRAM",
+    )
+
+    _, _, metadata = producer.put(
+        "0",
+        "1",
+        "req-mixed",
+        {"meta": "value", "hidden": torch.ones(4, dtype=torch.float32)},
+    )
+
+    assert metadata["schema_version"] == 1
+    assert metadata["descriptor_groups"] == [
+        {
+            "memory_type": "DRAM",
+            "tensor_indices": [0],
+            "regions": metadata["descriptor_groups"][0]["regions"],
+        },
+        {
+            "memory_type": "VRAM",
+            "tensor_indices": [1],
+            "regions": metadata["descriptor_groups"][1]["regions"],
+        },
+    ]
+    assert len(producer._agent.registered) == 2
+
+
+def test_omni_payload_struct_uses_structured_tensor_path(producer):
+    payload = OmniPayloadStruct(
+        hidden_states=HiddenStatesStruct(output=torch.ones(4, dtype=torch.float32)),
+        meta=MetaStruct(left_context_size=2),
+    )
+
+    _, _, metadata = producer.put("0", "1", "req-struct", payload)
+    skeleton, tensors = producer._extract_tensor_leaves(payload)
+
+    assert metadata["kind"] == "structured"
+    assert len(tensors) == 1
+    assert torch.equal(tensors[0], payload.hidden_states.output)
+    assert skeleton["meta"]["left_context_size"] == 2
+
+
+def test_partial_group_registration_failure_rolls_back(producer, monkeypatch):
+    monkeypatch.setattr(
+        producer,
+        "_resolve_memory_type",
+        lambda tensor: "DRAM" if tensor.dtype == torch.uint8 else "VRAM",
+    )
+    original_register = producer._agent.register_memory
+
+    def fail_second_group(descs, backends=None):
+        if descs[2] == "VRAM":
+            raise RuntimeError("registration failed")
+        original_register(descs, backends=backends)
+
+    monkeypatch.setattr(producer._agent, "register_memory", fail_second_group)
+
+    success, _, metadata = producer.put(
+        "0",
+        "1",
+        "req-partial",
+        {"meta": "value", "hidden": torch.ones(4, dtype=torch.float32)},
+    )
+
+    assert success is False
+    assert metadata is None
+    assert producer._agent.registered == []
+    assert producer._registered_descs == []
+    assert "req-partial" not in producer._pending
+
+
+def test_reusing_put_key_releases_previous_registration(producer):
+    producer.put("0", "1", "req-reuse", torch.zeros(2))
+    previous_registration = producer._agent.registered[0]
+
+    producer.put("0", "1", "req-reuse", torch.ones(2))
+
+    assert previous_registration not in producer._agent.registered
+    assert len(producer._agent.registered) == 1
+    assert len(producer._registered_descs) == 1
+
+
+def test_expired_snapshot_cannot_claim_replacement(producer):
+    from vllm_omni.distributed.omni_connectors.connectors.nixl_connector import _PendingPayload
+
+    old = _PendingPayload([torch.zeros(1)], ["old"], 0.0)
+    replacement = _PendingPayload([torch.ones(1)], ["new"], time.monotonic() + 60)
+    producer._pending["req-race"] = replacement
+
+    assert producer._take_pending("req-race", expected=old) is None
+    assert producer._pending["req-race"] is replacement
+
+
+@pytest.mark.parametrize(
+    "indices",
+    [
+        [0, 0],
+        [0],
+        [0, 2],
+        [-1, 0],
+    ],
+)
+def test_descriptor_groups_require_exact_tensor_index_partition(nixl_connector_cls, indices):
+    metadata = {
+        "schema_version": 1,
+        "descriptor_groups": [
+            {
+                "memory_type": "DRAM",
+                "tensor_indices": indices,
+                "regions": [(1, 4, 0, "")] * len(indices),
+            }
+        ],
+    }
+
+    with pytest.raises(RuntimeError, match="exact partition"):
+        nixl_connector_cls._validated_descriptor_groups(
+            metadata, [{"shape": [1], "dtype": "torch.float32", "size": 4}] * 2
+        )
+
+
+def test_receive_device_ignores_the_producer_index(nixl_connector_cls):
+    """A producer on cuda:3 must not dictate the consumer's card."""
+    connector = nixl_connector_cls({})
+    try:
+        assert connector._resolve_receive_device("cpu") == torch.device("cpu")
+        assert connector._resolve_receive_device(None) == torch.device("cpu")
+    finally:
+        connector.close()
+
+
+def test_receive_device_config_wins(nixl_connector_cls):
+    connector = nixl_connector_cls({"receive_device": "cpu"})
+    try:
+        assert connector._resolve_receive_device("cuda:3") == torch.device("cpu")
+    finally:
+        connector.close()
diff --git a/tests/distributed/omni_connectors/test_nixl_connector_native.py b/tests/distributed/omni_connectors/test_nixl_connector_native.py
new file mode 100644
index 000000000..e0936a02d
--- /dev/null
+++ b/tests/distributed/omni_connectors/test_nixl_connector_native.py
@@ -0,0 +1,204 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import multiprocessing as mp
+import socket
+import time
+from typing import Any
+
+import pytest
+import torch
+
+from vllm_omni.data_entry_keys import HiddenStatesStruct, MetaStruct, OmniPayloadStruct
+from vllm_omni.platforms import current_omni_platform
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cuda, pytest.mark.parallel]
+
+
+def _native_nixl_available() -> bool:
+    try:
+        from vllm.distributed.nixl_utils import NixlWrapper
+    except ImportError:
+        return False
+    return NixlWrapper is not None and torch.cuda.is_available() and torch.accelerator.device_count() >= 2
+
+
+def _free_port() -> int:
+    with socket.socket() as sock:
+        sock.bind(("127.0.0.1", 0))
+        return int(sock.getsockname()[1])
+
+
+def _producer(port: int, ready: Any, consumed: Any, result: Any, claimed: Any, proceed: Any, wire: Any) -> None:
+    from vllm_omni.distributed.omni_connectors.connectors.nixl_connector import NixlConnector
+
+    current_omni_platform.set_device(0)
+    connector = NixlConnector(
+        {
+            "role": "sender",
+            "host": "127.0.0.1",
+            "zmq_port": port,
+            "agent_name": "native-smoke-producer",
+        }
+    )
+    try:
+        payload = OmniPayloadStruct(
+            hidden_states=HiddenStatesStruct(output=torch.arange(8, dtype=torch.float32, device="cuda:0")),
+            meta=MetaStruct(token_role_ids=torch.tensor([1, 2, 3], dtype=torch.int64, device="cpu")),
+            kv_metadata={"empty": torch.empty((2, 0, 3), device="cuda:0")},
+            request_id="native-smoke",
+        )
+        success, size, metadata = connector.put("0", "1", "native-smoke", payload)
+        result.put(("put", success, size, metadata["kind"] if metadata else None))
+        wire.put(metadata)
+        ready.set()
+        if not claimed.wait(timeout=30):
+            raise TimeoutError("consumer did not claim source")
+        pending = connector._pending["native-smoke"]
+        pending.deadline = 0
+        connector._cleanup_expired_pending()
+        connector.cleanup("native-smoke")
+        assert connector._pending["native-smoke"] is pending
+        assert pending.claims and connector._registered_descs
+        result.put(("source_retained", len(pending.claims)))
+        proceed.set()
+        if not consumed.wait(timeout=30):
+            raise TimeoutError("consumer did not complete the native NIXL transfer")
+        deadline = time.monotonic() + 10
+        while connector._pending and time.monotonic() < deadline:
+            time.sleep(0.01)
+        result.put(("cleanup", len(connector._pending), len(connector._registered_descs)))
+    except Exception as error:
+        result.put(("producer_error", repr(error)))
+        raise
+    finally:
+        connector.close()
+
+
+def _consumer(
+    port: int, ready: Any, consumed: Any, result: Any, claimed: Any, proceed: Any, wire: Any, direct: bool
+) -> None:
+    from vllm_omni.distributed.omni_connectors.kv_transfer_manager import (
+        OmniKVCacheConfig,
+        OmniKVTransferManager,
+    )
+
+    if not ready.wait(timeout=30):
+        raise TimeoutError("producer did not publish native NIXL metadata")
+    current_omni_platform.set_device(1)
+    manager = OmniKVTransferManager(
+        OmniKVCacheConfig(
+            connector_config={
+                "type": "NixlConnector",
+                "role": "receiver",
+                "host": "127.0.0.1",
+                "zmq_port": port,  # Shared deployment edge: already bound by producer.
+                "backends": ["UCX"],
+                "receive_device": "cuda",
+                "agent_name": "native-smoke-consumer",
+            },
+            from_stage="0",
+            to_stage="1",
+            stage_id=1,
+            need_recv_cache=direct,  # Exercise both payload-only and KV receiver setup.
+        )
+    )
+    manager.update_sender_info({"host": "127.0.0.1", "zmq_port": port})
+    connector = manager.connector
+    assert connector is not None, "Receiver must not bind the producer's occupied port"
+    assert connector._zmq_port is None and not connector._serving_handshake
+    assert connector._backends == ["UCX"]
+    try:
+        original_wait = connector._wait_for_transfer
+        states = []
+
+        def wait(handle, key):
+            states.append(connector._agent.check_xfer_state(handle))
+            claimed.set()
+            if not proceed.wait(timeout=30):
+                raise TimeoutError("producer did not verify active ownership")
+            original_wait(handle, key)
+
+        connector._wait_for_transfer = wait
+        metadata = wire.get(timeout=5)
+        received = None
+        deadline = time.monotonic() + 30
+        while received is None and time.monotonic() < deadline:
+            received = connector.get(
+                "0",
+                "1",
+                "native-smoke",
+                metadata if direct else {"source_host": "127.0.0.1", "source_port": port},
+            )
+        if received is None:
+            raise TimeoutError("native NIXL transfer did not complete")
+        payload, size = received
+        hidden = payload["hidden_states"]["output"]
+        token_roles = payload["meta"]["token_role_ids"]
+        empty = payload["kv_metadata"]["empty"]
+        assert empty.shape == (2, 0, 3) and str(empty.device) == "cuda:1"
+        result.put(("native_states", states))
+        result.put(
+            (
+                "get",
+                size,
+                hidden.cpu().tolist(),
+                str(hidden.dtype),
+                list(hidden.shape),
+                str(hidden.device),
+                token_roles.cpu().tolist(),
+                str(token_roles.dtype),
+                list(token_roles.shape),
+                str(token_roles.device),
+            )
+        )
+        consumed.set()
+    except Exception as error:
+        result.put(("consumer_error", repr(error)))
+        raise
+    finally:
+        connector.close()
+
+
+@pytest.mark.skipif(not _native_nixl_available(), reason="requires NIXL and at least two CUDA devices")
+@pytest.mark.parametrize("direct", [False, True])
+def test_native_two_process_structured_mixed_device_transfer(direct):
+    context = mp.get_context("spawn")
+    ready = context.Event()
+    consumed = context.Event()
+    claimed = context.Event()
+    proceed = context.Event()
+    wire = context.Queue()
+    result = context.Queue()
+    port = _free_port()
+    producer = context.Process(target=_producer, args=(port, ready, consumed, result, claimed, proceed, wire))
+    consumer = context.Process(target=_consumer, args=(port, ready, consumed, result, claimed, proceed, wire, direct))
+
+    producer.start()
+    consumer.start()
+    producer.join(timeout=60)
+    consumer.join(timeout=60)
+    if producer.is_alive():
+        producer.terminate()
+    if consumer.is_alive():
+        consumer.terminate()
+
+    records = [result.get(timeout=5) for _ in range(5)]
+    print("Native ownership records:", records)
+    assert producer.exitcode == 0, records
+    assert consumer.exitcode == 0, records
+    assert records[0][0] == "put"
+    assert records[0][1] is True
+    assert records[0][2] >= 56
+    assert records[0][3] == "structured"
+    get_record = next(record for record in records if record[0] == "get")
+    assert get_record[1] == records[0][2]
+    assert get_record[2:6] == (
+        list(range(8)),
+        "torch.float32",
+        [8],
+        "cuda:1",
+    )
+    assert get_record[6:] == ([1, 2, 3], "torch.int64", [3], "cuda:1")
+    assert next(record for record in records if record[0] == "cleanup") == ("cleanup", 0, 0)
+    assert next(record for record in records if record[0] == "source_retained") == ("source_retained", 1)
diff --git a/tests/docs/test_generate_argparse.py b/tests/docs/test_generate_argparse.py
new file mode 100644
index 000000000..16b92365f
--- /dev/null
+++ b/tests/docs/test_generate_argparse.py
@@ -0,0 +1,24 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import importlib.util
+from pathlib import Path
+
+import pytest
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+ROOT_DIR = Path(__file__).parents[2]
+HOOK_PATH = ROOT_DIR / "docs/mkdocs/hooks/generate_argparse.py"
+SPEC = importlib.util.spec_from_file_location("generate_argparse", HOOK_PATH)
+assert SPEC and SPEC.loader
+generate_argparse = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(generate_argparse)
+
+
+def test_static_serve_parser_supports_video_output_transport() -> None:
+    parser = generate_argparse.create_parser_subparser_init(generate_argparse.OmniServeCommand)
+
+    args = parser.parse_args(["--omni", "--video-output-transport", '{"enable_device_postprocess": true}'])
+
+    assert args.video_output_transport == {"enable_device_postprocess": True}
diff --git a/tests/e2e/accuracy/helpers.py b/tests/e2e/accuracy/helpers.py
index cc1b7c589..0ea9074b8 100644
--- a/tests/e2e/accuracy/helpers.py
+++ b/tests/e2e/accuracy/helpers.py
@@ -135,6 +135,32 @@ def resolve_similarity_thresholds(
     return table.get(profile, table[DEFAULT_DEVICE_PROFILE])
 
 
+def resolve_device_threshold(
+    thresholds: float | int | Mapping[str, float],
+    *,
+    device_name: str | None = None,
+    label: str = "threshold",
+) -> tuple[str, float]:
+    """Resolve a scalar or per-GPU threshold for the current CUDA device.
+
+    Returns ``(profile_key, threshold)``. A bare number uses profile ``default``.
+    A mapping matches keys as substrings of the device name via
+    ``resolve_device_profile`` (for example ``{"H100": 0.3, "B200": 0.36}``).
+    Prefer an explicit ``default`` entry when unmatched GPUs should fall back;
+    otherwise unmatched devices raise.
+    """
+    if isinstance(thresholds, float | int):
+        return DEFAULT_DEVICE_PROFILE, float(thresholds)
+
+    profile = resolve_device_profile(device_name, profiles=thresholds)
+    if profile in thresholds:
+        return profile, float(thresholds[profile])
+    if DEFAULT_DEVICE_PROFILE in thresholds:
+        return DEFAULT_DEVICE_PROFILE, float(thresholds[DEFAULT_DEVICE_PROFILE])
+    known = ", ".join(str(key) for key in thresholds)
+    raise RuntimeError(f"no {label} entry for device profile {profile!r}; known: {known}")
+
+
 _SSIM_RE = re.compile(r"All:(?P<score>[0-9.]+)")
 _PSNR_RE = re.compile(r"average:(?P<score>[0-9.]+)")
 
diff --git a/tests/e2e/accuracy/hunyuanvideo15_i2v/test_hunyuanvideo15_i2v_video_similarity.py b/tests/e2e/accuracy/hunyuanvideo15_i2v/test_hunyuanvideo15_i2v_video_similarity.py
index eb8f2d769..f5df4004f 100644
--- a/tests/e2e/accuracy/hunyuanvideo15_i2v/test_hunyuanvideo15_i2v_video_similarity.py
+++ b/tests/e2e/accuracy/hunyuanvideo15_i2v/test_hunyuanvideo15_i2v_video_similarity.py
@@ -183,7 +183,7 @@ def _generate_online_video(
 
 
 @pytest.mark.benchmark
-@hardware_test(res={"cuda": "H100"}, num_cards=1)
+@hardware_test(res={"cuda": ["H100", "B200"]}, num_cards=1)
 def test_hunyuanvideo15_i2v_diffusers_offline_generates_video(
     hunyuanvideo15_i2v_image_source: str | None,
 ) -> None:
@@ -203,7 +203,7 @@ def test_hunyuanvideo15_i2v_diffusers_offline_generates_video(
 
 
 @pytest.mark.benchmark
-@hardware_test(res={"cuda": "H100"}, num_cards=1)
+@hardware_test(res={"cuda": ["H100", "B200"]}, num_cards=1)
 @pytest.mark.parametrize("omni_server", SERVER_CASES, indirect=True)
 def test_hunyuanvideo15_i2v_online_serving_generates_video(
     omni_server,
@@ -229,7 +229,7 @@ def test_hunyuanvideo15_i2v_online_serving_generates_video(
 
 
 @pytest.mark.benchmark
-@hardware_test(res={"cuda": "H100"}, num_cards=1)
+@hardware_test(res={"cuda": ["H100", "B200"]}, num_cards=1)
 def test_hunyuanvideo15_i2v_serving_matches_offline_video_similarity(
     hunyuanvideo15_i2v_image_source: str | None,
 ) -> None:
diff --git a/tests/e2e/accuracy/hunyuanvideo15_t2v/test_hunyuanvideo15_t2v_video_similarity.py b/tests/e2e/accuracy/hunyuanvideo15_t2v/test_hunyuanvideo15_t2v_video_similarity.py
index f5b90822d..f16813f12 100644
--- a/tests/e2e/accuracy/hunyuanvideo15_t2v/test_hunyuanvideo15_t2v_video_similarity.py
+++ b/tests/e2e/accuracy/hunyuanvideo15_t2v/test_hunyuanvideo15_t2v_video_similarity.py
@@ -144,7 +144,7 @@ def _generate_online_video(*, omni_server, online_client, timeout_seconds: int)
 
 
 @pytest.mark.benchmark
-@hardware_test(res={"cuda": "H100"}, num_cards=1)
+@hardware_test(res={"cuda": ["H100", "B200"]}, num_cards=1)
 def test_hunyuanvideo15_t2v_diffusers_offline_generates_video() -> None:
     if not torch.cuda.is_available():
         pytest.skip("HunyuanVideo-1.5 T2V offline accuracy test requires CUDA.")
@@ -160,7 +160,7 @@ def test_hunyuanvideo15_t2v_diffusers_offline_generates_video() -> None:
 
 
 @pytest.mark.benchmark
-@hardware_test(res={"cuda": "H100"}, num_cards=1)
+@hardware_test(res={"cuda": ["H100", "B200"]}, num_cards=1)
 @pytest.mark.parametrize("omni_server", SERVER_CASES, indirect=True)
 def test_hunyuanvideo15_t2v_online_serving_generates_video(
     omni_server,
@@ -182,7 +182,7 @@ def test_hunyuanvideo15_t2v_online_serving_generates_video(
 
 
 @pytest.mark.benchmark
-@hardware_test(res={"cuda": "H100"}, num_cards=1)
+@hardware_test(res={"cuda": ["H100", "B200"]}, num_cards=1)
 def test_hunyuanvideo15_t2v_serving_matches_offline_video_similarity() -> None:
     if not torch.cuda.is_available():
         pytest.skip("HunyuanVideo-1.5 T2V video similarity test requires CUDA.")
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 e688b9360..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 = {
@@ -141,7 +146,7 @@ def _inline_daily_omni_media(monkeypatch: pytest.MonkeyPatch) -> None:
 
 
 @requires_daily_omni_deps
-@hardware_test(res={"cuda": "H100", "npu": "A3"}, num_cards=1)
+@hardware_test(res={"cuda": ["H100", "B200"], "npu": "A3"}, num_cards=1)
 @pytest.mark.parametrize("omni_server", daily_test_params, indirect=True)
 def test_minicpmo_4_5_daily_omni_accuracy_bench(omni_server) -> None:
     _require_vllm_cli()
@@ -174,7 +179,7 @@ def test_minicpmo_4_5_daily_omni_accuracy_bench(omni_server) -> None:
     assert _acc_bench.run_acc_benchmark(_acc_bench.parse_acc_benchmark_args(argv)) == 0
 
 
-@hardware_test(res={"cuda": "H100", "npu": "A3"}, num_cards=1)
+@hardware_test(res={"cuda": ["H100", "B200"], "npu": "A3"}, num_cards=1)
 @pytest.mark.parametrize("omni_server", seed_test_params, indirect=True)
 def test_minicpmo_4_5_seed_tts_wer_bench(omni_server) -> None:
     _require_vllm_cli()
@@ -200,7 +205,7 @@ def test_minicpmo_4_5_seed_tts_wer_bench(omni_server) -> None:
     assert _acc_bench.run_acc_benchmark(_acc_bench.parse_acc_benchmark_args(argv)) == 0
 
 
-@hardware_test(res={"cuda": "H100"}, num_cards=1)
+@hardware_test(res={"cuda": ["H100", "B200"]}, num_cards=1)
 @pytest.mark.parametrize("omni_server", duplex_accuracy_test_params, indirect=True)
 def test_minicpmo_4_5_duplex_seed_tts_wer_bench(omni_server) -> None:
     """Gate Seed-TTS WER through the explicit Realtime TTS contract."""
diff --git a/tests/e2e/accuracy/minimax_h3/test_minimax_h3_i2va_ref2va_similarity.py b/tests/e2e/accuracy/minimax_h3/test_minimax_h3_i2va_ref2va_similarity.py
index 60f829bee..4ae45e4e1 100644
--- a/tests/e2e/accuracy/minimax_h3/test_minimax_h3_i2va_ref2va_similarity.py
+++ b/tests/e2e/accuracy/minimax_h3/test_minimax_h3_i2va_ref2va_similarity.py
@@ -138,8 +138,6 @@ def _server_args() -> list[str]:
         "--vae-parallel-mode",
         "tile",
         "--vae-use-tiling",
-        "--diffusion-attention-backend",
-        "FLASH_ATTN",
         "--stage-init-timeout",
         "1800",
         "--init-timeout",
@@ -228,7 +226,7 @@ def _assert_official_video(
     )
 
 
-@hardware_test(res={"cuda": "H100"}, num_cards=4)
+@hardware_test(res={"cuda": ["H100", "B200"]}, num_cards=4)
 def test_minimax_h3_i2va_matches_official_reference(
     accuracy_artifact_root: Path,
 ) -> None:
@@ -304,7 +302,7 @@ def test_minimax_h3_i2va_matches_official_reference(
     )
 
 
-@hardware_test(res={"cuda": "H100"}, num_cards=4)
+@hardware_test(res={"cuda": ["H100", "B200"]}, num_cards=4)
 def test_minimax_h3_ref2va_matches_official_reference(
     accuracy_artifact_root: Path,
 ) -> None:
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/qwen3_omni/test_qwen3_omni.py b/tests/e2e/accuracy/qwen3_omni/test_qwen3_omni.py
index 7c48053e1..0acf21692 100644
--- a/tests/e2e/accuracy/qwen3_omni/test_qwen3_omni.py
+++ b/tests/e2e/accuracy/qwen3_omni/test_qwen3_omni.py
@@ -110,7 +110,7 @@ def _daily_omni_hub_inline_media(monkeypatch: pytest.MonkeyPatch) -> None:
     monkeypatch.setenv("VLLM_WORKER_MULTIPROC_METHOD", "spawn")
 
 
-@hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
+@hardware_test(res={"cuda": ["H100", "B200"], "rocm": "MI325"}, num_cards=2)
 @pytest.mark.parametrize("omni_server", test_params, indirect=True)
 def test_qwen3_omni_daily_omni_accuracy_bench(omni_server) -> None:
     _require_vllm_cli()
@@ -122,7 +122,7 @@ def test_qwen3_omni_daily_omni_accuracy_bench(omni_server) -> None:
     assert _acc_bench.run_acc_benchmark(ns) == 0
 
 
-@hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
+@hardware_test(res={"cuda": ["H100", "B200"], "rocm": "MI325"}, num_cards=2)
 @pytest.mark.parametrize("omni_server", test_params, indirect=True)
 def test_qwen3_omni_seed_tts_wer_bench(omni_server) -> None:
     _require_vllm_cli()
diff --git a/tests/e2e/accuracy/sana_video/test_sana_video_golden.py b/tests/e2e/accuracy/sana_video/test_sana_video_golden.py
index c0c468315..cb6ffe6c9 100644
--- a/tests/e2e/accuracy/sana_video/test_sana_video_golden.py
+++ b/tests/e2e/accuracy/sana_video/test_sana_video_golden.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
 
@@ -44,7 +44,7 @@ SSIM_THRESHOLDS = {
 }
 
 pytestmark = [
-    pytest.mark.full_model,
+    pytest.mark.slow,
     pytest.mark.diffusion,
     pytest.mark.skipif(
         not GOLDEN_BASE_URL,
@@ -169,6 +169,7 @@ def _validate_metadata(payload: Any, manifest: dict[str, Any], variant: str, tas
 
 def _download_case(variant: str, task: str, output_dir: Path, filenames: set[str]) -> dict[str, Any]:
     output_dir.mkdir(parents=True, exist_ok=True)
+    assert GOLDEN_BASE_URL is not None
     base_url = f"{GOLDEN_BASE_URL.rstrip('/')}/{variant}/{task}"
     response = requests.get(f"{base_url}/manifest.json", timeout=60)
     response.raise_for_status()
diff --git a/tests/e2e/accuracy/sana_video/test_sana_video_i2v_alignment.py b/tests/e2e/accuracy/sana_video/test_sana_video_i2v_alignment.py
index 8dd35eca2..ec7d67027 100644
--- a/tests/e2e/accuracy/sana_video/test_sana_video_i2v_alignment.py
+++ b/tests/e2e/accuracy/sana_video/test_sana_video_i2v_alignment.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
 
@@ -11,7 +11,7 @@ import torch
 from tests.helpers.mark import hardware_marks
 
 pytestmark = [
-    pytest.mark.full_model,
+    pytest.mark.slow,
     pytest.mark.diffusion,
     pytest.mark.benchmark,
 ]
diff --git a/tests/e2e/accuracy/sana_video/test_sana_video_pipeline_alignment.py b/tests/e2e/accuracy/sana_video/test_sana_video_pipeline_alignment.py
index a88aec7e2..aabe166d2 100644
--- a/tests/e2e/accuracy/sana_video/test_sana_video_pipeline_alignment.py
+++ b/tests/e2e/accuracy/sana_video/test_sana_video_pipeline_alignment.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
 
@@ -7,7 +7,7 @@ import gc
 import os
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any
+from typing import Any, TypedDict
 
 import pytest
 import torch
@@ -16,7 +16,7 @@ import torch.nn.functional as F
 from tests.helpers.mark import hardware_marks
 
 pytestmark = [
-    pytest.mark.full_model,
+    pytest.mark.slow,
     pytest.mark.diffusion,
     pytest.mark.benchmark,
 ]
@@ -30,7 +30,23 @@ HEIGHT = 192
 WIDTH = 320
 NUM_FRAMES = 9
 
-VARIANTS = {
+
+class _VariantConfig(TypedDict):
+    model: str
+    revision: str
+    model_env: str
+    max_abs: float
+    relative_l2: float
+    cosine: float
+    cfg_max_abs: float
+    cfg_relative_l2: float
+    cfg_cosine: float
+    step_max_abs: float
+    step_relative_l2: float
+    step_cosine: float
+
+
+VARIANTS: dict[str, _VariantConfig] = {
     "480p": {
         "model": "Efficient-Large-Model/SANA-Video_2B_480p_diffusers",
         "revision": "fed3bce411c58a0f688a31afe8f52e61acc2b15f",
diff --git a/tests/e2e/accuracy/test_cosmos3_similarity.py b/tests/e2e/accuracy/test_cosmos3_similarity.py
index efa095fb1..a7c9a9ece 100644
--- a/tests/e2e/accuracy/test_cosmos3_similarity.py
+++ b/tests/e2e/accuracy/test_cosmos3_similarity.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
 
@@ -35,6 +35,7 @@ def _model_name() -> str:
         pytest.skip(f"Set {MODEL_ENV_VAR} to run Cosmos3 full-model smoke tests.")
     if not torch.cuda.is_available():
         pytest.skip("Cosmos3 full-model smoke tests require CUDA.")
+    assert model
     return model
 
 
@@ -56,7 +57,7 @@ def _image_data_url(image: Image.Image) -> str:
 
 
 @pytest.mark.benchmark
-@hardware_test(res={"cuda": "H100"}, num_cards=1)
+@hardware_test(res={"cuda": ["H100", "B200"]}, num_cards=1)
 def test_cosmos3_t2i_serving_smoke(accuracy_artifact_root: Path) -> None:
     output_dir = model_output_dir(accuracy_artifact_root, MODEL_ID)
     with OmniServer(_model_name(), _server_args(), use_omni=True) as server:
@@ -97,7 +98,7 @@ def test_cosmos3_t2i_serving_smoke(accuracy_artifact_root: Path) -> None:
     ],
 )
 @pytest.mark.benchmark
-@hardware_test(res={"cuda": "H100"}, num_cards=1)
+@hardware_test(res={"cuda": ["H100", "B200"]}, num_cards=1)
 def test_cosmos3_video_serving_smoke(
     accuracy_artifact_root: Path,
     name: str,
diff --git a/tests/e2e/accuracy/test_diffusers_backend_similarity.py b/tests/e2e/accuracy/test_diffusers_backend_similarity.py
index b12e9c1e7..a582666d4 100644
--- a/tests/e2e/accuracy/test_diffusers_backend_similarity.py
+++ b/tests/e2e/accuracy/test_diffusers_backend_similarity.py
@@ -29,6 +29,7 @@ from tests.e2e.accuracy.helpers import (
     assert_similarity,
     env_to_apply_ftfy_mock_in_subproc,
     model_output_dir,
+    resolve_device_threshold,
 )
 from tests.e2e.accuracy.helpers import (
     parse_psnr_score as _parse_psnr_score,
@@ -49,16 +50,25 @@ from vllm_omni.diffusion.models.diffusers_adapter.pipeline_diffusers_adapter imp
 pytestmark = [pytest.mark.full_model, pytest.mark.diffusion]
 
 
-def _set_matched_attention_backend(pipe: DiffusionPipeline) -> None:
-    """Walk the same backend chain the omni server's diffusers adapter walks.
+def _flash_attempt_backends() -> list[str]:
+    """Backends in ``CUDA_FLASH_ATTENTION_BACKEND_ATTEMPTS`` that can actually launch.
 
-    The server side (--diffusion-load-format diffusers) resolves its attention
-    backend through the adapter's preference chain, skipping backends that are
-    unavailable on the image (e.g. the FA3 hub kernel has no build variant for
-    the image's torch — build 2953). The reference run must resolve to the
-    same backend or the similarity comparison measures kernel differences.
+    Those names are Hopper FA2/FA3. ``set_attention_backend`` only checks import,
+    so a newer GPU still "selects" them and then dies with "no kernel image".
+    Do not probe by launching: a missing cubin can leave the CUDA context dead.
+    Capability >= 10 is outside that wheel, including future SKUs in that family.
     """
-    for backend in CUDA_FLASH_ATTENTION_BACKEND_ATTEMPTS:
+    if not torch.cuda.is_available():
+        return []
+    major, _ = torch.cuda.get_device_capability()
+    if major >= 10:
+        return []
+    return list(CUDA_FLASH_ATTENTION_BACKEND_ATTEMPTS)
+
+
+def _set_matched_attention_backend(pipe: DiffusionPipeline) -> None:
+    """Pick a Diffusers attention backend the reference run can actually execute."""
+    for backend in _flash_attempt_backends():
         try:
             pipe.transformer.set_attention_backend(backend)
             return
@@ -297,7 +307,7 @@ def _run_diffusers_qwen_image(*, model: str, output_path: Path) -> tuple[Image.I
 
 
 @pytest.mark.benchmark
-@hardware_test(res={"cuda": "H100"}, num_cards=1)
+@hardware_test(res={"cuda": ["H100", "B200"]}, num_cards=1)
 @pytest.mark.parametrize("model_id", ["Qwen/Qwen-Image"])
 def test_diffusers_backend_t2i_matches_diffusers(model_id: str, accuracy_artifact_root: Path) -> None:
     output_dir = model_output_dir(accuracy_artifact_root, model_id + "-diffusers-backend")
@@ -336,7 +346,7 @@ def test_diffusers_backend_t2i_matches_diffusers(model_id: str, accuracy_artifac
 
 
 @pytest.mark.benchmark
-@hardware_test(res={"cuda": "H100"}, num_cards=1)
+@hardware_test(res={"cuda": ["H100", "B200"]}, num_cards=1)
 @pytest.mark.parametrize(
     "model_id",
     [
@@ -363,7 +373,11 @@ def test_diffusers_backend_i2v_matches_diffusers(
         model=model_id, output_path=diffusers_path, conditioning_image=resized_image
     )
     diffusers_latency = diffusers_latency * 1000
-    latency_threshold_factor = 0.3
+    # H100 keeps the historical 30% slack. B200 measured ~35.8% (6008 vs 4425 ms).
+    gpu_key, latency_threshold_factor = resolve_device_threshold(
+        {"H100": 0.3, "B200": 0.36},
+        label="latency threshold factor",
+    )
     latency_threshold = diffusers_latency * (1 + latency_threshold_factor)
 
     ssim_output = _run_ffmpeg_similarity("ssim", vllm_path, diffusers_path)
@@ -372,7 +386,8 @@ def test_diffusers_backend_i2v_matches_diffusers(
     psnr_score = _parse_psnr_score(psnr_output)
     print(f"{model_id} latency metrics:")
     print(
-        f"  Latency={vllm_latency:.2f}ms, threshold<={latency_threshold:.2f}ms, diffusers latency={diffusers_latency:.2f}ms, lower is better"
+        f"  Latency={vllm_latency:.2f}ms, threshold<={latency_threshold:.2f}ms, "
+        f"diffusers latency={diffusers_latency:.2f}ms, slack={latency_threshold_factor:.0%} ({gpu_key}), lower is better"
     )
     print(f"{model_id} similarity metrics:")
     print(f"  SSIM: value={ssim_score:.6f}, threshold>={VIDEO_SSIM_THRESHOLD:.6f}, range=[-1, 1], higher is better")
diff --git a/tests/e2e/accuracy/test_hidream_o1_image.py b/tests/e2e/accuracy/test_hidream_o1_image.py
index 923e53a47..440050be1 100644
--- a/tests/e2e/accuracy/test_hidream_o1_image.py
+++ b/tests/e2e/accuracy/test_hidream_o1_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
 
 from __future__ import annotations
 
@@ -16,7 +16,7 @@ from vllm_omni.diffusion.data import DiffusionParallelConfig
 from vllm_omni.diffusion.utils.image_output import extract_images_from_outputs
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 
-pytestmark = [pytest.mark.full_model, pytest.mark.diffusion]
+pytestmark = [pytest.mark.slow, pytest.mark.diffusion]
 
 MODEL_ID = "HiDream-ai/HiDream-O1-Image"
 PROMPT = "A cat is sitting next to a sign that says 'HiDream-O1 vLLM-Omni'"
diff --git a/tests/e2e/accuracy/test_hunyuan_image3.py b/tests/e2e/accuracy/test_hunyuan_image3.py
index 3e37f22b6..4258a470e 100644
--- a/tests/e2e/accuracy/test_hunyuan_image3.py
+++ b/tests/e2e/accuracy/test_hunyuan_image3.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
 
@@ -12,6 +12,7 @@ import tempfile
 import time
 from dataclasses import dataclass
 from pathlib import Path
+from typing import Any, cast
 
 import pytest
 import requests
@@ -288,7 +289,7 @@ def _quant_accuracy_cases() -> list[pytest.ParameterSet]:
 
 
 def _make_config(enable_kv_reuse: bool, path: Path) -> None:
-    config = copy.deepcopy(_DEPLOY_CONFIG)
+    config = cast(dict[str, Any], copy.deepcopy(_DEPLOY_CONFIG))
     config["stages"][0]["omni_kv_config"] = {"need_send_cache": enable_kv_reuse}
     config["stages"][1]["omni_kv_config"] = {"need_recv_cache": enable_kv_reuse}
     path.write_text(yaml.dump(config, default_flow_style=False, sort_keys=False))
@@ -303,7 +304,7 @@ def _quant_tensor_parallel_size() -> int:
 
 
 def _make_quant_dit_config(path: Path) -> None:
-    config = copy.deepcopy(_QUANT_DIT_CONFIG)
+    config = cast(dict[str, Any], copy.deepcopy(_QUANT_DIT_CONFIG))
     config["stages"][0]["devices"] = _quant_devices()
     config["stages"][0]["parallel_config"]["tensor_parallel_size"] = _quant_tensor_parallel_size()
     path.write_text(yaml.dump(config, default_flow_style=False, sort_keys=False))
@@ -448,7 +449,7 @@ def test_image_to_image_alignment_online(accuracy_artifact_root: Path) -> None:
     """Online API test: same pipeline, same seed as offline → PSNR >= 10 dB."""
     if importlib.util.find_spec("FlagEmbedding") is None:
         raise ImportError("Missing dependency: FlagEmbedding\nInstall with: pip install FlagEmbedding")
-    from tabulate import tabulate
+    from tabulate import tabulate  # type: ignore[import-untyped]
 
     output_dir = model_output_dir(accuracy_artifact_root, MODEL_NAME + "-online")
 
@@ -556,7 +557,7 @@ def _run_dit_model(
             torch.accelerator.empty_cache()
 
 
-@hardware_test(res={"cuda": "H100"}, num_cards=8)
+@hardware_test(res={"cuda": "H200"}, num_cards=8)
 @pytest.mark.skipif(
     torch.accelerator.device_count() < AR_TP_SIZE + DIT_TP_SIZE,
     reason=f"Needs {AR_TP_SIZE + DIT_TP_SIZE}+ GPUs ({AR_TP_SIZE} AR + {DIT_TP_SIZE} DiT)",
@@ -564,7 +565,7 @@ def _run_dit_model(
 def test_image_to_image_alignment(accuracy_artifact_root: Path) -> None:
     if importlib.util.find_spec("FlagEmbedding") is None:
         raise ImportError("Missing dependency: FlagEmbedding\nInstall with: pip install FlagEmbedding")
-    from tabulate import tabulate  # lazy import
+    from tabulate import tabulate  # type: ignore[import-untyped]
 
     """KV reuse ON vs OFF: same pipeline, same seed → PSNR >= 10 dB."""
     output_dir = model_output_dir(accuracy_artifact_root, MODEL_NAME + "-offline-kv-reuse")
diff --git a/tests/e2e/accuracy/test_hunyuan_image3_pixel_accuracy.py b/tests/e2e/accuracy/test_hunyuan_image3_pixel_accuracy.py
index 71dd6f308..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
 
 
@@ -299,7 +296,7 @@ def _assert_against_baseline(image: Image.Image, label: str) -> None:
 
 
 @pytest.mark.full_model
-@hardware_test(res={"cuda": "H100", "npu": "A3"}, num_cards=4)
+@hardware_test(res={"cuda": ["H100", "B200"], "npu": "A3"}, num_cards=4)
 def test_hunyuan_image3_pixel_accuracy_online(accuracy_artifact_root: Path) -> None:
     model = _model_name()
     output_dir = model_output_dir(accuracy_artifact_root, MODEL_NAME)
@@ -314,7 +311,7 @@ def test_hunyuan_image3_pixel_accuracy_online(accuracy_artifact_root: Path) -> N
 
 
 @pytest.mark.full_model
-@hardware_test(res={"cuda": "H100", "npu": "A3"}, num_cards=4)
+@hardware_test(res={"cuda": ["H100", "B200"], "npu": "A3"}, num_cards=4)
 def test_hunyuan_image3_pixel_accuracy_offline(accuracy_artifact_root: Path) -> None:
     model = _model_name()
     output_dir = model_output_dir(accuracy_artifact_root, MODEL_NAME)
diff --git a/tests/e2e/accuracy/test_qwen_image.py b/tests/e2e/accuracy/test_qwen_image.py
index 45fd20934..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"
@@ -233,7 +233,7 @@ def _run_diffusers_qwen_image_2512(*, model: str, output_path: Path) -> Image.Im
 
 
 @pytest.mark.benchmark
-@hardware_test(res={"cuda": "H100"}, num_cards=1)
+@hardware_test(res={"cuda": ["H100", "B200"]}, num_cards=1)
 def test_qwen_image_matches_diffusers(accuracy_artifact_root: Path) -> None:
     model = _model_name()
     output_dir = model_output_dir(accuracy_artifact_root, MODEL_ID)
@@ -253,7 +253,7 @@ def test_qwen_image_matches_diffusers(accuracy_artifact_root: Path) -> None:
 
 
 @pytest.mark.benchmark
-@hardware_test(res={"cuda": "H100"}, num_cards=1)
+@hardware_test(res={"cuda": ["H100", "B200"]}, num_cards=1)
 def test_qwen_image_2512_matches_diffusers_pixelwise(accuracy_artifact_root: Path) -> None:
     model = _model_2512_name()
     output_dir = model_output_dir(accuracy_artifact_root, MODEL_2512_ID)
diff --git a/tests/e2e/accuracy/wan22_i2v/test_wan22_i2v_video_similarity.py b/tests/e2e/accuracy/wan22_i2v/test_wan22_i2v_video_similarity.py
index 771ced5bc..419bf867d 100644
--- a/tests/e2e/accuracy/wan22_i2v/test_wan22_i2v_video_similarity.py
+++ b/tests/e2e/accuracy/wan22_i2v/test_wan22_i2v_video_similarity.py
@@ -195,7 +195,7 @@ def _generate_offline_video(*, image_source: str) -> tuple[Path, Path]:
 
 @pytest.mark.benchmark
 @pytest.mark.full_model
-@hardware_test(res={"cuda": "H100"}, num_cards=1)
+@hardware_test(res={"cuda": ["H100", "B200"]}, num_cards=1)
 def test_wan22_i2v_diffusers_offline_generates_video(
     wan22_i2v_image_source: str | None,
 ) -> None:
@@ -217,7 +217,7 @@ def test_wan22_i2v_diffusers_offline_generates_video(
 
 @pytest.mark.benchmark
 @pytest.mark.full_model
-@hardware_test(res={"cuda": "H100"}, num_cards=2)
+@hardware_test(res={"cuda": ["H100", "B200"]}, num_cards=2)
 @pytest.mark.parametrize("omni_server", SERVER_CASES, indirect=True)
 def test_wan22_i2v_online_serving_generates_video(
     omni_server,
@@ -244,7 +244,7 @@ def test_wan22_i2v_online_serving_generates_video(
 
 @pytest.mark.benchmark
 @pytest.mark.full_model
-@hardware_test(res={"cuda": "H100"}, num_cards=2)
+@hardware_test(res={"cuda": ["H100", "B200"]}, num_cards=2)
 def test_wan22_i2v_serving_matches_diffusers_video_similarity(
     wan22_i2v_image_source: str | None,
 ) -> None:
diff --git a/tests/e2e/features/comfyui/test_comfyui_integration.py b/tests/e2e/features/comfyui/test_comfyui_integration.py
index 61cf76dcd..113879951 100644
--- a/tests/e2e/features/comfyui/test_comfyui_integration.py
+++ b/tests/e2e/features/comfyui/test_comfyui_integration.py
@@ -16,15 +16,19 @@ import time
 import traceback
 from collections.abc import Iterable, Sequence
 from enum import Enum
+from pathlib import Path
 from types import SimpleNamespace
 from typing import Any, NamedTuple
 
+import av
 import pytest
 import requests
 import torch
 from comfy_api.input import AudioInput, VideoInput
 from comfyui_vllm_omni.nodes import (
+    VLLMOmniFastH3Deployment,
     VLLMOmniGenerateImage,
+    VLLMOmniGenerateMusic,
     VLLMOmniGenerateVideo,
     VLLMOmniTTS,
     VLLMOmniUnderstanding,
@@ -59,6 +63,7 @@ class ServerCase(NamedTuple):
     stage_list: list
     stage_configs: list[Any]
     outputs: list[OmniRequestOutput]
+    tokenizer: Any = None
 
 
 class SamplingCase(NamedTuple):
@@ -76,10 +81,14 @@ 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"
+    VIDEO_REF2VA_MIXED = "video_ref2va_mixed"
 
 
 # Pre-defined arguments to be used in function calls during the tests
@@ -89,6 +98,9 @@ VIDEO_WIDTH = 32
 VIDEO_HEIGHT = 32
 VIDEO_FPS = 8
 VIDEO_NUM_FRAMES = 5
+VIDEO_DURATION = VIDEO_NUM_FRAMES / VIDEO_FPS  # 0.625 s at the generic 8 fps
+# FastH3 pins 24 fps, so the same duration is a different frame count there.
+VIDEO_FASTH3_NUM_FRAMES = round(VIDEO_DURATION * 24)
 DIFFUSION_SINGLE_SAMPLING_PARAMS = DiffusionSamplingParams(
     {
         "n": 2,
@@ -139,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",
@@ -148,6 +160,13 @@ H3_MODEL_PARAMS = MiniMaxH3ModelSpecificParams(
     }
 )
 
+H3_STAGE_CONFIG = {
+    "stage_type": "diffusion",
+    "final_output": True,
+    "final_output_type": "video",
+    "engine_args": {"model_class_name": "MiniMaxH3Pipeline"},
+}
+
 LORA_PARAMS = {"local_path": "test_lora_path", "name": "test_name", "scale": 0.7, "int_id": 10}
 
 
@@ -365,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:
@@ -394,6 +418,52 @@ 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]
+            _assert_sampling_param_values(
+                received,
+                {
+                    "width": VIDEO_WIDTH,
+                    "height": VIDEO_HEIGHT,
+                    "num_frames": VIDEO_FASTH3_NUM_FRAMES,
+                    "fps": 24,
+                    "num_inference_steps": 4,
+                },
+            )
+            assert received.lora_request is None
+            # t2va is refused without an explicit ratio; 32x32 derives "1:1".
+            _assert_model_param_values(received, {"task": "t2va", "aspect_ratio": "1:1"})
+            assert "flow_shift" not in received.extra_args
+            assert "audio_flow_shift" not in received.extra_args
         elif sampling_case.kind is SamplingKind.VIDEO_REF2VA_IMAGE_AUDIO:
             assert len(received_sampling_params_list) == 1
             assert isinstance(prompt, dict)
@@ -419,17 +489,30 @@ def _build_mock_outputs(outputs: Iterable[OmniRequestOutput], sampling_case: Sam
                     "audio_flow_shift": 3.0,
                 },
             )
-        elif sampling_case.kind is SamplingKind.VIDEO_REF2VA_MULTI_VIDEO:
+        elif sampling_case.kind in (SamplingKind.VIDEO_REF2VA_MULTI_VIDEO, SamplingKind.VIDEO_REF2VA_MIXED):
             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_videos = multi_modal_data.get("video")
             assert isinstance(input_videos, list)
-            assert len(input_videos) == 2
             assert all(isinstance(path, str) for path in input_videos)
-            assert "image" not in multi_modal_data
-            assert "audio" not in multi_modal_data
+            if sampling_case.kind is SamplingKind.VIDEO_REF2VA_MULTI_VIDEO:
+                assert len(input_videos) == 2
+                assert "image" not in multi_modal_data
+                assert "audio" not in multi_modal_data
+            else:
+                assert [Path(path).read_bytes() for path in input_videos] == [b"video-1", b"video-2", b"video-3"]
+                images = multi_modal_data.get("image")
+                assert isinstance(images, list)
+                assert len(images) == 6
+                assert [image.getpixel((0, 0)) for image in images] == [(i * 40,) * 3 for i in range(1, 7)]
+                audios = multi_modal_data.get("audio")
+                assert isinstance(audios, list)
+                assert len(audios) == 3
+                for path, sample_rate in zip(audios, (24000, 32000, 48000)):
+                    with av.open(path) as container:
+                        assert container.streams.audio[0].sample_rate == sample_rate
             _assert_sampling_param_values(
                 received_sampling_params_list[0],
                 {
@@ -479,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)
 
@@ -512,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
@@ -861,7 +949,7 @@ async def test_video_generation_node(api_server: str, model: str, image_input: b
         "width": VIDEO_WIDTH,
         "height": VIDEO_HEIGHT,
         "fps": VIDEO_FPS,
-        "num_frames": VIDEO_NUM_FRAMES,
+        "duration": VIDEO_DURATION,
         "model_params": VIDEO_MODEL_PARAMS,
     }
     if image_input:
@@ -880,7 +968,165 @@ async def test_video_generation_node(api_server: str, model: str, image_input: b
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
-    "server_case,sampling_case,ref_mode",
+    "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",
     [
         pytest.param(
             ServerCase(
@@ -889,6 +1135,67 @@ async def test_video_generation_node(api_server: str, model: str, image_input: b
                 stage_configs=[{"stage_type": "diffusion", "final_output": True, "final_output_type": "video"}],
                 outputs=[_build_diffusion_video_output()],
             ),
+            "MiniMaxAI/MiniMax-H3",
+            id="canonical_model_name",
+        ),
+        pytest.param(
+            ServerCase(
+                served_model="fasth3",
+                stage_list=["diffusion"],
+                stage_configs=[{"stage_type": "diffusion", "final_output": True, "final_output_type": "video"}],
+                outputs=[_build_diffusion_video_output()],
+            ),
+            "fasth3",
+            # A --served-model-name alias lookup_model_spec cannot resolve to H3. The
+            # request must still be built by the H3 params builder, or it goes out
+            # without the aspect_ratio (and task) a t2va request is refused without.
+            id="served_model_alias",
+        ),
+    ],
+    indirect=["server_case"],
+)
+@pytest.mark.parametrize(
+    "sampling_case",
+    [SamplingCase(kind=SamplingKind.VIDEO_FASTH3, sampling_params=DIFFUSION_VIDEO_SINGLE_SAMPLING_PARAMS)],
+    indirect=True,
+)
+async def test_fast_h3_deployment_node(api_server: str, sampling_case: SamplingCase, deployment_model: str):
+    deployment_node = VLLMOmniFastH3Deployment()
+    (deployment,) = deployment_node.get_deployment(
+        url=api_server,
+        model=deployment_model,
+    )
+
+    result = await VLLMOmniGenerateVideo().generate(
+        url="http://ignored.invalid/v1",
+        model="ignored-model",
+        prompt="A singer performs on a neon-lit stage.",
+        negative_prompt="",
+        width=VIDEO_WIDTH,
+        height=VIDEO_HEIGHT,
+        fps=VIDEO_FPS,
+        duration=VIDEO_DURATION,
+        sampling_params=sampling_case.sampling_params,
+        model_params=H3_MODEL_PARAMS,
+        fast_h3=deployment,
+    )
+
+    assert isinstance(result, tuple)
+    assert len(result) == 1
+    assert isinstance(result[0], VideoInput)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "server_case,sampling_case,ref_mode",
+    [
+        pytest.param(
+            ServerCase(
+                served_model="MiniMaxAI/MiniMax-H3",
+                stage_list=["diffusion"],
+                stage_configs=[H3_STAGE_CONFIG],
+                outputs=[_build_diffusion_video_output()],
+            ),
             SamplingCase(kind=SamplingKind.VIDEO_REF2VA_IMAGE_AUDIO, sampling_params=None),
             "image_audio",
             id="ref2va-image-audio",
@@ -897,13 +1204,24 @@ async def test_video_generation_node(api_server: str, model: str, image_input: b
             ServerCase(
                 served_model="MiniMaxAI/MiniMax-H3",
                 stage_list=["diffusion"],
-                stage_configs=[{"stage_type": "diffusion", "final_output": True, "final_output_type": "video"}],
+                stage_configs=[H3_STAGE_CONFIG],
                 outputs=[_build_diffusion_video_output()],
             ),
             SamplingCase(kind=SamplingKind.VIDEO_REF2VA_MULTI_VIDEO, sampling_params=None),
             "multi_video",
             id="ref2va-multi-video",
         ),
+        pytest.param(
+            ServerCase(
+                served_model="MiniMaxAI/MiniMax-H3",
+                stage_list=["diffusion"],
+                stage_configs=[H3_STAGE_CONFIG],
+                outputs=[_build_diffusion_video_output()],
+            ),
+            SamplingCase(kind=SamplingKind.VIDEO_REF2VA_MIXED, sampling_params=None),
+            "mixed",
+            id="ref2va-mixed-12-references",
+        ),
     ],
     indirect=["server_case", "sampling_case"],
 )
@@ -933,6 +1251,17 @@ async def test_video_generation_node_minimax_h3_ref2va(
         prompt = (
             "Remove the green screen background of Video 1 and replace it with the fairytale environment from Video 2."
         )
+    elif ref_mode == "mixed":
+        inputs = {f"image_{i}": torch.full((1, VIDEO_HEIGHT, VIDEO_WIDTH, 3), i * 40 / 255) for i in range(1, 7)}
+        inputs.update({f"video_{i}": VideoInput(f"video-{i}".encode()) for i in range(1, 4)})
+        inputs.update(
+            {
+                f"audio_{i}": {"waveform": torch.zeros(1, 1, sample_rate), "sample_rate": sample_rate}
+                for i, sample_rate in enumerate((24000, 32000, 48000), start=1)
+            }
+        )
+        (references,) = refs_node.get_references(**inputs)
+        prompt = "Combine the subjects from the images with the reference videos and audio clips."
     else:
         raise AssertionError(f"Unknown ref_mode: {ref_mode}")
 
@@ -944,7 +1273,7 @@ async def test_video_generation_node_minimax_h3_ref2va(
         width=VIDEO_WIDTH,
         height=VIDEO_HEIGHT,
         fps=VIDEO_FPS,
-        num_frames=VIDEO_NUM_FRAMES,
+        duration=VIDEO_DURATION,
         references=references,
         model_params=H3_MODEL_PARAMS,
     )
@@ -952,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/comfyui/test_h3_reference_workflow.py b/tests/e2e/features/comfyui/test_h3_reference_workflow.py
new file mode 100644
index 000000000..852e39383
--- /dev/null
+++ b/tests/e2e/features/comfyui/test_h3_reference_workflow.py
@@ -0,0 +1,115 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import json
+from graphlib import TopologicalSorter
+from pathlib import Path
+
+import pytest
+from comfyui_vllm_omni import nodes as omni_nodes
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+WORKFLOW = (
+    Path(__file__).resolve().parents[4]
+    / "apps/ComfyUI-vLLM-Omni/example_workflows/vLLM-Omni MiniMax-H3 Reference to Video.json"
+)
+
+
+@pytest.fixture
+def workflow():
+    return json.loads(WORKFLOW.read_text())
+
+
+def test_reference_workflow_connections(workflow):
+    nodes = {node["id"]: node for node in workflow["nodes"]}
+    links = {link[0]: link for link in workflow["links"]}
+    assert len(nodes) == len(workflow["nodes"])
+    assert len(links) == len(workflow["links"])
+    graph: dict[int, set[int]] = {node_id: set() for node_id in nodes}
+    for link_id, source, output_slot, target, input_slot, kind in links.values():
+        output = nodes[source]["outputs"][output_slot]
+        input_ = nodes[target]["inputs"][input_slot]
+        assert output["type"] == input_["type"] == kind
+        assert link_id in output["links"]
+        assert input_["link"] == link_id
+        graph[target].add(source)
+    assert len(tuple(TopologicalSorter(graph).static_order())) == len(nodes)
+    for node in nodes.values():
+        for slot, input_ in enumerate(node.get("inputs", [])):
+            if input_["link"] is not None:
+                assert links[input_["link"]][3:5] == [node["id"], slot]
+        for slot, output in enumerate(node.get("outputs", [])):
+            for link_id in output.get("links") or []:
+                assert links[link_id][1:3] == [node["id"], slot]
+
+
+def test_reference_workflow_matches_omni_node_interfaces(workflow):
+    for node in workflow["nodes"]:
+        if not node["type"].startswith("VLLMOmni"):
+            continue
+        cls = getattr(omni_nodes, node["type"])
+        schema = cls.INPUT_TYPES()
+        inputs = {**schema.get("required", {}), **schema.get("optional", {})}
+        for input_ in node["inputs"]:
+            assert input_["type"] == inputs[input_["name"]][0]
+        assert tuple(output["type"] for output in node["outputs"]) == cls.RETURN_TYPES
+        expected_widgets = len(schema.get("required", {}))
+        if "seed" in schema.get("required", {}):
+            expected_widgets += 1
+        assert len(node["widgets_values"]) == expected_widgets
+    refs = next(node for node in workflow["nodes"] if node["type"] == "VLLMOmniVideoReferences")
+    assert [input_["name"] for input_ in refs["inputs"]] == list(
+        omni_nodes.VLLMOmniVideoReferences.INPUT_TYPES()["optional"]
+    )
+
+
+def test_reference_workflow_default_route_and_output(workflow):
+    nodes = {node["id"]: node for node in workflow["nodes"]}
+    links = {link[0]: link for link in workflow["links"]}
+    generate = next(node for node in nodes.values() if node["type"] == "VLLMOmniGenerateVideo")
+    inputs = {input_["name"]: input_["link"] for input_ in generate["inputs"]}
+    assert inputs["frame"] is None
+    assert inputs["lora"] is None
+    for name, kind in (
+        ("references", "VLLMOmniVideoReferences"),
+        ("sampling_params", "VLLMOmniDiffusionSampling"),
+        ("model_params", "VLLMOmniMiniMaxH3Params"),
+    ):
+        assert nodes[links[inputs[name]][1]]["type"] == kind
+    save = next(node for node in nodes.values() if node["type"] == "SaveVideo")
+    assert links[save["inputs"][0]["link"]][1] == generate["id"]
+    assert save["widgets_values"] == ["video/MiniMax-H3-Ref2VA", "mp4", "h264"]
+
+
+def test_reference_workflow_defaults_and_portable_assets(workflow):
+    by_type = {node["type"]: node for node in workflow["nodes"]}
+    values = by_type["VLLMOmniGenerateVideo"]["widgets_values"]
+    assert values[0] == "http://localhost:8000/v1"
+    assert values[1] == "MiniMaxAI/MiniMax-H3"
+    assert "<Picture 1>" in values[2]
+    assert values[4:8] == [1344, 768, 24, 5.167]
+    num_frames = round(values[7] * values[6])
+    assert num_frames == 124
+    assert values[3] == ""
+    assert (num_frames - 5) % 17 == 0
+    assert 4 <= values[7] <= 15
+    assert by_type["VLLMOmniDiffusionSampling"]["widgets_values"] == [1, 50, 1.0, 1.0, False, False, 42, "fixed"]
+    assert by_type["VLLMOmniMiniMaxH3Params"]["widgets_values"] == [3.0, 12.0]
+    assert by_type["VLLMOmniRemoteLoRA"]["widgets_values"][0] == ""
+    for kind in ("LoadImage", "LoadVideo", "LoadAudio"):
+        filename = by_type[kind]["widgets_values"][0]
+        assert filename and Path(filename).name == filename
+        assert ":" not in filename and "\\" not in filename
+    assert set(by_type) == {
+        "LoadImage",
+        "LoadVideo",
+        "LoadAudio",
+        "SaveVideo",
+        "MarkdownNote",
+        "VLLMOmniVideoReferences",
+        "VLLMOmniGenerateVideo",
+        "VLLMOmniDiffusionSampling",
+        "VLLMOmniMiniMaxH3Params",
+        "VLLMOmniRemoteLoRA",
+    }
diff --git a/tests/e2e/features/comfyui/test_video_references.py b/tests/e2e/features/comfyui/test_video_references.py
new file mode 100644
index 000000000..33e86850c
--- /dev/null
+++ b/tests/e2e/features/comfyui/test_video_references.py
@@ -0,0 +1,138 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from io import BytesIO
+from unittest.mock import AsyncMock
+
+import av
+import pytest
+import torch
+from comfy_api.input import VideoInput
+from comfyui_vllm_omni.nodes import VLLMOmniVideoReferences
+from comfyui_vllm_omni.utils import api_client
+from PIL import Image
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+@pytest.fixture
+def api_calls(monkeypatch):
+    calls = AsyncMock(return_value={"id": "test-video", "status": "completed"})
+    monkeypatch.setattr(api_client, "url_json", calls)
+    monkeypatch.setattr(api_client, "url_bytes", AsyncMock(return_value=b"generated-video"))
+    monkeypatch.setattr(api_client, "bytes_to_video", lambda data: data)
+    return calls
+
+
+async def _generate(references, **kwargs):
+    return await api_client.VLLMOmniClient("http://localhost/v1").generate_video(
+        model="MiniMaxAI/MiniMax-H3",
+        prompt="Use the reference subjects and sounds.",
+        width=896,
+        height=512,
+        num_frames=90,
+        fps=24,
+        references=references,
+        **kwargs,
+    )
+
+
+def _references(image_count, video_count, audio_count):
+    refs = {f"image_{i}": torch.full((1, 16, 16, 3), i / 10) for i in range(1, image_count + 1)}
+    refs.update({f"video_{i}": VideoInput(f"video-{i}".encode()) for i in range(1, video_count + 1)})
+    refs.update(
+        {f"audio_{i}": {"waveform": torch.zeros(1, 1, 24000), "sample_rate": 24000} for i in range(1, audio_count + 1)}
+    )
+    return refs
+
+
+def test_reference_node_preserves_existing_ports_and_exposes_h3_limits():
+    ports = VLLMOmniVideoReferences.INPUT_TYPES()["optional"]
+    assert list(ports)[:6] == ["image_1", "image_2", "audio_1", "audio_2", "video_1", "video_2"]
+    assert {name for name, kind in ports.items() if kind == ("IMAGE",)} == {f"image_{i}" for i in range(1, 10)}
+    assert {name for name, kind in ports.items() if kind == ("VIDEO",)} == {"video_1", "video_2", "video_3"}
+    assert {name for name, kind in ports.items() if kind == ("AUDIO",)} == {"audio_1", "audio_2", "audio_3"}
+    inputs = _references(6, 3, 3)
+    (refs,) = VLLMOmniVideoReferences().get_references(**inputs)
+    assert refs.keys() == inputs.keys()
+    assert all(refs[name] is value for name, value in inputs.items())
+
+
+@pytest.mark.parametrize(
+    "counts", [(1, 0, 0), (9, 0, 0), (0, 3, 0), (1, 0, 3), (0, 1, 3), (6, 3, 3), (9, 3, 0), (9, 0, 3)]
+)
+async def test_reference_uploads_keep_numeric_order_and_media_types(api_calls, counts):
+    refs = _references(*counts)
+    result = await _generate(dict(reversed(list(refs.items()))))
+    assert result == b"generated-video"
+    fields = api_calls.call_args_list[0].kwargs["data"]._fields
+    uploads = [
+        (options["filename"], headers["Content-Type"], value)
+        for options, headers, value in fields
+        if options["name"] == "input_references"
+    ]
+    expected = [
+        (f"{kind}_{i}.{extension}", content_type)
+        for kind, count, extension, content_type in (
+            ("image", counts[0], "png", "image/png"),
+            ("video", counts[1], "mp4", "video/mp4"),
+            ("audio", counts[2], "mp3", "audio/mpeg"),
+        )
+        for i in range(1, count + 1)
+    ]
+    assert [(name, content_type) for name, content_type, _ in uploads] == expected
+    for name, content_type, payload in uploads:
+        data = payload.getvalue()
+        if content_type == "image/png":
+            index = int(name.removeprefix("image_").removesuffix(".png"))
+            assert Image.open(BytesIO(data)).getpixel((0, 0)) == (int(index / 10 * 255),) * 3
+        elif content_type == "video/mp4":
+            assert data == name.removesuffix(".mp4").replace("_", "-").encode()
+        else:
+            with av.open(BytesIO(data)) as container:
+                assert container.streams.audio[0].sample_rate == 24000
+                assert sum(frame.samples for frame in container.decode(audio=0)) > 0
+
+
+async def test_sparse_reference_slots_are_not_dropped(api_calls):
+    inputs = _references(9, 3, 3)
+    inputs = {name: inputs[name] for name in ("audio_3", "image_9", "video_3", "image_2")}
+    (refs,) = VLLMOmniVideoReferences().get_references(image_1=None, **inputs)
+    await _generate(refs)
+    fields = api_calls.call_args_list[0].kwargs["data"]._fields
+    assert [options["filename"] for options, _, _ in fields if options["name"] == "input_references"] == [
+        "image_2.png",
+        "image_9.png",
+        "video_3.mp4",
+        "audio_3.mp3",
+    ]
+
+
+@pytest.mark.parametrize(
+    "counts, message",
+    [
+        ((0, 0, 0), "at least one image or video"),
+        ((0, 0, 3), "at least one image or video"),
+        ((9, 3, 1), "at most 12"),
+        ((9, 3, 3), "at most 12"),
+    ],
+)
+async def test_invalid_reference_combinations_fail_before_upload(api_calls, counts, message):
+    with pytest.raises(ValueError, match=message):
+        await _generate(_references(*counts))
+    api_calls.assert_not_called()
+
+
+@pytest.mark.parametrize("name", ["image_10", "video_4", "audio_4", "image_0"])
+async def test_unsupported_reference_slots_are_not_silently_ignored(api_calls, name):
+    refs = _references(1, 0, 0)
+    refs[name] = object()
+    with pytest.raises(ValueError, match="Unsupported reference input"):
+        await _generate(refs)
+    api_calls.assert_not_called()
+
+
+async def test_frame_and_references_are_mutually_exclusive(api_calls):
+    with pytest.raises(ValueError, match="only one of frame or references"):
+        await _generate(_references(1, 0, 0), frame=torch.zeros(1, 16, 16, 3))
+    api_calls.assert_not_called()
diff --git a/tests/e2e/features/custom_pipeline/test_async_omni_collective_rpc.py b/tests/e2e/features/custom_pipeline/test_async_omni_collective_rpc.py
index a11c9b7e4..722d42a26 100644
--- a/tests/e2e/features/custom_pipeline/test_async_omni_collective_rpc.py
+++ b/tests/e2e/features/custom_pipeline/test_async_omni_collective_rpc.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 AsyncOmni collective_rpc in inline diffusion mode.
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 12ad4f1b3..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
@@ -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 tests for AsyncOmni Qwen-Image generation with trajectory_* fields.
 
@@ -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/custom_pipeline/test_worker_extension.py b/tests/e2e/features/custom_pipeline/test_worker_extension.py
index da7b0ac17..fff39cd1e 100644
--- a/tests/e2e/features/custom_pipeline/test_worker_extension.py
+++ b/tests/e2e/features/custom_pipeline/test_worker_extension.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
 
diff --git a/tests/e2e/features/fullduplex/test_client.py b/tests/e2e/features/fullduplex/test_client.py
index 266df1fa0..250391fe2 100644
--- a/tests/e2e/features/fullduplex/test_client.py
+++ b/tests/e2e/features/fullduplex/test_client.py
@@ -241,7 +241,7 @@ def test_realtime_event_collector_partitions_audio_by_response():
     collector.add({"type": "response.created", "response": {"id": "resp-a"}})
     collector.add(
         {
-            "type": "response.audio.delta",
+            "type": "response.output_audio.delta",
             "response_id": "resp-a",
             "delta": base64.b64encode(b"audio-a").decode("ascii"),
             "sample_rate_hz": 16_000,
@@ -252,7 +252,7 @@ def test_realtime_event_collector_partitions_audio_by_response():
     assert collector.audio_bytes("resp-a") == b"audio-a"
     assert collector.output_sample_rate_hz == 16_000
     assert collector.first_received_at("response.created") is not None
-    assert collector.last_received_at("response.audio.delta") is not None
+    assert collector.last_received_at("response.output_audio.delta") is not None
 
 
 def test_realtime_event_collector_reports_engine_token_and_audio_intervals():
@@ -273,7 +273,7 @@ def test_realtime_event_collector_reports_engine_token_and_audio_intervals():
     for received_at_s, cumulative_audio_ms in ((10.2, 80), (10.25, 160), (10.36, 240)):
         collector.add(
             {
-                "type": "response.audio.delta",
+                "type": "response.output_audio.delta",
                 "response_id": "resp-a",
                 "delta": base64.b64encode(b"audio").decode("ascii"),
                 "sample_rate_hz": 16_000,
@@ -286,7 +286,7 @@ def test_realtime_event_collector_reports_engine_token_and_audio_intervals():
         )
     collector.add(
         {
-            "type": "response.audio_transcript.delta",
+            "type": "response.output_audio_transcript.delta",
             "response_id": "resp-a",
             "delta": "",
         },
@@ -294,7 +294,7 @@ def test_realtime_event_collector_reports_engine_token_and_audio_intervals():
     )
     collector.add(
         {
-            "type": "response.audio_transcript.delta",
+            "type": "response.output_audio_transcript.delta",
             "response_id": "resp-a",
             "delta": "hello",
         },
@@ -369,7 +369,7 @@ def test_response_timing_ignores_unowned_session_level_metrics():
     )
     collector.add(
         {
-            "type": "response.audio.delta",
+            "type": "response.output_audio.delta",
             "response_id": "resp-a",
             "delta": base64.b64encode(b"audio").decode("ascii"),
             "metadata": {
diff --git a/tests/e2e/features/fullduplex/test_core_contracts.py b/tests/e2e/features/fullduplex/test_core_contracts.py
index 12a87640f..45493745c 100644
--- a/tests/e2e/features/fullduplex/test_core_contracts.py
+++ b/tests/e2e/features/fullduplex/test_core_contracts.py
@@ -14,7 +14,7 @@ import dataclasses
 
 import pytest
 
-from vllm_omni.engine.duplex.messages import DuplexFence
+from vllm_omni.engine.duplex.contracts import DuplexFence
 from vllm_omni.experimental.fullduplex.core import protocol as ev
 from vllm_omni.experimental.fullduplex.core.adapter import (
     DuplexAdapter,
@@ -32,12 +32,15 @@ pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
 
 def test_fence_is_frozen_value_identity():
+    # The fence carries (session_id, epoch, turn_id). response_seq was
+    # dropped with the incarnation concept: response identity is the session's
+    # active_response_id, not a field of the fence.
     f = DuplexFence(session_id="s1")
-    assert (f.epoch, f.turn_id, f.response_seq) == (0, 0, 0)
+    assert (f.epoch, f.turn_id) == (0, 0)
     with pytest.raises(dataclasses.FrozenInstanceError):
         f.epoch = 1  # type: ignore[misc]
-    assert DuplexFence("s1", 1, 2, 3) == DuplexFence("s1", 1, 2, 3)
-    assert DuplexFence("s1", 1, 2, 3) != DuplexFence("s1", 2, 2, 3)
+    assert DuplexFence("s1", 1, 2) == DuplexFence("s1", 1, 2)
+    assert DuplexFence("s1", 1, 2) != DuplexFence("s1", 2, 2)
 
 
 def test_session_identity_rules():
diff --git a/tests/e2e/features/fullduplex/test_omni_duplex_eval_cli.py b/tests/e2e/features/fullduplex/test_omni_duplex_eval_cli.py
index 192859de5..b1b02ef65 100644
--- a/tests/e2e/features/fullduplex/test_omni_duplex_eval_cli.py
+++ b/tests/e2e/features/fullduplex/test_omni_duplex_eval_cli.py
@@ -15,6 +15,15 @@ import pytest
 from vllm_omni.benchmarks.duplex import omni_duplex_eval_runner as runner
 from vllm_omni.benchmarks.duplex.omni_duplex_eval_dataset import DuplexSample
 from vllm_omni.benchmarks.duplex.omni_duplex_eval_judge import DuplexJudge
+from vllm_omni.benchmarks.duplex.omni_duplex_eval_runner import GenerateSampleResult
+from vllm_omni.benchmarks.duplex_session_metrics import (
+    DUPLEX_METRICS_FILENAME,
+    build_duplex_metrics_report,
+    collect_duplex_session_metrics,
+    merge_duplex_metrics_report,
+    read_duplex_metrics_report,
+)
+from vllm_omni.clients.duplex import EventCollector
 from vllm_omni.entrypoints.cli.benchmark import omni_duplex_eval as cli
 from vllm_omni.entrypoints.cli.benchmark.omni_duplex_eval import OmniDuplexEvalSubcommand
 
@@ -44,7 +53,25 @@ def test_cli_generate_evaluate_summarize_flow(tmp_path: Path, monkeypatch: pytes
         output.parent.mkdir(parents=True, exist_ok=True)
         output.write_text(json.dumps([{"sentence": "It moved.", "start": 0, "end": 1}]), encoding="utf-8")
         output.with_name(output.stem + ".meta.json").write_text(json.dumps({"clock": "media"}), encoding="utf-8")
-        return output
+        return GenerateSampleResult(
+            output=output,
+            request_metrics=[
+                {
+                    "sample_id": sample.id,
+                    "split": sample.split,
+                    "ttft_ms": 10.0,
+                    "ttfp_ms": 20.0,
+                    "rtf": 0.5,
+                }
+            ],
+            session_metrics={
+                "sample_id": sample.id,
+                "split": sample.split,
+                "stream_ttft_ms": 10.0,
+                "stream_ttfp_ms": 20.0,
+                "stream_rtf": 0.5,
+            },
+        )
 
     class FakeJudge:
         def __init__(self, *args, **kwargs):
@@ -75,6 +102,19 @@ def test_cli_generate_evaluate_summarize_flow(tmp_path: Path, monkeypatch: pytes
         ]
     )
     OmniDuplexEvalSubcommand.cmd(generate)
+    duplex_metrics = json.loads((response_root / DUPLEX_METRICS_FILENAME).read_text(encoding="utf-8"))
+    assert duplex_metrics["duplex_request_metrics"] == [
+        {
+            "sample_id": "sample-1",
+            "split": "PR_correction",
+            "ttft_ms": 10.0,
+            "ttfp_ms": 20.0,
+            "rtf": 0.5,
+        }
+    ]
+    assert duplex_metrics["duplex_stream_ttft_ms"]["mean"] == 10.0
+    assert duplex_metrics["duplex_stream_ttfp_ms"]["mean"] == 20.0
+    assert duplex_metrics["duplex_stream_rtf"]["mean"] == 0.5
     evaluate = parser.parse_args(
         [
             "evaluate",
@@ -119,7 +159,7 @@ async def test_generate_exercises_realtime_socket_and_media_clock(tmp_path: Path
                 await websocket.send(
                     json.dumps(
                         {
-                            "type": "response.audio.delta",
+                            "type": "response.output_audio.delta",
                             "response_id": "r1",
                             "delta": base64.b64encode(b"\0\0" * 240).decode(),
                             "sample_rate_hz": 24_000,
@@ -144,7 +184,7 @@ async def test_generate_exercises_realtime_socket_and_media_clock(tmp_path: Path
 
     async with websockets.serve(handler, "127.0.0.1", 0) as server:
         port = server.sockets[0].getsockname()[1]
-        output = await runner.generate_sample(
+        result = await runner.generate_sample(
             sample,
             url=f"ws://127.0.0.1:{port}/v1/realtime?duplex=1",
             model="mock",
@@ -152,13 +192,231 @@ async def test_generate_exercises_realtime_socket_and_media_clock(tmp_path: Path
             output_root=tmp_path / "responses",
         )
 
-    assert json.loads(output.read_text(encoding="utf-8")) == [{"sentence": "Done.", "start": 0.8, "end": 0.8}]
-    meta = json.loads(output.with_name("sample.meta.json").read_text(encoding="utf-8"))
+    assert json.loads(result.output.read_text(encoding="utf-8")) == [{"sentence": "Done.", "start": 0.8, "end": 0.8}]
+    meta = json.loads(result.output.with_name("sample.meta.json").read_text(encoding="utf-8"))
     assert meta["response_done"] is True
     assert meta["drain_timeout"] is None
+    assert "duplex_request_metrics" not in meta
+    assert result.request_metrics
+    assert result.request_metrics[0]["sample_id"] == "sample"
+    assert result.session_metrics["stream_ttfp_ms"] is not None
     assert any(event["type"] == "playback.ack" for event in received)
 
 
+def _pr_manifest(tmp_path: Path, sample_ids: tuple[str, ...]) -> Path:
+    manifest = tmp_path / "manifest.json"
+    manifest.write_text(
+        json.dumps(
+            [
+                {
+                    "id": sample_id,
+                    "split": "PR_correction",
+                    "question_text": "What changed?",
+                    "answer1": "The object moved.",
+                }
+                for sample_id in sample_ids
+            ]
+        ),
+        encoding="utf-8",
+    )
+    return manifest
+
+
+def _run_generate_cli(manifest: Path, response_root: Path) -> None:
+    parser = argparse.ArgumentParser()
+    OmniDuplexEvalSubcommand.add_cli_args(parser)
+    OmniDuplexEvalSubcommand.cmd(
+        parser.parse_args(
+            [
+                "generate",
+                "--dataset",
+                str(manifest),
+                "--family",
+                "pr",
+                "--model",
+                "mock",
+                "--ref-audio",
+                str(manifest),
+                "--response-root",
+                str(response_root),
+            ]
+        )
+    )
+
+
+def _metrics_for(sample_id: str, *, ttft_ms: float, ttfp_ms: float, rtf: float) -> GenerateSampleResult:
+    split = "PR_correction"
+    return GenerateSampleResult(
+        output=Path(split) / f"{sample_id}.json",
+        request_metrics=[{"sample_id": sample_id, "split": split, "ttft_ms": ttft_ms, "ttfp_ms": ttfp_ms, "rtf": rtf}],
+        session_metrics={
+            "sample_id": sample_id,
+            "split": split,
+            "stream_ttft_ms": ttft_ms,
+            "stream_ttfp_ms": ttfp_ms,
+            "stream_rtf": rtf,
+        },
+    )
+
+
+def _fake_generate(results: dict[str, GenerateSampleResult | None]):
+    async def generate(
+        sample: DuplexSample,
+        *,
+        output_root: str | Path,
+        url: str,
+        model: str,
+        ref_audio: str | Path,
+        fps: float = 1.0,
+        mix: str = "question",
+        pace: str = "realtime",
+        clock: str = "media",
+        overwrite: bool = False,
+        unit_ms: int = 1000,
+    ) -> GenerateSampleResult:
+        _ = (url, model, ref_audio, fps, mix, pace, clock, overwrite, unit_ms)
+        result = results[sample.id]
+        if result is None:
+            return GenerateSampleResult(output=Path(output_root) / sample.split / f"{sample.id}.json")
+        return result
+
+    return generate
+
+
+def test_merge_duplex_metrics_report_replaces_only_incoming_sample_keys():
+    existing = build_duplex_metrics_report(
+        request_metrics=[
+            {"sample_id": "kept", "split": "PR_correction", "ttft_ms": 11.0},
+            {"sample_id": "replaced", "split": "PR_correction", "ttft_ms": 12.0},
+        ],
+        session_metrics=[
+            {"sample_id": "kept", "split": "PR_correction", "stream_ttft_ms": 11.0},
+            {"sample_id": "replaced", "split": "PR_correction", "stream_ttft_ms": 12.0},
+        ],
+    )
+    merged = merge_duplex_metrics_report(
+        existing,
+        request_metrics=[{"sample_id": "replaced", "split": "PR_correction", "ttft_ms": 99.0}],
+        session_metrics=[{"sample_id": "replaced", "split": "PR_correction", "stream_ttft_ms": 99.0}],
+    )
+    assert [row["sample_id"] for row in merged["duplex_request_metrics"]] == ["kept", "replaced"]
+    assert merged["duplex_request_metrics"][1]["ttft_ms"] == 99.0
+    assert merged["duplex_stream_ttft_ms"]["mean"] == 55.0
+
+
+def test_read_duplex_metrics_report_returns_none_when_missing(tmp_path: Path):
+    assert read_duplex_metrics_report(tmp_path / DUPLEX_METRICS_FILENAME) is None
+
+
+def test_read_duplex_metrics_report_rejects_invalid_json(tmp_path: Path):
+    path = tmp_path / DUPLEX_METRICS_FILENAME
+    path.write_text("{not-json", encoding="utf-8")
+    with pytest.raises(json.JSONDecodeError):
+        read_duplex_metrics_report(path)
+
+
+def test_merge_duplex_metrics_report_without_existing_is_passthrough():
+    merged = merge_duplex_metrics_report(
+        None,
+        request_metrics=[{"sample_id": "a", "split": "PR_correction", "ttft_ms": 1.0}],
+        session_metrics=[{"sample_id": "a", "split": "PR_correction", "stream_ttft_ms": 1.0}],
+    )
+    assert merged["duplex_request_metrics"][0]["ttft_ms"] == 1.0
+    assert merged["duplex_stream_ttft_ms"]["mean"] == 1.0
+
+
+def test_merge_duplex_metrics_report_rejects_non_object_rows():
+    with pytest.raises(ValueError, match="duplex_request_metrics entries must be JSON objects"):
+        merge_duplex_metrics_report(
+            {"duplex_request_metrics": ["bad"]},
+            request_metrics=[],
+            session_metrics=[],
+        )
+
+
+def test_cli_generate_all_skipped_keeps_existing_metrics(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
+    manifest = _pr_manifest(tmp_path, ("sample-1",))
+    response_root = tmp_path / "responses"
+    monkeypatch.setattr(
+        cli,
+        "generate_sample",
+        _fake_generate({"sample-1": _metrics_for("sample-1", ttft_ms=10.0, ttfp_ms=20.0, rtf=0.5)}),
+    )
+    _run_generate_cli(manifest, response_root)
+    monkeypatch.setattr(cli, "generate_sample", _fake_generate({"sample-1": None}))
+    _run_generate_cli(manifest, response_root)
+    duplex_metrics = json.loads((response_root / DUPLEX_METRICS_FILENAME).read_text(encoding="utf-8"))
+    assert duplex_metrics["duplex_request_metrics"][0]["ttft_ms"] == 10.0
+    assert duplex_metrics["duplex_stream_ttft_ms"]["mean"] == 10.0
+    assert duplex_metrics["duplex_stream_ttfp_ms"]["mean"] == 20.0
+    assert duplex_metrics["duplex_stream_rtf"]["mean"] == 0.5
+
+
+def test_cli_generate_partial_resume_merges_metrics(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
+    manifest = _pr_manifest(tmp_path, ("sample-1", "sample-2"))
+    response_root = tmp_path / "responses"
+    monkeypatch.setattr(
+        cli,
+        "generate_sample",
+        _fake_generate(
+            {
+                "sample-1": _metrics_for("sample-1", ttft_ms=10.0, ttfp_ms=20.0, rtf=0.5),
+                "sample-2": _metrics_for("sample-2", ttft_ms=30.0, ttfp_ms=40.0, rtf=0.25),
+            }
+        ),
+    )
+    _run_generate_cli(manifest, response_root)
+    monkeypatch.setattr(
+        cli,
+        "generate_sample",
+        _fake_generate(
+            {
+                "sample-1": None,
+                "sample-2": _metrics_for("sample-2", ttft_ms=90.0, ttfp_ms=80.0, rtf=1.5),
+            }
+        ),
+    )
+    _run_generate_cli(manifest, response_root)
+    duplex_metrics = json.loads((response_root / DUPLEX_METRICS_FILENAME).read_text(encoding="utf-8"))
+    by_id = {row["sample_id"]: row for row in duplex_metrics["duplex_request_metrics"]}
+    assert by_id["sample-1"]["ttft_ms"] == 10.0
+    assert by_id["sample-2"]["ttft_ms"] == 90.0
+    assert duplex_metrics["duplex_stream_ttft_ms"]["mean"] == 50.0
+    assert duplex_metrics["duplex_stream_ttfp_ms"]["mean"] == 50.0
+    assert duplex_metrics["duplex_stream_rtf"]["mean"] == 1.0
+
+
+def test_collect_duplex_session_metrics_matches_omniinteract_window():
+    collector = EventCollector()
+    audio = {
+        "type": "response.output_audio.delta",
+        "response_id": "r1",
+        "format": "pcm16",
+        "delta": base64.b64encode(bytes((1, 0)) * 2400).decode(),
+        "sample_rate_hz": 24_000,
+        "metadata": {"audio_duration_ms": 100},
+    }
+    collector.add({"type": "response.created", "response": {"id": "r1"}}, received_at_s=10.1)
+    collector.add(
+        {"type": "response.output_text.delta", "response_id": "r1", "delta": "Done."},
+        received_at_s=10.2,
+    )
+    collector.add(audio, received_at_s=10.3)
+    collector.add({"type": "response.done", "response": {"id": "r1"}}, received_at_s=10.4)
+    bundle = collect_duplex_session_metrics(collector, stream_start=10.0, session_id="sample")
+    assert bundle.request_metrics[0]["ttft_ms"] == 100.0
+    assert bundle.request_metrics[0]["ttfp_ms"] == 200.0
+    assert bundle.request_metrics[0]["rtf"] == 2.0
+    assert bundle.session_metrics["stream_ttft_ms"] == 200.0
+    assert bundle.session_metrics["stream_ttfp_ms"] == 300.0
+    report = build_duplex_metrics_report(
+        request_metrics=bundle.request_metrics,
+        session_metrics=[bundle.session_metrics],
+    )
+    assert report["duplex_stream_ttft_ms"]["mean"] == 200.0
+    assert report["duplex_stream_ttfp_ms"]["mean"] == 300.0
+
+
 def test_judge_exercises_openai_http_schema():
     requests = []
 
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_auk.py b/tests/e2e/offline_inference/test_auk.py
new file mode 100644
index 000000000..746af7bd2
--- /dev/null
+++ b/tests/e2e/offline_inference/test_auk.py
@@ -0,0 +1,121 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Offline E2E smoke test for AuK (encoder stage -> diffusion stage).
+
+AuK ships as ``config.yaml`` plus loose safetensors and needs the Qwen2.5-Omni-3B
+snapshot next to it, so the test expects an assembled directory produced by
+``tools/prepare_auk_checkpoint.py`` and skips when it is not available:
+
+    VLLM_OMNI_AUK_MODEL_DIR=/path/to/auk-omni python -m pytest tests/e2e/offline_inference/test_auk.py
+
+Two requests are exercised: zero-shot TTS from a reference clip and text-only
+instruct TTS. The checks are structural (duration, sample rate, level,
+finiteness); fidelity against the upstream implementation is covered by the
+parity suites under ``tests/diffusion/models/auk``.
+"""
+
+from __future__ import annotations
+
+import functools
+import math
+import os
+from pathlib import Path
+
+import numpy as np
+import pytest
+import soundfile as sf
+
+from tests.helpers.mark import hardware_test
+from tests.helpers.media import get_asset_path
+from tests.helpers.runtime import OmniRunner
+from tests.helpers.stage_config import get_deploy_config_path
+from vllm_omni.model_extras.auk import HOP, SAMPLE_RATE, auk_prompt, auk_sampling_params
+
+MODEL_DIR_ENV = "VLLM_OMNI_AUK_MODEL_DIR"
+
+# Any clean speech clip works as the cloning reference; reuse the vendored
+# CosyVoice3 prompt so no new binary asset is needed.
+REFERENCE_WAV_PATH = get_asset_path("cosyvoice3/zero_shot_prompt.wav")
+ZERO_SHOT_TEXT = "The quick brown fox jumps over the lazy dog."
+ZERO_SHOT_SECONDS = 3.0
+# The upstream cookbook template: description first, then the content.
+INSTRUCT_TEXT = (
+    'Generate speech based on the following description: "A calm young woman speaking warmly and slowly.". '
+    'The content to speak is: "Welcome back, how was your day?".'
+)
+INSTRUCT_SECONDS = 2.5
+# 8 Euler steps keep the test short; the base recipe is 32.
+TEST_NFE = 8
+
+_model_dir = os.environ.get(MODEL_DIR_ENV)
+pytestmark = [
+    pytest.mark.slow,
+    pytest.mark.tts,
+    pytest.mark.skipif(not _model_dir, reason=f"set {MODEL_DIR_ENV} to an assembled AuK directory"),
+    pytest.mark.parametrize(
+        "omni_runner",
+        [pytest.param((str(Path(_model_dir or ".").resolve()), get_deploy_config_path("auk.yaml"), {}), id="auk")],
+        indirect=True,
+    ),
+]
+
+
+@functools.lru_cache(maxsize=1)
+def _load_reference_wav() -> tuple[np.ndarray, int]:
+    audio, sr = sf.read(str(REFERENCE_WAV_PATH), dtype="float32", always_2d=False)
+    if isinstance(audio, np.ndarray) and audio.ndim > 1:
+        audio = np.mean(audio, axis=-1)
+    return np.asarray(audio, dtype=np.float32), int(sr)
+
+
+def _audio_from_output(output) -> tuple[np.ndarray, int]:
+    mm = getattr(output, "multimodal_output", None) or {}
+    assert "audio" in mm, f"no audio in the final output; keys={sorted(mm)}"
+    audio = mm["audio"]
+    if isinstance(audio, list):
+        audio = np.concatenate([np.asarray(a, dtype=np.float32).reshape(-1) for a in audio])
+    if hasattr(audio, "detach"):
+        audio = audio.detach().cpu().float().numpy()
+    audio = np.asarray(audio, dtype=np.float32).reshape(-1)
+    sr = mm.get("audio_sample_rate", SAMPLE_RATE)
+    if isinstance(sr, list) and sr:
+        sr = sr[-1]
+    if hasattr(sr, "item"):
+        sr = sr.item()
+    return audio, int(sr)
+
+
+def _check_waveform(audio: np.ndarray, sr: int, *, gen_seconds: float) -> None:
+    assert sr == SAMPLE_RATE
+    expected = math.ceil(gen_seconds * SAMPLE_RATE / HOP) * HOP
+    assert audio.size == expected, f"expected {expected} samples for {gen_seconds}s, got {audio.size}"
+    assert np.isfinite(audio).all(), "non-finite samples"
+    assert np.abs(audio).max() <= 1.0 + 1e-6, "audio exceeds full scale"
+    assert float(np.sqrt(np.mean(audio**2))) > 1e-3, "audio is silent"
+
+
+@hardware_test(res={"cuda": "H100"}, num_cards=1)
+def test_auk_zero_shot_tts(omni_runner: OmniRunner) -> None:
+    """A reference clip plus an instruction yields speech of the requested length."""
+    wav, sr = _load_reference_wav()
+    prompt = auk_prompt(
+        f"Say the following with the same voice: '{ZERO_SHOT_TEXT}'",
+        (wav, sr),
+        gen_seconds=ZERO_SHOT_SECONDS,
+    )
+    outputs = omni_runner.omni.generate(prompt, auk_sampling_params(nfe=TEST_NFE, cfg=2.0, seed=0))
+    assert outputs, "no outputs returned"
+    audio, out_sr = _audio_from_output(outputs[0])
+    _check_waveform(audio, out_sr, gen_seconds=ZERO_SHOT_SECONDS)
+
+
+@hardware_test(res={"cuda": "H100"}, num_cards=1)
+def test_auk_instruct_tts_text_only(omni_runner: OmniRunner) -> None:
+    """A text-only request (no reference audio) takes the no-prompt-audio path."""
+    prompt = auk_prompt(INSTRUCT_TEXT, None, gen_seconds=INSTRUCT_SECONDS)
+    assert prompt["prompt"].rstrip().endswith("<|im_start|>assistant\n".rstrip())
+    assert "|<no_prompt_audio>|" in prompt["prompt"]
+    outputs = omni_runner.omni.generate(prompt, auk_sampling_params(nfe=TEST_NFE, cfg=2.0, seed=0))
+    assert outputs, "no outputs returned"
+    audio, out_sr = _audio_from_output(outputs[0])
+    _check_waveform(audio, out_sr, gen_seconds=INSTRUCT_SECONDS)
diff --git a/tests/e2e/offline_inference/test_device_postprocess_equivalence.py b/tests/e2e/offline_inference/test_device_postprocess_equivalence.py
new file mode 100644
index 000000000..019d90a65
--- /dev/null
+++ b/tests/e2e/offline_inference/test_device_postprocess_equivalence.py
@@ -0,0 +1,105 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""End-to-end WAN check for the typed pre-D2H media contract.
+
+Runs the whole engine twice with the same seed, once per flag state, and compares
+the frames a client receives. WAN denormalizes historical bfloat16 output in the
+input dtype while device preparation computes in float32, so the paths may differ
+by one 255th.
+
+Run with a WAN2.2 checkpoint::
+
+    VLLM_OMNI_DEVICE_POSTPROCESS_MODEL=Wan-AI/Wan2.2-TI2V-5B-Diffusers \
+        pytest -s tests/e2e/offline_inference/test_device_postprocess_equivalence.py
+"""
+
+from __future__ import annotations
+
+import os
+
+import numpy as np
+import pytest
+
+from tests.helpers.mark import hardware_test
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+MODEL = os.environ.get("VLLM_OMNI_DEVICE_POSTPROCESS_MODEL")
+
+pytestmark = [
+    pytest.mark.full_model,
+    pytest.mark.diffusion,
+    pytest.mark.gpu,
+    pytest.mark.skipif(
+        not MODEL,
+        reason="Set VLLM_OMNI_DEVICE_POSTPROCESS_MODEL to a WAN2.2 checkpoint to run this.",
+    ),
+]
+
+_SEED = 1234
+_STEPS = int(os.environ.get("VLLM_OMNI_DEVICE_POSTPROCESS_STEPS", "2"))
+_SIZE = int(os.environ.get("VLLM_OMNI_DEVICE_POSTPROCESS_SIZE", "256"))
+_FRAMES = int(os.environ.get("VLLM_OMNI_DEVICE_POSTPROCESS_FRAMES", "17"))
+
+
+def _generate(enable_device_postprocess: bool) -> np.ndarray:
+    from vllm_omni.entrypoints.omni import Omni
+
+    engine = Omni(
+        model=MODEL,
+        num_gpus=1,
+        video_output_transport={"enable_device_postprocess": enable_device_postprocess},
+    )
+    try:
+        # output_type must travel with the request: the pipelines read it from the
+        # sampling params, and the reduction only covers the "np" path.
+        sampling_params = OmniDiffusionSamplingParams(
+            output_type="np",
+            seed=_SEED,
+            num_inference_steps=_STEPS,
+            height=_SIZE,
+            width=_SIZE,
+            num_frames=_FRAMES,
+        )
+        outputs = engine.generate({"prompt": "a robot waving"}, sampling_params)
+    finally:
+        engine.close()
+
+    video = outputs[0].images[0]
+    return video.numpy() if hasattr(video, "numpy") else np.asarray(video)
+
+
+def _as_uint8_frames(video: np.ndarray) -> np.ndarray:
+    """Reproduce what the API server does before encoding.
+
+    A float payload is scaled and rounded there, so that is the only fair place to
+    compare it against a payload the worker already reduced.
+    """
+    if video.dtype == np.uint8:
+        return video
+    return np.rint(np.clip(video, 0.0, 1.0) * 255.0).astype(np.uint8)
+
+
+# A dtype difference moves ~20% of pixels by one; dropping the round moves ~50%.
+_MAX_DIFFERING_FRACTION = 0.35
+
+
+@hardware_test(res={"cuda": ["H100", "B200"]}, num_cards=1)
+def test_device_postprocess_produces_equivalent_frames() -> None:
+    float_path = _generate(False)
+    device_path = _generate(True)
+
+    # Guard against the run silently taking the float path twice, which would make
+    # the comparison meaningless.
+    assert float_path.dtype != np.uint8, "the float path returned uint8; the gate may be stuck open"
+    assert device_path.dtype == np.uint8, "the WAN typed-media path did not prepare uint8 frames"
+    assert float_path.shape == device_path.shape
+
+    expected = _as_uint8_frames(float_path)
+    deviation = np.abs(device_path.astype(np.int16) - expected.astype(np.int16))
+    differing = float((deviation > 0).mean())
+    print(f"maxdiff={deviation.max()} differing={differing:.4f} ({int((deviation > 0).sum())}/{deviation.size})")
+
+    assert deviation.max() <= 1, "the reduction moved a pixel by more than one 255th"
+    assert differing < _MAX_DIFFERING_FRACTION, (
+        f"{differing:.1%} of pixels differ, more than a denormalize-precision difference explains"
+    )
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 1c9362a23..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 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_gepard_tts.py b/tests/e2e/offline_inference/test_gepard_tts.py
index 2dec32ffc..e1b68eb5c 100644
--- a/tests/e2e/offline_inference/test_gepard_tts.py
+++ b/tests/e2e/offline_inference/test_gepard_tts.py
@@ -246,7 +246,7 @@ def _transcribe_for(wav: torch.Tensor, tmp_dir: str, name: str, accepts) -> str:
         pytest.param(
             "The quick brown fox jumps over the lazy dog.",
             None,
-            marks=pytest.mark.full_model,
+            marks=pytest.mark.slow,
             id="second_text",
         ),
     ],
@@ -274,7 +274,7 @@ def test_gepard_offline_zero_shot(omni_runner, run_level: str, text: str, keywor
     assert keyword in transcript, f"expected {keyword!r} in transcript, got {transcript!r}"
 
 
-@pytest.mark.full_model
+@pytest.mark.slow
 @hardware_test(res={"cuda": "L4"}, num_cards=1)
 def test_gepard_offline_long_text_skips_repetition(omni_runner, run_level: str) -> None:
     """The other branch of the prompt layout, end to end.
diff --git a/tests/e2e/offline_inference/test_hunyuanimage3.py b/tests/e2e/offline_inference/test_hunyuanimage3.py
index 97179d963..21bfe9b39 100644
--- a/tests/e2e/offline_inference/test_hunyuanimage3.py
+++ b/tests/e2e/offline_inference/test_hunyuanimage3.py
@@ -1,5 +1,13 @@
+# 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
 
 import pytest
 import torch
@@ -7,18 +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_image3.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").
@@ -280,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)
 
@@ -315,20 +414,49 @@ 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)
 
 
-@pytest.mark.skipif(torch.accelerator.device_count() < 8, reason="Need at least 8 CUDA GPUs for this test.")
+# A floor for "this is recognizably the same generation" against each
+# case's precomputed reference embedding, not a quality bar -- catches a
+# gross migration regression (wrong/blank/garbage image, or the wrong
+# system prompt applied) without being flaky on run-to-run sampling noise.
+# Matches the threshold test_shared_script_ar_path_reaches_generation uses
+# for its own (seed=1234, en_recaption) comparison below.
+MIN_SEMANTIC_SIMILARITY = 0.5
+
+
+@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,
@@ -342,3 +470,109 @@ def test_system_prompt_scores(
     score = compare_semantic(expected_embedding, generated_image, clip_model, clip_processor)
 
     print(f"{system_prompt_name}: CLIP cosine similarity = {score:.6f}")
+    assert score >= MIN_SEMANTIC_SIMILARITY, (
+        f"{system_prompt_name}: CLIP similarity {score:.4f} is below "
+        f"{MIN_SEMANTIC_SIMILARITY} against the reference (seed=1234) embedding -- "
+        "the migrated path may have diverged from the reference HunyuanImage-3.0 "
+        f"output for use_system_prompt={use_system_prompt!r}."
+    )
+
+
+def _load_text_to_image_module():
+    """Dynamically load the shared example script by file path (``examples/``
+    is not an installed package) so this test can call its real
+    ``_apply_ar_stage_inputs`` instead of re-implementing its logic."""
+    repo_root = Path(__file__).resolve().parents[3]
+    path = repo_root / "examples/offline_inference/text_to_image/text_to_image.py"
+    spec = importlib.util.spec_from_file_location("_e2e_shared_text_to_image", path)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+@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],
+) -> None:
+    """Exercise the path this PR actually migrates HunyuanImage-3.0 onto:
+
+        get_model_class_name -> get_ar_input_builder -> _apply_ar_stage_inputs
+        -> Omni.generate()
+
+    using the *real* model_extras registry lookup (keyed on the engine's
+    live ``model_class_name``) and the shared ``text_to_image.py``'s own
+    helper -- not the hand-constructed ``sampling_params.extra_args`` that
+    ``_generate_image``/``test_system_prompt_scores`` above use, which never
+    touch the registry or the AR-tokenizer-loading path at all. This is the
+    one gap those tests leave: a regression in the registry key (the bug
+    this PR fixes), in ``_apply_ar_stage_inputs``, or in the
+    ``ar_tokenizer_validator`` wiring would not fail any of them.
+
+    Reuses the ``en_recaption`` reference embedding from
+    ``test_system_prompt_scores`` so this also asserts the migrated path
+    produces the *same* output as the hand-constructed one, not just "didn't
+    crash."
+    """
+    text_to_image = _load_text_to_image_module()
+    clip_model, clip_processor = clip_bundle
+
+    model_class_name = get_model_class_name(omni)
+    ar_input_builder = get_ar_input_builder(model_class_name)
+    assert ar_input_builder is not None, (
+        f"get_ar_input_builder({model_class_name!r}) returned None for the running "
+        "engine -- this is exactly the registry-key regression this PR fixes "
+        "(spec registered under the wrong model_class_name), and it would "
+        "silently skip AR-stage input building entirely."
+    )
+
+    generator_device = current_omni_platform.device_type or "cuda"
+    diffusion_params = OmniDiffusionSamplingParams(
+        seed=1234,
+        generator=torch.Generator(device=generator_device).manual_seed(1234),
+        num_outputs_per_prompt=1,
+    )
+    defaults = list(omni.default_sampling_params_list or [])
+    sampling_params_list = [clone_sampling_params(p) for p in defaults]
+    for idx, params in enumerate(sampling_params_list):
+        if isinstance(params, OmniDiffusionSamplingParams):
+            sampling_params_list[idx] = diffusion_params
+
+    prompt_dict: dict[str, object] = {"prompt": PROMPT, "modalities": ["image"]}
+    text_to_image._apply_ar_stage_inputs(
+        ar_input_builder,
+        model=MODEL_NAME,
+        prompt_text=PROMPT,
+        extra_body={"use_system_prompt": "en_recaption"},
+        num_images=0,
+        height=None,
+        width=None,
+        prompt_dict=prompt_dict,
+        sampling_params_list=sampling_params_list,
+        trust_remote_code=True,
+        # validate_special_token_ids now tolerates tokens the loaded tokenizer
+        # doesn't recognize at all (unk_token_id) instead of requiring every
+        # entry in HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS to be present, so this is
+        # safe against MODEL_NAME's base checkpoint missing the Instruct-only
+        # <img_ratio_33>/<img_ratio_36> tokens. Wiring it here exercises the
+        # real production path (get_ar_tokenizer_validator via the registry),
+        # not just the isolated fake-tokenizer coverage in test_prompt_utils.py
+        # / test_shared_script_ar_integration.py.
+        validate_tokenizer=get_ar_tokenizer_validator(model_class_name),
+    )
+
+    outputs = omni.generate(prompt_dict, sampling_params_list=sampling_params_list)
+    generated_image = _extract_generated_image(outputs)
+    score = compare_semantic(SYSTEM_EN_RECAPTION, generated_image, clip_model, clip_processor)
+    print(f"shared-script AR path (en_recaption): CLIP cosine similarity = {score:.6f}")
+    # test_system_prompt_scores now asserts this same (seed=1234, en_recaption)
+    # case through the hand-constructed extra_args path against the same
+    # module-level MIN_SEMANTIC_SIMILARITY floor, so this reuses it too rather
+    # than picking an independent threshold for the same comparison.
+    assert score >= MIN_SEMANTIC_SIMILARITY, (
+        f"shared-script AR path (en_recaption) CLIP similarity {score:.4f} is below "
+        f"{MIN_SEMANTIC_SIMILARITY} -- the migrated get_ar_input_builder path may have "
+        "diverged from the reference HunyuanImage-3.0 output for this prompt/system-prompt."
+    )
diff --git a/tests/e2e/offline_inference/test_hunyuanimage3_i2t_expansion.py b/tests/e2e/offline_inference/test_hunyuanimage3_i2t_expansion.py
index 7e7c63900..925833216 100644
--- a/tests/e2e/offline_inference/test_hunyuanimage3_i2t_expansion.py
+++ b/tests/e2e/offline_inference/test_hunyuanimage3_i2t_expansion.py
@@ -57,7 +57,7 @@ def omni() -> Generator[Omni, None, None]:
         yield runner.omni
 
 
-@hardware_test(res={"cuda": "H100"}, num_cards=4)
+@hardware_test(res={"cuda": ["H100", "B200"]}, num_cards=4)
 def test_i2t_generates_text(omni: Omni) -> None:
     """Verify I2T output's first 20 token IDs match the HF greedy baseline."""
     # Solid-color image keeps the input self-contained and reproducible.
diff --git a/tests/e2e/offline_inference/test_lingbot_world_v2.py b/tests/e2e/offline_inference/test_lingbot_world_v2.py
index 64578af01..bf1d2ca23 100644
--- a/tests/e2e/offline_inference/test_lingbot_world_v2.py
+++ b/tests/e2e/offline_inference/test_lingbot_world_v2.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
 """End-to-end smoke test for LingBot-World v2 generation."""
 
 from __future__ import annotations
@@ -37,7 +37,7 @@ _OMNI_RUNNER_PARAM = (
 )
 
 pytestmark = [
-    pytest.mark.slow,
+    pytest.mark.full_model,
     pytest.mark.diffusion,
     pytest.mark.skipif(
         not _HAS_INPUT_ASSETS,
@@ -47,7 +47,7 @@ pytestmark = [
 ]
 
 
-@hardware_test(res={"cuda": "H100"}, num_cards=1)
+@hardware_test(res={"cuda": ["H100", "B200"]}, num_cards=1)
 def test_lingbot_world_v2_tp1_one_block(omni_runner_handler: OmniRunnerHandler) -> None:
     """Load the real checkpoint and generate one causal block on one GPU."""
 
diff --git a/tests/e2e/offline_inference/test_longcat_video_avatar.py b/tests/e2e/offline_inference/test_longcat_video_avatar.py
index 404ad9485..59f9ae4e4 100644
--- a/tests/e2e/offline_inference/test_longcat_video_avatar.py
+++ b/tests/e2e/offline_inference/test_longcat_video_avatar.py
@@ -1,7 +1,8 @@
 # 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.abc import Generator
+from typing import Any
 
 import numpy as np
 import pytest
@@ -105,15 +106,17 @@ def _generate_avatar_frames(
     num_frames: int = 5,
     sampling_extra_args: dict | None = None,
 ):
+    extra_info: dict[str, Any] = dict(additional_information or {})
+    extra_info.update({"stage": stage, "resolution": "480p"})
+    multi_modal_data: dict[str, Any] = {"audio": audio_path}
+    if image_path is not None:
+        multi_modal_data["image"] = image_path
     prompt = {
         "prompt": PROMPT,
         "negative_prompt": NEGATIVE_PROMPT,
-        "multi_modal_data": {"audio": audio_path},
-        "additional_information": additional_information or {},
+        "multi_modal_data": multi_modal_data,
+        "additional_information": extra_info,
     }
-    prompt["additional_information"].update({"stage": stage, "resolution": "480p"})
-    if image_path is not None:
-        prompt["multi_modal_data"]["image"] = image_path
 
     outputs = omni_runner.generate(
         [prompt],
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_nano_expansion.py b/tests/e2e/offline_inference/test_moss_tts_nano_expansion.py
index 41e2229d3..3d9dafaf9 100644
--- a/tests/e2e/offline_inference/test_moss_tts_nano_expansion.py
+++ b/tests/e2e/offline_inference/test_moss_tts_nano_expansion.py
@@ -121,7 +121,7 @@ def _collect_audio(omni: Omni, request: dict) -> tuple[torch.Tensor, int]:
 
 
 @pytest.mark.advanced_model
-@hardware_test(res={"cuda": "L4"})
+@hardware_test(res={"cuda": "L4", "npu": "A2"})
 def test_moss_tts_nano_english(omni_runner: OmniRunner, ref_audio_path) -> None:
     """English TTS produces non-empty 48 kHz stereo audio."""
     req = _build_request("Hello, this is a short voice cloning demo for testing.", ref_audio_path)
@@ -133,7 +133,7 @@ def test_moss_tts_nano_english(omni_runner: OmniRunner, ref_audio_path) -> None:
 
 
 @pytest.mark.advanced_model
-@hardware_test(res={"cuda": "L4"})
+@hardware_test(res={"cuda": "L4", "npu": "A2"})
 def test_moss_tts_nano_chinese(omni_runner: OmniRunner, ref_audio_path) -> None:
     """Chinese TTS produces non-empty audio."""
     req = _build_request("你好，这是语音合成测试。", ref_audio_path)
@@ -145,7 +145,7 @@ def test_moss_tts_nano_chinese(omni_runner: OmniRunner, ref_audio_path) -> None:
 
 
 @pytest.mark.advanced_model
-@hardware_test(res={"cuda": "L4"})
+@hardware_test(res={"cuda": "L4", "npu": "A2"})
 def test_moss_tts_nano_deterministic(omni_runner: OmniRunner, ref_audio_path) -> None:
     """Same seed produces identical waveforms."""
     req = _build_request("Reproducible output test.", ref_audio_path, seed=123)
@@ -157,7 +157,7 @@ def test_moss_tts_nano_deterministic(omni_runner: OmniRunner, ref_audio_path) ->
 
 
 @pytest.mark.advanced_model
-@hardware_test(res={"cuda": "L4"})
+@hardware_test(res={"cuda": "L4", "npu": "A2"})
 def test_moss_tts_nano_batch(omni_runner: OmniRunner, ref_audio_path) -> None:
     """Batch of two requests returns audio for each."""
     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 e7b4d061e..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
@@ -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 test for Qwen-Image AutoRound W4A16 quantized inference.
 
 Verifies that the W4A16 quantized Qwen-Image checkpoint loads end-to-end
@@ -47,15 +47,16 @@ def _first_request_images(outputs) -> list:
     return req_out.images
 
 
+@pytest.mark.full_model
 @pytest.mark.diffusion
-@hardware_test(res={"cuda": "L4"})
+@hardware_test(res={"cuda": ["L4", "B200"]})
 def test_qwen_image_autoround_w4a16_load():
     """Load the W4A16 quantized Qwen-Image model and run a minimal generation.
 
     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(),
@@ -68,8 +69,9 @@ def test_qwen_image_autoround_w4a16_load():
         assert arr.std() > 1.0, "Generated image appears blank (std ≈ 0)"
 
 
+@pytest.mark.full_model
 @pytest.mark.diffusion
-@hardware_test(res={"cuda": "L4"})
+@hardware_test(res={"cuda": ["L4", "B200"]})
 def test_qwen_image_autoround_w4a16_generate():
     """Full generation: 512×512, 20 steps, CFG=5.0.
 
@@ -83,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 af55c51aa..67f36254b 100644
--- a/tests/e2e/offline_inference/test_voxcpm2_tts.py
+++ b/tests/e2e/offline_inference/test_voxcpm2_tts.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 """E2E test for VoxCPM2 native AR offline inference."""
 
 import os
@@ -10,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
 
@@ -41,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."}])
@@ -54,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.
 
@@ -95,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_autoround_w4a16_expansion.py b/tests/e2e/offline_inference/test_wan22_autoround_w4a16_expansion.py
index 4ac51a344..9594a0f99 100644
--- a/tests/e2e/offline_inference/test_wan22_autoround_w4a16_expansion.py
+++ b/tests/e2e/offline_inference/test_wan22_autoround_w4a16_expansion.py
@@ -156,7 +156,7 @@ def _generate_t2v_video(offline_client, prompt: str = "A cat sitting on a table"
 # ------------------------------------------------------------------
 
 
-@hardware_test(res={"cuda": "H100"})
+@hardware_test(res={"cuda": ["H100", "B200"]})
 @pytest.mark.parametrize("omni_runner", quant_i2v_params, indirect=True)
 def test_wan22_i2v_autoround_w4a16_generates_video(omni_runner, offline_client):
     """Load the W4A16 quantized Wan2.2 I2V model and verify it produces a valid video."""
@@ -180,7 +180,7 @@ def test_wan22_i2v_autoround_w4a16_generates_video(omni_runner, offline_client):
 # ------------------------------------------------------------------
 
 
-@hardware_test(res={"cuda": "H100"})
+@hardware_test(res={"cuda": ["H100", "B200"]})
 @pytest.mark.parametrize("omni_runner", quant_t2v_params, indirect=True)
 def test_wan22_t2v_autoround_w4a16_generates_video(omni_runner, offline_client):
     """Load the W4A16 quantized Wan2.2 T2V model and verify it produces a valid video."""
@@ -202,7 +202,7 @@ def test_wan22_t2v_autoround_w4a16_generates_video(omni_runner, offline_client):
 # ------------------------------------------------------------------
 
 
-@hardware_test(res={"cuda": "H100"})
+@hardware_test(res={"cuda": ["H100", "B200"]})
 @pytest.mark.parametrize("omni_runner", quant_i2v_params, indirect=True)
 def test_wan22_i2v_autoround_w4a16_quant_peak(omni_runner, offline_client):
     """Measure peak GPU memory of W4A16 quantized I2V model."""
@@ -218,7 +218,7 @@ def test_wan22_i2v_autoround_w4a16_quant_peak(omni_runner, offline_client):
 # ------------------------------------------------------------------
 
 
-@hardware_test(res={"cuda": "H100"})
+@hardware_test(res={"cuda": ["H100", "B200"]})
 @pytest.mark.parametrize("omni_runner", baseline_i2v_params, indirect=True)
 def test_wan22_i2v_autoround_w4a16_baseline_peak(omni_runner, offline_client):
     """Measure peak GPU memory of BF16 baseline I2V model."""
@@ -234,7 +234,7 @@ def test_wan22_i2v_autoround_w4a16_baseline_peak(omni_runner, offline_client):
 # ------------------------------------------------------------------
 
 
-@hardware_test(res={"cuda": "H100"})
+@hardware_test(res={"cuda": ["H100", "B200"]})
 def test_wan22_i2v_autoround_w4a16_memory_savings():
     """Assert quantized I2V model uses meaningfully less memory than BF16 baseline."""
     quant_peak = _memory_results["quant_i2v"]
@@ -259,7 +259,7 @@ def test_wan22_i2v_autoround_w4a16_memory_savings():
 # ------------------------------------------------------------------
 
 
-@hardware_test(res={"cuda": "H100"})
+@hardware_test(res={"cuda": ["H100", "B200"]})
 @pytest.mark.parametrize("omni_runner", quant_t2v_params, indirect=True)
 def test_wan22_t2v_autoround_w4a16_quant_peak(omni_runner, offline_client):
     """Measure peak GPU memory of W4A16 quantized T2V model."""
@@ -275,7 +275,7 @@ def test_wan22_t2v_autoround_w4a16_quant_peak(omni_runner, offline_client):
 # ------------------------------------------------------------------
 
 
-@hardware_test(res={"cuda": "H100"})
+@hardware_test(res={"cuda": ["H100", "B200"]})
 @pytest.mark.parametrize("omni_runner", baseline_t2v_params, indirect=True)
 def test_wan22_t2v_autoround_w4a16_baseline_peak(omni_runner, offline_client):
     """Measure peak GPU memory of BF16 baseline T2V model."""
@@ -291,7 +291,7 @@ def test_wan22_t2v_autoround_w4a16_baseline_peak(omni_runner, offline_client):
 # ------------------------------------------------------------------
 
 
-@hardware_test(res={"cuda": "H100"})
+@hardware_test(res={"cuda": ["H100", "B200"]})
 def test_wan22_t2v_autoround_w4a16_memory_savings():
     """Assert quantized T2V model uses meaningfully less memory than BF16 baseline."""
     quant_peak = _memory_results["quant_t2v"]
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/helpers/minicpmo_realtime_duplex_scenarios.py b/tests/e2e/online_serving/helpers/minicpmo_realtime_duplex_scenarios.py
index ebd59fc3e..0f9b4af51 100644
--- a/tests/e2e/online_serving/helpers/minicpmo_realtime_duplex_scenarios.py
+++ b/tests/e2e/online_serving/helpers/minicpmo_realtime_duplex_scenarios.py
@@ -71,15 +71,8 @@ from vllm_omni.experimental.fullduplex.video_stacking import (  # noqa: E402
 from vllm_omni.metrics.definitions import compute_audio_rtf  # noqa: E402
 
 
-def _url_with_model(url, model, *, autostart=None, session_id=None):
-    # This driver speaks the MiniCPM-o native duplex wire contract.
-    return build_realtime_url(
-        url,
-        model,
-        autostart=autostart,
-        session_id=session_id,
-        extra_query={"native_duplex": "1"},
-    )
+def _url_with_model(url, model, *, autostart=None):
+    return build_realtime_url(url, model, autostart=autostart)
 
 
 _read_wav_pcm16 = read_pcm16_wav
@@ -213,7 +206,7 @@ class DemoState:
                 item_id = item.get("id")
                 if isinstance(item_id, str) and item_id not in self.assistant_item_ids:
                     self.assistant_item_ids.append(item_id)
-        elif event_type == "response.audio.delta":
+        elif event_type == "response.output_audio.delta":
             delta = event.get("delta") or event.get("audio")
             if isinstance(delta, str) and delta:
                 try:
@@ -386,8 +379,8 @@ class DemoState:
             "response.output_item.added",
             "response.content_part.added",
             "response.speak",
-            "response.audio.delta",
-            "response.audio.done",
+            "response.output_audio.delta",
+            "response.output_audio.done",
             "response.content_part.done",
             "response.output_item.done",
             "response.done",
@@ -402,8 +395,8 @@ class DemoState:
             )
             if index is None and event_type not in {
                 "response.speak",
-                "response.audio.delta",
-                "response.audio.done",
+                "response.output_audio.delta",
+                "response.output_audio.done",
             }:
                 return {}
             if index is not None:
@@ -451,13 +444,13 @@ class DemoState:
             "response.output_item.added",
             "response.content_part.added",
             "response.speak",
-            "response.audio.delta",
-            "response.audio.done",
+            "response.output_audio.delta",
+            "response.output_audio.done",
             "response.content_part.done",
             "response.output_item.done",
             "response.done",
         ]
-        if "response.audio.delta" not in indices_by_type:
+        if "response.output_audio.delta" not in indices_by_type:
             listen_index = self.first_index(
                 "response.listen",
                 lambda event: (
@@ -515,7 +508,7 @@ class DemoState:
 
     def model_speak_before_audio_ok(self) -> bool:
         speak_index = self.first_index("response.speak")
-        audio_index = self.first_index("response.audio.delta")
+        audio_index = self.first_index("response.output_audio.delta")
         return speak_index is not None and audio_index is not None and speak_index < audio_index
 
     def response_done(self, response_id: str | None) -> bool:
@@ -532,7 +525,7 @@ class DemoState:
         return sum(
             1
             for event in self.events
-            if event.get("type") == "response.audio.delta" and self._event_response_id(event) == response_id
+            if event.get("type") == "response.output_audio.delta" and self._event_response_id(event) == response_id
         )
 
     def response_playback_sent_ms(self, response_id: str | None) -> int:
@@ -565,14 +558,16 @@ class DemoState:
         return "".join(
             str(event.get("delta", ""))
             for event in self.events
-            if event.get("type") == "response.audio_transcript.delta" and self._event_response_id(event) == response_id
+            if event.get("type") == "response.output_audio_transcript.delta"
+            and self._event_response_id(event) == response_id
         )
 
     def response_transcript_done(self, response_id: str) -> list[str]:
         return [
             str(event.get("transcript", ""))
             for event in self.events
-            if event.get("type") == "response.audio_transcript.done" and self._event_response_id(event) == response_id
+            if event.get("type") == "response.output_audio_transcript.done"
+            and self._event_response_id(event) == response_id
         ]
 
     def completed_response_ids(self) -> list[str]:
@@ -603,7 +598,7 @@ class DemoState:
             return 0
         stale = 0
         for index, event in enumerate(self.events):
-            if event.get("type") != "response.audio.delta":
+            if event.get("type") != "response.output_audio.delta":
                 continue
             metadata = event.get("metadata")
             if not isinstance(metadata, dict):
@@ -628,7 +623,6 @@ def _session_update_event(args: DemoArgs) -> dict[str, object]:
         "playback_commit_policy": "ack_only",
         "extra_body": {
             "auto_response": True,
-            "native_duplex": True,
             "force_listen_count": 0,
         },
     }
@@ -644,9 +638,6 @@ def _session_update_event(args: DemoArgs) -> dict[str, object]:
         "type": "session.update",
         "session": session_payload,
     }
-    session_id = getattr(args, "session_id", None)
-    if session_id:
-        session_payload["session_id"] = session_id
     return event
 
 
@@ -1126,7 +1117,7 @@ async def _send_clean_turn(
             state,
             lambda: state.response_audio_delta_count(response_id) > 0,
             timeout_s=timeout_s,
-            label=f"{transcript} response.audio.delta",
+            label=f"{transcript} response.output_audio.delta",
         )
     await _wait_for(
         state,
@@ -1341,7 +1332,7 @@ async def _send_listen_only_overlap_pair(
         state,
         lambda: state.response_audio_delta_count(first_response_id) > 0,
         timeout_s=timeout_s,
-        label=f"{transcripts[0]} response.audio.delta",
+        label=f"{transcripts[0]} response.output_audio.delta",
     )
     if state.response_done(first_response_id):
         raise RuntimeError("first response completed before overlap input could start")
@@ -1460,7 +1451,6 @@ async def run_demo(args: DemoArgs) -> dict[str, object]:
         args.url,
         args.model,
         autostart=False if getattr(args, "ref_audio", None) else None,
-        session_id=getattr(args, "session_id", None),
     )
     state = DemoState()
     stop = asyncio.Event()
@@ -1600,7 +1590,9 @@ async def run_demo(args: DemoArgs) -> dict[str, object]:
         transcript_hints_enabled=transcript_hints_enabled and not continuous_input,
     )
     model_speak_event_ok = state.model_speak_before_audio_ok()
-    realtime_audio_lifecycle_ok = state.count("response.audio.delta") > 0 and state.count("response.audio.done") > 0
+    realtime_audio_lifecycle_ok = (
+        state.count("response.output_audio.delta") > 0 and state.count("response.output_audio.done") > 0
+    )
     completed_response_ids = state.completed_response_ids()
     observed_turn_response_ids = [response_id for response_id in turn_response_ids if isinstance(response_id, str)]
     expected_empty_response_ids = {
@@ -1625,7 +1617,7 @@ async def run_demo(args: DemoArgs) -> dict[str, object]:
         state.count("response.created") == state.count("response.done")
         and len(state.response_ids) == len(completed_response_ids)
         and len(completed_response_ids) == len(set(completed_response_ids))
-        and state.count("response.audio.done") <= state.count("response.done")
+        and state.count("response.output_audio.done") <= state.count("response.done")
         and _response_cardinality_ok(
             completed_response_ids,
             expected_turns=expected_turns,
@@ -1670,6 +1662,10 @@ async def run_demo(args: DemoArgs) -> dict[str, object]:
     )
     unexpected_error_events = _unexpected_error_events(state)
     continuous_input_ok = not continuous_input or state.count("input_audio_buffer.committed") == 0
+    # The server allocates every session id; label metrics with the one it announced.
+    created = state.events[0] if state.events else {}
+    created_session = created.get("session") if isinstance(created, dict) else None
+    server_session_id = created_session.get("id") if isinstance(created_session, dict) else None
     result = {
         "ok": terminal_activity_ok
         and state.count("session.closed") > 0
@@ -1707,8 +1703,8 @@ async def run_demo(args: DemoArgs) -> dict[str, object]:
         "input_transcription_ok": input_transcription_ok,
         "completed_response_ids": completed_response_ids,
         "response_timings": state.response_timing_summaries(),
-        "request_metrics": state.session_request_metrics(session_id=args.session_id),
-        "session_metrics": state.session_metric_summary(session_id=args.session_id),
+        "request_metrics": state.session_request_metrics(session_id=server_session_id),
+        "session_metrics": state.session_metric_summary(session_id=server_session_id),
         "lifecycle_counts_ok": lifecycle_counts_ok,
         "validation_mode": validation_mode,
         "scenario": scenario,
@@ -1769,7 +1765,6 @@ def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser()
     parser.add_argument("--url", default="ws://localhost:8099/v1/realtime?duplex=1")
     parser.add_argument("--model", default="openbmb/MiniCPM-o-4_5")
-    parser.add_argument("--session-id", help="Use an explicit public session ID, including for close/reopen tests.")
     parser.add_argument("--input-wav", required=True)
     parser.add_argument("--ref-audio", help="Optional WAV used as the MiniCPM-o voice prompt.")
     parser.add_argument(
diff --git a/tests/e2e/online_serving/minimax_h3/test_minimax_h3_dlo_dp2_fl2va.py b/tests/e2e/online_serving/minimax_h3/test_minimax_h3_dlo_dp2_fl2va.py
index 24cc2f7e9..7f14e403d 100644
--- a/tests/e2e/online_serving/minimax_h3/test_minimax_h3_dlo_dp2_fl2va.py
+++ b/tests/e2e/online_serving/minimax_h3/test_minimax_h3_dlo_dp2_fl2va.py
@@ -12,7 +12,7 @@ from tests.helpers.runtime import OmniServer, OpenAIClientHandler
 
 from ._common import assert_h3_video, dlo_params, run_dlo_wave, run_fl2va
 
-pytestmark = [pytest.mark.core_model, pytest.mark.advanced_model, pytest.mark.diffusion, pytest.mark.slow]
+pytestmark = [pytest.mark.advanced_model, pytest.mark.diffusion]
 H100_TWO_CARD_MARKS = hardware_marks(res={"cuda": "H100"}, num_cards=2)
 
 
diff --git a/tests/e2e/online_serving/minimax_h3/test_minimax_h3_dlo_dp2_ref2va.py b/tests/e2e/online_serving/minimax_h3/test_minimax_h3_dlo_dp2_ref2va.py
index f988a4431..2c61d2a3c 100644
--- a/tests/e2e/online_serving/minimax_h3/test_minimax_h3_dlo_dp2_ref2va.py
+++ b/tests/e2e/online_serving/minimax_h3/test_minimax_h3_dlo_dp2_ref2va.py
@@ -12,7 +12,7 @@ from tests.helpers.runtime import OmniServer, OpenAIClientHandler
 
 from ._common import assert_h3_video, dlo_params, run_dlo_wave, run_ref2va
 
-pytestmark = [pytest.mark.core_model, pytest.mark.advanced_model, pytest.mark.diffusion, pytest.mark.slow]
+pytestmark = [pytest.mark.advanced_model, pytest.mark.diffusion]
 H100_TWO_CARD_MARKS = hardware_marks(res={"cuda": "H100"}, num_cards=2)
 
 
diff --git a/tests/e2e/online_serving/minimax_h3/test_minimax_h3_fasth3_lora.py b/tests/e2e/online_serving/minimax_h3/test_minimax_h3_fasth3_lora.py
index 9fc3e8e31..1fd80454b 100644
--- a/tests/e2e/online_serving/minimax_h3/test_minimax_h3_fasth3_lora.py
+++ b/tests/e2e/online_serving/minimax_h3/test_minimax_h3_fasth3_lora.py
@@ -21,7 +21,7 @@ from ._common import (
     post_sync,
 )
 
-pytestmark = [pytest.mark.core_model, pytest.mark.advanced_model, pytest.mark.diffusion, pytest.mark.slow]
+pytestmark = [pytest.mark.advanced_model, pytest.mark.diffusion]
 H100_TWO_CARD_MARKS = hardware_marks(res={"cuda": "H100"}, num_cards=2)
 
 
diff --git a/tests/e2e/online_serving/minimax_h3/test_minimax_h3_turbo_lora.py b/tests/e2e/online_serving/minimax_h3/test_minimax_h3_turbo_lora.py
index 0190598d5..8a1a6542a 100644
--- a/tests/e2e/online_serving/minimax_h3/test_minimax_h3_turbo_lora.py
+++ b/tests/e2e/online_serving/minimax_h3/test_minimax_h3_turbo_lora.py
@@ -20,7 +20,7 @@ from ._common import (
     turbo_params,
 )
 
-pytestmark = [pytest.mark.core_model, pytest.mark.advanced_model, pytest.mark.diffusion, pytest.mark.slow]
+pytestmark = [pytest.mark.advanced_model, pytest.mark.diffusion]
 H100_TWO_CARD_MARKS = hardware_marks(res={"cuda": "H100"}, num_cards=2)
 
 
diff --git a/tests/e2e/online_serving/nemotron_voicechat_realtime_duplex.py b/tests/e2e/online_serving/nemotron_voicechat_realtime_duplex.py
index 11c35cecc..6aba7cfe7 100644
--- a/tests/e2e/online_serving/nemotron_voicechat_realtime_duplex.py
+++ b/tests/e2e/online_serving/nemotron_voicechat_realtime_duplex.py
@@ -215,7 +215,7 @@ async def run(args: argparse.Namespace) -> dict[str, object]:
                     client.events.count("response.function_call_arguments.done") > 0
                     if args.expect_function_call
                     else (
-                        client.events.count("response.audio.delta") >= args.minimum_audio_chunks
+                        client.events.count("response.output_audio.delta") >= args.minimum_audio_chunks
                         and (
                             args.allow_incomplete_response
                             or client.events.count("response.done") > completed_responses_at_commit
@@ -279,10 +279,10 @@ async def run(args: argparse.Namespace) -> dict[str, object]:
                     transcript = "".join(
                         str(event.get("delta", ""))
                         for event in later
-                        if event.get("type") == "response.audio_transcript.delta"
+                        if event.get("type") == "response.output_audio_transcript.delta"
                     ).lower()
                     return (
-                        any(event.get("type") == "response.audio.delta" for event in later)
+                        any(event.get("type") == "response.output_audio.delta" for event in later)
                         and any(event.get("type") == "response.done" for event in later)
                         and (args.expected_post_tool_text is None or args.expected_post_tool_text.lower() in transcript)
                     )
@@ -297,7 +297,7 @@ async def run(args: argparse.Namespace) -> dict[str, object]:
                 await asyncio.sleep(args.drain_s)
 
         audio = client.events.audio_bytes()
-        audio_events = _events(client, "response.audio.delta")
+        audio_events = _events(client, "response.output_audio.delta")
         rates = {event.get("sample_rate_hz") for event in audio_events}
         if not args.expect_function_call and audio and rates != {OUTPUT_SAMPLE_RATE_HZ}:
             raise AssertionError(f"unexpected output sample rates: {rates}")
diff --git a/tests/e2e/online_serving/personaplex_realtime_duplex.py b/tests/e2e/online_serving/personaplex_realtime_duplex.py
index 26ee22037..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.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.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.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/run_minicpmo_realtime_duplex_demo_pair.py b/tests/e2e/online_serving/run_minicpmo_realtime_duplex_demo_pair.py
index f5539968b..19b4b8107 100644
--- a/tests/e2e/online_serving/run_minicpmo_realtime_duplex_demo_pair.py
+++ b/tests/e2e/online_serving/run_minicpmo_realtime_duplex_demo_pair.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 """Run two MiniCPM-o Realtime duplex demo processes concurrently.
 
 This E2E driver covers the same process boundary users exercise manually:
@@ -14,13 +17,12 @@ import hashlib
 import io
 import json
 import sys
-import uuid
 import wave
 from pathlib import Path
 
 REPO_ROOT = Path(__file__).resolve().parents[3]
 DEMO_PATH = REPO_ROOT / "examples/online_serving/minicpmo/realtime_duplex_demo.py"
-AUDIO_DELTA_EVENTS = {"response.audio.delta", "response.output_audio.delta"}
+AUDIO_DELTA_EVENTS = {"response.output_audio.delta"}
 
 
 def _canonical_path(path: str) -> Path:
@@ -263,8 +265,6 @@ async def _run_demo_process(
         str(args.chunk_ms),
         "--timeout-s",
         str(args.timeout_s),
-        "--session-id",
-        f"duplex-pair-{label}-{uuid.uuid4().hex}",
     ]
     if args.no_realtime_pacing:
         command.append("--no-realtime-pacing")
diff --git a/tests/e2e/online_serving/run_minicpmo_realtime_duplex_multi_session.py b/tests/e2e/online_serving/run_minicpmo_realtime_duplex_multi_session.py
index 32e6e01da..c13f8ca7f 100644
--- a/tests/e2e/online_serving/run_minicpmo_realtime_duplex_multi_session.py
+++ b/tests/e2e/online_serving/run_minicpmo_realtime_duplex_multi_session.py
@@ -21,7 +21,7 @@ from websockets.asyncio.client import ClientConnection
 from websockets.exceptions import ConnectionClosed
 
 SCRIPT_DIR = Path(__file__).resolve().parent
-REPO_ROOT = SCRIPT_DIR.parents[3]
+REPO_ROOT = SCRIPT_DIR.parents[2]
 if str(REPO_ROOT) not in sys.path:
     sys.path.insert(0, str(REPO_ROOT))
 
@@ -42,6 +42,15 @@ def _url_with_model(*args, **kwargs) -> str:
     return _scenario_module()._url_with_model(*args, **kwargs)
 
 
+def _created_session_id(created: dict[str, object]) -> str:
+    """The server-allocated session id announced by ``session.created``."""
+    session = created.get("session")
+    session_id = session.get("id") if isinstance(session, dict) else None
+    if not isinstance(session_id, str) or not session_id:
+        raise RuntimeError("session.created omitted the server-allocated session id")
+    return session_id
+
+
 async def run_demo(args):
     return await _scenario_module().run_demo(args)
 
@@ -217,7 +226,6 @@ async def _open_admission_session(
         args.url,
         args.model,
         autostart=False if getattr(args, "ref_audio", None) else None,
-        session_id=session_id,
     )
     ws = await websockets.connect(url, max_size=64 * 1024 * 1024)
     await ws.send(
@@ -225,10 +233,8 @@ async def _open_admission_session(
             {
                 "type": "session.update",
                 "session": {
-                    "session_id": session_id,
                     "model": args.model,
                     "modalities": ["audio", "text"],
-                    "extra_body": {"native_duplex": True},
                     **({"ref_audio": _ref_audio_data_url(args.ref_audio)} if getattr(args, "ref_audio", None) else {}),
                 },
             }
@@ -255,12 +261,10 @@ async def _admission_probe(args: argparse.Namespace, *, limit: int) -> dict[str,
         for index in range(limit):
             accepted.append(await _open_admission_session(args, f"{prefix}-accepted-{index}"))
 
-        overflow_id = f"{prefix}-overflow"
         overflow_url = _url_with_model(
             args.url,
             args.model,
             autostart=False if getattr(args, "ref_audio", None) else None,
-            session_id=overflow_id,
         )
         async with websockets.connect(overflow_url, max_size=64 * 1024 * 1024) as overflow:
             await overflow.send(
@@ -268,10 +272,8 @@ async def _admission_probe(args: argparse.Namespace, *, limit: int) -> dict[str,
                     {
                         "type": "session.update",
                         "session": {
-                            "session_id": overflow_id,
                             "model": args.model,
                             "modalities": ["audio", "text"],
-                            "extra_body": {"native_duplex": True},
                             **(
                                 {"ref_audio": _ref_audio_data_url(args.ref_audio)}
                                 if getattr(args, "ref_audio", None)
@@ -326,7 +328,6 @@ async def _resume_probe(
         args.url,
         args.model,
         autostart=False if getattr(args, "ref_audio", None) else None,
-        session_id=session_id,
     )
     async with websockets.connect(url, max_size=64 * 1024 * 1024) as first:
         await first.send(
@@ -334,10 +335,8 @@ async def _resume_probe(
                 {
                     "type": "session.update",
                     "session": {
-                        "session_id": session_id,
                         "model": args.model,
                         "modalities": ["audio", "text"],
-                        "extra_body": {"native_duplex": True},
                         **(
                             {"ref_audio": _ref_audio_data_url(args.ref_audio)}
                             if getattr(args, "ref_audio", None)
@@ -348,10 +347,10 @@ async def _resume_probe(
             )
         )
         created, first_events = await _receive_until(first, "session.created", timeout_s=args.timeout_s)
+        session_id = _created_session_id(created)
         token = created.get("resume_token")
-        incarnation = created.get("incarnation")
         generation = created.get("attachment_generation")
-        if not isinstance(token, str) or not isinstance(incarnation, int):
+        if not isinstance(token, str):
             raise RuntimeError("session.created omitted resumable credentials")
         last_seq = max(_server_event_sequences(first_events), default=0)
 
@@ -366,7 +365,6 @@ async def _resume_probe(
                 {
                     "type": "session.resume",
                     "session_id": session_id,
-                    "incarnation": incarnation,
                     "resume_token": token,
                     "last_received_server_event_seq": last_seq,
                 }
@@ -429,7 +427,6 @@ async def _takeover_probe(
         args.url,
         args.model,
         autostart=False if getattr(args, "ref_audio", None) else None,
-        session_id=session_id,
     )
     first = await websockets.connect(url, max_size=64 * 1024 * 1024)
     second = None
@@ -439,10 +436,8 @@ async def _takeover_probe(
                 {
                     "type": "session.update",
                     "session": {
-                        "session_id": session_id,
                         "model": args.model,
                         "modalities": ["audio", "text"],
-                        "extra_body": {"native_duplex": True},
                         **(
                             {"ref_audio": _ref_audio_data_url(args.ref_audio)}
                             if getattr(args, "ref_audio", None)
@@ -453,10 +448,10 @@ async def _takeover_probe(
             )
         )
         created, first_events = await _receive_until(first, "session.created", timeout_s=args.timeout_s)
+        session_id = _created_session_id(created)
         token = created.get("resume_token")
-        incarnation = created.get("incarnation")
         generation = created.get("attachment_generation")
-        if not isinstance(token, str) or not isinstance(incarnation, int) or not isinstance(generation, int):
+        if not isinstance(token, str) or not isinstance(generation, int):
             raise RuntimeError("session.created omitted takeover credentials")
         last_seq = max(_server_event_sequences(first_events), default=0)
 
@@ -466,7 +461,6 @@ async def _takeover_probe(
                 {
                     "type": "session.resume",
                     "session_id": session_id,
-                    "incarnation": incarnation,
                     "resume_token": token,
                     "last_received_server_event_seq": last_seq,
                 }
diff --git a/tests/e2e/online_serving/run_minicpmo_realtime_duplex_server_vad.py b/tests/e2e/online_serving/run_minicpmo_realtime_duplex_server_vad.py
index 4047a0901..0fb1c57b3 100644
--- a/tests/e2e/online_serving/run_minicpmo_realtime_duplex_server_vad.py
+++ b/tests/e2e/online_serving/run_minicpmo_realtime_duplex_server_vad.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 import base64
 from pathlib import Path
 
@@ -41,7 +44,10 @@ async def run_server_vad_interrupt(args) -> dict[str, object]:
             next(e for e in client.events.events if e.get("type") == "response.created")
         )
         assert target_id
-        await until(lambda: _events(client.events.events, target_id, "response.audio.delta"), "response.audio.delta")
+        await until(
+            lambda: _events(client.events.events, target_id, "response.output_audio.delta"),
+            "response.output_audio.delta",
+        )
         cursor = len(client.events.events)
         await client.stream_pcm16(interrupt + bytes(16_000 * 2 * 800 // 1000), chunk_ms=args.chunk_ms, realtime=True)
         await until(lambda: _events(client.events.events, target_id, "response.done"), "cancelled response.done")
@@ -64,10 +70,11 @@ async def run_server_vad_interrupt(args) -> dict[str, object]:
     terminal = done[0] if len(done) == 1 else None
     trailing = events[events.index(terminal) + 1 :] if terminal is not None else events
     stale = any(
-        e.get("type") == "response.audio.delta" and RealtimeEventCollector.response_id(e) == target_id for e in trailing
+        e.get("type") == "response.output_audio.delta" and RealtimeEventCollector.response_id(e) == target_id
+        for e in trailing
     )
     followup_audio = any(
-        e.get("type") == "response.audio.delta" and RealtimeEventCollector.response_id(e) != target_id
+        e.get("type") == "response.output_audio.delta" and RealtimeEventCollector.response_id(e) != target_id
         for e in events[cursor:]
     )
     ok = (
diff --git a/tests/e2e/online_serving/run_minicpmo_realtime_duplex_soft_interrupt.py b/tests/e2e/online_serving/run_minicpmo_realtime_duplex_soft_interrupt.py
index 3aff0cf8d..2eee43fae 100644
--- a/tests/e2e/online_serving/run_minicpmo_realtime_duplex_soft_interrupt.py
+++ b/tests/e2e/online_serving/run_minicpmo_realtime_duplex_soft_interrupt.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 """Validate MiniCPM-o Realtime duplex soft-interrupt delta streaming.
 
 This E2E driver runs the public ``realtime_duplex_demo.py`` against a live
@@ -15,15 +18,14 @@ import hashlib
 import io
 import json
 import sys
-import uuid
 import wave
 from pathlib import Path
 
 REPO_ROOT = Path(__file__).resolve().parents[3]
 DEMO_PATH = REPO_ROOT / "examples/online_serving/minicpmo/realtime_duplex_demo.py"
-AUDIO_DELTA_EVENTS = {"response.audio.delta", "response.output_audio.delta"}
+AUDIO_DELTA_EVENTS = {"response.output_audio.delta"}
 TRANSCRIPT_DELTA_EVENTS = {
-    "response.audio_transcript.delta",
+    "response.output_audio_transcript.delta",
     "response.output_text.delta",
 }
 
@@ -409,8 +411,6 @@ async def run_soft_interrupt(args: argparse.Namespace) -> dict[str, object]:
         str(args.chunk_ms),
         "--timeout-s",
         str(args.timeout_s),
-        "--session-id",
-        f"duplex-soft-interrupt-{uuid.uuid4().hex}",
     ]
     command.extend(["--ref-audio", str(_canonical_path(args.ref_audio))])
     temperature = getattr(args, "temperature", None)
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_dots_tts_expansion.py b/tests/e2e/online_serving/test_breeze_tts_2.py
similarity index 55%
rename from tests/e2e/online_serving/test_dots_tts_expansion.py
rename to tests/e2e/online_serving/test_breeze_tts_2.py
index e5df55a33..29cd43b68 100644
--- a/tests/e2e/online_serving/test_dots_tts_expansion.py
+++ b/tests/e2e/online_serving/test_breeze_tts_2.py
@@ -1,28 +1,34 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """
-E2E Online expansion tests for dots.tts(text-only).
+E2E Online tests for Breeze-TTS-2 with text input and audio output.
+
+These tests verify the /v1/audio/speech endpoint works correctly with
+actual model inference, not mocks. Breeze-TTS-2 plain mode needs only
+``input`` and a speaker tag (``voice`` defaults to ``S0``); reference
+cloning requires ``ref_audio`` + ``ref_text`` and is not exercised here.
 """
 
 import os
 
+os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
+
 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"
+MODEL = "BreezeBlue/Breeze-TTS-2"
 DEFAULT_AUDIO_SPEECH_TIMEOUT_S = 300.0
-_MIN_AUDIO_BYTES = 40_000
 MAX_CONCURRENT = 4
 
+# ~0.5 s of 24 kHz mono PCM_16 in WAV (~24k payload + header).
+_MIN_AUDIO_BYTES = 40_000
+
 
 def get_prompt(prompt_type="text"):
+    """English prompt for zero-shot TTS."""
     prompts = {
         "text": "The weather is nice today, perfect for a walk in the park.",
     }
@@ -33,24 +39,52 @@ tts_server_params = [
     pytest.param(
         OmniServerParams(
             model=MODEL,
-            stage_config_path=get_deploy_config_path("dots_tts.yaml"),
+            stage_config_path=get_deploy_config_path("breeze_tts_2.yaml"),
             server_args=["--trust-remote-code", "--disable-log-stats"],
         ),
-        id="dots_tts",
+        id="breeze_tts_2",
     )
 ]
 
 
+@pytest.mark.slow
+@pytest.mark.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:
+def test_text_to_audio_001(omni_server, online_client) -> None:
     """
-    Test text-only text-to-audio via OpenAI API.
-    Deploy Setting: dots_tts.yaml
+    Test plain text-to-audio via OpenAI API.
+    Deploy Setting: breeze_tts_2.yaml
+    Input Modal: text
+    Output Modal: audio
+    Input Setting: stream=False
+    Datasets: few requests (max_num_seqs=8)
+    """
+    request_config = {
+        "model": omni_server.model,
+        "input": get_prompt(),
+        "stream": False,
+        "timeout": DEFAULT_AUDIO_SPEECH_TIMEOUT_S,
+        "response_format": "wav",
+        "voice": "S0",
+        "sample_rate": 24000,
+        "min_audio_bytes": _MIN_AUDIO_BYTES,
+    }
+    online_client.send_audio_speech_request(request_config, request_num=MAX_CONCURRENT)
+
+
+@pytest.mark.slow
+@pytest.mark.tts
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
+def test_text_to_audio_002(omni_server, online_client) -> None:
+    """
+    Test streaming text-to-audio via OpenAI API (async-chunk SSE deltas).
+    Deploy Setting: breeze_tts_2.yaml
     Input Modal: text
     Output Modal: audio
     Input Setting: stream=True
-    Datasets: few requests (max_num_seqs=4)
+    Datasets: single request
     """
     request_config = {
         "model": omni_server.model,
@@ -59,33 +93,8 @@ def test_text_only_streaming_001(omni_server, openai_client) -> None:
         "stream_format": "audio",
         "timeout": DEFAULT_AUDIO_SPEECH_TIMEOUT_S,
         "response_format": "wav",
-        "voice": "default",
+        "voice": "S0",
+        "sample_rate": 24000,
         "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)
+    online_client.send_audio_speech_request(request_config)
diff --git a/tests/e2e/online_serving/test_duplex_client_live.py b/tests/e2e/online_serving/test_duplex_client_live.py
index d90a8a683..28044cdd1 100644
--- a/tests/e2e/online_serving/test_duplex_client_live.py
+++ b/tests/e2e/online_serving/test_duplex_client_live.py
@@ -12,7 +12,6 @@ incremental playback acks, a forced transport drop recovered by automatic
 from __future__ import annotations
 
 import asyncio
-import uuid
 from pathlib import Path
 
 import pytest
@@ -47,7 +46,6 @@ async def _run_live_session(*, url: str, model: str, ref_audio: Path, input_wav:
         url,
         model=model,
         config=config,
-        session_id=f"duplex-client-live-{uuid.uuid4().hex}",
         reconnect=ReconnectPolicy(max_attempts=5, backoff_s=(0.25, 1.0)),
         # Short interval so the periodic heartbeat path runs during the
         # session — including across the forced transport drop below.
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_gepard_tts.py b/tests/e2e/online_serving/test_gepard_tts.py
new file mode 100644
index 000000000..e6887bbbc
--- /dev/null
+++ b/tests/e2e/online_serving/test_gepard_tts.py
@@ -0,0 +1,524 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""E2E online serving tests for Gepard-1.0 via ``/v1/audio/speech``.
+
+Zero-shot default voice. Needs a GPU and the NeMo NanoCodec; the weekly
+``TTS · Gepard-1.0 · L4`` step installs NeMo then runs this file.
+"""
+
+from __future__ import annotations
+
+import array
+import os
+import statistics
+import struct
+import time
+import wave
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
+from io import BytesIO
+
+os.environ.setdefault("VLLM_WORKER_MULTIPROC_METHOD", "spawn")
+
+import pytest
+import requests
+import soundfile as sf
+
+from tests.helpers.mark import hardware_test
+from tests.helpers.media import convert_audio_bytes_to_text
+from tests.helpers.runtime import OmniServerParams
+from tests.helpers.stage_config import get_deploy_config_path
+
+pytest.importorskip("nemo.collections.tts.models")
+
+pytestmark = [pytest.mark.slow, pytest.mark.tts]
+
+MODEL = "nineninesix/gepard-1.0"
+SAMPLE_RATE = 22050
+SAMPLES_PER_FRAME = 1024
+PCM16_BYTES_PER_FRAME = SAMPLES_PER_FRAME * 2
+DEFAULT_TIMEOUT_S = 180.0
+
+_DISTINGUISHABLE_PROMPTS = {
+    "He drinks coffee every morning.": "coffee",
+    "Machine learning is interesting.": "learning",
+    "Please close the window before leaving.": "window",
+    "My favorite color is purple.": "purple",
+}
+
+tts_server_params = [
+    pytest.param(
+        OmniServerParams(
+            model=MODEL,
+            stage_config_path=get_deploy_config_path("gepard.yaml"),
+            server_args=["--trust-remote-code", "--disable-log-stats"],
+            stage_init_timeout=900,
+        ),
+        id="gepard",
+    )
+]
+
+
+def _base_config(omni_server, text: str, **extra) -> dict:
+    cfg = {
+        "model": omni_server.model,
+        "input": text,
+        "voice": "default",
+        "timeout": DEFAULT_TIMEOUT_S,
+        "seed": 7,
+        # NanoCodec is quieter than the 24 kHz models the PCM HNR helper was
+        # calibrated on; keep the catastrophic-failure check, not a quality gate.
+        "min_hnr_db": -2.0,
+        "transcript_escalation_model": "large-v3",
+    }
+    cfg.update(extra)
+    return cfg
+
+
+def _wav_sample_rate(wav_bytes: bytes) -> int:
+    return struct.unpack_from("<I", wav_bytes, 24)[0]
+
+
+def _wav_pcm_payload_len(wav_bytes: bytes) -> int:
+    data, _sr = sf.read(BytesIO(wav_bytes), dtype="int16")
+    return int(data.size) * 2
+
+
+def _pcm16le_to_wav(pcm: bytes, sample_rate: int = SAMPLE_RATE) -> bytes:
+    """Whisper helpers expect a container; streamed speech is raw s16le."""
+    buf = BytesIO()
+    with wave.open(buf, "wb") as wf:
+        wf.setnchannels(1)
+        wf.setsampwidth(2)
+        wf.setframerate(sample_rate)
+        wf.writeframes(pcm)
+    return buf.getvalue()
+
+
+def _pcm16_samples(pcm: bytes) -> array.array:
+    samples = array.array("h")
+    samples.frombytes(pcm)
+    return samples
+
+
+def _pcm16_diag(label: str, left: bytes, right: bytes) -> None:
+    extra_frames = (len(left) - len(right)) // PCM16_BYTES_PER_FRAME
+    overlap = min(len(left), len(right))
+    first_frame_match = (
+        overlap >= PCM16_BYTES_PER_FRAME and left[:PCM16_BYTES_PER_FRAME] == right[:PCM16_BYTES_PER_FRAME]
+    )
+    worst = None
+    corr = None
+    first_diff_sample = None
+    if overlap >= 2 and overlap % 2 == 0:
+        a = _pcm16_samples(left[:overlap])
+        b = _pcm16_samples(right[:overlap])
+        worst = max(abs(x - y) for x, y in zip(a, b, strict=True))
+        for i, (x, y) in enumerate(zip(a, b, strict=True)):
+            if x != y:
+                first_diff_sample = i
+                break
+        try:
+            corr = round(statistics.correlation(a, b), 6)
+        except statistics.StatisticsError:
+            corr = None
+    print(
+        f"[Gepard pcm-diag] {label} left={len(left)} right={len(right)} "
+        f"extra_frames={extra_frames} first_frame_match={first_frame_match} "
+        f"first_diff_sample={first_diff_sample} max_abs={worst} corr={corr}"
+    )
+
+
+def _scan_logs_for_preemption(omni_server) -> None:
+    log_paths = getattr(omni_server, "_stage_log_paths", {}) or {}
+    hits: list[str] = []
+    for path in log_paths.values():
+        if path is None or not path.exists():
+            continue
+        text = path.read_text(encoding="utf-8", errors="replace").lower()
+        if "preempt" in text:
+            hits.append(str(path))
+    assert not hits, f"preemption mentioned in stage logs: {hits}"
+
+
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
+@pytest.mark.parametrize("response_format", ["wav", "pcm"])
+def test_text_to_audio_basic(omni_server, online_client, response_format: str, run_level: str) -> None:
+    text = "Hello, this is Gepard speaking."
+    # whisper-small/large-v3 mishear 22.05 kHz WAV of this prompt as
+    # "Jeb Ard" / "Jeff Bard" (cosine 0.80 / 0.75). Offline uses keyword
+    # containment; the PCM twin below still goes through the 0.9 ASR gate.
+    if response_format == "wav":
+        url = f"http://{omni_server.host}:{omni_server.port}/v1/audio/speech"
+        payload = {
+            "model": omni_server.model,
+            "input": text,
+            "voice": "default",
+            "seed": 7,
+            "stream": False,
+            "response_format": "wav",
+        }
+        r = requests.post(url, json=payload, timeout=DEFAULT_TIMEOUT_S)
+        r.raise_for_status()
+        audio = r.content
+        assert _wav_sample_rate(audio) == SAMPLE_RATE
+        pcm_len = _wav_pcm_payload_len(audio)
+    else:
+        [resp] = online_client.send_audio_speech_request(
+            _base_config(omni_server, text, stream=False, response_format=response_format)
+        )
+        assert resp.audio_bytes
+        pcm_len = len(resp.audio_bytes)
+    assert pcm_len % PCM16_BYTES_PER_FRAME == 0
+    if run_level in {"advanced_model", "full_model"}:
+        duration = pcm_len / 2 / SAMPLE_RATE
+        assert 0.5 < duration < 30.0, f"implausible duration {duration:.2f}s"
+
+
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
+def test_seed_determinism(omni_server, online_client) -> None:
+    text = "Hello, this is Gepard speaking."
+    [a] = online_client.send_audio_speech_request(_base_config(omni_server, text, seed=7, response_format="pcm"))
+    [b] = online_client.send_audio_speech_request(_base_config(omni_server, text, seed=7, response_format="pcm"))
+    [c] = online_client.send_audio_speech_request(_base_config(omni_server, text, seed=11, response_format="pcm"))
+    assert a.audio_bytes == b.audio_bytes
+    assert a.audio_bytes != c.audio_bytes
+
+
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
+def test_streaming_pcm_incremental(omni_server, online_client) -> None:
+    text = "Hello, this is Gepard speaking."
+    url = f"http://{omni_server.host}:{omni_server.port}/v1/audio/speech"
+    payload = {
+        "model": omni_server.model,
+        "input": text,
+        "voice": "default",
+        "seed": 7,
+        "stream": True,
+        "stream_format": "audio",
+        "response_format": "pcm",
+    }
+    start = time.perf_counter()
+    arrivals: list[tuple[float, int]] = []
+    streamed = bytearray()
+    with requests.post(url, json=payload, stream=True, timeout=DEFAULT_TIMEOUT_S) as resp:
+        resp.raise_for_status()
+        content_type = resp.headers.get("content-type") or ""
+        assert "pcm" in content_type or "octet-stream" in content_type
+        for chunk in resp.iter_content(chunk_size=None):
+            if not chunk:
+                continue
+            arrivals.append((time.perf_counter(), len(chunk)))
+            streamed.extend(chunk)
+    assert len(arrivals) >= 2, f"expected incremental chunks, got {len(arrivals)}"
+    assert arrivals[1][0] > arrivals[0][0]
+    ttfa_ms = (arrivals[0][0] - start) * 1000.0
+    cadence_ms = [(arrivals[i][0] - arrivals[i - 1][0]) * 1000.0 for i in range(1, len(arrivals))]
+    print(f"[Gepard streaming] TTFA_ms={ttfa_ms:.1f} chunk_cadence_ms={cadence_ms}")
+
+    [non_stream] = online_client.send_audio_speech_request(
+        _base_config(omni_server, text, seed=7, stream=False, response_format="pcm")
+    )
+    assert bytes(streamed) == non_stream.audio_bytes
+
+
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
+def test_seeded_streaming_stops(omni_server) -> None:
+    url = f"http://{omni_server.host}:{omni_server.port}/v1/audio/speech"
+    payload = {
+        "model": omni_server.model,
+        "input": "Hello, this is Gepard speaking.",
+        "voice": "default",
+        "seed": 7,
+        "stream": True,
+        "stream_format": "audio",
+        "response_format": "pcm",
+    }
+    with requests.post(url, json=payload, stream=True, timeout=DEFAULT_TIMEOUT_S) as resp:
+        resp.raise_for_status()
+        audio = b"".join(chunk for chunk in resp.iter_content(chunk_size=None) if chunk)
+    duration = len(audio) / 2 / SAMPLE_RATE
+    assert duration < 30.0, f"seeded stream ran {duration:.1f}s — stop constraint dropped?"
+
+
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
+def test_sse_stream_emits_delta_then_done(omni_server) -> None:
+    url = f"http://{omni_server.host}:{omni_server.port}/v1/audio/speech"
+    payload = {
+        "model": omni_server.model,
+        "input": "Hello, this is Gepard speaking.",
+        "voice": "default",
+        "seed": 7,
+        "stream": True,
+        "stream_format": "sse",
+        "response_format": "pcm",
+    }
+    with requests.post(url, json=payload, stream=True, timeout=DEFAULT_TIMEOUT_S) as resp:
+        resp.raise_for_status()
+        assert resp.headers.get("content-type", "").startswith("text/event-stream")
+        body = b"".join(resp.iter_content(chunk_size=None)).decode("utf-8", errors="replace")
+    assert "speech.audio.delta" in body
+    assert "speech.audio.done" in body
+
+
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
+def test_concurrent_requests_stay_isolated(omni_server, online_client, run_level: str) -> None:
+    def _one(text: str):
+        return online_client.send_audio_speech_request(_base_config(omni_server, text, seed=7, response_format="wav"))[
+            0
+        ]
+
+    texts = list(_DISTINGUISHABLE_PROMPTS)
+    with ThreadPoolExecutor(max_workers=4) as pool:
+        responses = list(pool.map(_one, texts))
+
+    assert all(r.success for r in responses)
+    for i in range(len(responses)):
+        for j in range(i + 1, len(responses)):
+            assert responses[i].audio_bytes != responses[j].audio_bytes
+
+    if run_level in {"advanced_model", "full_model"}:
+        for text, resp in zip(texts, responses, strict=True):
+            keyword = _DISTINGUISHABLE_PROMPTS[text]
+            transcript = convert_audio_bytes_to_text(resp.audio_bytes, language="en").lower()
+            assert keyword in transcript, f"expected {keyword!r} in {transcript!r} for {text!r}"
+
+    _scan_logs_for_preemption(omni_server)
+
+
+def _speech_url(omni_server) -> str:
+    return f"http://{omni_server.host}:{omni_server.port}/v1/audio/speech"
+
+
+def _stream_payload(omni_server, text: str, **extra) -> dict:
+    payload = {
+        "model": omni_server.model,
+        "input": text,
+        "voice": "default",
+        "seed": 7,
+        "stream": True,
+        "stream_format": "audio",
+        "response_format": "pcm",
+    }
+    payload.update(extra)
+    return payload
+
+
+@dataclass
+class _StreamCapture:
+    pcm: bytes
+    arrivals: list[tuple[float, int]]
+
+    @property
+    def duration_s(self) -> float:
+        return len(self.pcm) / 2 / SAMPLE_RATE
+
+
+def _capture_stream(
+    url: str,
+    payload: dict,
+    timeout_s: float,
+    *,
+    sleep_after_first_s: float = 0.0,
+) -> _StreamCapture:
+    start = time.perf_counter()
+    arrivals: list[tuple[float, int]] = []
+    pcm = bytearray()
+    with requests.post(url, json=payload, stream=True, timeout=timeout_s) as resp:
+        resp.raise_for_status()
+        first = True
+        for chunk in resp.iter_content(chunk_size=None):
+            if not chunk:
+                continue
+            arrivals.append((time.perf_counter() - start, len(chunk)))
+            pcm.extend(chunk)
+            if first and sleep_after_first_s > 0:
+                time.sleep(sleep_after_first_s)
+            first = False
+    return _StreamCapture(bytes(pcm), arrivals)
+
+
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
+def test_concurrent_streaming_stays_isolated(omni_server, run_level: str) -> None:
+    url = _speech_url(omni_server)
+    texts = list(_DISTINGUISHABLE_PROMPTS)
+
+    def _one(text: str) -> tuple[str, _StreamCapture]:
+        return text, _capture_stream(url, _stream_payload(omni_server, text), DEFAULT_TIMEOUT_S)
+
+    with ThreadPoolExecutor(max_workers=4) as pool:
+        results = list(pool.map(_one, texts))
+
+    captures = [cap for _, cap in results]
+    assert all(len(c.arrivals) >= 2 for c in captures)
+    for i in range(len(captures)):
+        for j in range(i + 1, len(captures)):
+            assert captures[i].pcm != captures[j].pcm
+
+    if run_level in {"advanced_model", "full_model"}:
+        for text, cap in results:
+            keyword = _DISTINGUISHABLE_PROMPTS[text]
+            transcript = convert_audio_bytes_to_text(_pcm16le_to_wav(cap.pcm), language="en").lower()
+            assert keyword in transcript, f"expected {keyword!r} in {transcript!r} for {text!r}"
+
+    _scan_logs_for_preemption(omni_server)
+
+
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
+def test_slow_client_still_completes(omni_server, online_client) -> None:
+    """Slow reader must finish, and seed=7 must match a prior non-stream.
+
+    Runs before ``test_client_disconnect_releases_capacity`` so an abort
+    storm cannot contaminate this comparison. Prints overlap diagnostics
+    before the bit-exact asserts.
+    """
+    text = "Hello, this is Gepard speaking."
+    [baseline] = online_client.send_audio_speech_request(
+        _base_config(omni_server, text, seed=7, stream=False, response_format="pcm")
+    )
+    cap = _capture_stream(
+        url=_speech_url(omni_server),
+        payload=_stream_payload(omni_server, text),
+        timeout_s=DEFAULT_TIMEOUT_S,
+        sleep_after_first_s=3.0,
+    )
+    assert len(cap.arrivals) >= 2
+    assert len(cap.pcm) % PCM16_BYTES_PER_FRAME == 0
+    assert 0.5 < cap.duration_s < 30.0
+    print(f"[Gepard slow-client] chunks={len(cap.arrivals)} duration_s={cap.duration_s:.3f}")
+    _pcm16_diag("slow-vs-prior-nonstream", cap.pcm, baseline.audio_bytes)
+    [after] = online_client.send_audio_speech_request(
+        _base_config(omni_server, text, seed=7, stream=False, response_format="pcm")
+    )
+    _pcm16_diag("after-nonstream-vs-prior", after.audio_bytes, baseline.audio_bytes)
+    assert cap.pcm == baseline.audio_bytes
+    assert after.audio_bytes == baseline.audio_bytes
+
+
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
+def test_client_disconnect_releases_capacity(omni_server, online_client) -> None:
+    """A follow-up request must complete after in-flight streams are closed.
+
+    Logs PCM diagnostics against a pre-abort ``seed=7`` baseline. Bit-exact
+    equality after abort is not asserted here: a dying stream can still share
+    a GPU batch with the next generate after ``abort()`` returns, and Gepard's
+    in-model stop head / bf16 GEMM are not row-stable in that batch.
+    """
+    url = _speech_url(omni_server)
+    text = "Hello, this is Gepard speaking."
+    [baseline] = online_client.send_audio_speech_request(
+        _base_config(omni_server, text, seed=7, stream=False, response_format="pcm")
+    )
+    long_payload = _stream_payload(
+        omni_server,
+        "Please keep talking about the weather, the window, coffee, and purple flowers.",
+        max_new_tokens=80,
+    )
+    for _ in range(4):
+        resp = requests.post(url, json=long_payload, stream=True, timeout=DEFAULT_TIMEOUT_S)
+        resp.raise_for_status()
+        try:
+            chunk = next(c for c in resp.iter_content(chunk_size=None) if c)
+            assert chunk
+        finally:
+            resp.close()
+
+    t0 = time.perf_counter()
+    follow = requests.post(
+        url,
+        json={
+            "model": omni_server.model,
+            "input": text,
+            "voice": "default",
+            "seed": 7,
+            "stream": False,
+            "response_format": "pcm",
+        },
+        timeout=DEFAULT_TIMEOUT_S,
+    )
+    follow.raise_for_status()
+    elapsed = time.perf_counter() - t0
+    pcm_len = len(follow.content)
+    assert pcm_len % PCM16_BYTES_PER_FRAME == 0
+    print(f"[Gepard disconnect] followup_s={elapsed:.2f} pcm_bytes={pcm_len}")
+    _pcm16_diag("disconnect-followup-vs-prior", follow.content, baseline.audio_bytes)
+
+
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
+def test_mixed_stream_and_nonstream_isolated(omni_server, online_client, run_level: str) -> None:
+    url = _speech_url(omni_server)
+    stream_text = "He drinks coffee every morning."
+    nonstream_text = "My favorite color is purple."
+
+    def _stream():
+        return _capture_stream(url, _stream_payload(omni_server, stream_text), DEFAULT_TIMEOUT_S)
+
+    def _nonstream():
+        return online_client.send_audio_speech_request(
+            _base_config(omni_server, nonstream_text, seed=7, response_format="wav")
+        )[0]
+
+    with ThreadPoolExecutor(max_workers=2) as pool:
+        stream_future = pool.submit(_stream)
+        nonstream_future = pool.submit(_nonstream)
+        streamed = stream_future.result()
+        nonstream = nonstream_future.result()
+
+    assert streamed.pcm
+    assert nonstream.success
+    assert streamed.pcm != nonstream.audio_bytes
+    if run_level in {"advanced_model", "full_model"}:
+        stream_tr = convert_audio_bytes_to_text(_pcm16le_to_wav(streamed.pcm), language="en").lower()
+        nonstream_tr = convert_audio_bytes_to_text(nonstream.audio_bytes, language="en").lower()
+        assert "coffee" in stream_tr, stream_tr
+        assert "purple" in nonstream_tr, nonstream_tr
+    _scan_logs_for_preemption(omni_server)
+
+
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
+def test_max_new_tokens_caps_whole_frames(omni_server) -> None:
+    frames = 16
+    url = _speech_url(omni_server)
+    r = requests.post(
+        url,
+        json={
+            "model": omni_server.model,
+            "input": "Hello, this is Gepard speaking.",
+            "voice": "default",
+            "seed": 7,
+            "stream": False,
+            "response_format": "pcm",
+            "max_new_tokens": frames,
+        },
+        timeout=DEFAULT_TIMEOUT_S,
+    )
+    assert r.status_code == 200, r.text
+    pcm_len = len(r.content)
+    assert pcm_len % PCM16_BYTES_PER_FRAME == 0
+    assert pcm_len == frames * PCM16_BYTES_PER_FRAME, f"got {pcm_len} bytes, want {frames} frames"
+    duration = pcm_len / 2 / SAMPLE_RATE
+    assert duration < 1.0, f"budget cap should stop near 16 frames, got {duration:.2f}s"
+
+    over = requests.post(
+        url,
+        json={
+            "model": omni_server.model,
+            "input": "Hello, this is Gepard speaking.",
+            "voice": "default",
+            "max_new_tokens": 4097,
+        },
+        timeout=DEFAULT_TIMEOUT_S,
+    )
+    assert over.status_code == 400
+    assert "max_new_tokens" in over.text
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 0bc3f449f..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,23 +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")
 
-SINGLE_CARD_MARKS = hardware_marks(res={"cuda": "H100"})
-PARALLEL_MARKS = hardware_marks(res={"cuda": "H100"}, num_cards=2)
-
-# Only the most basic single-card deployment row is cheap enough for PR (L2) / merge (L3)
-# CI; the CacheDiT / parallel feature combinations run nightly (L4).
-_CORE_MARKS = [pytest.mark.core_model, pytest.mark.advanced_model]
-_FULL_MARKS = [pytest.mark.full_model]
+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,
@@ -57,9 +61,13 @@ def _get_diffusion_feature_cases(model: str):
                 ],
             ),
             id="single_card_cpu_offload",
-            marks=SINGLE_CARD_MARKS + _CORE_MARKS,
+            marks=[
+                *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,
@@ -70,9 +78,12 @@ def _get_diffusion_feature_cases(model: str):
                 ],
             ),
             id="single_card_cachedit_layerwise",
-            marks=SINGLE_CARD_MARKS + _FULL_MARKS,
+            marks=[
+                *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,
@@ -87,21 +98,18 @@ def _get_diffusion_feature_cases(model: str):
                 ],
             ),
             id="parallel_cachedit_tp2_vae2",
-            marks=PARALLEL_MARKS + _FULL_MARKS,
+            marks=[
+                *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,
@@ -119,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_lingbot_video.py b/tests/e2e/online_serving/test_lingbot_video.py
index 8f0f45639..e6f275bb9 100644
--- a/tests/e2e/online_serving/test_lingbot_video.py
+++ b/tests/e2e/online_serving/test_lingbot_video.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
 
 """Online serving smoke coverage for the dense LingBot-Video checkpoint."""
 
@@ -20,7 +20,7 @@ PROMPT = "a robotic arm picks up a red block"
 NEGATIVE_PROMPT = "low quality, blurry, watermark, text"
 DEFAULT_SAMPLING_PARAMS = '{"0":{"num_frames":81,"num_inference_steps":40,"guidance_scale":6.0}}'
 
-SINGLE_CARD_FEATURE_MARKS = hardware_marks(res={"cuda": "H100"})
+SINGLE_CARD_FEATURE_MARKS = hardware_marks(res={"cuda": ["H100", "B200"]})
 
 
 def _get_diffusion_feature_cases(model: str):
@@ -41,7 +41,7 @@ def _get_diffusion_feature_cases(model: str):
     ]
 
 
-@pytest.mark.slow
+@pytest.mark.full_model
 @pytest.mark.diffusion
 @pytest.mark.parametrize("omni_server", _get_diffusion_feature_cases(MODEL), indirect=True)
 def test_text_to_image_001(omni_server: OmniServer, openai_client: OpenAIClientHandler) -> None:
@@ -63,7 +63,7 @@ def test_text_to_image_001(omni_server: OmniServer, openai_client: OpenAIClientH
     )
 
 
-@pytest.mark.slow
+@pytest.mark.full_model
 @pytest.mark.diffusion
 @pytest.mark.parametrize("omni_server", _get_diffusion_feature_cases(MODEL), indirect=True)
 def test_video_generation_modes_001(omni_server: OmniServer, openai_client: OpenAIClientHandler) -> None:
diff --git a/tests/e2e/online_serving/test_lingbot_video_expansion.py b/tests/e2e/online_serving/test_lingbot_video_expansion.py
index fbf2bd5fa..4a411ddcf 100644
--- a/tests/e2e/online_serving/test_lingbot_video_expansion.py
+++ b/tests/e2e/online_serving/test_lingbot_video_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
 
 """
 L4 expansion coverage for ``robbyant/lingbot-video-dense-1.3b``.
@@ -26,7 +26,7 @@ MODEL = "robbyant/lingbot-video-dense-1.3b"
 PROMPT = "a robotic arm picks up a red block"
 NEGATIVE_PROMPT = "low quality, blurry, watermark, text"
 
-SINGLE_CARD_FEATURE_MARKS = hardware_marks(res={"cuda": "H100"})
+SINGLE_CARD_FEATURE_MARKS = hardware_marks(res={"cuda": ["H100", "B200"]})
 
 
 def _get_diffusion_feature_cases(model: str):
diff --git a/tests/e2e/online_serving/test_lingbot_video_moe.py b/tests/e2e/online_serving/test_lingbot_video_moe.py
index 7e4d16568..cc56161c9 100644
--- a/tests/e2e/online_serving/test_lingbot_video_moe.py
+++ b/tests/e2e/online_serving/test_lingbot_video_moe.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
 
 """Single-GPU serving smoke for ``robbyant/lingbot-video-moe-30b-a3b``."""
 
@@ -20,7 +20,7 @@ PROMPT = "a robotic arm picks up a red block"
 NEGATIVE_PROMPT = "low quality, blurry, watermark, text"
 SMOKE_DEFAULT_SAMPLING_PARAMS = '{"0":{"num_frames":81,"num_inference_steps":2,"guidance_scale":3.0}}'
 
-SINGLE_CARD_MARKS = hardware_marks(res={"cuda": "H100"})
+SINGLE_CARD_MARKS = hardware_marks(res={"cuda": ["H100", "B200"]})
 
 
 def _get_server_cases(model: str):
@@ -41,7 +41,7 @@ def _get_server_cases(model: str):
     ]
 
 
-@pytest.mark.slow
+@pytest.mark.full_model
 @pytest.mark.diffusion
 @pytest.mark.parametrize("omni_server", _get_server_cases(MODEL), indirect=True)
 def test_text_to_image_moe(omni_server: OmniServer, openai_client: OpenAIClientHandler) -> None:
@@ -63,7 +63,7 @@ def test_text_to_image_moe(omni_server: OmniServer, openai_client: OpenAIClientH
     )
 
 
-@pytest.mark.slow
+@pytest.mark.full_model
 @pytest.mark.diffusion
 @pytest.mark.parametrize("omni_server", _get_server_cases(MODEL), indirect=True)
 def test_video_generation_modes_moe(omni_server: OmniServer, openai_client: OpenAIClientHandler) -> None:
diff --git a/tests/e2e/online_serving/test_magi2.py b/tests/e2e/online_serving/test_magi2.py
index 22a30b495..d713abab9 100644
--- a/tests/e2e/online_serving/test_magi2.py
+++ b/tests/e2e/online_serving/test_magi2.py
@@ -8,7 +8,7 @@ It exercises the recommended resident SP4 topology through ``/v1/videos``.
 
 From ``tests/``::
 
-    pytest -s -v e2e/online_serving/test_magi2.py -m "advanced_model and diffusion" --run-level=advanced_model
+    pytest -s -v e2e/online_serving/test_magi2.py -m "slow and diffusion" --run-level=full_model
 """
 
 import json
@@ -27,8 +27,7 @@ PROMPT = "A red fox walks through fresh snow while wind moves the pine branches.
 FOUR_CARD_MARKS = hardware_marks(res={"cuda": "H100"}, num_cards=4)
 
 
-@pytest.mark.core_model
-@pytest.mark.advanced_model
+@pytest.mark.slow
 @pytest.mark.diffusion
 @pytest.mark.parametrize(
     "omni_server",
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_minicpmo_4_5_duplex.py b/tests/e2e/online_serving/test_minicpmo_4_5_duplex.py
index a8ed72511..59b40f5e5 100644
--- a/tests/e2e/online_serving/test_minicpmo_4_5_duplex.py
+++ b/tests/e2e/online_serving/test_minicpmo_4_5_duplex.py
@@ -6,8 +6,8 @@
 from __future__ import annotations
 
 import asyncio
+import base64
 import json
-import uuid
 from pathlib import Path
 
 import pytest
@@ -30,7 +30,7 @@ from tests.e2e.online_serving.run_minicpmo_realtime_duplex_multi_session import
     run_multi_session,
 )
 from tests.helpers.mark import hardware_test
-from vllm_omni.clients.duplex import build_realtime_url
+from vllm_omni.clients.duplex import build_realtime_url, metric_mean
 from vllm_omni.experimental.fullduplex.video_stacking import concat_frames_b64
 
 pytestmark = pytest.mark.omni
@@ -59,9 +59,12 @@ def _assert_session_metrics(metrics: object, *, expected_count: int) -> None:
     assert isinstance(metrics, dict)
     assert isinstance(metrics["session_id"], str)
     assert metrics["audio_turn_count"] == expected_count
-    assert metrics["mean_ttft_ms"] is not None and metrics["mean_ttft_ms"] >= 0
-    assert metrics["mean_ttfp_ms"] is not None and metrics["mean_ttfp_ms"] >= 0
-    assert metrics["mean_rtf"] is not None and metrics["mean_rtf"] >= 0
+    ttft_ms = metric_mean(metrics["ttft_ms"])
+    ttfp_ms = metric_mean(metrics["ttfp_ms"])
+    rtf = metric_mean(metrics["rtf"])
+    assert ttft_ms is not None and ttft_ms >= 0
+    assert ttfp_ms is not None and ttfp_ms >= 0
+    assert rtf is not None and rtf >= 0
 
 
 async def _receive_protocol_events(ws, required_types: set[str], *, timeout_s: float) -> list[dict[str, object]]:
@@ -87,25 +90,16 @@ async def _receive_protocol_events(ws, required_types: set[str], *, timeout_s: f
 
 
 async def _run_protocol_smoke(*, url: str, model: str, ref_audio: Path) -> list[dict[str, object]]:
-    session_id = f"duplex-ci-protocol-{uuid.uuid4().hex}"
-    websocket_url = build_realtime_url(
-        url,
-        model,
-        autostart=False,
-        session_id=session_id,
-        extra_query={"native_duplex": "1"},
-    )
+    websocket_url = build_realtime_url(url, model, autostart=False)
     async with websockets.connect(websocket_url, max_size=64 * 1024 * 1024) as ws:
         await ws.send(
             json.dumps(
                 {
                     "type": "session.update",
                     "session": {
-                        "session_id": session_id,
                         "model": model,
                         "modalities": ["audio", "text"],
                         "ref_audio": _ref_audio_data_url(str(ref_audio)),
-                        "extra_body": {"native_duplex": True},
                     },
                 }
             )
@@ -120,6 +114,170 @@ async def _run_protocol_smoke(*, url: str, model: str, ref_audio: Path) -> list[
     return events
 
 
+async def _run_text_only_response_create(
+    *,
+    url: str,
+    model: str,
+    ref_audio: Path,
+    text: str,
+    timeout_s: float = 120.0,
+) -> dict[str, object]:
+    """Drive a text prompt with no audio and return the server's answer.
+
+    A Realtime client asks for speech from text with a user message item
+    followed by ``response.create``. A model-native duplex session generates
+    from audio units, so this returns whatever the server answers rather than
+    assuming a response.
+    """
+    websocket_url = build_realtime_url(url, model, autostart=False)
+    async with websockets.connect(websocket_url, max_size=64 * 1024 * 1024) as ws:
+        await ws.send(
+            json.dumps(
+                {
+                    "type": "session.update",
+                    "session": {
+                        "model": model,
+                        "modalities": ["audio", "text"],
+                        "output_audio_format": "pcm16",
+                        "turn_detection": None,
+                        "temperature": 0.0,
+                        "ref_audio": _ref_audio_data_url(str(ref_audio)),
+                        "extra_body": {"auto_response": False},
+                    },
+                }
+            )
+        )
+        await _receive_protocol_events(ws, {"session.created", "session.updated"}, timeout_s=60)
+        await ws.send(
+            json.dumps(
+                {
+                    "type": "conversation.item.create",
+                    "item": {
+                        "type": "message",
+                        "role": "user",
+                        "content": [{"type": "input_text", "text": text}],
+                    },
+                }
+            )
+        )
+        await ws.send(json.dumps({"type": "response.create"}))
+
+        async def receive_outcome() -> dict[str, object]:
+            while True:
+                raw = await ws.recv()
+                if not isinstance(raw, str):
+                    continue
+                event = json.loads(raw)
+                if isinstance(event, dict) and event.get("type") in {"error", "response.done"}:
+                    return event
+
+        return await asyncio.wait_for(receive_outcome(), timeout=timeout_s)
+
+
+async def _run_seeded_text_to_audio(
+    *,
+    url: str,
+    model: str,
+    ref_audio: Path | None,
+    text: str,
+    modalities: tuple[str, ...] = ("audio", "text"),
+    silence_seconds: float = 12.0,
+    timeout_s: float = 180.0,
+) -> dict[str, object]:
+    """Speak a seeded text: the duplex route's text-to-speech shape.
+
+    A model-native session takes its text once, in the session context
+    (``duplex_initial_user_text``), and then generates per audio unit. Silence
+    carries no content of its own, so it only advances the clock and lets the
+    model answer the seeded turn.
+    """
+    websocket_url = build_realtime_url(url, model, autostart=False)
+    audio_bytes = 0
+    transcript: list[str] = []
+    output_text: list[str] = []
+    seen: list[str] = []
+    session_payload: dict[str, object] = {
+        "model": model,
+        "modalities": list(modalities),
+        "input_audio_format": "pcm16",
+        "output_audio_format": "pcm16",
+        "turn_detection": None,
+        "temperature": 0.0,
+        "extra_body": {
+            "auto_response": True,
+            "force_listen_count": 0,
+            "duplex_initial_user_text": text,
+        },
+    }
+    if ref_audio is not None:
+        session_payload["ref_audio"] = _ref_audio_data_url(str(ref_audio))
+    async with websockets.connect(websocket_url, max_size=64 * 1024 * 1024) as ws:
+        await ws.send(json.dumps({"type": "session.update", "session": session_payload}))
+
+        async def reader() -> None:
+            nonlocal audio_bytes
+            while True:
+                raw = await ws.recv()
+                if not isinstance(raw, str):
+                    continue
+                event = json.loads(raw)
+                if not isinstance(event, dict):
+                    continue
+                event_type = event.get("type")
+                if isinstance(event_type, str):
+                    seen.append(event_type)
+                delta = event.get("delta")
+                if event_type == "response.output_audio.delta" and isinstance(delta, str):
+                    audio_bytes += len(base64.b64decode(delta))
+                elif event_type == "response.output_audio_transcript.delta" and isinstance(delta, str):
+                    transcript.append(delta)
+                elif event_type == "response.output_text.delta" and isinstance(delta, str):
+                    output_text.append(delta)
+                elif event_type == "error":
+                    raise AssertionError(f"seeded text turn received an error: {event}")
+
+        reader_task = asyncio.create_task(reader())
+        silence = bytes(2 * 16_000 * 200 // 1000)
+        sent_ms = 0
+        try:
+            while sent_ms < silence_seconds * 1000 and "response.done" not in seen:
+                sent_ms += 200
+                await ws.send(
+                    json.dumps(
+                        {
+                            "type": "input_audio_buffer.append",
+                            "audio": base64.b64encode(silence).decode("ascii"),
+                            "input_audio_format": "pcm16",
+                            "sample_rate_hz": 16_000,
+                            "duration_ms": 200,
+                            "audio_end_ms": sent_ms,
+                        }
+                    )
+                )
+                await asyncio.sleep(0.2)
+            loop = asyncio.get_running_loop()
+            deadline = loop.time() + timeout_s
+            while loop.time() < deadline and "response.done" not in seen:
+                await asyncio.sleep(0.5)
+            if reader_task.done():
+                await reader_task
+            # Close explicitly. Dropping the socket parks the session in its
+            # disconnect grace, where it keeps holding an admission slot and
+            # starves the tests that follow.
+            await ws.send(json.dumps({"type": "session.close"}))
+            deadline = loop.time() + 30
+            while loop.time() < deadline and "session.closed" not in seen:
+                await asyncio.sleep(0.25)
+        finally:
+            reader_task.cancel()
+    return {
+        "audio_bytes": audio_bytes,
+        "transcript": "".join(transcript),
+        "output_text": "".join(output_text),
+        "event_types": seen,
+    }
+
+
 @pytest.mark.core_model
 @hardware_test(res={"cuda": "H100", "npu": "A3"}, num_cards=1)
 @pytest.mark.parametrize("omni_server", SERVER_PARAMS, indirect=True)
@@ -202,6 +360,215 @@ def test_duplex_single_session_video_input(omni_server, tmp_path: Path) -> None:
     _assert_session_metrics(result["session_metrics"], expected_count=2)
 
 
+@pytest.mark.advanced_model
+@hardware_test(res={"cuda": "H100", "npu": "A3"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", SERVER_PARAMS, indirect=True)
+@pytest.mark.parametrize(
+    ("locale", "text"),
+    [
+        ("en", "Please say exactly: the quick brown fox jumps over the lazy dog."),
+        ("zh", "请朗读：今天天气很好，我们一起去公园散步。"),
+    ],
+)
+def test_duplex_seeded_text_to_audio(omni_server, locale: str, text: str) -> None:
+    """text -> audio over the duplex route, in both locales.
+
+    This is the case the deleted turn-based ``text -> audio`` tests covered.
+    It is also the shape the Seed-TTS Realtime backend uses, so it guards the
+    benchmark path as well as the modality.
+    """
+    result = asyncio.run(
+        _run_seeded_text_to_audio(
+            url=realtime_url(omni_server),
+            model=omni_server.model,
+            ref_audio=resolve_ref_audio(),
+            text=text,
+        )
+    )
+
+    assert "response.done" in result["event_types"], result["event_types"]
+    assert int(result["audio_bytes"]) > 0, f"{locale} seeded text produced no audio"
+    assert str(result["transcript"]).strip(), f"{locale} seeded text produced audio with no transcript"
+
+
+@pytest.mark.advanced_model
+@hardware_test(res={"cuda": "H100", "npu": "A3"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", SERVER_PARAMS, indirect=True)
+def test_duplex_seeded_text_to_text_needs_no_reference_voice(omni_server) -> None:
+    """text -> text, the one duplex session that opens without a reference voice.
+
+    ``ref_audio`` is required only when the session asks for audio output, so a
+    ``modalities: ["text"]`` session is the duplex equivalent of the deleted
+    turn-based ``text -> text`` case. The model is model-native and still
+    speaks its answer, so this asserts the text side and the absence of the
+    ``ref_audio_required`` rejection, not the absence of audio.
+    """
+    result = asyncio.run(
+        _run_seeded_text_to_audio(
+            url=realtime_url(omni_server),
+            model=omni_server.model,
+            ref_audio=None,
+            text="What is the capital of France? Answer in one short sentence.",
+            modalities=("text",),
+        )
+    )
+
+    assert "response.done" in result["event_types"], result["event_types"]
+    produced_text = str(result["output_text"]) or str(result["transcript"])
+    assert produced_text.strip(), f"text-only session produced nothing: {result['event_types']}"
+
+
+@pytest.mark.advanced_model
+@hardware_test(res={"cuda": "H100", "npu": "A3"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", SERVER_PARAMS, indirect=True)
+def test_duplex_seeded_text_to_long_audio_output(omni_server) -> None:
+    """A longer answer, so Code2Wav runs across many frames rather than one.
+
+    Replaces the deleted ``text_to_audio_long_output`` case. The assertion is
+    on the amount of audio rather than its content: the point is that a long
+    answer streams to completion, not that the model says any given word.
+    """
+    result = asyncio.run(
+        _run_seeded_text_to_audio(
+            url=realtime_url(omni_server),
+            model=omni_server.model,
+            ref_audio=resolve_ref_audio(),
+            text="What is the capital of China? Answer in about 40 words.",
+            silence_seconds=30.0,
+            timeout_s=240.0,
+        )
+    )
+
+    assert "response.done" in result["event_types"], result["event_types"]
+    # 24 kHz mono pcm16: 2 s of speech is 96000 bytes, comfortably more than a
+    # single Code2Wav frame and well under a 40-word answer.
+    assert int(result["audio_bytes"]) > 96_000, f"expected a long answer, got {result['audio_bytes']} bytes"
+    assert str(result["transcript"]).strip()
+
+
+@pytest.mark.advanced_model
+@hardware_test(res={"cuda": "H100", "npu": "A3"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", SERVER_PARAMS, indirect=True)
+def test_duplex_seeded_long_form_generation(omni_server) -> None:
+    """Long-form Chinese generation, replacing the deleted long-form case."""
+    result = asyncio.run(
+        _run_seeded_text_to_audio(
+            url=realtime_url(omni_server),
+            model=omni_server.model,
+            ref_audio=resolve_ref_audio(),
+            text="帮我讲一个100字的故事。",
+            silence_seconds=30.0,
+            timeout_s=240.0,
+        )
+    )
+
+    assert "response.done" in result["event_types"], result["event_types"]
+    assert int(result["audio_bytes"]) > 96_000, f"expected long-form audio, got {result['audio_bytes']} bytes"
+    assert str(result["transcript"]).strip()
+
+
+@pytest.mark.advanced_model
+@hardware_test(res={"cuda": "H100", "npu": "A3"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", SERVER_PARAMS, indirect=True)
+def test_duplex_sequential_sessions_are_independent(omni_server) -> None:
+    """A second session must answer its own prompt, not replay the first one.
+
+    Replaces the deleted ``sequential_requests_independent`` case. Sessions are
+    engine-resident now, so this is the check that one session's context does
+    not leak into the next one on the same stages.
+    """
+    first = asyncio.run(
+        _run_seeded_text_to_audio(
+            url=realtime_url(omni_server),
+            model=omni_server.model,
+            ref_audio=resolve_ref_audio(),
+            text="What is the capital of France? Answer in one short sentence.",
+        )
+    )
+    second = asyncio.run(
+        _run_seeded_text_to_audio(
+            url=realtime_url(omni_server),
+            model=omni_server.model,
+            ref_audio=resolve_ref_audio(),
+            text="What is the capital of China? Answer in one short sentence.",
+        )
+    )
+
+    for result in (first, second):
+        assert "response.done" in result["event_types"], result["event_types"]
+        assert int(result["audio_bytes"]) > 0
+        assert str(result["transcript"]).strip()
+
+    # Different prompts must not produce the same answer: that would mean the
+    # second session inherited the first one's context.
+    assert str(first["transcript"]).strip() != str(second["transcript"]).strip()
+
+
+@pytest.mark.advanced_model
+@hardware_test(res={"cuda": "H100", "npu": "A3"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", SERVER_PARAMS, indirect=True)
+def test_duplex_text_only_response_create_is_rejected(omni_server) -> None:
+    """A duplex session generates from audio: a text-only prompt is refused, not ignored.
+
+    Every session on this route is model-native, and such a model decides per
+    audio unit whether to speak: conversation items are context, not a turn.
+    Refusing is the point -- opening a response the model never fills costs the
+    caller the session's whole idle timeout to discover. A text prompt reaches
+    the model through the session's seeded opening turn
+    (``initial_user_text``) instead, which is what ``/v1/chat/completions``
+    uses and what the Seed-TTS Realtime backend has to be ported to.
+    """
+    outcome = asyncio.run(
+        _run_text_only_response_create(
+            url=realtime_url(omni_server),
+            model=omni_server.model,
+            ref_audio=resolve_ref_audio(),
+            text="Please say: the quick brown fox jumps over the lazy dog.",
+        )
+    )
+
+    assert outcome.get("type") == "error", outcome
+    error = outcome.get("error")
+    assert isinstance(error, dict), outcome
+    assert error.get("code") == "text_only_turn_unsupported", outcome
+    assert error.get("type") == "invalid_request_error", outcome
+
+
+@pytest.mark.advanced_model
+@hardware_test(res={"cuda": "H100", "npu": "A3"}, num_cards=1)
+@pytest.mark.parametrize("omni_server", SERVER_PARAMS, indirect=True)
+def test_duplex_single_session_still_image_input(omni_server, tmp_path: Path) -> None:
+    """A spoken turn with one still image attached.
+
+    The still-image case is a one-element frame list, which the client repeats
+    on every unit of the turn: unlike the camera track it never advances, so
+    this covers the image path the turn-based ``image -> text + audio`` request
+    used to cover.
+    """
+    args = demo_args(
+        omni_server=omni_server,
+        input_wav=validated_input_wav(),
+        ref_audio=resolve_ref_audio(),
+        output_dir=tmp_path / "still_image",
+    )
+    args.turns = 2
+    args.turn_duration_ms = [args.first_turn_ms] * args.turns
+    args.video_frames_b64 = duplex_camera_frames(seconds=1, cache_dir=tmp_path / "still")[:1]
+
+    result = asyncio.run(run_demo(args))
+
+    assert result["ok"] is True
+    assert result["video_frame_count"] == 1
+    assert result["video_stacked_frame_count"] == 0
+    _assert_positive_int(result["audio_delta_count"])
+    assert result["done_count"] == 2
+    assert result["error_count"] == 0
+    assert result["all_audio_responses_have_transcript"] is True
+    assert result["transcript_delta_done_ok"] is True
+    _assert_request_metrics(result["request_metrics"], expected_count=2)
+    _assert_session_metrics(result["session_metrics"], expected_count=2)
+
+
 @pytest.mark.advanced_model
 @hardware_test(res={"cuda": "H100", "npu": "A3"}, num_cards=1)
 @pytest.mark.parametrize("omni_server", SERVER_PARAMS, indirect=True)
diff --git a/tests/e2e/online_serving/test_minicpmo_4_5_duplex_expansion.py b/tests/e2e/online_serving/test_minicpmo_4_5_duplex_expansion.py
index c3c6fd90a..f931fb95d 100644
--- a/tests/e2e/online_serving/test_minicpmo_4_5_duplex_expansion.py
+++ b/tests/e2e/online_serving/test_minicpmo_4_5_duplex_expansion.py
@@ -30,7 +30,7 @@ from tests.e2e.online_serving.run_minicpmo_realtime_duplex_soft_interrupt import
     run_soft_interrupt,
 )
 from tests.helpers.mark import hardware_test
-from vllm_omni.entrypoints.duplex.server_vad import (
+from vllm_omni.engine.duplex.vad import (
     SILERO_VAD_FILENAME,
     SILERO_VAD_REPO_ID,
     SILERO_VAD_REVISION,
@@ -51,7 +51,7 @@ def _cached_server_vad_artifact() -> None:
     )
 
 
-@hardware_test(res={"cuda": "H100", "npu": "A3"}, num_cards=1)
+@hardware_test(res={"cuda": ["H100", "B200"], "npu": "A3"}, num_cards=1)
 @pytest.mark.parametrize("omni_server", SERVER_PARAMS, indirect=True)
 def test_duplex_admission_and_expiry_reaper(omni_server, tmp_path: Path) -> None:
     args = multi_session_args(
@@ -79,7 +79,7 @@ def test_duplex_admission_and_expiry_reaper(omni_server, tmp_path: Path) -> None
 # still talking, which only holds when the duplex pipeline sustains real-time
 # throughput. The current NPU stack runs several times slower than real time,
 # so it never reaches a mid-stream decision point.
-@hardware_test(res={"cuda": "H100"}, num_cards=1)
+@hardware_test(res={"cuda": ["H100", "B200"]}, num_cards=1)
 @pytest.mark.parametrize("omni_server", SERVER_PARAMS, indirect=True)
 def test_duplex_soft_interrupt(omni_server, tmp_path: Path) -> None:
     input_wav = validated_soft_interrupt_wav()
@@ -112,7 +112,7 @@ def test_duplex_soft_interrupt(omni_server, tmp_path: Path) -> None:
     assert result["followup_response_transcript_ok"] is True
 
 
-@hardware_test(res={"cuda": "H100"}, num_cards=1)
+@hardware_test(res={"cuda": ["H100", "B200"]}, num_cards=1)
 @pytest.mark.parametrize("omni_server", SERVER_PARAMS, indirect=True)
 def test_duplex_server_vad_hard_interrupt(_cached_server_vad_artifact, omni_server) -> None:
     result = asyncio.run(
diff --git a/tests/e2e/online_serving/test_minicpmo_realtime_duplex_drivers.py b/tests/e2e/online_serving/test_minicpmo_realtime_duplex_drivers.py
index 22c8e6b34..a23ce73e8 100644
--- a/tests/e2e/online_serving/test_minicpmo_realtime_duplex_drivers.py
+++ b/tests/e2e/online_serving/test_minicpmo_realtime_duplex_drivers.py
@@ -152,7 +152,6 @@ def test_realtime_duplex_demo_pair_launches_demo_processes_concurrently(tmp_path
                 "parser.add_argument('--output-dir')",
                 "parser.add_argument('--chunk-ms')",
                 "parser.add_argument('--timeout-s')",
-                "parser.add_argument('--session-id')",
                 "parser.add_argument('--ref-audio')",
                 "parser.add_argument('--require-audio', action='store_true')",
                 "parser.add_argument('--no-realtime-pacing', action='store_true')",
@@ -168,9 +167,9 @@ def test_realtime_duplex_demo_pair_launches_demo_processes_concurrently(tmp_path
                 "events = [",
                 "    {'type': 'session.created'},",
                 "    {'type': 'response.created', 'response': {'id': response_id}},",
-                "    {'type': 'response.audio.delta', 'response_id': response_id, "
+                "    {'type': 'response.output_audio.delta', 'response_id': response_id, "
                 "'delta': 'AAAA', 'sample_rate_hz': 24000, '_client_received_at_s': 10.1},",
-                "    {'type': 'response.audio.delta', 'response_id': response_id, "
+                "    {'type': 'response.output_audio.delta', 'response_id': response_id, "
                 "'delta': 'AAAA', 'sample_rate_hz': 24000, '_client_received_at_s': 10.6},",
                 "    {'type': 'response.done', 'response_id': response_id},",
                 "    {'type': 'session.closed'},",
@@ -237,8 +236,8 @@ def test_realtime_duplex_demo_pair_rejects_false_green_audio_contract(tmp_path):
     response_id = "resp-a"
     events = [
         {"type": "response.created", "response": {"id": response_id}},
-        {"type": "response.audio.delta", "response_id": response_id, "delta": "AAAA", "sample_rate_hz": 24000},
-        {"type": "response.audio.delta", "response_id": "resp-other", "delta": "AAAA", "sample_rate_hz": 24000},
+        {"type": "response.output_audio.delta", "response_id": response_id, "delta": "AAAA", "sample_rate_hz": 24000},
+        {"type": "response.output_audio.delta", "response_id": "resp-other", "delta": "AAAA", "sample_rate_hz": 24000},
         {"type": "response.done", "response_id": response_id},
     ]
     (output / "events.jsonl").write_text(
@@ -459,25 +458,25 @@ def test_realtime_duplex_soft_interrupt_accepts_multi_delta_handoff_sequence(tmp
         {"type": "response.created", "response": {"id": first_response_id}, "_client_received_at_s": 2.0},
         {"type": "response.speak", "response_id": first_response_id, "_client_received_at_s": 2.0},
         {
-            "type": "response.audio.delta",
+            "type": "response.output_audio.delta",
             "response_id": first_response_id,
             "delta": "AAAA",
             "_client_received_at_s": 2.1,
         },
         {
-            "type": "response.audio_transcript.delta",
+            "type": "response.output_audio_transcript.delta",
             "response_id": first_response_id,
             "delta": "中国古代四大发明",
             "_client_received_at_s": 2.1,
         },
         {
-            "type": "response.audio.delta",
+            "type": "response.output_audio.delta",
             "response_id": first_response_id,
             "delta": "AAAA",
             "_client_received_at_s": 2.6,
         },
         {
-            "type": "response.audio_transcript.delta",
+            "type": "response.output_audio_transcript.delta",
             "response_id": first_response_id,
             "delta": "是造纸术。",
             "_client_received_at_s": 2.6,
@@ -486,25 +485,25 @@ def test_realtime_duplex_soft_interrupt_accepts_multi_delta_handoff_sequence(tmp
         {"type": "response.created", "response": {"id": second_response_id}, "_client_received_at_s": 4.0},
         {"type": "response.speak", "response_id": second_response_id, "_client_received_at_s": 4.0},
         {
-            "type": "response.audio.delta",
+            "type": "response.output_audio.delta",
             "response_id": second_response_id,
             "delta": "AAAA",
             "_client_received_at_s": 4.1,
         },
         {
-            "type": "response.audio_transcript.delta",
+            "type": "response.output_audio_transcript.delta",
             "response_id": second_response_id,
             "delta": "一加一等于",
             "_client_received_at_s": 4.1,
         },
         {
-            "type": "response.audio.delta",
+            "type": "response.output_audio.delta",
             "response_id": second_response_id,
             "delta": "AAAA",
             "_client_received_at_s": 4.6,
         },
         {
-            "type": "response.audio_transcript.delta",
+            "type": "response.output_audio_transcript.delta",
             "response_id": second_response_id,
             "delta": "二。",
             "_client_received_at_s": 4.6,
@@ -561,25 +560,25 @@ def test_realtime_duplex_soft_interrupt_accepts_followup_done_after_commit(tmp_p
         {"type": "response.created", "response": {"id": first_response_id}, "_client_received_at_s": 2.0},
         {"type": "response.speak", "response_id": first_response_id, "_client_received_at_s": 2.0},
         {
-            "type": "response.audio.delta",
+            "type": "response.output_audio.delta",
             "response_id": first_response_id,
             "delta": "AAAA",
             "_client_received_at_s": 2.1,
         },
         {
-            "type": "response.audio_transcript.delta",
+            "type": "response.output_audio_transcript.delta",
             "response_id": first_response_id,
             "delta": "中国古代四大发明",
             "_client_received_at_s": 2.1,
         },
         {
-            "type": "response.audio.delta",
+            "type": "response.output_audio.delta",
             "response_id": first_response_id,
             "delta": "AAAA",
             "_client_received_at_s": 2.6,
         },
         {
-            "type": "response.audio_transcript.delta",
+            "type": "response.output_audio_transcript.delta",
             "response_id": first_response_id,
             "delta": "是造纸术。",
             "_client_received_at_s": 2.6,
@@ -589,25 +588,25 @@ def test_realtime_duplex_soft_interrupt_accepts_followup_done_after_commit(tmp_p
         {"type": "response.created", "response": {"id": second_response_id}, "_client_received_at_s": 3.5},
         {"type": "response.speak", "response_id": second_response_id, "_client_received_at_s": 3.5},
         {
-            "type": "response.audio.delta",
+            "type": "response.output_audio.delta",
             "response_id": second_response_id,
             "delta": "AAAA",
             "_client_received_at_s": 3.6,
         },
         {
-            "type": "response.audio_transcript.delta",
+            "type": "response.output_audio_transcript.delta",
             "response_id": second_response_id,
             "delta": "一加一等于",
             "_client_received_at_s": 3.6,
         },
         {
-            "type": "response.audio.delta",
+            "type": "response.output_audio.delta",
             "response_id": second_response_id,
             "delta": "AAAA",
             "_client_received_at_s": 3.7,
         },
         {
-            "type": "response.audio_transcript.delta",
+            "type": "response.output_audio_transcript.delta",
             "response_id": second_response_id,
             "delta": "二。",
             "_client_received_at_s": 3.7,
@@ -653,8 +652,18 @@ def test_realtime_duplex_soft_interrupt_model_policy_accepts_single_response(tmp
     events = [
         {"type": "response.listen", "_client_received_at_s": 1.0},
         {"type": "response.created", "response": {"id": response_id}, "_client_received_at_s": 2.0},
-        {"type": "response.audio.delta", "response_id": response_id, "delta": "AAAA", "_client_received_at_s": 2.1},
-        {"type": "response.audio.delta", "response_id": response_id, "delta": "AAAA", "_client_received_at_s": 2.15},
+        {
+            "type": "response.output_audio.delta",
+            "response_id": response_id,
+            "delta": "AAAA",
+            "_client_received_at_s": 2.1,
+        },
+        {
+            "type": "response.output_audio.delta",
+            "response_id": response_id,
+            "delta": "AAAA",
+            "_client_received_at_s": 2.15,
+        },
         {"type": "response.done", "response_id": response_id, "_client_received_at_s": 2.2},
         {"type": "response.listen", "_client_received_at_s": 2.3},
         {"type": "input_audio_buffer.committed", "_client_received_at_s": 3.0},
@@ -692,10 +701,25 @@ def test_realtime_duplex_soft_interrupt_model_policy_accepts_commit_during_speak
     events = [
         {"type": "response.listen", "_client_received_at_s": 1.0},
         {"type": "response.created", "response": {"id": response_id}, "_client_received_at_s": 2.0},
-        {"type": "response.audio.delta", "response_id": response_id, "delta": "AAAA", "_client_received_at_s": 2.1},
-        {"type": "response.audio.delta", "response_id": response_id, "delta": "AAAA", "_client_received_at_s": 2.2},
+        {
+            "type": "response.output_audio.delta",
+            "response_id": response_id,
+            "delta": "AAAA",
+            "_client_received_at_s": 2.1,
+        },
+        {
+            "type": "response.output_audio.delta",
+            "response_id": response_id,
+            "delta": "AAAA",
+            "_client_received_at_s": 2.2,
+        },
         {"type": "input_audio_buffer.committed", "_client_received_at_s": 3.0},
-        {"type": "response.audio.delta", "response_id": response_id, "delta": "AAAA", "_client_received_at_s": 4.0},
+        {
+            "type": "response.output_audio.delta",
+            "response_id": response_id,
+            "delta": "AAAA",
+            "_client_received_at_s": 4.0,
+        },
         {"type": "response.done", "response_id": response_id, "_client_received_at_s": 5.0},
     ]
     (output / "events.jsonl").write_text(
@@ -729,8 +753,18 @@ def test_realtime_duplex_soft_interrupt_response_required_rejects_single_respons
     events = [
         {"type": "response.listen", "_client_received_at_s": 1.0},
         {"type": "response.created", "response": {"id": response_id}, "_client_received_at_s": 2.0},
-        {"type": "response.audio.delta", "response_id": response_id, "delta": "AAAA", "_client_received_at_s": 2.1},
-        {"type": "response.audio.delta", "response_id": response_id, "delta": "AAAA", "_client_received_at_s": 2.15},
+        {
+            "type": "response.output_audio.delta",
+            "response_id": response_id,
+            "delta": "AAAA",
+            "_client_received_at_s": 2.1,
+        },
+        {
+            "type": "response.output_audio.delta",
+            "response_id": response_id,
+            "delta": "AAAA",
+            "_client_received_at_s": 2.15,
+        },
         {"type": "response.done", "response_id": response_id, "_client_received_at_s": 2.2},
         {"type": "response.listen", "_client_received_at_s": 2.3},
         {"type": "input_audio_buffer.committed", "_client_received_at_s": 3.0},
@@ -767,19 +801,19 @@ def test_realtime_duplex_soft_interrupt_reports_text_expectation_without_gating(
         {"type": "response.listen", "_client_received_at_s": 1.0},
         {"type": "response.created", "response": {"id": first_response_id}, "_client_received_at_s": 2.0},
         {
-            "type": "response.audio.delta",
+            "type": "response.output_audio.delta",
             "response_id": first_response_id,
             "delta": "AAAA",
             "_client_received_at_s": 2.1,
         },
         {
-            "type": "response.audio.delta",
+            "type": "response.output_audio.delta",
             "response_id": first_response_id,
             "delta": "AAAA",
             "_client_received_at_s": 2.2,
         },
         {
-            "type": "response.audio_transcript.delta",
+            "type": "response.output_audio_transcript.delta",
             "response_id": first_response_id,
             "delta": "一加一等于二",
             "_client_received_at_s": 2.2,
@@ -788,19 +822,19 @@ def test_realtime_duplex_soft_interrupt_reports_text_expectation_without_gating(
         {"type": "response.listen", "_client_received_at_s": 2.4},
         {"type": "response.created", "response": {"id": second_response_id}, "_client_received_at_s": 3.0},
         {
-            "type": "response.audio.delta",
+            "type": "response.output_audio.delta",
             "response_id": second_response_id,
             "delta": "AAAA",
             "_client_received_at_s": 3.1,
         },
         {
-            "type": "response.audio.delta",
+            "type": "response.output_audio.delta",
             "response_id": second_response_id,
             "delta": "AAAA",
             "_client_received_at_s": 3.2,
         },
         {
-            "type": "response.audio_transcript.delta",
+            "type": "response.output_audio_transcript.delta",
             "response_id": second_response_id,
             "delta": "不知道",
             "_client_received_at_s": 3.2,
@@ -834,7 +868,7 @@ def test_realtime_duplex_soft_interrupt_reports_text_expectation_without_gating(
     events = [
         event
         for event in events
-        if event.get("response_id") != second_response_id or event["type"] != "response.audio_transcript.delta"
+        if event.get("response_id") != second_response_id or event["type"] != "response.output_audio_transcript.delta"
     ]
     (output / "events.jsonl").write_text(
         "".join(demo.json.dumps(event) + "\n" for event in events),
@@ -992,7 +1026,7 @@ def test_realtime_duplex_demo_resolves_distinct_turn_inputs():
         demo._turn_input_paths(primary, ["second.wav"], turns=3)
 
 
-def test_realtime_duplex_demo_explicitly_enables_native_runtime_before_connect():
+def test_realtime_duplex_demo_url_carries_no_model_opt_in_or_session_id():
     demo = _load_demo_module()
 
     url = demo._url_with_model(
@@ -1001,23 +1035,12 @@ def test_realtime_duplex_demo_explicitly_enables_native_runtime_before_connect()
     )
 
     query = parse_qs(urlsplit(url).query)
-    assert query["native_duplex"] == ["1"]
+    assert query["duplex"] == ["1"]
+    assert "native_duplex" not in query
+    assert "session_id" not in query
 
 
-def test_realtime_duplex_demo_explicit_session_id_reaches_autostart_query():
-    demo = _load_demo_module()
-
-    url = demo._url_with_model(
-        "ws://localhost:8099/v1/realtime?duplex=1",
-        "openbmb/MiniCPM-o-4_5",
-        session_id="reopen-e2e",
-    )
-
-    query = parse_qs(urlsplit(url).query)
-    assert query["session_id"] == ["reopen-e2e"]
-
-
-def test_realtime_duplex_demo_session_update_uses_explicit_session_id():
+def test_realtime_duplex_demo_session_update_leaves_session_id_to_the_server():
     demo = _load_demo_module()
 
     event = demo._session_update_event(
@@ -1031,8 +1054,8 @@ def test_realtime_duplex_demo_session_update_uses_explicit_session_id():
 
     assert event["type"] == "session.update"
     assert "session_id" not in event
-    assert event["session"]["session_id"] == "reopen-e2e"
-    assert event["session"]["extra_body"]["native_duplex"] is True
+    assert "session_id" not in event["session"]
+    assert "native_duplex" not in event["session"]["extra_body"]
 
 
 def test_realtime_duplex_demo_response_required_uses_deterministic_sampling():
@@ -1123,7 +1146,7 @@ def test_realtime_duplex_demo_partitions_timing_by_response_identity():
         )
         state.add(
             {
-                "type": "response.audio.delta",
+                "type": "response.output_audio.delta",
                 "response_id": response_id,
                 "delta": base64.b64encode(b"audio").decode("ascii"),
                 "metadata": {
@@ -1142,7 +1165,7 @@ def test_realtime_duplex_demo_partitions_timing_by_response_identity():
         )
         state.add(
             {
-                "type": "response.audio_transcript.delta",
+                "type": "response.output_audio_transcript.delta",
                 "response_id": response_id,
                 "delta": "audio",
             },
@@ -1174,7 +1197,9 @@ def test_realtime_duplex_demo_partitions_timing_by_response_identity():
                 "ttft": "input_audio_buffer.commit client send to first non-empty text delta",
                 "ttfp": "input_audio_buffer.commit client send to first audio packet",
                 "rtf": "commit-to-last-audio receive time divided by emitted audio duration",
+                "tpot": "Stage-0 engine mean time per output token",
             },
+            "tpot_ms": None,
         },
         {
             "session_id": "seed-tts-session",
@@ -1190,15 +1215,17 @@ def test_realtime_duplex_demo_partitions_timing_by_response_identity():
                 "ttft": "input_audio_buffer.commit client send to first non-empty text delta",
                 "ttfp": "input_audio_buffer.commit client send to first audio packet",
                 "rtf": "commit-to-last-audio receive time divided by emitted audio duration",
+                "tpot": "Stage-0 engine mean time per output token",
             },
+            "tpot_ms": None,
         },
     ]
     assert session_metrics == {
         "session_id": "seed-tts-session",
         "audio_turn_count": 2,
-        "mean_ttft_ms": 150.0,
-        "mean_ttfp_ms": 250.0,
-        "mean_rtf": 3.125,
+        "ttft_ms": {"count": 2, "mean": 150.0, "p50": 150.0, "p99": 150.0},
+        "ttfp_ms": {"count": 2, "mean": 250.0, "p50": 200.0, "p99": 300.0},
+        "rtf": {"count": 2, "mean": 3.125, "p50": 2.5, "p99": 3.75},
     }
 
 
@@ -1251,8 +1278,8 @@ def test_realtime_duplex_demo_distinguishes_late_and_missing_commit():
         {"type": "response.output_item.added", "response_id": response_id},
         {"type": "response.content_part.added", "response_id": response_id},
         {"type": "response.speak", "response_id": response_id},
-        {"type": "response.audio.delta", "response_id": response_id, "delta": "AAAA"},
-        {"type": "response.audio.done", "response_id": response_id},
+        {"type": "response.output_audio.delta", "response_id": response_id, "delta": "AAAA"},
+        {"type": "response.output_audio.done", "response_id": response_id},
         {"type": "response.content_part.done", "response_id": response_id},
         {"type": "response.output_item.done", "response_id": response_id},
         {"type": "response.done", "response_id": response_id},
@@ -1314,7 +1341,7 @@ def test_realtime_duplex_demo_distinct_inputs_compare_audio_content():
 def _add_response_transcript(state, response_id, *, transcript, audio=True):
     state.add(
         {
-            "type": "response.audio.delta",
+            "type": "response.output_audio.delta",
             "response_id": response_id,
             "delta": "YQ==" if audio else "",
         }
@@ -1322,14 +1349,14 @@ def _add_response_transcript(state, response_id, *, transcript, audio=True):
     if transcript:
         state.add(
             {
-                "type": "response.audio_transcript.delta",
+                "type": "response.output_audio_transcript.delta",
                 "response_id": response_id,
                 "delta": transcript,
             }
         )
         state.add(
             {
-                "type": "response.audio_transcript.done",
+                "type": "response.output_audio_transcript.done",
                 "response_id": response_id,
                 "transcript": transcript,
             }
@@ -1404,7 +1431,7 @@ def test_realtime_duplex_demo_speak_gate_rejects_text_channel():
         {
             "type": "response.speak",
             "response_id": "resp-1",
-            "text": "must be emitted through response.audio_transcript.delta",
+            "text": "must be emitted through response.output_audio_transcript.delta",
         }
     )
 
@@ -1450,7 +1477,7 @@ def test_realtime_duplex_demo_gate_rejects_delta_done_mismatch():
     demo = _load_demo_module()
     state = demo.DemoState()
     _add_response_transcript(state, "resp-1", transcript="delta文本")
-    done = next(event for event in state.events if event.get("type") == "response.audio_transcript.done")
+    done = next(event for event in state.events if event.get("type") == "response.output_audio_transcript.done")
     done["transcript"] = "另一个done文本"
 
     result = demo._evaluate_transcript_integrity(
@@ -2180,7 +2207,7 @@ def test_realtime_duplex_demo_listen_only_overlap_accepts_silence_unit_before_fi
             state.add({"type": "response.created", "response": {"id": "resp-first"}})
             state.add(
                 {
-                    "type": "response.audio.delta",
+                    "type": "response.output_audio.delta",
                     "response_id": "resp-first",
                     "delta": "YQ==",
                 }
@@ -2290,7 +2317,7 @@ def test_realtime_duplex_demo_writes_audio_per_response(tmp_path):
         state.add({"type": "response.created", "response": {"id": response_id}})
         state.add(
             {
-                "type": "response.audio.delta",
+                "type": "response.output_audio.delta",
                 "response_id": response_id,
                 "delta": demo.base64.b64encode(payload).decode(),
                 "sample_rate_hz": 24000,
diff --git a/tests/e2e/online_serving/test_minimax_h3_dlo_dp2_t2va.py b/tests/e2e/online_serving/test_minimax_h3_dlo_dp2_t2va.py
index 0bf546683..4fa71aead 100644
--- a/tests/e2e/online_serving/test_minimax_h3_dlo_dp2_t2va.py
+++ b/tests/e2e/online_serving/test_minimax_h3_dlo_dp2_t2va.py
@@ -111,7 +111,6 @@ def _run_t2va_request(client: OpenAIClientHandler, seed: int) -> bytes:
 @pytest.mark.core_model
 @pytest.mark.advanced_model
 @pytest.mark.diffusion
-@pytest.mark.slow
 @pytest.mark.parametrize(
     "omni_server",
     [
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_moss_tts_nano_expansion.py b/tests/e2e/online_serving/test_moss_tts_nano_expansion.py
index 3ea8c91ea..cf623b203 100644
--- a/tests/e2e/online_serving/test_moss_tts_nano_expansion.py
+++ b/tests/e2e/online_serving/test_moss_tts_nano_expansion.py
@@ -84,7 +84,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_text_to_audio_001(omni_server, online_client, ref_audio_data_url) -> None:
     """
@@ -106,7 +106,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", "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, ref_audio_data_url) -> None:
     """
@@ -138,7 +138,7 @@ def test_text_to_audio_002(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", "npu": "A2"}, num_cards=1)
 @pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
 def test_text_to_audio_003(omni_server, online_client, ref_audio_data_url) -> None:
     """
@@ -160,7 +160,7 @@ def test_text_to_audio_003(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", "npu": "A2"}, num_cards=1)
 @pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
 def test_text_to_audio_004_ref_text_ignored(omni_server, online_client, ref_audio_data_url) -> None:
     """
@@ -181,3 +181,23 @@ def test_text_to_audio_004_ref_text_ignored(omni_server, online_client, ref_audi
     }
 
     online_client.send_audio_speech_request(request_config)
+
+
+@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_005_concurrent_requests_are_serialized(omni_server, online_client, ref_audio_data_url) -> None:
+    """Concurrent clients produce identical audio when generation is serialized."""
+    request_config = {
+        "model": omni_server.model,
+        "input": "Concurrent clients should receive clean and deterministic speech.",
+        "stream": False,
+        "response_format": "wav",
+        "ref_audio": ref_audio_data_url,
+        "seed": 42,
+    }
+
+    responses = online_client.send_audio_speech_request(request_config, request_num=2)
+
+    assert len(responses) == 2
+    assert responses[0].audio_bytes
+    assert responses[0].audio_bytes == responses[1].audio_bytes
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_pi0_expansion.py b/tests/e2e/online_serving/test_pi0_expansion.py
index 3a9c3b177..6a16edc71 100644
--- a/tests/e2e/online_serving/test_pi0_expansion.py
+++ b/tests/e2e/online_serving/test_pi0_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 online serving test for π0 (Pi-Zero) OpenPI websocket serving.
 
@@ -58,7 +58,7 @@ test_params = [
 
 @pytest.mark.full_model
 @pytest.mark.diffusion
-@hardware_test(res={"cuda": "H100"})
+@hardware_test(res={"cuda": ["H100", "B200"]})
 @pytest.mark.parametrize("omni_server", test_params, indirect=True)
 def test_pi0_openpi_online(omni_server):
     try:
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_omni_multi_replicas.py b/tests/e2e/online_serving/test_qwen3_omni_multi_replicas.py
index 1a27a5449..a2d64de22 100644
--- a/tests/e2e/online_serving/test_qwen3_omni_multi_replicas.py
+++ b/tests/e2e/online_serving/test_qwen3_omni_multi_replicas.py
@@ -91,7 +91,7 @@ def _assert_audio_outputs(responses: list[OmniResponse], *, expect_text: bool) -
 
 @pytest.mark.full_model
 @pytest.mark.omni
-@hardware_test(res={"cuda": "H100"}, num_cards=4)
+@hardware_test(res={"cuda": ["H100", "B200"]}, num_cards=4)
 @pytest.mark.parametrize("omni_server", test_params, indirect=True)
 def test_text_only_batch_uses_multi_replica_talker(omni_server, online_client) -> None:
     request_config = {
@@ -108,7 +108,7 @@ def test_text_only_batch_uses_multi_replica_talker(omni_server, online_client) -
 
 @pytest.mark.full_model
 @pytest.mark.omni
-@hardware_test(res={"cuda": "H100"}, num_cards=4)
+@hardware_test(res={"cuda": ["H100", "B200"]}, num_cards=4)
 @pytest.mark.parametrize("omni_server", test_params, indirect=True)
 def test_text_to_audio_stream_batch_uses_multi_replica_vocoder(omni_server, online_client) -> None:
     request_config = {
@@ -125,7 +125,7 @@ def test_text_to_audio_stream_batch_uses_multi_replica_vocoder(omni_server, onli
 
 @pytest.mark.full_model
 @pytest.mark.omni
-@hardware_test(res={"cuda": "H100"}, num_cards=4)
+@hardware_test(res={"cuda": ["H100", "B200"]}, num_cards=4)
 @pytest.mark.parametrize("omni_server", test_params, indirect=True)
 def test_mixed_modal_stream_batch_generates_text_and_audio(omni_server, online_client) -> None:
     request_config = {
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_base_expansion.py b/tests/e2e/online_serving/test_qwen3_tts_base_expansion.py
index e126877db..abf80fb85 100644
--- a/tests/e2e/online_serving/test_qwen3_tts_base_expansion.py
+++ b/tests/e2e/online_serving/test_qwen3_tts_base_expansion.py
@@ -69,7 +69,7 @@ tts_no_async_chunk_server_params = [
 DEFAULT_AUDIO_SPEECH_TIMEOUT_S = 180.0
 
 
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@hardware_test(res={"cuda": ["L4", "B200"]}, num_cards=1)
 @pytest.mark.parametrize(
     "omni_server",
     tts_async_chunk_server_params + tts_no_async_chunk_server_params,
@@ -99,7 +99,7 @@ def test_voice_clone_streaming_001(omni_server, online_client) -> None:
     online_client.send_audio_speech_request(request_config, request_num=get_max_batch_size("few"))
 
 
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@hardware_test(res={"cuda": ["L4", "B200"]}, num_cards=1)
 @pytest.mark.parametrize(
     "omni_server",
     tts_async_chunk_server_params + tts_no_async_chunk_server_params,
@@ -127,7 +127,7 @@ def test_response_format_001(omni_server, online_client) -> None:
     online_client.send_audio_speech_request(request_config)
 
 
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@hardware_test(res={"cuda": ["L4", "B200"]}, num_cards=1)
 @pytest.mark.parametrize("omni_server", tts_async_chunk_server_params, indirect=True)
 def test_xvector_then_icl_same_ref_audio_keeps_engine_alive(omni_server, online_client) -> None:
     """Regression for #5049: x-vector-only then ICL on the same ``ref_audio``.
diff --git a/tests/e2e/online_serving/test_qwen3_tts_customvoice_expansion.py b/tests/e2e/online_serving/test_qwen3_tts_customvoice_expansion.py
index 15198870e..e292ea4e8 100644
--- a/tests/e2e/online_serving/test_qwen3_tts_customvoice_expansion.py
+++ b/tests/e2e/online_serving/test_qwen3_tts_customvoice_expansion.py
@@ -60,7 +60,7 @@ tts_server_params = [
 ]
 
 
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@hardware_test(res={"cuda": ["L4", "B200"]}, num_cards=1)
 @pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
 def test_voice_001(omni_server, online_client) -> None:
     """
@@ -92,7 +92,7 @@ def test_voice_001(omni_server, online_client) -> None:
             raise
 
 
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@hardware_test(res={"cuda": ["L4", "B200"]}, num_cards=1)
 @pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
 def test_voice_002(omni_server, online_client) -> None:
     """
@@ -115,7 +115,7 @@ def test_voice_002(omni_server, online_client) -> None:
     online_client.send_audio_speech_request(request_config)
 
 
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@hardware_test(res={"cuda": ["L4", "B200"]}, num_cards=1)
 @pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
 def test_voice_003(omni_server, online_client) -> None:
     """
@@ -138,7 +138,7 @@ def test_voice_003(omni_server, online_client) -> None:
     online_client.send_audio_speech_request(request_config)
 
 
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@hardware_test(res={"cuda": ["L4", "B200"]}, num_cards=1)
 @pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
 def test_sample_rate_001(omni_server, online_client) -> None:
     """The speech API resamples Qwen3-TTS output from native 24 kHz to 8 kHz."""
@@ -155,7 +155,7 @@ def test_sample_rate_001(omni_server, online_client) -> None:
     online_client.send_audio_speech_request(request_config)
 
 
-@hardware_test(res={"cuda": "L4"}, num_cards=1)
+@hardware_test(res={"cuda": ["L4", "B200"]}, num_cards=1)
 @pytest.mark.parametrize("omni_server", tts_server_params, indirect=True)
 def test_language_001(omni_server, online_client) -> None:
     """
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_qwen_image_expansion.py b/tests/e2e/online_serving/test_qwen_image_expansion.py
index 890b077d2..73e55789e 100644
--- a/tests/e2e/online_serving/test_qwen_image_expansion.py
+++ b/tests/e2e/online_serving/test_qwen_image_expansion.py
@@ -21,8 +21,8 @@ pytestmark = [pytest.mark.diffusion, pytest.mark.full_model]
 
 T2I_PROMPT = "A photo of a cat sitting on a laptop keyboard, digital art style."
 NEGATIVE_PROMPT = "blurry, low quality"
-SINGLE_CARD_FEATURE_MARKS = hardware_marks(res={"cuda": "H100"})
-PARALLEL_FEATURE_MARKS = hardware_marks(res={"cuda": "H100"}, num_cards=2)
+SINGLE_CARD_FEATURE_MARKS = hardware_marks(res={"cuda": ["H100", "B200"]})
+PARALLEL_FEATURE_MARKS = hardware_marks(res={"cuda": ["H100", "B200"]}, num_cards=2)
 
 MODEL_IMAGE = "Qwen/Qwen-Image"
 MODEL_2512 = "Qwen/Qwen-Image-2512"
diff --git a/tests/e2e/online_serving/test_sana_wm.py b/tests/e2e/online_serving/test_sana_wm.py
index 883e4c367..38277f08e 100644
--- a/tests/e2e/online_serving/test_sana_wm.py
+++ b/tests/e2e/online_serving/test_sana_wm.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
 
 """
 Online serving smoke for SANA-WM image-to-video (first-frame I2V via ``/v1/videos``).
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/e2e/online_serving/test_voxcpm2_tts_lora.py b/tests/e2e/online_serving/test_voxcpm2_tts_lora.py
new file mode 100644
index 000000000..37efbea37
--- /dev/null
+++ b/tests/e2e/online_serving/test_voxcpm2_tts_lora.py
@@ -0,0 +1,106 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Serve a native VoxCPM2 adapter through the speech API."""
+
+import json
+from pathlib import Path
+
+import pytest
+import torch
+import yaml
+from huggingface_hub import hf_hub_download
+from safetensors import safe_open
+from safetensors.torch import save_file
+
+from tests.helpers.fixtures.runtime import omni_fixture_lock
+from tests.helpers.mark import hardware_test
+from tests.helpers.runtime import OmniServerParams, get_model_prefix, iter_omni_server
+from tests.helpers.stage_config import get_deploy_config_path
+
+pytestmark = [pytest.mark.slow, pytest.mark.tts]
+MODEL = "openbmb/VoxCPM2"
+
+
+@pytest.fixture(scope="module")
+def omni_server(request, run_level, tmp_path_factory):
+    directory = tmp_path_factory.mktemp("voxcpm2-lora")
+    model = get_model_prefix() + MODEL
+    weights = Path(model) / "model.safetensors"
+    if not weights.is_file():
+        weights = Path(hf_hub_download(MODEL, "model.safetensors"))
+    projections = ["enc_to_lm_proj", "lm_to_dit_proj", "res_to_dit_proj", "fusion_concat_proj"]
+    generator = torch.Generator().manual_seed(42)
+    tensors = {}
+    with safe_open(weights, framework="pt", device="cpu") as checkpoint:
+        for key in checkpoint.keys():
+            if not key.endswith(".weight"):
+                continue
+            name = key.removesuffix(".weight")
+            attention = name.startswith(("base_lm.", "residual_lm.", "feat_decoder.estimator.")) and name.rsplit(
+                ".", 1
+            )[-1] in {"q_proj", "k_proj", "v_proj", "o_proj"}
+            if not attention and name not in projections:
+                continue
+            out_features, in_features = checkpoint.get_slice(key).get_shape()
+            # Small nonzero deltas exercise every group without retraining a voice.
+            tensors[f"{name}.lora_A"] = torch.randn(2, in_features, generator=generator) * 0.001
+            tensors[f"{name}.lora_B"] = torch.randn(out_features, 2, generator=generator) * 0.001
+    assert tensors
+    save_file(tensors, str(directory / "lora_weights.safetensors"))
+    (directory / "lora_config.json").write_text(
+        json.dumps({"lora_config": {"r": 2, "alpha": 2, "enable_lm": True, "enable_dit": True, "enable_proj": True}})
+    )
+
+    with open(get_deploy_config_path("voxcpm2.yaml")) as stream:
+        config = yaml.safe_load(stream)
+    stage = config["stages"][0]
+    stage.update(
+        max_num_seqs=4,
+        kv_cache_memory_bytes=1024**3,
+        gpu_memory_utilization=0.65,
+        max_model_len=2048,
+        max_num_batched_tokens=2048,
+    )
+    stage["default_sampling_params"]["max_tokens"] = 256
+    runtime = stage["engine_extras"]["hf_overrides"]["voxcpm2_runtime_config"]
+    runtime.update(startup_lora_path=str(directory), unified_decode_graph_max_batch_size=4)
+    deploy_path = directory / "deploy.yaml"
+    deploy_path.write_text(yaml.safe_dump(config))
+    request.param = OmniServerParams(
+        model=MODEL,
+        stage_config_path=str(deploy_path),
+        server_args=["--trust-remote-code", "--disable-log-stats"],
+    )
+    yield from iter_omni_server(request, run_level, omni_fixture_lock)
+
+
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+def test_startup_lora_concurrent_speech(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": "default",
+            "response_format": "wav",
+            "stream": False,
+            "timeout": 300,
+            "min_audio_bytes": 40_000,
+        },
+        request_num=4,
+    )
+
+
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+def test_startup_lora_streaming_speech(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": "default",
+            "response_format": "wav",
+            "stream": True,
+            "stream_format": "audio",
+            "timeout": 300,
+            "min_audio_bytes": 40_000,
+        }
+    )
diff --git a/tests/e2e/online_serving/test_voxtral_tts_expansion.py b/tests/e2e/online_serving/test_voxtral_tts_expansion.py
index 278e563e8..40d419a91 100644
--- a/tests/e2e/online_serving/test_voxtral_tts_expansion.py
+++ b/tests/e2e/online_serving/test_voxtral_tts_expansion.py
@@ -12,11 +12,14 @@ import os
 os.environ.setdefault("VLLM_WORKER_MULTIPROC_METHOD", "spawn")
 
 import pytest
+from openai import BadRequestError as OpenAIBadRequestError
 
 from tests.helpers.mark import hardware_test
+from tests.helpers.media import generate_synthetic_audio
 from tests.helpers.runtime import OmniServerParams
 from tests.helpers.stage_config import get_deploy_config_path
 
+# Note this model is the public checkpoint without the encoder weights required for voice cloning
 MODEL = "mistralai/Voxtral-4B-TTS-2603"
 STAGE_CONFIG = get_deploy_config_path("voxtral_tts.yaml")
 EXTRA_ARGS = ["--trust-remote-code", "--enforce-eager", "--disable-log-stats"]
@@ -173,3 +176,21 @@ def test_speech_batches(omni_server, online_client) -> None:
             "timeout": 120.0,
         }
     )
+
+
+@hardware_test(res={"cuda": "L4"}, num_cards=1)
+def test_speech_ref_audio(omni_server, online_client) -> None:
+    """Test ref_audio failure is handled as a BadRequest instead of a RuntimeError"""
+    audio_data = f"data:audio/wav;base64,{generate_synthetic_audio(5, 1)['base64']}"
+    with pytest.raises(OpenAIBadRequestError) as exc_info:
+        online_client.send_audio_speech_request(
+            {
+                "model": omni_server.model,
+                "input": "how are you",
+                "ref_audio": audio_data,
+                "language": "English",
+                "response_format": "wav",
+            }
+        )
+
+    assert exc_info.value.status_code == 400
diff --git a/tests/e2e/online_serving/test_wan22_expansion.py b/tests/e2e/online_serving/test_wan22_expansion.py
index 322cde3cd..8734ddebb 100644
--- a/tests/e2e/online_serving/test_wan22_expansion.py
+++ b/tests/e2e/online_serving/test_wan22_expansion.py
@@ -30,8 +30,8 @@ PROMPT = "Two anthropomorphic cats in comfy boxing gear and bright gloves fight
 NEGATIVE_PROMPT = "low quality, blurry, distorted face, extra limbs, bad anatomy, watermark, logo, text, ugly, deformed, mutated, jpeg artifacts"
 
 # CUDA marks (original matrix, unchanged)
-CUDA_SINGLE_CARD_MARKS = hardware_marks(res={"cuda": "H100"})
-CUDA_PARALLEL_MARKS = hardware_marks(res={"cuda": "H100"}, num_cards=2)
+CUDA_SINGLE_CARD_MARKS = hardware_marks(res={"cuda": ["H100", "B200"]})
+CUDA_PARALLEL_MARKS = hardware_marks(res={"cuda": ["H100", "B200"]}, num_cards=2)
 
 # NPU marks
 NPU_TWO_CARD_MARKS = hardware_marks(res={"npu": "A2"}, num_cards=2)
diff --git a/tests/e2e/online_serving/test_zimage_expansion.py b/tests/e2e/online_serving/test_zimage_expansion.py
index c37a947f4..680cc3910 100644
--- a/tests/e2e/online_serving/test_zimage_expansion.py
+++ b/tests/e2e/online_serving/test_zimage_expansion.py
@@ -19,7 +19,7 @@ import pytest
 from tests.helpers.mark import hardware_marks
 from tests.helpers.runtime import OmniServer, OmniServerParams, OnlineOmniClient
 
-pytestmark = [pytest.mark.diffusion, pytest.mark.full_model]
+pytestmark = [pytest.mark.diffusion, pytest.mark.slow]
 
 MODEL = "Tongyi-MAI/Z-Image-Turbo"
 PROMPT = "A high-detail studio photo of an orange tabby cat sitting on a laptop keyboard."
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/entrypoints/duplex/test_duplex_audio.py b/tests/engine/duplex/test_duplex_audio.py
similarity index 95%
rename from tests/entrypoints/duplex/test_duplex_audio.py
rename to tests/engine/duplex/test_duplex_audio.py
index d0be02072..ca358abb0 100644
--- a/tests/entrypoints/duplex/test_duplex_audio.py
+++ b/tests/engine/duplex/test_duplex_audio.py
@@ -6,7 +6,7 @@ import base64
 import numpy as np
 import pytest
 
-from vllm_omni.entrypoints.duplex.audio import convert_input_audio_with_rate
+from vllm_omni.engine.duplex.audio import convert_input_audio_with_rate
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
diff --git a/tests/engine/duplex/test_duplex_commands.py b/tests/engine/duplex/test_duplex_commands.py
new file mode 100644
index 000000000..ad45c8355
--- /dev/null
+++ b/tests/engine/duplex/test_duplex_commands.py
@@ -0,0 +1,453 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""OpenAI Realtime client events -> typed ``DuplexCommand`` objects and their mailbox payloads."""
+
+from __future__ import annotations
+
+import base64
+
+import numpy as np
+import pytest
+
+from vllm_omni.engine.duplex.commands import (
+    REALTIME_COMMAND_TYPES,
+    AckPlayback,
+    AppendAudio,
+    AppendText,
+    BargeIn,
+    CancelInput,
+    CancelResponse,
+    ClearInput,
+    ClearOutputAudio,
+    CloseSession,
+    Commit,
+    CreateItem,
+    CreateResponse,
+    DeleteItem,
+    DuplexCommand,
+    DuplexCommandError,
+    Heartbeat,
+    SignalTurn,
+    TruncateItem,
+    UpdateSession,
+    command_from_realtime,
+)
+from vllm_omni.engine.duplex.realtime_commands import (
+    RealtimeInputDefaults,
+    translate_realtime_command,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+_LOUD_PCM16 = base64.b64encode(b"\x00\x10" * 8).decode("ascii")
+_SILENT_PCM16 = base64.b64encode(b"\x00\x00" * 8).decode("ascii")
+_JPEG_FRAME = base64.b64encode(b"\xff\xd8\xff\xe0" + b"\x00" * 12).decode("ascii")
+
+_MINIMAL_PAYLOADS: dict[str, tuple[dict[str, object], type[DuplexCommand]]] = {
+    "input_audio_buffer.append": ({"audio": _LOUD_PCM16}, AppendAudio),
+    "input_audio_buffer.commit": ({}, Commit),
+    "input_audio_buffer.clear": ({}, ClearInput),
+    "output_audio_buffer.clear": ({}, ClearOutputAudio),
+    "response.create": ({}, CreateResponse),
+    "response.cancel": ({}, CancelResponse),
+    "conversation.item.create": ({"item": {"type": "message", "role": "user", "content": []}}, CreateItem),
+    "conversation.item.delete": ({"item_id": "item_1"}, DeleteItem),
+    "conversation.item.truncate": ({"item_id": "item_1", "audio_end_ms": 100}, TruncateItem),
+    "session.update": ({"session": {"instructions": "hi"}}, UpdateSession),
+    "playback.ack": ({"played_ms": 10}, AckPlayback),
+    "session.heartbeat": ({}, Heartbeat),
+    "session.close": ({}, CloseSession),
+    "turn.signal": ({"event": "user_started"}, SignalTurn),
+    "input.text.append": ({"text": "hello"}, AppendText),
+    "input.cancel": ({}, CancelInput),
+    "barge_in": ({}, BargeIn),
+}
+
+
+def test_every_realtime_command_type_has_a_mapping_case():
+    assert set(_MINIMAL_PAYLOADS) == set(REALTIME_COMMAND_TYPES)
+
+
+@pytest.mark.parametrize("event_type", sorted(REALTIME_COMMAND_TYPES))
+def test_command_from_realtime_maps_each_type_to_its_dataclass_and_propagates_event_id(event_type: str):
+    body, expected_cls = _MINIMAL_PAYLOADS[event_type]
+
+    command = command_from_realtime({"type": event_type, "event_id": f"evt-{event_type}", **body})
+
+    assert type(command) is expected_cls
+    assert command.event_id == f"evt-{event_type}"
+    payload = command.payload()
+    assert payload["type"] == expected_cls.type
+    assert payload["realtime_event_id"] == f"evt-{event_type}"
+    assert "event_id" not in payload
+
+    anonymous = command_from_realtime({"type": event_type, **body})
+    assert anonymous.event_id is None
+    assert "realtime_event_id" not in anonymous.payload()
+
+
+@pytest.mark.parametrize(
+    ("alias", "expected_cls", "body"),
+    [
+        ("push_text", AppendText, {"text": "hello"}),
+        ("input_text.append", AppendText, {"text": "hello"}),
+        ("signal_turn", SignalTurn, {"event": "user_started"}),
+        ("close_session", CloseSession, {}),
+        ("close", CloseSession, {}),
+        ("audio.playback_ack", AckPlayback, {"played_ms": 10}),
+        ("input.commit", Commit, {}),
+    ],
+)
+def test_pre_realtime_client_event_aliases_map_to_their_canonical_command(
+    alias: str, expected_cls: type[DuplexCommand], body: dict[str, object]
+):
+    assert type(command_from_realtime({"type": alias, **body})) is expected_cls
+
+
+def test_append_audio_decodes_and_converts_pcm16_to_16k_float32():
+    command = command_from_realtime(
+        {"type": "input_audio_buffer.append", "audio": _LOUD_PCM16, "format": "pcm16", "sample_rate_hz": 16000}
+    )
+
+    assert isinstance(command, AppendAudio)
+    assert command.format == "pcm_f32le"
+    assert command.sample_rate_hz == 16000
+    samples = np.frombuffer(command.audio, dtype="<f4")
+    assert samples.shape == (8,)
+    assert np.allclose(samples, 4096 / 32768.0)
+    assert command.is_speech is True
+    assert command.video_frames == ()
+    assert command.duration_ms is None
+    assert command.audio_end_ms is None
+
+
+def test_append_audio_defaults_come_from_the_session_payload():
+    defaults = RealtimeInputDefaults().with_session_payload({"input_audio_format": "pcm16", "sample_rate_hz": 8000})
+    assert defaults.input_audio_format == "pcm16"
+    assert defaults.input_sample_rate_hz == 8000
+
+    command = translate_realtime_command({"type": "input_audio_buffer.append", "audio": _LOUD_PCM16}, defaults=defaults)
+
+    assert isinstance(command, AppendAudio)
+    assert command.format == "pcm_f32le"
+    # 8 kHz input is resampled to the model's 16 kHz float stream.
+    assert command.sample_rate_hz == 16000
+    assert len(command.audio) > 8 * 4
+
+    passthrough = translate_realtime_command(
+        {"type": "input_audio_buffer.append", "audio": base64.b64encode(np.zeros(4, dtype="<f4").tobytes()).decode()},
+        defaults=RealtimeInputDefaults(input_audio_format="pcm_f32le", input_sample_rate_hz=16000),
+    )
+    assert passthrough.format == "pcm_f32le"
+    assert passthrough.audio == np.zeros(4, dtype="<f4").tobytes()
+
+
+def test_append_audio_speech_classification_uses_hints_then_rms():
+    silent = command_from_realtime({"type": "input_audio_buffer.append", "audio": _SILENT_PCM16})
+    assert silent.is_speech is False
+
+    forced = command_from_realtime({"type": "input_audio_buffer.append", "audio": _SILENT_PCM16, "is_speech": True})
+    assert forced.is_speech is True
+    assert forced.hints == {"is_speech": True}
+
+    vad = command_from_realtime(
+        {"type": "input_audio_buffer.append", "audio": _LOUD_PCM16, "vad": {"speech_probability": 0.1}}
+    )
+    assert vad.is_speech is False
+    assert vad.hints["vad"] == {"speech_probability": 0.1}
+
+
+def test_append_audio_carries_wire_hints_and_video_frames():
+    command = command_from_realtime(
+        {
+            "type": "input_audio_buffer.append",
+            "event_id": "evt-append",
+            "audio": _LOUD_PCM16,
+            "transcript": "hi there",
+            "duration_ms": 1000,
+            "audio_end_ms": 3000,
+            "video_frames": [_JPEG_FRAME],
+            "unknown_key": "dropped",
+        }
+    )
+
+    assert isinstance(command, AppendAudio)
+    assert command.duration_ms == 1000
+    assert command.audio_end_ms == 3000
+    assert command.video_frames == (_JPEG_FRAME,)
+    assert dict(command.hints) == {"transcript": "hi there", "duration_ms": 1000, "audio_end_ms": 3000}
+
+    payload = command.payload()
+    assert payload["type"] == "input_audio_buffer.append"
+    assert payload["realtime_event_id"] == "evt-append"
+    assert payload["audio"] == base64.b64encode(command.audio).decode("ascii")
+    assert payload["format"] == "pcm_f32le"
+    assert payload["sample_rate_hz"] == 16000
+    assert payload["is_speech"] is True
+    assert payload["transcript"] == "hi there"
+    assert payload["duration_ms"] == 1000
+    assert payload["audio_end_ms"] == 3000
+    assert payload["video_frames"] == [_JPEG_FRAME]
+    assert "hints" not in payload
+    assert "unknown_key" not in payload
+
+
+def test_append_audio_payload_re_encodes_bytes_and_flattens_hints():
+    command = AppendAudio(audio=b"\x01\x02", hints={"vad": {"is_speech": True}}, is_speech=True)
+
+    assert command.payload() == {
+        "type": "input_audio_buffer.append",
+        "audio": "AQI=",
+        "format": "pcm16",
+        "is_speech": True,
+        "vad": {"is_speech": True},
+    }
+
+
+@pytest.mark.parametrize(
+    ("body", "code"),
+    [
+        ({"audio": _LOUD_PCM16, "format": "mp3"}, "unsupported_audio_format"),
+        ({"audio": "@@@@", "format": "pcm_f32le"}, "bad_audio"),
+        ({"audio": _LOUD_PCM16, "video_frames": ["aGVsbG8="]}, "invalid_video_frames"),
+        ({"audio": _LOUD_PCM16, "video_frames": [_JPEG_FRAME], "max_slice_nums": 4}, "invalid_video_frames"),
+        ({"audio": _LOUD_PCM16, "format": "pcm16", "sample_rate_hz": 3}, "bad_event"),
+    ],
+)
+def test_malformed_append_raises_command_error_with_code(body: dict[str, object], code: str):
+    with pytest.raises(DuplexCommandError) as excinfo:
+        command_from_realtime({"type": "input_audio_buffer.append", "event_id": "evt-bad", **body})
+
+    assert excinfo.value.code == code
+    assert excinfo.value.event_id == "evt-bad"
+
+
+# ---- other malformed payloads ----
+
+
+@pytest.mark.parametrize(
+    ("payload", "code"),
+    [
+        ({}, "bad_event"),
+        ({"type": 7}, "bad_event"),
+        ({"type": "session.resume", "session_id": "s", "resume_token": "t"}, "unknown_event"),
+        ({"type": "session.event_ack", "server_event_seq": 1}, "unknown_event"),
+        ({"type": "conversation.item.frobnicate", "item_id": "item_1"}, "unknown_event"),
+        ({"type": "conversation.item.create"}, "bad_event"),
+        (
+            {
+                "type": "conversation.item.create",
+                "item": {"type": "message", "role": "user", "content": [{"type": "input_audio", "format": "mp3"}]},
+            },
+            "unsupported_audio_format",
+        ),
+        ({"type": "conversation.item.delete"}, "missing_item_id"),
+        ({"type": "conversation.item.truncate", "audio_end_ms": 1}, "missing_item_id"),
+        ({"type": "conversation.item.truncate", "item_id": "item_1"}, "bad_event"),
+        ({"type": "session.update", "session": {"output_audio_format": "opus"}}, "unsupported_audio_format"),
+        (
+            {"type": "session.update", "session": {"turn_detection": {"type": "semantic_vad"}}},
+            "unsupported_turn_detection",
+        ),
+        ({"type": "response.create", "response": {"output_audio_format": "opus"}}, "unsupported_audio_format"),
+        ({"type": "playback.ack"}, "bad_event"),
+        ({"type": "input.text.append"}, "bad_event"),
+        ({"type": "turn.signal"}, "bad_event"),
+        ({"type": "turn.signal", "event": "conversation.item.delete", "payload": {}}, "missing_item_id"),
+        ({"type": "turn.signal", "event": "conversation.item.truncate", "payload": {"item_id": "i"}}, "bad_event"),
+    ],
+)
+def test_malformed_payloads_raise_command_error_with_code(payload: dict[str, object], code: str):
+    with pytest.raises(DuplexCommandError) as excinfo:
+        command_from_realtime({"event_id": "evt-bad", **payload})
+
+    assert excinfo.value.code == code
+    assert excinfo.value.event_id == "evt-bad"
+
+
+# ---- payload() rendering ----
+
+
+def test_commit_maps_create_response_to_response_create():
+    command = command_from_realtime(
+        {"type": "input_audio_buffer.commit", "event_id": "evt-commit", "response_create": True, "final": False}
+    )
+
+    assert command == Commit(event_id="evt-commit", final=False, create_response=True)
+    assert command.payload() == {
+        "type": "input_audio_buffer.commit",
+        "realtime_event_id": "evt-commit",
+        "final": False,
+        "response_create": True,
+    }
+    assert Commit().payload() == {"type": "input_audio_buffer.commit", "final": True}
+    assert Commit(is_speech=False, realtime_item_id="item_1").payload() == {
+        "type": "input_audio_buffer.commit",
+        "final": True,
+        "is_speech": False,
+        "realtime_item_id": "item_1",
+    }
+    assert (
+        command_from_realtime({"type": "input_audio_buffer.commit", "create_response": False}).create_response is False
+    )
+
+
+def test_create_response_renders_options_as_response_object():
+    command = command_from_realtime({"type": "response.create", "response": {"modalities": ["text"]}})
+
+    assert isinstance(command, CreateResponse)
+    assert dict(command.options) == {"modalities": ["text"]}
+    assert command.payload() == {"type": "response.create", "response": {"modalities": ["text"]}}
+    assert command_from_realtime({"type": "response.create"}).payload() == {"type": "response.create", "response": {}}
+
+
+def test_cancel_and_clear_commands_keep_optional_response_id():
+    assert command_from_realtime({"type": "response.cancel", "response_id": ""}).response_id is None
+    cancel = command_from_realtime({"type": "response.cancel", "response_id": "resp_1"})
+    assert cancel == CancelResponse(response_id="resp_1")
+    assert cancel.payload() == {"type": "response.cancel", "response_id": "resp_1"}
+    clear = command_from_realtime({"type": "output_audio_buffer.clear", "response_id": "resp_2"})
+    assert clear == ClearOutputAudio(response_id="resp_2")
+    assert ClearInput().payload() == {"type": "input_audio_buffer.clear"}
+
+
+def test_update_session_renders_as_turn_signal_payload():
+    command = command_from_realtime(
+        {"type": "session.update", "session": {"instructions": "be brief", "voice": "alloy"}}
+    )
+
+    assert command == UpdateSession(patch={"instructions": "be brief", "voice": "alloy"})
+    assert command.payload() == {
+        "type": "turn.signal",
+        "event": "session.update",
+        "payload": {"instructions": "be brief", "voice": "alloy"},
+    }
+
+
+def test_create_item_normalizes_item_and_renders_as_turn_signal_payload():
+    command = command_from_realtime(
+        {
+            "type": "conversation.item.create",
+            "previous_item_id": "item_0",
+            "item": {"type": "message", "role": "assistant", "content": [{"type": "text", "text": "hi"}]},
+        }
+    )
+
+    assert isinstance(command, CreateItem)
+    assert command.previous_item_id == "item_0"
+    assert command.item["id"].startswith("item_")
+    assert command.item["object"] == "realtime.item"
+    assert command.item["status"] == "completed"
+    payload = command.payload()
+    assert payload["type"] == "turn.signal"
+    assert payload["event"] == "conversation.item.create"
+    assert payload["payload"] == {"item": dict(command.item), "previous_item_id": "item_0"}
+    assert "item" not in payload
+    assert "previous_item_id" not in payload
+
+    without_previous = command_from_realtime({"type": "conversation.item.create", "item": {"content": "x"}})
+    assert without_previous.item["role"] == "user"
+    assert without_previous.item["content"] == []
+    assert without_previous.payload()["payload"] == {"item": dict(without_previous.item)}
+
+
+def test_delete_and_truncate_render_as_turn_signal_payloads():
+    delete = command_from_realtime({"type": "conversation.item.delete", "item_id": "item_1"})
+    assert delete == DeleteItem(item_id="item_1")
+    assert delete.payload() == {
+        "type": "turn.signal",
+        "event": "conversation.item.delete",
+        "payload": {"item_id": "item_1"},
+    }
+
+    truncate = command_from_realtime(
+        {"type": "conversation.item.truncate", "item_id": "item_1", "audio_end_ms": 1500.0, "content_index": 1}
+    )
+    assert truncate == TruncateItem(item_id="item_1", audio_end_ms=1500, content_index=1)
+    assert truncate.payload() == {
+        "type": "turn.signal",
+        "event": "conversation.item.truncate",
+        "payload": {"item_id": "item_1", "audio_end_ms": 1500, "content_index": 1},
+    }
+
+
+def test_playback_ack_close_and_text_append_payloads():
+    ack = command_from_realtime(
+        {"type": "playback.ack", "played_ms": 1200.0, "committed_ms": 1000, "response_id": "resp_1", "item_id": ""}
+    )
+    assert ack == AckPlayback(played_ms=1200, committed_ms=1000, response_id="resp_1")
+    assert ack.payload() == {
+        "type": "playback.ack",
+        "played_ms": 1200,
+        "committed_ms": 1000,
+        "response_id": "resp_1",
+    }
+
+    assert command_from_realtime({"type": "session.close"}) == CloseSession(reason="client_close")
+    assert command_from_realtime({"type": "session.close", "reason": "done"}).payload() == {
+        "type": "session.close",
+        "reason": "done",
+    }
+    assert command_from_realtime({"type": "input.text.append", "text": "hello"}).payload() == {
+        "type": "input.text.append",
+        "text": "hello",
+    }
+    assert Heartbeat().payload() == {"type": "session.heartbeat"}
+
+
+def test_turn_signal_renders_payload_only_when_present_and_dispatches_known_events():
+    signal = command_from_realtime({"type": "turn.signal", "event": "user_started", "payload": {"source": "client"}})
+    assert signal == SignalTurn(event="user_started", signal_payload={"source": "client"})
+    assert signal.payload() == {"type": "turn.signal", "event": "user_started", "payload": {"source": "client"}}
+    assert command_from_realtime({"type": "turn.signal", "event": "user_started"}).payload() == {
+        "type": "turn.signal",
+        "event": "user_started",
+    }
+
+    assert command_from_realtime({"type": "turn.signal", "event": "barge_in"}) == BargeIn()
+    assert command_from_realtime({"type": "turn.signal", "event": "input.cancel"}) == CancelInput()
+    assert command_from_realtime(
+        {"type": "turn.signal", "event": "response.cancel", "payload": {"response_id": "resp_1"}}
+    ) == CancelResponse(response_id="resp_1")
+    assert command_from_realtime(
+        {"type": "turn.signal", "event": "session.update", "payload": {"voice": "alloy"}}
+    ) == UpdateSession(patch={"voice": "alloy"})
+    assert command_from_realtime(
+        {"type": "turn.signal", "event": "conversation.item.delete", "payload": {"item_id": "item_1"}}
+    ) == DeleteItem(item_id="item_1")
+    assert command_from_realtime(
+        {"type": "turn.signal", "event": "conversation.item.truncate", "payload": {"item_id": "i", "audio_end_ms": 5}}
+    ) == TruncateItem(item_id="i", audio_end_ms=5)
+    created = command_from_realtime(
+        {"type": "turn.signal", "event": "conversation.item.create", "payload": {"item": {"role": "system"}}}
+    )
+    assert isinstance(created, CreateItem)
+    assert created.item["role"] == "system"
+
+
+def test_raw_wire_hints_cannot_override_the_normalized_typed_fields():
+    """``build_append_audio`` normalizes; a client's raw value must not undo it.
+
+    A wire ``"is_speech": 0`` used to land in ``hints`` and overwrite the
+    computed ``bool | None`` in the rendered payload, so the runner's
+    silent-commit fast path (``event.get("is_speech") is False``) missed and
+    overlap classification followed the unvalidated value.
+    """
+    command = AppendAudio(
+        audio=b"\x00\x00" * 8,
+        is_speech=False,
+        hints={"is_speech": 0, "rms": 0.001},
+    )
+
+    payload = command.payload()
+
+    assert payload["is_speech"] is False, "the normalized field wins over the raw hint"
+    assert payload["rms"] == 0.001, "a hint with no typed counterpart still comes through"
+
+
+def test_a_hint_survives_when_its_typed_field_is_unset():
+    """Unset typed fields are absent from the payload, so the hint is the only value."""
+    command = AppendAudio(audio=b"\x00\x00" * 8, hints={"is_speech": True})
+
+    assert command.payload()["is_speech"] is True
diff --git a/tests/engine/duplex/test_duplex_control_client.py b/tests/engine/duplex/test_duplex_control_client.py
deleted file mode 100644
index 7974b14c9..000000000
--- a/tests/engine/duplex/test_duplex_control_client.py
+++ /dev/null
@@ -1,110 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-from __future__ import annotations
-
-import pytest
-
-from vllm_omni.engine.duplex.control_client import (
-    DuplexControlClient,
-    DuplexControlRequestError,
-)
-from vllm_omni.engine.duplex.lease import DuplexLeaseActivity
-from vllm_omni.engine.duplex.messages import (
-    DuplexControlError,
-    DuplexControlResultMessage,
-    DuplexFence,
-    ResumeDuplexSessionMessage,
-    TouchDuplexSessionMessage,
-)
-
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
-
-
-class _Transport:
-    def __init__(self) -> None:
-        self.calls = []
-
-    def execute(self, key, message, **kwargs):
-        self.calls.append((key, message, kwargs))
-        return DuplexControlResultMessage(
-            control_id=message.control_id,
-            fence=message.fence,
-            operation="touch" if isinstance(message, TouchDuplexSessionMessage) else "resume",
-            session_id=message.session_id,
-            ok=True,
-            stage_results=[],
-        )
-
-
-class _UnsupportedTransport:
-    def execute(self, key, message, **kwargs):
-        del key, kwargs
-        return DuplexControlResultMessage(
-            control_id=message.control_id,
-            fence=message.fence,
-            operation="touch",
-            session_id=message.session_id,
-            ok=False,
-            stage_results=[{"result": {"supported": False}}],
-            unsupported_count=1,
-            error=DuplexControlError(code="invalid_capability", message="unsupported", retryable=False),
-            accepted_fence=DuplexFence(message.session_id, epoch=2),
-            lease_generation=7,
-        )
-
-
-def test_control_client_routes_touch_and_resume_by_control_id() -> None:
-    transport = _Transport()
-    control_ids = iter(("touch-id", "resume-id"))
-    client = DuplexControlClient(transport, control_id_factory=lambda: next(control_ids))
-    fence = DuplexFence("sid-client")
-
-    assert (
-        client.touch(
-            fence.session_id,
-            fence=fence,
-            activity=DuplexLeaseActivity.PLAYBACK_ACK,
-            timeout=2.0,
-        )["ok"]
-        is True
-    )
-    assert (
-        client.resume(
-            fence.session_id,
-            fence=fence,
-            expected_lease_generation=7,
-            timeout=3.0,
-        )["ok"]
-        is True
-    )
-
-    touch_key, touch_message, touch_kwargs = transport.calls[0]
-    assert touch_key == ("duplex", "touch-id")
-    assert isinstance(touch_message, TouchDuplexSessionMessage)
-    assert touch_message.activity == DuplexLeaseActivity.PLAYBACK_ACK.value
-    assert touch_kwargs["timeout"] == 2.0
-
-    resume_key, resume_message, resume_kwargs = transport.calls[1]
-    assert resume_key == ("duplex", "resume-id")
-    assert isinstance(resume_message, ResumeDuplexSessionMessage)
-    assert resume_message.expected_lease_generation == 7
-    assert resume_kwargs["timeout"] == 3.0
-
-
-def test_control_client_treats_ok_false_as_authoritative_failure() -> None:
-    client = DuplexControlClient(_UnsupportedTransport(), control_id_factory=lambda: "unsupported")
-    fence = DuplexFence("sid-unsupported")
-
-    with pytest.raises(DuplexControlRequestError, match="duplex touch failed") as exc_info:
-        client.touch(
-            fence.session_id,
-            fence=fence,
-            activity=DuplexLeaseActivity.HEARTBEAT,
-            timeout=1.0,
-        )
-
-    assert exc_info.value.code == "invalid_capability"
-    assert exc_info.value.retryable is False
-    assert exc_info.value.accepted_fence == DuplexFence(fence.session_id, epoch=2)
-    assert exc_info.value.lease_generation == 7
diff --git a/tests/engine/duplex/test_duplex_control_plane.py b/tests/engine/duplex/test_duplex_control_plane.py
deleted file mode 100644
index 14da4d21c..000000000
--- a/tests/engine/duplex/test_duplex_control_plane.py
+++ /dev/null
@@ -1,1270 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-from __future__ import annotations
-
-import asyncio
-import logging
-from dataclasses import FrozenInstanceError
-
-import msgspec
-import pytest
-
-from vllm_omni.engine.duplex.control_plane import (
-    DuplexControlPlane,
-    DuplexOutputContext,
-    DuplexRequestIdentity,
-    DuplexStageRequestContext,
-    DuplexStageSubmission,
-    DuplexStageSubmissionResult,
-)
-from vllm_omni.engine.duplex.lease import DuplexLeaseActivity, DuplexLeaseConfig
-from vllm_omni.engine.duplex.messages import (
-    AppendDuplexInputMessage,
-    CloseDuplexSessionMessage,
-    DuplexFence,
-    DuplexSessionLifecycleMessage,
-    OpenDuplexSessionMessage,
-    ResumeDuplexSessionMessage,
-    SignalDuplexTurnMessage,
-    TouchDuplexSessionMessage,
-)
-from vllm_omni.engine.duplex.runtime import (
-    DuplexAppendPlan,
-    DuplexInputMode,
-    DuplexRuntimeCapabilities,
-)
-
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
-
-
-class _Extension:
-    def configure_sampling_params(self, *, runtime_config, defaults):
-        del runtime_config
-        return tuple(f"configured-{stage_id}" for stage_id, _ in enumerate(defaults))
-
-    def plan_append(
-        self,
-        *,
-        request_id,
-        fence,
-        session_config,
-        runtime_config,
-        seq,
-        turn_seq,
-        mode,
-        payload,
-        final,
-        sampling_params,
-    ):
-        del request_id, fence, session_config, runtime_config, seq, turn_seq, mode, payload, final
-        assert sampling_params == "configured-0"
-        return DuplexAppendPlan(prompt={"prompt_token_ids": [1, 2, 3]})
-
-    def decide_output(self, **kwargs):
-        del kwargs
-        return None
-
-
-class _TypedStagePort:
-    stage_count = 2
-
-    def __init__(self) -> None:
-        self.ensure_calls: list[DuplexStageRequestContext] = []
-        self.submit_calls: list[DuplexStageSubmission] = []
-        self.cleanup_calls: list[tuple[list[str], bool]] = []
-
-    def sampling_defaults(self) -> tuple[object, ...]:
-        return ("default-0", "default-1")
-
-    def ensure_request(self, context: DuplexStageRequestContext) -> None:
-        self.ensure_calls.append(context)
-
-    async def submit(self, submission: DuplexStageSubmission) -> DuplexStageSubmissionResult:
-        self.submit_calls.append(submission)
-        return DuplexStageSubmissionResult(
-            request_id=submission.context.request_id,
-            stage_id=submission.context.stage_id,
-            replica_id=3,
-        )
-
-    async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
-        self.cleanup_calls.append((request_ids, abort))
-
-
-class _Clock:
-    def __init__(self) -> None:
-        self.value = 0.0
-
-    def __call__(self) -> float:
-        return self.value
-
-    def advance(self, seconds: float) -> None:
-        self.value += seconds
-
-
-@pytest.mark.asyncio
-async def test_control_plane_uses_frozen_typed_stage_context_without_request_state() -> None:
-    stage_port = _TypedStagePort()
-    result_sink: asyncio.Queue = asyncio.Queue()
-    plane = DuplexControlPlane(
-        extension=_Extension(),
-        stage_port=stage_port,
-        result_sink=result_sink,
-    )
-    fence = DuplexFence("typed-port")
-
-    await plane.handle(
-        OpenDuplexSessionMessage(
-            control_id="open",
-            fence=fence,
-            session_id=fence.session_id,
-            capabilities={
-                "input_modes": [DuplexInputMode.APPEND_AUDIO_CHUNK.value],
-            },
-            session_config={"voice": "test"},
-            runtime_config={"runtime": "test"},
-        )
-    )
-    assert (await result_sink.get()).ok is True
-
-    context = stage_port.ensure_calls[-1]
-    assert context.session_id == fence.session_id
-    assert context.fence == fence
-    assert context.stage_id == 0
-    assert context.final_stage_id == 1
-    assert context.sampling_params == ("configured-0", "configured-1")
-    assert context.session_config == {"voice": "test"}
-    assert context.runtime_config == {"runtime": "test"}
-    with pytest.raises(FrozenInstanceError):
-        context.stage_id = 1  # type: ignore[misc]
-
-    await plane.handle(
-        AppendDuplexInputMessage(
-            control_id="append",
-            fence=fence,
-            session_id=fence.session_id,
-            mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
-            payload={"audio": b"pcm"},
-            final=True,
-        )
-    )
-    append_result = await result_sink.get()
-    assert append_result.ok is True
-    assert append_result.stage_results[0]["replica_id"] == 3
-    assert append_result.stage_results[0]["result"]["response_stage_id"] == 1
-
-    submission = stage_port.submit_calls[-1]
-    assert submission.context == stage_port.ensure_calls[-1]
-    assert submission.prompt == {"prompt_token_ids": [1, 2, 3]}
-    assert submission.already_submitted is False
-    assert not hasattr(submission, "request_state")
-
-
-def test_control_plane_accepts_only_typed_duplex_messages() -> None:
-    plane = DuplexControlPlane(
-        extension=None,
-        stage_port=_TypedStagePort(),
-        result_sink=asyncio.Queue(),
-    )
-
-    assert plane.accepts(
-        OpenDuplexSessionMessage(
-            control_id="open",
-            fence=DuplexFence("typed-message"),
-            session_id="typed-message",
-            capabilities=DuplexRuntimeCapabilities().__dict__,
-        )
-    )
-    assert plane.accepts(type("Lookalike", (), {"type": "open_duplex_session"})()) is False
-
-
-@pytest.mark.parametrize(
-    "message",
-    [
-        TouchDuplexSessionMessage(
-            control_id="touch-1",
-            fence=DuplexFence("sid-message"),
-            session_id="sid-message",
-            activity=DuplexLeaseActivity.HEARTBEAT.value,
-        ),
-        ResumeDuplexSessionMessage(
-            control_id="resume-1",
-            fence=DuplexFence("sid-message"),
-            session_id="sid-message",
-            expected_lease_generation=3,
-        ),
-        DuplexSessionLifecycleMessage(
-            fence=DuplexFence("sid-message"),
-            session_id="sid-message",
-            event="expired",
-            reason="idle_ttl_expired",
-            lease_generation=4,
-            submitted_request_ids=["req-submitted"],
-            reserved_request_ids=["req-reserved"],
-        ),
-    ],
-)
-def test_duplex_lease_messages_round_trip(message) -> None:
-    encoded = msgspec.json.encode(message)
-    decoded = msgspec.json.decode(encoded, type=type(message))
-
-    assert decoded == message
-
-
-@pytest.mark.asyncio
-async def test_control_plane_touches_append_signal_and_explicit_activity() -> None:
-    clock = _Clock()
-    stage_port = _TypedStagePort()
-    result_sink: asyncio.Queue = asyncio.Queue()
-    lifecycle_sink: asyncio.Queue = asyncio.Queue()
-    plane = DuplexControlPlane(
-        extension=_Extension(),
-        stage_port=stage_port,
-        result_sink=result_sink,
-        lifecycle_sink=lifecycle_sink,
-        lease_config=DuplexLeaseConfig(idle_ttl_s=30.0, disconnect_grace_s=5.0),
-        clock=clock,
-    )
-    fence = DuplexFence("sid-touch")
-    await plane.handle(
-        OpenDuplexSessionMessage(
-            control_id="open",
-            fence=fence,
-            session_id=fence.session_id,
-            capabilities={"input_modes": [DuplexInputMode.APPEND_AUDIO_CHUNK.value]},
-        )
-    )
-    await result_sink.get()
-    session = plane.sessions.require(fence.session_id)
-
-    clock.advance(1.0)
-    await plane.handle(
-        AppendDuplexInputMessage(
-            control_id="append",
-            fence=fence,
-            session_id=fence.session_id,
-            mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
-            payload={"audio": b"pcm"},
-        )
-    )
-    assert (await result_sink.get()).ok is True
-    assert session.lease.last_activity == 1.0
-
-    clock.advance(1.0)
-    await plane.handle(
-        SignalDuplexTurnMessage(
-            control_id="signal",
-            fence=fence,
-            session_id=fence.session_id,
-            event="session.update",
-        )
-    )
-    assert (await result_sink.get()).ok is True
-    assert session.lease.last_activity == 2.0
-
-    submit_count = len(stage_port.submit_calls)
-    clock.advance(1.0)
-    await plane.handle(
-        TouchDuplexSessionMessage(
-            control_id="heartbeat",
-            fence=fence,
-            session_id=fence.session_id,
-            activity=DuplexLeaseActivity.HEARTBEAT.value,
-        )
-    )
-    touch_result = await result_sink.get()
-    assert touch_result.ok is True
-    assert session.lease.last_activity == 3.0
-    assert len(stage_port.submit_calls) == submit_count
-    assert lifecycle_sink.empty()
-
-
-@pytest.mark.asyncio
-async def test_control_plane_resume_requires_expected_lease_generation() -> None:
-    clock = _Clock()
-    result_sink: asyncio.Queue = asyncio.Queue()
-    plane = DuplexControlPlane(
-        extension=None,
-        stage_port=_TypedStagePort(),
-        result_sink=result_sink,
-        lifecycle_sink=asyncio.Queue(),
-        lease_config=DuplexLeaseConfig(),
-        clock=clock,
-    )
-    fence = DuplexFence("sid-resume-control")
-    await plane.handle(
-        OpenDuplexSessionMessage(
-            control_id="open",
-            fence=fence,
-            session_id=fence.session_id,
-            capabilities={},
-        )
-    )
-    await result_sink.get()
-    await plane.handle(
-        TouchDuplexSessionMessage(
-            control_id="detach",
-            fence=fence,
-            session_id=fence.session_id,
-            activity=DuplexLeaseActivity.DETACH.value,
-        )
-    )
-    await result_sink.get()
-
-    await plane.handle(
-        ResumeDuplexSessionMessage(
-            control_id="resume",
-            fence=fence,
-            session_id=fence.session_id,
-            expected_lease_generation=0,
-        )
-    )
-    result = await result_sink.get()
-
-    assert result.ok is True
-    assert result.stage_results[0]["result"]["lease_generation"] == 1
-
-    await plane.handle(
-        ResumeDuplexSessionMessage(
-            control_id="stale-resume",
-            fence=fence,
-            session_id=fence.session_id,
-            expected_lease_generation=0,
-        )
-    )
-    stale_result = await result_sink.get()
-    assert stale_result.ok is False
-    assert stale_result.accepted_fence == fence
-    assert stale_result.lease_generation == 1
-
-
-@pytest.mark.asyncio
-async def test_control_plane_reaps_one_session_through_cleanup_and_lifecycle_sink() -> None:
-    clock = _Clock()
-    stage_port = _TypedStagePort()
-    result_sink: asyncio.Queue = asyncio.Queue()
-    lifecycle_sink: asyncio.Queue = asyncio.Queue()
-    plane = DuplexControlPlane(
-        extension=None,
-        stage_port=stage_port,
-        result_sink=result_sink,
-        lifecycle_sink=lifecycle_sink,
-        lease_config=DuplexLeaseConfig(idle_ttl_s=2.0, disconnect_grace_s=1.0),
-        clock=clock,
-    )
-    for session_id in ("sid-a", "sid-b"):
-        fence = DuplexFence(session_id)
-        await plane.handle(
-            OpenDuplexSessionMessage(
-                control_id=f"open-{session_id}",
-                fence=fence,
-                session_id=session_id,
-                capabilities={},
-            )
-        )
-        await result_sink.get()
-    clock.advance(1.0)
-    plane.sessions.require("sid-b").touch(DuplexFence("sid-b"), DuplexLeaseActivity.HEARTBEAT)
-    clock.advance(1.1)
-
-    expired_count = await plane.reap_expired()
-
-    assert expired_count == 1
-    assert plane.sessions.get("sid-a") is None
-    assert plane.sessions.get("sid-b") is not None
-    assert stage_port.cleanup_calls == []
-    lifecycle = await lifecycle_sink.get()
-    assert isinstance(lifecycle, DuplexSessionLifecycleMessage)
-    assert lifecycle.session_id == "sid-a"
-    assert lifecycle.reason == "idle_ttl_expired"
-    assert result_sink.empty()
-
-
-@pytest.mark.asyncio
-async def test_control_plane_retries_expired_cleanup_before_publishing_lifecycle() -> None:
-    class _FailOnceStagePort(_TypedStagePort):
-        def __init__(self) -> None:
-            super().__init__()
-            self.failures_remaining = 1
-
-        async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
-            if self.failures_remaining:
-                self.failures_remaining -= 1
-                raise RuntimeError("transient cleanup failure")
-            await super().cleanup(request_ids, abort=abort)
-
-    clock = _Clock()
-    stage_port = _FailOnceStagePort()
-    result_sink: asyncio.Queue = asyncio.Queue()
-    lifecycle_sink: asyncio.Queue = asyncio.Queue()
-    plane = DuplexControlPlane(
-        extension=None,
-        stage_port=stage_port,
-        result_sink=result_sink,
-        lifecycle_sink=lifecycle_sink,
-        lease_config=DuplexLeaseConfig(idle_ttl_s=1.0, disconnect_grace_s=1.0),
-        clock=clock,
-    )
-    fence = DuplexFence("sid-retry-expiry")
-    await plane.handle(
-        OpenDuplexSessionMessage(
-            control_id="open-retry",
-            fence=fence,
-            session_id=fence.session_id,
-            capabilities={},
-        )
-    )
-    await result_sink.get()
-    request_id = plane.stage_request_id(fence, stage_id=0)
-    plane.sessions.require(fence.session_id).reserve_stage_request(0, request_id, fence=fence)
-    clock.advance(2.0)
-
-    assert await plane.reap_expired() == 0
-    assert lifecycle_sink.empty()
-
-    assert await plane.reap_expired() == 1
-    assert (await lifecycle_sink.get()).session_id == fence.session_id
-
-
-@pytest.mark.asyncio
-async def test_expired_session_holds_admission_slot_while_cleanup_is_blocked() -> None:
-    class _BlockedCleanupStagePort(_TypedStagePort):
-        def __init__(self) -> None:
-            super().__init__()
-            self.cleanup_started = asyncio.Event()
-            self.release_cleanup = asyncio.Event()
-
-        async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
-            self.cleanup_started.set()
-            await self.release_cleanup.wait()
-            await super().cleanup(request_ids, abort=abort)
-
-    clock = _Clock()
-    stage_port = _BlockedCleanupStagePort()
-    result_sink: asyncio.Queue = asyncio.Queue()
-    plane = DuplexControlPlane(
-        extension=None,
-        stage_port=stage_port,
-        result_sink=result_sink,
-        lease_config=DuplexLeaseConfig(idle_ttl_s=1.0, disconnect_grace_s=1.0),
-        clock=clock,
-        max_sessions=1,
-    )
-    old_fence = DuplexFence("sid-expired-blocked")
-    await plane.handle(
-        OpenDuplexSessionMessage(
-            control_id="open-expired-blocked",
-            fence=old_fence,
-            session_id=old_fence.session_id,
-            capabilities={},
-        )
-    )
-    assert (await result_sink.get()).ok is True
-    old_session = plane.sessions.require(old_fence.session_id)
-    old_session.bind_stage_request(0, "req-expired-blocked", fence=old_fence)
-    clock.advance(2.0)
-
-    reap_task = asyncio.create_task(plane.reap_expired())
-    await asyncio.wait_for(stage_port.cleanup_started.wait(), timeout=1.0)
-    replacement_fence = DuplexFence("sid-replacement-blocked")
-    await plane.handle(
-        OpenDuplexSessionMessage(
-            control_id="open-replacement-blocked",
-            fence=replacement_fence,
-            session_id=replacement_fence.session_id,
-            capabilities={},
-        )
-    )
-
-    blocked_result = await result_sink.get()
-    assert blocked_result.ok is False
-    assert blocked_result.error is not None
-    assert blocked_result.error.code == "resource_exhausted"
-    assert plane.sessions.get(old_fence.session_id) is old_session
-
-    stage_port.release_cleanup.set()
-    assert await reap_task == 1
-    assert plane.sessions.get(old_fence.session_id) is None
-
-    await plane.handle(
-        OpenDuplexSessionMessage(
-            control_id="open-replacement-after-cleanup",
-            fence=replacement_fence,
-            session_id=replacement_fence.session_id,
-            capabilities={},
-        )
-    )
-    assert (await result_sink.get()).ok is True
-
-
-@pytest.mark.asyncio
-async def test_failed_expiry_cleanup_retains_admission_slot_for_retry() -> None:
-    class _FailingCleanupStagePort(_TypedStagePort):
-        async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
-            del request_ids, abort
-            raise RuntimeError("cleanup failed")
-
-    clock = _Clock()
-    result_sink: asyncio.Queue = asyncio.Queue()
-    plane = DuplexControlPlane(
-        extension=None,
-        stage_port=_FailingCleanupStagePort(),
-        result_sink=result_sink,
-        lease_config=DuplexLeaseConfig(idle_ttl_s=1.0, disconnect_grace_s=1.0),
-        clock=clock,
-        max_sessions=1,
-    )
-    old_fence = DuplexFence("sid-expired-failed")
-    await plane.handle(
-        OpenDuplexSessionMessage(
-            control_id="open-expired-failed",
-            fence=old_fence,
-            session_id=old_fence.session_id,
-            capabilities={},
-        )
-    )
-    assert (await result_sink.get()).ok is True
-    old_session = plane.sessions.require(old_fence.session_id)
-    old_session.bind_stage_request(0, "req-expired-failed", fence=old_fence)
-    clock.advance(2.0)
-
-    assert await plane.reap_expired() == 0
-    replacement_fence = DuplexFence("sid-replacement-failed")
-    await plane.handle(
-        OpenDuplexSessionMessage(
-            control_id="open-replacement-failed",
-            fence=replacement_fence,
-            session_id=replacement_fence.session_id,
-            capabilities={},
-        )
-    )
-
-    blocked_result = await result_sink.get()
-    assert blocked_result.ok is False
-    assert blocked_result.error is not None
-    assert blocked_result.error.code == "resource_exhausted"
-    assert plane.sessions.get(old_fence.session_id) is old_session
-
-
-@pytest.mark.asyncio
-async def test_capacity_rejection_is_an_info_event(caplog: pytest.LogCaptureFixture) -> None:
-    result_sink: asyncio.Queue = asyncio.Queue()
-    plane = DuplexControlPlane(
-        extension=None,
-        stage_port=_TypedStagePort(),
-        result_sink=result_sink,
-        max_sessions=1,
-    )
-    first_fence = DuplexFence("sid-capacity-first")
-    await plane.handle(
-        OpenDuplexSessionMessage(
-            control_id="open-capacity-first",
-            fence=first_fence,
-            session_id=first_fence.session_id,
-            capabilities={},
-        )
-    )
-    assert (await result_sink.get()).ok is True
-    caplog.clear()
-
-    rejected_fence = DuplexFence("sid-capacity-rejected")
-    await plane.handle(
-        OpenDuplexSessionMessage(
-            control_id="open-capacity-rejected",
-            fence=rejected_fence,
-            session_id=rejected_fence.session_id,
-            capabilities={},
-        )
-    )
-
-    result = await result_sink.get()
-    assert result.error.code == "resource_exhausted"
-    assert not [record for record in caplog.records if record.levelno >= logging.ERROR]
-
-
-@pytest.mark.asyncio
-async def test_failed_request_cleanup_retries_before_releasing_admission() -> None:
-    class _FailOnceCleanupStagePort(_TypedStagePort):
-        def __init__(self) -> None:
-            super().__init__()
-            self.attempts = 0
-
-        async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
-            self.cleanup_calls.append((list(request_ids), abort))
-            self.attempts += 1
-            if self.attempts == 1:
-                raise RuntimeError("transient request cleanup failure")
-
-    stage_port = _FailOnceCleanupStagePort()
-    result_sink: asyncio.Queue = asyncio.Queue()
-    plane = DuplexControlPlane(
-        extension=None,
-        stage_port=stage_port,
-        result_sink=result_sink,
-        max_sessions=1,
-    )
-    old_fence = DuplexFence("sid-request-cleanup")
-    await plane.handle(
-        OpenDuplexSessionMessage(
-            control_id="open-request-cleanup",
-            fence=old_fence,
-            session_id=old_fence.session_id,
-            capabilities={},
-        )
-    )
-    assert (await result_sink.get()).ok is True
-    old_session = plane.sessions.require(old_fence.session_id)
-    old_session.bind_stage_request(0, "req-request-cleanup", fence=old_fence)
-
-    closed = plane.close_sessions_for_request_ids(
-        ["req-request-cleanup"],
-        abort=True,
-    )
-    assert closed == {old_fence.session_id: ["req-request-cleanup"]}
-    assert plane.sessions.get(old_fence.session_id) is old_session
-    with pytest.raises(RuntimeError, match="transient request cleanup failure"):
-        await stage_port.cleanup(closed[old_fence.session_id], abort=True)
-
-    replacement_fence = DuplexFence("sid-request-cleanup-replacement")
-    await plane.handle(
-        OpenDuplexSessionMessage(
-            control_id="open-request-cleanup-replacement-blocked",
-            fence=replacement_fence,
-            session_id=replacement_fence.session_id,
-            capabilities={},
-        )
-    )
-    assert (await result_sink.get()).error.code == "resource_exhausted"
-
-    assert await plane.reap_expired() == 1
-    assert plane.sessions.get(old_fence.session_id) is None
-    assert stage_port.cleanup_calls == [
-        (["req-request-cleanup"], True),
-        (["req-request-cleanup"], True),
-    ]
-
-    await plane.handle(
-        OpenDuplexSessionMessage(
-            control_id="open-request-cleanup-replacement",
-            fence=replacement_fence,
-            session_id=replacement_fence.session_id,
-            capabilities={},
-        )
-    )
-    assert (await result_sink.get()).ok is True
-
-
-@pytest.mark.asyncio
-async def test_stale_request_cleanup_does_not_finalize_reopened_incarnation() -> None:
-    stage_port = _TypedStagePort()
-    result_sink: asyncio.Queue = asyncio.Queue()
-    plane = DuplexControlPlane(
-        extension=None,
-        stage_port=stage_port,
-        result_sink=result_sink,
-        max_sessions=1,
-    )
-    old_fence = DuplexFence("sid-request-cleanup-reopen")
-    await plane.handle(
-        OpenDuplexSessionMessage(
-            control_id="open-request-cleanup-old",
-            fence=old_fence,
-            session_id=old_fence.session_id,
-            capabilities={},
-        )
-    )
-    assert (await result_sink.get()).ok is True
-    old_session = plane.sessions.require(old_fence.session_id)
-    old_session.bind_stage_request(0, "req-request-cleanup-old", fence=old_fence)
-    closed = plane.close_sessions_for_request_ids(
-        ["req-request-cleanup-old"],
-        abort=True,
-        cleanup_in_progress=True,
-    )
-    assert closed == {old_fence.session_id: ["req-request-cleanup-old"]}
-    plane.defer_request_cleanups([old_fence.session_id])
-
-    await plane.handle(
-        CloseDuplexSessionMessage(
-            control_id="close-request-cleanup-old",
-            fence=old_fence,
-            session_id=old_fence.session_id,
-            reason="client_close",
-        )
-    )
-    assert (await result_sink.get()).ok is True
-    assert plane.sessions.get(old_fence.session_id) is None
-
-    new_fence = DuplexFence(old_fence.session_id, incarnation=1)
-    await plane.handle(
-        OpenDuplexSessionMessage(
-            control_id="open-request-cleanup-new",
-            fence=new_fence,
-            session_id=new_fence.session_id,
-            capabilities={},
-        )
-    )
-    assert (await result_sink.get()).ok is True
-    new_session = plane.sessions.require(new_fence.session_id)
-    assert new_session.resume(new_fence, expected_lease_generation=0) == 1
-
-    assert await plane.reap_expired() == 1
-    assert plane.sessions.get(new_fence.session_id) is new_session
-
-
-@pytest.mark.asyncio
-async def test_failed_open_cleanup_is_retried_before_releasing_admission() -> None:
-    class _FailOpenAndFirstCleanupStagePort(_TypedStagePort):
-        def __init__(self) -> None:
-            super().__init__()
-            self.ensure_attempts = 0
-            self.cleanup_attempts = 0
-
-        def ensure_request(self, context: DuplexStageRequestContext) -> None:
-            self.ensure_attempts += 1
-            if self.ensure_attempts == 1:
-                raise RuntimeError("initial stage setup failed")
-            super().ensure_request(context)
-
-        async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
-            self.cleanup_calls.append((list(request_ids), abort))
-            self.cleanup_attempts += 1
-            if self.cleanup_attempts == 1:
-                raise RuntimeError("transient open rollback failure")
-
-    stage_port = _FailOpenAndFirstCleanupStagePort()
-    result_sink: asyncio.Queue = asyncio.Queue()
-    plane = DuplexControlPlane(
-        extension=_Extension(),
-        stage_port=stage_port,
-        result_sink=result_sink,
-        max_sessions=1,
-    )
-    failed_fence = DuplexFence("sid-open-rollback")
-
-    await plane.handle(
-        OpenDuplexSessionMessage(
-            control_id="open-fails-during-stage-setup",
-            fence=failed_fence,
-            session_id=failed_fence.session_id,
-            capabilities={"input_modes": ["append_audio_chunk"]},
-        )
-    )
-
-    failed_result = await result_sink.get()
-    assert failed_result.ok is False
-    assert plane.sessions.get(failed_fence.session_id) is not None
-
-    replacement_fence = DuplexFence("sid-open-rollback-replacement")
-    await plane.handle(
-        OpenDuplexSessionMessage(
-            control_id="open-replacement-before-rollback",
-            fence=replacement_fence,
-            session_id=replacement_fence.session_id,
-            capabilities={"input_modes": ["append_audio_chunk"]},
-        )
-    )
-    assert (await result_sink.get()).error.code == "resource_exhausted"
-
-    assert await plane.reap_expired() == 0
-    assert plane.sessions.get(failed_fence.session_id) is None
-
-    await plane.handle(
-        OpenDuplexSessionMessage(
-            control_id="open-replacement-after-rollback",
-            fence=replacement_fence,
-            session_id=replacement_fence.session_id,
-            capabilities={"input_modes": ["append_audio_chunk"]},
-        )
-    )
-    assert (await result_sink.get()).ok is True
-
-
-@pytest.mark.asyncio
-async def test_expired_cleanup_failure_does_not_block_other_sessions() -> None:
-    class _OneStuckExpiryStagePort(_TypedStagePort):
-        async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
-            if request_ids == [stuck_request_id]:
-                raise RuntimeError("stuck expiry cleanup")
-            await super().cleanup(request_ids, abort=abort)
-
-    clock = _Clock()
-    stage_port = _OneStuckExpiryStagePort()
-    result_sink: asyncio.Queue = asyncio.Queue()
-    lifecycle_sink: asyncio.Queue = asyncio.Queue()
-    plane = DuplexControlPlane(
-        extension=None,
-        stage_port=stage_port,
-        result_sink=result_sink,
-        lifecycle_sink=lifecycle_sink,
-        lease_config=DuplexLeaseConfig(idle_ttl_s=1.0, disconnect_grace_s=1.0),
-        clock=clock,
-    )
-    stuck_fence = DuplexFence("sid-expiry-stuck")
-    ready_fence = DuplexFence("sid-expiry-ready")
-    stuck_request_id = plane.stage_request_id(stuck_fence, stage_id=0)
-    ready_request_id = plane.stage_request_id(ready_fence, stage_id=0)
-    for fence in (stuck_fence, ready_fence):
-        await plane.handle(
-            OpenDuplexSessionMessage(
-                control_id=f"open-{fence.session_id}",
-                fence=fence,
-                session_id=fence.session_id,
-                capabilities={},
-            )
-        )
-        assert (await result_sink.get()).ok is True
-        plane.sessions.require(fence.session_id).reserve_stage_request(
-            0,
-            plane.stage_request_id(fence, stage_id=0),
-            fence=fence,
-        )
-    clock.advance(2.0)
-
-    assert await plane.reap_expired() == 1
-
-    assert (await lifecycle_sink.get()).session_id == ready_fence.session_id
-    assert stage_port.cleanup_calls == [([ready_request_id], False)]
-
-
-@pytest.mark.asyncio
-async def test_cancel_retains_request_resources_until_abort_succeeds() -> None:
-    class _FailOnceStagePort(_TypedStagePort):
-        def __init__(self) -> None:
-            super().__init__()
-            self.failures_remaining = 1
-
-        async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
-            if self.failures_remaining:
-                self.failures_remaining -= 1
-                raise RuntimeError("transient abort failure")
-            await super().cleanup(request_ids, abort=abort)
-
-    stage_port = _FailOnceStagePort()
-    result_sink: asyncio.Queue = asyncio.Queue()
-    plane = DuplexControlPlane(extension=None, stage_port=stage_port, result_sink=result_sink)
-    cancelled_fence = DuplexFence("sid-cancel-retry")
-    next_fence = DuplexFence("sid-cancel-retry", epoch=1)
-    session = plane.sessions.open_session(cancelled_fence)
-    session.bind_stage_request(0, "req-cancel-retry", fence=cancelled_fence)
-
-    def signal(control_id: str) -> SignalDuplexTurnMessage:
-        return SignalDuplexTurnMessage(
-            control_id=control_id,
-            fence=cancelled_fence,
-            next_fence=next_fence,
-            session_id=cancelled_fence.session_id,
-            event="input.cancel",
-        )
-
-    await plane.handle(signal("cancel-first"))
-    assert (await result_sink.get()).ok is False
-    assert session.fence == next_fence
-    assert session.resource_request_ids(cancelled_fence) == ["req-cancel-retry"]
-
-    await plane.handle(signal("cancel-retry"))
-    assert (await result_sink.get()).ok is True
-    assert session.resource_request_ids(cancelled_fence) == []
-    assert stage_port.cleanup_calls == [(["req-cancel-retry"], True)]
-
-
-@pytest.mark.asyncio
-async def test_close_retains_session_resources_until_cleanup_succeeds() -> None:
-    class _FailOnceStagePort(_TypedStagePort):
-        def __init__(self) -> None:
-            super().__init__()
-            self.failures_remaining = 1
-
-        async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
-            if self.failures_remaining:
-                self.failures_remaining -= 1
-                raise RuntimeError("transient close cleanup failure")
-            await super().cleanup(request_ids, abort=abort)
-
-    stage_port = _FailOnceStagePort()
-    result_sink: asyncio.Queue = asyncio.Queue()
-    plane = DuplexControlPlane(extension=None, stage_port=stage_port, result_sink=result_sink)
-    fence = DuplexFence("sid-close-retry")
-    session = plane.sessions.open_session(fence)
-    session.bind_stage_request(0, "req-close-retry", fence=fence)
-
-    def close(control_id: str) -> CloseDuplexSessionMessage:
-        return CloseDuplexSessionMessage(
-            control_id=control_id,
-            fence=fence,
-            session_id=fence.session_id,
-            reason="client_close",
-        )
-
-    await plane.handle(close("close-first"))
-    assert (await result_sink.get()).ok is False
-    assert plane.sessions.get(fence.session_id) is session
-    assert session.resource_request_ids() == ["req-close-retry"]
-
-    await plane.handle(close("close-retry"))
-    assert (await result_sink.get()).ok is True
-    assert plane.sessions.get(fence.session_id) is None
-    assert stage_port.cleanup_calls == [(["req-close-retry"], True)]
-
-
-@pytest.mark.asyncio
-async def test_control_cleanup_failure_does_not_block_other_sessions() -> None:
-    class _IndependentFailureStagePort(_TypedStagePort):
-        def __init__(self) -> None:
-            super().__init__()
-            self.attempts: dict[str, int] = {}
-
-        async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
-            request_id = request_ids[0]
-            self.attempts[request_id] = self.attempts.get(request_id, 0) + 1
-            if request_id == "req-stuck" or self.attempts[request_id] == 1:
-                raise RuntimeError(f"cleanup failed for {request_id}")
-            await super().cleanup(request_ids, abort=abort)
-
-    stage_port = _IndependentFailureStagePort()
-    result_sink: asyncio.Queue = asyncio.Queue()
-    plane = DuplexControlPlane(extension=None, stage_port=stage_port, result_sink=result_sink)
-
-    for session_id, request_id in (("sid-stuck", "req-stuck"), ("sid-ready", "req-ready")):
-        fence = DuplexFence(session_id)
-        session = plane.sessions.open_session(fence)
-        session.bind_stage_request(0, request_id, fence=fence)
-        await plane.handle(
-            CloseDuplexSessionMessage(
-                control_id=f"close-{session_id}",
-                fence=fence,
-                session_id=session_id,
-                reason="client_close",
-            )
-        )
-        assert (await result_sink.get()).ok is False
-
-    await plane.reap_expired()
-
-    assert plane.sessions.get("sid-stuck") is not None
-    assert plane.sessions.get("sid-ready") is None
-    assert stage_port.cleanup_calls == [(["req-ready"], True)]
-
-
-@pytest.mark.asyncio
-async def test_control_cleanup_is_single_flight_with_concurrent_reaper() -> None:
-    class _SlowCleanupStagePort(_TypedStagePort):
-        def __init__(self) -> None:
-            super().__init__()
-            self.cleanup_started = asyncio.Event()
-            self.release_cleanup = asyncio.Event()
-            self.cleanup_attempts = 0
-
-        async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
-            self.cleanup_attempts += 1
-            self.cleanup_started.set()
-            await self.release_cleanup.wait()
-            await super().cleanup(request_ids, abort=abort)
-
-    stage_port = _SlowCleanupStagePort()
-    result_sink: asyncio.Queue = asyncio.Queue()
-    plane = DuplexControlPlane(extension=None, stage_port=stage_port, result_sink=result_sink)
-    fence = DuplexFence("sid-concurrent-cleanup")
-    session = plane.sessions.open_session(fence)
-    session.bind_stage_request(0, "req-concurrent-cleanup", fence=fence)
-
-    close_task = asyncio.create_task(
-        plane.handle(
-            CloseDuplexSessionMessage(
-                control_id="close-concurrent-cleanup",
-                fence=fence,
-                session_id=fence.session_id,
-                reason="client_close",
-            )
-        )
-    )
-    await asyncio.wait_for(stage_port.cleanup_started.wait(), timeout=1)
-
-    reaper_task = asyncio.create_task(plane.reap_expired())
-    await asyncio.sleep(0)
-    await asyncio.sleep(0)
-    assert stage_port.cleanup_attempts == 1
-
-    stage_port.release_cleanup.set()
-    await asyncio.gather(close_task, reaper_task)
-
-    assert (await result_sink.get()).ok is True
-    assert plane.sessions.get(fence.session_id) is None
-    assert stage_port.cleanup_calls == [(["req-concurrent-cleanup"], True)]
-
-
-@pytest.mark.asyncio
-async def test_unknown_input_mode_rejects_open_without_registering_session() -> None:
-    result_sink: asyncio.Queue = asyncio.Queue()
-    plane = DuplexControlPlane(extension=None, stage_port=_TypedStagePort(), result_sink=result_sink)
-    fence = DuplexFence("sid-unknown-mode")
-
-    await plane.handle(
-        OpenDuplexSessionMessage(
-            control_id="open-unknown-mode",
-            fence=fence,
-            session_id=fence.session_id,
-            capabilities={"input_modes": ["future_mode"]},
-        )
-    )
-
-    result = await result_sink.get()
-    assert result.ok is False
-    assert result.error is not None
-    assert result.error.code == "invalid_capability"
-    assert plane.sessions.get(fence.session_id) is None
-
-
-@pytest.mark.asyncio
-async def test_extension_free_turn_commit_does_not_allocate_or_submit_stage_request() -> None:
-    stage_port = _TypedStagePort()
-    result_sink: asyncio.Queue = asyncio.Queue()
-    plane = DuplexControlPlane(extension=None, stage_port=stage_port, result_sink=result_sink)
-    fence = DuplexFence("sid-turn-commit")
-
-    await plane.handle(
-        OpenDuplexSessionMessage(
-            control_id="open-turn-commit",
-            fence=fence,
-            session_id=fence.session_id,
-            capabilities={"input_modes": [DuplexInputMode.TURN_COMMIT_ONLY.value]},
-        )
-    )
-    assert (await result_sink.get()).ok is True
-
-    await plane.handle(
-        AppendDuplexInputMessage(
-            control_id="append-turn-commit",
-            fence=fence,
-            session_id=fence.session_id,
-            mode=DuplexInputMode.TURN_COMMIT_ONLY.value,
-            payload=None,
-            final=True,
-        )
-    )
-    result = await result_sink.get()
-
-    assert result.ok is True
-    assert result.stage_results[0]["result"]["data_plane_append"] is False
-    assert stage_port.ensure_calls == []
-    assert stage_port.submit_calls == []
-
-
-@pytest.mark.asyncio
-async def test_session_update_replaces_both_configs_with_one_generation() -> None:
-    result_sink: asyncio.Queue = asyncio.Queue()
-    plane = DuplexControlPlane(extension=_Extension(), stage_port=_TypedStagePort(), result_sink=result_sink)
-    fence = DuplexFence("sid-atomic-config")
-    session = plane.sessions.open_session(fence)
-
-    await plane.handle(
-        SignalDuplexTurnMessage(
-            control_id="update-config",
-            fence=fence,
-            session_id=fence.session_id,
-            event="session.update",
-            session_config={"voice": "new"},
-            runtime_config={"temperature": 0.5},
-        )
-    )
-
-    assert (await result_sink.get()).ok is True
-    assert session.config_generation == 1
-    assert session.session_config == {"voice": "new"}
-    assert session.runtime_config == {"temperature": 0.5}
-
-
-@pytest.mark.asyncio
-async def test_stage_submission_is_compensated_when_local_commit_fails() -> None:
-    stage_port = _TypedStagePort()
-    result_sink: asyncio.Queue = asyncio.Queue()
-    plane = DuplexControlPlane(extension=_Extension(), stage_port=stage_port, result_sink=result_sink)
-    fence = DuplexFence("sid-submit-compensation")
-    session = plane.sessions.open_session(
-        fence,
-        capabilities=DuplexRuntimeCapabilities(input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK}),
-    )
-    request_id = plane.stage_request_id(fence, stage_id=0)
-
-    def fail_commit(_reservation):
-        raise RuntimeError("local commit failed")
-
-    session.commit_append = fail_commit  # type: ignore[method-assign]
-    await plane.handle(
-        AppendDuplexInputMessage(
-            control_id="append-compensation",
-            fence=fence,
-            session_id=fence.session_id,
-            mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
-            payload={"audio": b"pcm"},
-        )
-    )
-
-    assert (await result_sink.get()).ok is False
-    assert stage_port.cleanup_calls == [([request_id], True)]
-
-
-@pytest.mark.asyncio
-async def test_failed_submission_compensation_blocks_append_until_reaper_cleans_it() -> None:
-    class _FailingCleanupStagePort(_TypedStagePort):
-        def __init__(self) -> None:
-            super().__init__()
-            self.cleanup_failures = 2
-
-        async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
-            await super().cleanup(request_ids, abort=abort)
-            if self.cleanup_failures > 0:
-                self.cleanup_failures -= 1
-                raise RuntimeError("stage abort failed")
-
-    stage_port = _FailingCleanupStagePort()
-    result_sink: asyncio.Queue = asyncio.Queue()
-    plane = DuplexControlPlane(extension=_Extension(), stage_port=stage_port, result_sink=result_sink)
-    fence = DuplexFence("sid-durable-submit-compensation")
-    session = plane.sessions.open_session(
-        fence,
-        capabilities=DuplexRuntimeCapabilities(input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK}),
-    )
-    original_commit = session.commit_append
-
-    def fail_commit(_reservation):
-        raise RuntimeError("local commit failed")
-
-    session.commit_append = fail_commit  # type: ignore[method-assign]
-    first = AppendDuplexInputMessage(
-        control_id="append-compensation-1",
-        fence=fence,
-        session_id=fence.session_id,
-        mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
-        payload={"audio": b"pcm"},
-    )
-    await plane.handle(first)
-    assert (await result_sink.get()).ok is False
-    assert plane.pending_submission_cleanup_count == 1
-    assert len(stage_port.submit_calls) == 1
-
-    await plane.handle(
-        AppendDuplexInputMessage(
-            control_id="append-compensation-2",
-            fence=fence,
-            session_id=fence.session_id,
-            mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
-            payload={"audio": b"pcm"},
-        )
-    )
-    assert (await result_sink.get()).ok is False
-    assert plane.pending_submission_cleanup_count == 1
-    assert len(stage_port.submit_calls) == 1
-
-    session.commit_append = original_commit  # type: ignore[method-assign]
-    stage_port.cleanup_failures = 0
-    await plane.reap_expired()
-
-    assert plane.pending_submission_cleanup_count == 0
-    assert session.resource_request_ids() == []
-
-
-def test_stale_output_is_rejected_before_extension_decision() -> None:
-    class _CountingExtension(_Extension):
-        def __init__(self) -> None:
-            self.decision_calls = 0
-
-        def decide_output(self, **kwargs):
-            del kwargs
-            self.decision_calls += 1
-            return None
-
-    extension = _CountingExtension()
-    plane = DuplexControlPlane(extension=extension, stage_port=_TypedStagePort(), result_sink=asyncio.Queue())
-    current = DuplexFence("sid-stale-output", epoch=1)
-    plane.sessions.open_session(current)
-    context = DuplexOutputContext(
-        identity=DuplexRequestIdentity(
-            session_id=current.session_id,
-            fence=DuplexFence(current.session_id, epoch=0),
-        ),
-        final_stage_id=1,
-        segment_finished=True,
-    )
-
-    assert plane.decide_output(0, object(), context) is None
-    assert extension.decision_calls == 0
-
-
-@pytest.mark.asyncio
-async def test_control_dispatch_is_ordered_per_session_without_blocking_other_sessions() -> None:
-    class _BlockingStagePort(_TypedStagePort):
-        def __init__(self) -> None:
-            super().__init__()
-            self.started = asyncio.Event()
-            self.release = asyncio.Event()
-
-        async def submit(self, submission: DuplexStageSubmission) -> DuplexStageSubmissionResult:
-            if submission.context.session_id == "sid-blocked":
-                self.started.set()
-                await self.release.wait()
-            return await super().submit(submission)
-
-    stage_port = _BlockingStagePort()
-    result_sink: asyncio.Queue = asyncio.Queue()
-    plane = DuplexControlPlane(extension=_Extension(), stage_port=stage_port, result_sink=result_sink)
-    blocked = DuplexFence("sid-blocked")
-    independent = DuplexFence("sid-independent")
-    capabilities = DuplexRuntimeCapabilities(input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK})
-    plane.sessions.open_session(blocked, capabilities=capabilities)
-    plane.sessions.open_session(independent, capabilities=capabilities)
-
-    plane.dispatch(
-        AppendDuplexInputMessage(
-            control_id="blocked-append",
-            fence=blocked,
-            session_id=blocked.session_id,
-            mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
-            payload={"audio": b"pcm"},
-            operation_id="blocked-operation",
-        )
-    )
-    await asyncio.wait_for(stage_port.started.wait(), timeout=1)
-    plane.dispatch(
-        AppendDuplexInputMessage(
-            control_id="blocked-append-retry",
-            fence=blocked,
-            session_id=blocked.session_id,
-            mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
-            payload={"audio": b"pcm"},
-            operation_id="blocked-operation",
-        )
-    )
-    plane.dispatch(
-        TouchDuplexSessionMessage(
-            control_id="blocked-touch",
-            fence=blocked,
-            session_id=blocked.session_id,
-            activity=DuplexLeaseActivity.HEARTBEAT.value,
-        )
-    )
-    plane.dispatch(
-        TouchDuplexSessionMessage(
-            control_id="independent-touch",
-            fence=independent,
-            session_id=independent.session_id,
-            activity=DuplexLeaseActivity.HEARTBEAT.value,
-        )
-    )
-
-    independent_result = await asyncio.wait_for(result_sink.get(), timeout=1)
-    assert independent_result.control_id == "independent-touch"
-
-    stage_port.release.set()
-    await plane.drain()
-    assert [result_sink.get_nowait().control_id for _ in range(3)] == [
-        "blocked-append",
-        "blocked-append-retry",
-        "blocked-touch",
-    ]
-    assert [
-        submission.context.session_id
-        for submission in stage_port.submit_calls
-        if submission.context.session_id == blocked.session_id
-    ] == [blocked.session_id]
diff --git a/tests/engine/duplex/test_duplex_events.py b/tests/engine/duplex/test_duplex_events.py
new file mode 100644
index 000000000..6330059a1
--- /dev/null
+++ b/tests/engine/duplex/test_duplex_events.py
@@ -0,0 +1,480 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Typed duplex events: pure ``to_realtime()`` rendering and the stateful Realtime projection."""
+
+from __future__ import annotations
+
+import base64
+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,
+    DuplexEvent,
+    DuplexRawEvent,
+    ErrorEvent,
+    InputCommitted,
+    ItemAdded,
+    ItemCreated,
+    ItemDone,
+    Listen,
+    OutputItemAdded,
+    OverlapDecision,
+    ResponseDone,
+    SessionClosed,
+    SessionCreated,
+    SessionExpired,
+    SessionHeartbeatAck,
+    SessionReplaced,
+    SessionResumed,
+    SessionResyncRequired,
+    TextDelta,
+    TranscriptDone,
+    TurnEvent,
+    error_event,
+)
+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]
+
+#: Classes whose wire object carries ``session_id`` by contract.
+_SESSION_ID_ON_WIRE = {
+    SessionClosed,
+    SessionExpired,
+    SessionHeartbeatAck,
+    Listen,
+    TurnEvent,
+    OverlapDecision,
+    SessionResumed,
+    SessionReplaced,
+    SessionResyncRequired,
+}
+#: Classes whose wire object carries ``epoch`` by contract.
+_EPOCH_ON_WIRE = {Listen, TurnEvent, OverlapDecision}
+
+
+def _public_event_classes() -> list[type[DuplexEvent]]:
+    classes = [
+        getattr(events_module, name)
+        for name in events_module.__all__
+        if inspect.isclass(getattr(events_module, name)) and issubclass(getattr(events_module, name), DuplexEvent)
+    ]
+    assert len(classes) > 40
+    return [cls for cls in classes if cls is not DuplexEvent]
+
+
+@pytest.mark.parametrize("event_cls", _public_event_classes(), ids=lambda cls: cls.__name__)
+def test_to_realtime_renders_wire_type_event_id_and_documented_fields(event_cls: type[DuplexEvent]):
+    event = event_cls(session_id="duplex-hidden", epoch=7)
+
+    wire = event.to_realtime()
+
+    assert wire["type"] == event.type
+    assert wire["event_id"] == event.event_id
+    assert wire["event_id"].startswith("event_")
+    if event_cls is DuplexRawEvent:
+        assert wire["type"] == "duplex."
+    else:
+        assert wire["type"] == event_cls.wire_type
+    if event_cls in _SESSION_ID_ON_WIRE:
+        assert wire["session_id"] == "duplex-hidden"
+    else:
+        assert "session_id" not in wire
+    if event_cls in _EPOCH_ON_WIRE:
+        assert wire["epoch"] == 7
+    else:
+        assert "epoch" not in wire
+    # Every value is plain JSON (mappings / sequences are copied into dict / list).
+    for value in wire.values():
+        assert isinstance(value, str | int | float | bool | dict | list) or value is None
+
+
+def test_optional_wire_fields_are_omitted_when_none():
+    created = SessionCreated(session={"id": "sid"})
+    assert created.optional_wire_fields == frozenset({"attachment_generation", "resume_token"})
+    wire = created.to_realtime()
+    assert "attachment_generation" not in wire
+    assert "resume_token" not in wire
+    assert wire["session"] == {"id": "sid"}
+
+    with_resume = SessionCreated(session={"id": "sid"}, attachment_generation=2, resume_token="tok").to_realtime()
+    assert with_resume["attachment_generation"] == 2
+    assert with_resume["resume_token"] == "tok"
+
+    delta = AudioDelta(response_id="resp_1", item_id="item_resp_1", delta="AAAA").to_realtime()
+    assert "sample_rate_hz" not in delta
+    assert "metadata" not in delta
+    assert delta["format"] == "pcm16"
+    assert delta["output_index"] == 0
+    assert delta["content_index"] == 0
+
+    anonymous_listen = Listen(session_id="sid", epoch=0, details={"reason": "silence"}).to_realtime()
+    assert "response_id" not in anonymous_listen
+    assert "id" not in anonymous_listen["response"]
+    assert anonymous_listen["response"]["status"] == "listening"
+    assert anonymous_listen["response"]["metadata"] == {"reason": "silence"}
+
+    bound_listen = Listen(session_id="sid", epoch=0, response_id="resp_1").to_realtime()
+    assert bound_listen["response_id"] == "resp_1"
+    assert bound_listen["response"]["id"] == "resp_1"
+
+
+def test_error_event_maps_codes_to_openai_error_types_and_echoes_client_event_id():
+    assert REALTIME_ERROR_TYPES_BY_CODE["resource_exhausted"] == "rate_limit_error"
+    assert REALTIME_ERROR_TYPES_BY_CODE["internal_error"] == "server_error"
+    assert REALTIME_ERROR_TYPES_BY_CODE["bad_event"] == "invalid_request_error"
+
+    error = ErrorEvent(
+        code="resource_exhausted",
+        message="too many sessions",
+        related_event_id="evt_client",
+        param="session",
+        extra={"retryable": True},
+    )
+
+    assert error.error_type == "rate_limit_error"
+    assert error.text == "too many sessions"
+    assert error.error == {
+        "type": "rate_limit_error",
+        "code": "resource_exhausted",
+        "message": "too many sessions",
+        "event_id": "evt_client",
+        "param": "session",
+        "retryable": True,
+    }
+    wire = error.to_realtime()
+    assert wire["type"] == "error"
+    assert wire["error"] == error.error
+    # The server event id and the echoed client event id are distinct.
+    assert wire["event_id"] != "evt_client"
+    assert ErrorEvent(code="never-seen-code").error_type == "invalid_request_error"
+
+
+def test_error_event_helper_normalizes_optional_client_event_id_and_param():
+    event = error_event("bad_event", "nope", event_id="evt_1", param="item", extra={"retryable": False})
+    assert isinstance(event, ErrorEvent)
+    assert event.related_event_id == "evt_1"
+    assert event.param == "item"
+    assert event.error["retryable"] is False
+
+    anonymous = error_event("bad_event", "nope", event_id=42, param="")
+    assert anonymous.related_event_id is None
+    assert anonymous.param is None
+    assert "event_id" not in anonymous.error
+    assert "param" not in anonymous.error
+
+
+def test_audio_delta_decodes_base64_and_invalid_payloads_yield_none():
+    raw = bytes(range(16))
+    delta = AudioDelta(delta=base64.b64encode(raw).decode("ascii"), format="pcm16", sample_rate_hz=24000)
+
+    assert delta.audio == raw
+    assert delta.to_realtime()["sample_rate_hz"] == 24000
+    assert AudioDelta(delta="@@not base64@@").audio is None
+
+
+def test_session_closed_and_expired_are_the_only_terminal_events():
+    closed = SessionClosed(session_id="sid", reason="client_close", details={"type": "session.closed"})
+    expired = SessionExpired(session_id="sid", reason="idle_timeout")
+
+    assert closed.is_terminal is True
+    assert expired.is_terminal is True
+    assert closed.to_realtime() == {
+        "type": "session.closed",
+        "event_id": closed.event_id,
+        "session_id": "sid",
+        "reason": "client_close",
+        "event": {"type": "session.closed"},
+    }
+    assert expired.to_realtime() == {
+        "type": "session.expired",
+        "event_id": expired.event_id,
+        "session_id": "sid",
+        "reason": "idle_timeout",
+    }
+    non_terminal = [cls for cls in _public_event_classes() if cls().is_terminal]
+    assert non_terminal == [SessionClosed, SessionExpired]
+
+
+def test_generic_accessors_expose_response_item_text_and_status():
+    assert TextDelta(response_id="resp_1", item_id="item_resp_1", delta="hi").text == "hi"
+    assert TranscriptDone(transcript="done").text == "done"
+    assert OutputItemAdded(item={"id": "item_1"}).item_id == "item_1"
+    assert ItemAdded(item={"id": 3}).item_id is None
+    assert ResponseDone(response={"status": "cancelled"}).status == "cancelled"
+    assert ResponseDone().status is None
+    assert TurnEvent(event="user_started", turn_state="user_speaking").response_id is None
+    assert TurnEvent().audio is None
+
+
+def test_raw_event_prefixes_internal_type_and_wraps_details():
+    raw = DuplexRawEvent(internal_type="model.custom", details={"type": "model.custom", "value": (1, 2)})
+
+    assert raw.type == "duplex.model.custom"
+    assert raw.to_realtime() == {
+        "type": "duplex.model.custom",
+        "event_id": raw.event_id,
+        "event": {"type": "model.custom", "value": [1, 2]},
+    }
+
+
+def test_turn_event_and_overlap_decision_carry_session_identity_on_the_wire():
+    turn = TurnEvent(session_id="sid", epoch=2, event="barge_in", turn_state="barge_in").to_realtime()
+    assert turn == {
+        "type": "turn.event",
+        "event_id": turn["event_id"],
+        "session_id": "sid",
+        "event": "barge_in",
+        "turn_state": "barge_in",
+        "epoch": 2,
+    }
+    decision = OverlapDecision(
+        session_id="sid", epoch=2, policy="listen_only", action="ignore", reason="short", details={"ms": 300}
+    ).to_realtime()
+    assert decision["policy"] == "listen_only"
+    assert decision["action"] == "ignore"
+    assert decision["metadata"] == {"ms": 300}
+    assert decision["session_id"] == "sid"
+
+
+# ---- RealtimeProjectionState / project_internal_event ----
+
+
+def _types(events: list[DuplexEvent]) -> list[str]:
+    return [event.type for event in events]
+
+
+def test_projection_of_the_main_internal_event_sequence():
+    state = RealtimeProjectionState(session_id="duplex-proj", model="test-model", initial_session_update=True)
+    pcm = base64.b64encode(b"\x00\x10" * 8).decode("ascii")
+
+    created = project_internal_event(state, {"type": "session.created", "session": {"voice": "alloy"}})
+    assert _types(created) == ["session.created", "session.updated"]
+    assert isinstance(created[0], SessionCreated)
+    session_payload = created[0].session
+    assert session_payload["id"] == "duplex-proj"
+    assert session_payload["model"] == "test-model"
+    assert session_payload["voice"] == "alloy"
+    assert session_payload["input_audio_format"] == "pcm16"
+    assert session_payload["output_audio_format"] == "pcm16"
+    assert state.initial_session_update is False
+    # The extra session.updated is a one-shot for the opening session.update.
+    assert _types(project_internal_event(state, {"type": "session.created", "session": {}})) == ["session.created"]
+
+    response_created = project_internal_event(
+        state, {"type": "response.created", "response_id": "resp_1", "modalities": ["audio", "text"]}
+    )
+    assert _types(response_created) == [
+        "response.created",
+        "conversation.item.added",
+        "conversation.item.created",
+        "response.output_item.added",
+        "response.content_part.added",
+    ]
+    assert state.active_response_id == "resp_1"
+    assert response_created[0].response_id == "resp_1"
+    assert response_created[0].to_realtime()["response"]["status"] == "in_progress"
+    assert isinstance(response_created[1], ItemAdded)
+    assert isinstance(response_created[2], ItemCreated)
+    assert response_created[1].item_id == "item_resp_1"
+    assert response_created[3].item_id == "item_resp_1"
+    assert response_created[4].to_realtime()["part"] == {"type": "audio", "transcript": ""}
+
+    audio_delta = project_internal_event(
+        state,
+        {"type": "response.output_audio.delta", "response_id": "resp_1", "audio": pcm, "text": "hi", "format": "pcm16"},
+    )
+    assert _types(audio_delta) == ["response.output_audio.delta", "response.output_audio_transcript.delta"]
+    assert isinstance(audio_delta[0], AudioDelta)
+    assert audio_delta[0].delta == pcm
+    assert audio_delta[0].format == "pcm16"
+    assert audio_delta[0].item_id == "item_resp_1"
+    assert audio_delta[1].text == "hi"
+    assert state.conversation_items["item_resp_1"]["content"][0]["transcript"] == "hi"
+
+    done = project_internal_event(state, {"type": "response.done", "response_id": "resp_1"})
+    assert _types(done) == [
+        "response.output_audio.done",
+        "response.output_audio_transcript.done",
+        "response.content_part.done",
+        "response.output_item.done",
+        "conversation.item.done",
+        "response.done",
+        "rate_limits.updated",
+    ]
+    assert done[1].text == "hi"
+    assert isinstance(done[4], ItemDone)
+    assert done[4].item["status"] == "completed"
+    assert isinstance(done[5], ResponseDone)
+    assert done[5].status == "completed"
+    assert done[5].response["output"][0]["content"][0] == {"type": "output_audio", "transcript": "hi"}
+    assert state.active_response_id is None
+    # A duplicate terminal for the same response is idempotent.
+    assert project_internal_event(state, {"type": "response.done", "response_id": "resp_1"}) == []
+
+    committed = project_internal_event(
+        state, {"type": "input.committed", "message": {"role": "user", "content": "hello"}, "input_commit_seq": 1}
+    )
+    assert _types(committed) == [
+        "conversation.item.added",
+        "conversation.item.created",
+        "input_audio_buffer.committed",
+        "conversation.item.done",
+    ]
+    assert isinstance(committed[2], InputCommitted)
+    assert committed[2].previous_item_id == "item_resp_1"
+    assert committed[2].item_id == committed[0].item_id
+    assert committed[2].to_realtime()["event"]["input_commit_seq"] == 1
+    assert committed[0].item["content"] == [{"type": "input_text", "text": "hello"}]
+
+    project_internal_event(state, {"type": "response.created", "response_id": "resp_2"})
+    project_internal_event(state, {"type": "response.output_audio.delta", "response_id": "resp_2", "audio": pcm})
+    cancelled = project_internal_event(
+        state, {"type": "audio.cancelled", "response_id": "resp_2", "reason": "barge_in", "committed_ms": 0}
+    )
+    assert _types(cancelled) == [
+        "response.output_audio.done",
+        "response.content_part.done",
+        "response.output_item.done",
+        "conversation.item.done",
+        "response.done",
+        "rate_limits.updated",
+    ]
+    assert cancelled[4].status == "cancelled"
+    assert cancelled[4].response["status_details"] == {"type": "cancelled", "reason": "barge_in"}
+    assert state.active_response_id is None
+
+    closed = project_internal_event(state, {"type": "session.closed", "reason": "client_close"})
+    assert _types(closed) == ["session.closed"]
+    assert closed[0].is_terminal is True
+    assert closed[0].to_realtime()["reason"] == "client_close"
+
+
+def test_projection_of_output_audio_buffer_clear_emits_cleared_before_terminals():
+    state = RealtimeProjectionState(session_id="duplex-clear")
+    pcm = base64.b64encode(b"\x00\x10" * 8).decode("ascii")
+    project_internal_event(state, {"type": "response.created", "response_id": "resp_1"})
+    project_internal_event(state, {"type": "response.output_audio.delta", "response_id": "resp_1", "audio": pcm})
+
+    cleared = project_internal_event(
+        state, {"type": "audio.cancelled", "reason": "output_audio_buffer_clear", "committed_ms": 250}
+    )
+
+    assert _types(cleared)[:2] == ["output_audio_buffer.cleared", "response.output_audio.done"]
+    assert cleared[0].response_id == "resp_1"
+    assert _types(cleared)[-2:] == ["response.done", "rate_limits.updated"]
+    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.
+    state = RealtimeProjectionState(session_id="duplex-err")
+
+    projected = project_internal_event(state, {"type": "error", "code": "bad_event", "error": "nope"})
+
+    assert len(projected) == 1
+    assert isinstance(projected[0], DuplexRawEvent)
+    assert projected[0].type == "duplex.error"
+    assert projected[0].to_realtime()["event"]["code"] == "bad_event"
diff --git a/tests/engine/duplex/test_duplex_lease.py b/tests/engine/duplex/test_duplex_lease.py
index 62fc8c70c..bd26b5740 100644
--- a/tests/engine/duplex/test_duplex_lease.py
+++ b/tests/engine/duplex/test_duplex_lease.py
@@ -1,19 +1,22 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
+"""Lease semantics of the engine-resident duplex session (idle TTL, disconnect grace, resume CAS)."""
+
 from __future__ import annotations
 
 from dataclasses import FrozenInstanceError
 
 import pytest
 
-from vllm_omni.engine.duplex.lease import (
+from vllm_omni.engine.duplex.config import DuplexSessionConfig
+from vllm_omni.engine.duplex.contracts import DuplexFence
+from vllm_omni.engine.duplex.session.engine_session import DuplexEngineSession, DuplexFenceMismatchError
+from vllm_omni.engine.duplex.session.lease import (
     DuplexLeaseActivity,
     DuplexLeaseConfig,
+    DuplexLeaseState,
 )
-from vllm_omni.engine.duplex.messages import DuplexFence
-from vllm_omni.engine.duplex.runtime import DuplexInputMode
-from vllm_omni.engine.duplex.session import DuplexSessionRuntimeManager
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
@@ -30,195 +33,148 @@ class FakeMonotonicClock:
 
 
 def _lease_config(*, idle_ttl_s: float | None = 300.0) -> DuplexLeaseConfig:
-    return DuplexLeaseConfig(
-        idle_ttl_s=idle_ttl_s,
-        disconnect_grace_s=30.0,
+    return DuplexLeaseConfig(idle_ttl_s=idle_ttl_s, disconnect_grace_s=30.0)
+
+
+def _session(session_id: str, clock: FakeMonotonicClock, *, idle_ttl_s: float | None = 300.0) -> DuplexEngineSession:
+    return DuplexEngineSession(
+        session_id=session_id,
+        config=DuplexSessionConfig(),
+        lease=DuplexLeaseState(config=_lease_config(idle_ttl_s=idle_ttl_s), generation=0, last_activity=clock()),
+        _clock=clock,
     )
 
 
-def test_open_touch_detach_and_idle_expiry_use_monotonic_time() -> None:
+def test_open_touch_detach_and_expiry_use_monotonic_time() -> None:
     clock = FakeMonotonicClock(100.0)
-    manager = DuplexSessionRuntimeManager(clock=clock)
-    fence = DuplexFence("sid-expiry")
-    session = manager.open_session(fence, lease_config=_lease_config())
+    session = _session("sid-expiry", clock)
 
     assert session.lease.last_activity == 100.0
     clock.advance(10.0)
-    session.touch(fence, DuplexLeaseActivity.HEARTBEAT)
-    session.detach(fence)
+    session.touch_lease(DuplexLeaseActivity.HEARTBEAT)
+    assert session.lease.last_activity == 110.0
+    session.detach_lease()
     clock.advance(29.0)
     assert session.lease.disconnect_grace_expired(clock()) is False
-    assert manager.collect_expired() == []
+    assert session.lease.idle_expired(clock()) is False
 
-    clock.advance(272.0)
-    expired = manager.collect_expired()
+    clock.advance(1.0)
+    assert session.lease.disconnect_grace_expired(clock()) is True
 
-    assert [item.session_id for item in expired] == ["sid-expiry"]
-    assert expired[0].reason == "disconnect_grace_expired"
-    assert manager.get("sid-expiry") is session
-    manager.finalize_close_session(session)
-    assert manager.get("sid-expiry") is None
+    clock.advance(271.0)
+    assert session.lease.idle_expired(clock()) is True
 
 
-def test_detach_grace_and_resume_advance_token_independent_lease_generation() -> None:
+def test_detach_grace_and_resume_advance_the_lease_generation() -> None:
     clock = FakeMonotonicClock(10.0)
-    manager = DuplexSessionRuntimeManager(clock=clock)
-    fence = DuplexFence("sid-resume")
-    session = manager.open_session(fence, lease_config=_lease_config())
+    session = _session("sid-resume", clock)
 
-    session.detach(fence)
+    session.detach_lease()
     clock.advance(29.0)
     assert session.lease.disconnect_grace_expired(clock()) is False
     clock.advance(2.0)
     assert session.lease.disconnect_grace_expired(clock()) is True
 
-    generation = session.resume(fence, expected_lease_generation=0)
+    generation = session.resume_lease(expected_lease_generation=0)
 
     assert generation == 1
+    assert session.lease_generation == 1
     assert session.lease.detached_at is None
     assert session.lease.disconnect_grace_expired(clock()) is False
     with pytest.raises(ValueError, match="lease generation mismatch"):
-        session.resume(fence, expected_lease_generation=0)
+        session.resume_lease(expected_lease_generation=0)
 
 
 def test_active_operation_prevents_mid_transaction_expiry() -> None:
     clock = FakeMonotonicClock(0.0)
-    manager = DuplexSessionRuntimeManager(clock=clock)
-    fence = DuplexFence("sid-operation")
-    session = manager.open_session(fence, lease_config=_lease_config(idle_ttl_s=5.0))
+    session = _session("sid-operation", clock, idle_ttl_s=5.0)
 
-    session.begin_operation(fence, "append-1")
+    session.begin_lease_operation(session.fence, "append-1")
     clock.advance(10.0)
-    assert manager.collect_expired() == []
+    assert session.lease.idle_expired(clock()) is False
 
-    session.end_operation(fence, "append-1")
-    assert manager.collect_expired() == []
+    session.end_lease_operation("append-1")
+    assert session.lease.idle_expired(clock()) is False
     clock.advance(6.0)
-    assert [item.session_id for item in manager.collect_expired()] == ["sid-operation"]
+    assert session.lease.idle_expired(clock()) is True
 
 
 def test_sessions_have_independent_activity_deadlines_and_resources() -> None:
     clock = FakeMonotonicClock(0.0)
-    manager = DuplexSessionRuntimeManager(clock=clock)
-    fence_a = DuplexFence("sid-a")
-    fence_b = DuplexFence("sid-b")
-    session_a = manager.open_session(fence_a, lease_config=_lease_config(idle_ttl_s=10.0))
-    session_b = manager.open_session(fence_b, lease_config=_lease_config(idle_ttl_s=10.0))
-    session_a.reserve_stage_request(0, "req-a-reserved", fence=fence_a)
-    session_a.bind_stage_request(1, "req-a-submitted", fence=fence_a)
-    session_b.bind_stage_request(0, "req-b", fence=fence_b)
+    session_a = _session("sid-a", clock, idle_ttl_s=10.0)
+    session_b = _session("sid-b", clock, idle_ttl_s=10.0)
+    session_a.reserve_stage_request(0, "req-a-reserved", fence=session_a.fence)
+    session_a.bind_stage_request(1, "req-a-submitted", fence=session_a.fence)
+    session_b.bind_stage_request(0, "req-b", fence=session_b.fence)
 
     clock.advance(6.0)
-    session_b.touch(fence_b, DuplexLeaseActivity.MODEL_OUTPUT)
+    session_b.touch_lease(DuplexLeaseActivity.MODEL_OUTPUT)
     clock.advance(5.0)
-    expired = manager.collect_expired()
 
-    assert len(expired) == 1
-    assert expired[0].session_id == "sid-a"
-    assert expired[0].reserved_request_ids == ("req-a-reserved",)
-    assert expired[0].submitted_request_ids == ("req-a-submitted",)
-    assert manager.get("sid-b") is session_b
+    assert session_a.lease.idle_expired(clock()) is True
+    assert session_b.lease.idle_expired(clock()) is False
+    assert session_a.resource_request_ids(submitted=False) == ["req-a-reserved"]
+    assert session_a.resource_request_ids(submitted=True) == ["req-a-submitted"]
     assert session_b.resource_request_ids() == ["req-b"]
 
 
-def test_close_and_reaper_select_exactly_one_terminal_transition() -> None:
+def test_close_is_a_single_terminal_transition() -> None:
     clock = FakeMonotonicClock(0.0)
-    manager = DuplexSessionRuntimeManager(clock=clock)
-    fence = DuplexFence("sid-race")
-    manager.open_session(fence, lease_config=_lease_config(idle_ttl_s=1.0))
+    session = _session("sid-race", clock, idle_ttl_s=1.0)
     clock.advance(2.0)
+    assert session.lease.idle_expired(clock()) is True
 
-    assert len(manager.collect_expired()) == 1
-    assert manager.close_session(fence, reason="explicit_close") is None
-    assert manager.collect_expired() == []
-
-    fence_2 = DuplexFence("sid-race-2")
-    manager.open_session(fence_2, lease_config=_lease_config(idle_ttl_s=1.0))
-    assert manager.close_session(fence_2, reason="explicit_close") is not None
-    clock.advance(2.0)
-    assert manager.collect_expired() == []
+    assert session.begin_close(reason="explicit_close") is True
+    assert session.lease.terminal_reason == "explicit_close"
+    # A terminal lease is never reaped again and a second close is a no-op.
+    assert session.lease.idle_expired(clock()) is False
+    assert session.lease.disconnect_grace_expired(clock()) is False
+    assert session.begin_close(reason="idle_ttl_expired") is True
+    assert session.lease.terminal_reason == "explicit_close"
+    with pytest.raises(RuntimeError, match="terminal"):
+        session.touch_lease(DuplexLeaseActivity.HEARTBEAT)
 
 
-def test_stale_fence_cannot_touch_detach_or_resume_lease() -> None:
+def test_stale_fence_cannot_start_a_lease_operation() -> None:
     clock = FakeMonotonicClock(0.0)
-    manager = DuplexSessionRuntimeManager(clock=clock)
-    current = DuplexFence("sid-fence", epoch=1)
+    session = _session("sid-fence", clock)
+    session.epoch = 1
+    session.sync_fence()
     stale = DuplexFence("sid-fence", epoch=0)
-    session = manager.open_session(current, lease_config=_lease_config())
 
-    with pytest.raises(RuntimeError, match="fence mismatch"):
-        session.touch(stale, DuplexLeaseActivity.APPEND)
-    with pytest.raises(RuntimeError, match="fence mismatch"):
-        session.detach(stale)
-    with pytest.raises(RuntimeError, match="fence mismatch"):
-        session.resume(stale, expected_lease_generation=0)
+    with pytest.raises(DuplexFenceMismatchError, match="fence mismatch"):
+        session.begin_lease_operation(stale, "append-1")
+    with pytest.raises(DuplexFenceMismatchError, match="fence mismatch"):
+        session.begin_lease_operation(DuplexFence("other-session", epoch=1), "append-2")
 
 
-def test_disabled_idle_expiry_never_collects_session() -> None:
+def test_disabled_idle_expiry_never_expires_session() -> None:
     clock = FakeMonotonicClock(0.0)
-    manager = DuplexSessionRuntimeManager(clock=clock)
-    manager.open_session(DuplexFence("sid-no-expiry"), lease_config=_lease_config(idle_ttl_s=None))
+    session = _session("sid-no-expiry", clock, idle_ttl_s=None)
 
     clock.advance(1_000_000.0)
 
-    assert manager.collect_expired() == []
+    assert session.lease.expires_at is None
+    assert session.lease.idle_expired(clock()) is False
 
 
 def test_detached_session_expires_at_disconnect_grace_when_idle_ttl_is_disabled() -> None:
     clock = FakeMonotonicClock(0.0)
-    manager = DuplexSessionRuntimeManager(clock=clock)
-    fence = DuplexFence("sid-disconnect-grace")
-    session = manager.open_session(fence, lease_config=_lease_config(idle_ttl_s=None))
+    session = _session("sid-disconnect-grace", clock, idle_ttl_s=None)
 
-    session.detach(fence)
+    session.detach_lease()
     clock.advance(29.0)
-    assert manager.collect_expired() == []
+    assert session.lease.disconnect_grace_expired(clock()) is False
 
     clock.advance(1.0)
-    expired = manager.collect_expired()
-
-    assert [item.session_id for item in expired] == [fence.session_id]
-    assert expired[0].reason == "disconnect_grace_expired"
+    assert session.lease.disconnect_grace_expired(clock()) is True
 
 
-def test_runtime_manager_enforces_server_owned_session_admission() -> None:
-    manager = DuplexSessionRuntimeManager(max_sessions=2)
-    manager.open_session(DuplexFence("sid-admission-a"))
-    manager.open_session(DuplexFence("sid-admission-b"))
-
-    with pytest.raises(RuntimeError, match="duplex_session_capacity_exhausted"):
-        manager.open_session(DuplexFence("sid-admission-c"))
-
-
-def test_completed_append_cache_is_bounded() -> None:
-    manager = DuplexSessionRuntimeManager(completed_append_limit=2)
-    fence = DuplexFence("sid-completed-cache")
-    session = manager.open_session(fence)
-
-    for index in range(3):
-        session.record_completed_append(
-            f"operation-{index}",
-            fence=fence,
-            mode=DuplexInputMode.TURN_COMMIT_ONLY,
-            final=True,
-            stage_results=[{"index": index}],
-        )
-
-    assert list(session.completed_appends) == ["operation-1", "operation-2"]
-
-    session.accept_fence(DuplexFence(fence.session_id, epoch=1))
-    assert session.completed_appends == {}
-
-
-def test_lease_config_and_expiry_record_are_immutable() -> None:
+def test_lease_config_is_immutable_and_validated() -> None:
     config = _lease_config()
     with pytest.raises(FrozenInstanceError):
         config.idle_ttl_s = 1.0  # type: ignore[misc]
-
-    clock = FakeMonotonicClock(0.0)
-    manager = DuplexSessionRuntimeManager(clock=clock)
-    manager.open_session(DuplexFence("sid-record"), lease_config=_lease_config(idle_ttl_s=1.0))
-    clock.advance(2.0)
-    record = manager.collect_expired()[0]
-    with pytest.raises(FrozenInstanceError):
-        record.reason = "changed"  # type: ignore[misc]
+    with pytest.raises(ValueError, match="idle_ttl_s"):
+        DuplexLeaseConfig(idle_ttl_s=0.0)
+    with pytest.raises(ValueError, match="disconnect_grace_s"):
+        DuplexLeaseConfig(disconnect_grace_s=0.0)
diff --git a/tests/engine/duplex/test_duplex_plugin.py b/tests/engine/duplex/test_duplex_plugin.py
new file mode 100644
index 000000000..f45b625e7
--- /dev/null
+++ b/tests/engine/duplex/test_duplex_plugin.py
@@ -0,0 +1,324 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""``DuplexModelPlugin`` loading/validation helpers and the ``PipelineConfig.duplex_plugin`` binding."""
+
+from __future__ import annotations
+
+from dataclasses import fields
+from pathlib import Path
+from typing import Any
+
+import pytest
+from vllm.sampling_params import SamplingParams
+
+from vllm_omni.config.stage_config import DuplexSessionRuntimeConfig, PipelineConfig
+from vllm_omni.engine.duplex.config import DuplexCapabilities, DuplexSessionConfig
+from vllm_omni.engine.duplex.contracts import DuplexAppendPlan
+from vllm_omni.engine.duplex.plugin import (
+    DuplexDataPlane,
+    DuplexModelPlugin,
+    DuplexModelSessionState,
+    DuplexRuntimeConfigError,
+    coerce_int,
+    load_duplex_plugin,
+    payload_turn_id,
+    reject_changed_runtime_value,
+    validate_duplex_plugin_sampling,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _encode_audio(audio: object, sample_rate_hz: int, fmt: str, speed: float | None) -> str | None:
+    del audio, sample_rate_hz, fmt, speed
+    return None
+
+
+class FakeDataPlane(DuplexDataPlane):
+    def begin_request(self, request_id: str) -> None:
+        pass
+
+    def is_terminal(self, request_id: str | None) -> bool:
+        return False
+
+    def mark_terminal(self, request_id: str) -> None:
+        pass
+
+    def close_stream(self, request_id: str) -> None:
+        pass
+
+    def close_session(self, session_id: str, *, active_request_id: str | None = None) -> None:
+        pass
+
+    def project(self, result, *, context=None):
+        del result, context
+        return []
+
+
+class FakePlugin(DuplexModelPlugin):
+    """Minimal plugin; referenced by dotted path from ``load_duplex_plugin`` tests."""
+
+    plugin_id = "fake-duplex"
+
+    def __init__(self, encode_audio) -> None:
+        super().__init__(encode_audio)
+        self.data_plane = FakeDataPlane()
+
+    def configure_sampling_params(self, *, runtime_config, defaults):
+        del runtime_config
+        return tuple(defaults)
+
+    def plan_append(self, **kwargs) -> DuplexAppendPlan:
+        del kwargs
+        return DuplexAppendPlan(prompt={"prompt_token_ids": [1]})
+
+    def decide_output(self, **kwargs):
+        del kwargs
+        return None
+
+    def create_session_state(self) -> DuplexModelSessionState:
+        raise NotImplementedError
+
+    def capabilities(self, *, max_sessions: int) -> DuplexCapabilities:
+        del max_sessions
+        return DuplexCapabilities()
+
+    def validate_client_extra_body(self, extra_body: object) -> None:
+        pass
+
+    async def prepare_runtime_config(self, config: DuplexSessionConfig, *, model_config: Any) -> dict[str, object]:
+        del config, model_config
+        return {}
+
+    def runtime_config_for_update(self, config, current):
+        del config
+        return dict(current)
+
+    def data_plane_context(self, **kwargs) -> object:
+        return dict(kwargs)
+
+
+class PluginWithoutId(FakePlugin):
+    plugin_id = ""
+
+
+class PluginWithoutDataPlane(FakePlugin):
+    def __init__(self, encode_audio) -> None:
+        DuplexModelPlugin.__init__(self, encode_audio)
+
+
+class PluginWithWrongDataPlane(FakePlugin):
+    def __init__(self, encode_audio) -> None:
+        DuplexModelPlugin.__init__(self, encode_audio)
+        self.data_plane = object()  # type: ignore[assignment]
+
+
+class NotAPlugin:
+    plugin_id = "lookalike"
+    data_plane = FakeDataPlane()
+
+    def __init__(self, encode_audio) -> None:
+        self.encode_audio = encode_audio
+
+
+def _path(cls: type) -> str:
+    return f"{__name__}.{cls.__name__}"
+
+
+# --------------------------------------------------------------------------- #
+# load_duplex_plugin                                                          #
+# --------------------------------------------------------------------------- #
+
+
+def test_load_duplex_plugin_instantiates_the_class_at_the_dotted_path() -> None:
+    plugin = load_duplex_plugin(_path(FakePlugin), _encode_audio)
+
+    assert type(plugin) is FakePlugin
+    assert plugin.plugin_id == "fake-duplex"
+    assert isinstance(plugin.data_plane, FakeDataPlane)
+    # Defaults of the optional class-level policy.
+    assert plugin.private_runtime_config_keys == frozenset()
+    assert plugin.silence_continuation_samples == 16000
+    assert plugin.runtime_config_for_function_output(DuplexSessionConfig(), {}, {"name": "tool"}) is None
+
+
+def test_load_duplex_plugin_rejects_a_non_plugin_class() -> None:
+    with pytest.raises(TypeError, match="not a DuplexModelPlugin"):
+        load_duplex_plugin(_path(NotAPlugin), _encode_audio)
+
+
+def test_load_duplex_plugin_requires_a_plugin_id() -> None:
+    with pytest.raises(TypeError, match="plugin_id"):
+        load_duplex_plugin(_path(PluginWithoutId), _encode_audio)
+
+
+@pytest.mark.parametrize("plugin_cls", [PluginWithoutDataPlane, PluginWithWrongDataPlane])
+def test_load_duplex_plugin_requires_a_data_plane(plugin_cls: type) -> None:
+    with pytest.raises(TypeError, match="DuplexDataPlane as data_plane"):
+        load_duplex_plugin(_path(plugin_cls), _encode_audio)
+
+
+def test_load_duplex_plugin_rejects_paths_without_a_module() -> None:
+    with pytest.raises(ValueError, match="Invalid duplex plugin path"):
+        load_duplex_plugin("FakePlugin", _encode_audio)
+
+
+def test_load_duplex_plugin_propagates_missing_attributes() -> None:
+    with pytest.raises(AttributeError):
+        load_duplex_plugin(f"{__name__}.NoSuchPlugin", _encode_audio)
+
+
+# --------------------------------------------------------------------------- #
+# validate_duplex_plugin_sampling                                             #
+# --------------------------------------------------------------------------- #
+
+
+def test_validate_duplex_plugin_sampling_accepts_one_parameter_per_stage() -> None:
+    plugin = FakePlugin(_encode_audio)
+
+    validate_duplex_plugin_sampling(plugin, sampling_defaults=(SamplingParams(), SamplingParams()))
+    validate_duplex_plugin_sampling(plugin, sampling_defaults=())
+
+
+def test_validate_duplex_plugin_sampling_rejects_stage_count_mismatch() -> None:
+    class WrongStageCountPlugin(FakePlugin):
+        def configure_sampling_params(self, *, runtime_config, defaults):
+            del runtime_config
+            return defaults[:1]
+
+    with pytest.raises(ValueError, match="one sampling parameter per stage"):
+        validate_duplex_plugin_sampling(
+            WrongStageCountPlugin(_encode_audio),
+            sampling_defaults=(SamplingParams(), SamplingParams()),
+        )
+
+
+def test_validate_duplex_plugin_sampling_rejects_type_mismatch() -> None:
+    class WrongSamplingTypePlugin(FakePlugin):
+        def configure_sampling_params(self, *, runtime_config, defaults):
+            del runtime_config
+            return tuple(object() for _ in defaults)
+
+    with pytest.raises(TypeError, match="sampling parameter type mismatch for stage 0"):
+        validate_duplex_plugin_sampling(
+            WrongSamplingTypePlugin(_encode_audio),
+            sampling_defaults=(SamplingParams(), SamplingParams()),
+        )
+
+
+def test_validate_duplex_plugin_sampling_skips_type_check_for_stages_without_defaults() -> None:
+    class ObjectSamplingPlugin(FakePlugin):
+        def configure_sampling_params(self, *, runtime_config, defaults):
+            del runtime_config
+            return tuple(object() for _ in defaults)
+
+    validate_duplex_plugin_sampling(ObjectSamplingPlugin(_encode_audio), sampling_defaults=(None, None))
+
+
+def test_validate_duplex_plugin_sampling_rejects_non_tuple_results() -> None:
+    class ListSamplingPlugin(FakePlugin):
+        def configure_sampling_params(self, *, runtime_config, defaults):
+            del runtime_config
+            return list(defaults)
+
+    with pytest.raises(TypeError, match="as a tuple"):
+        validate_duplex_plugin_sampling(ListSamplingPlugin(_encode_audio), sampling_defaults=(SamplingParams(),))
+
+
+# --------------------------------------------------------------------------- #
+# Runtime-config helpers                                                      #
+# --------------------------------------------------------------------------- #
+
+
+def test_reject_changed_runtime_value_only_raises_on_change() -> None:
+    reject_changed_runtime_value("voice-a", "voice-a", message="voice is fixed", code="voice_changed")
+
+    with pytest.raises(DuplexRuntimeConfigError, match="voice is fixed") as excinfo:
+        reject_changed_runtime_value("voice-b", "voice-a", message="voice is fixed", code="voice_changed")
+
+    assert excinfo.value.code == "voice_changed"
+    assert isinstance(excinfo.value, ValueError)
+
+
+def test_reject_changed_runtime_value_uses_the_requested_error_class() -> None:
+    class CustomRuntimeConfigError(DuplexRuntimeConfigError):
+        pass
+
+    with pytest.raises(CustomRuntimeConfigError) as excinfo:
+        reject_changed_runtime_value(1, 2, message="changed", code="custom", error_cls=CustomRuntimeConfigError)
+
+    assert excinfo.value.code == "custom"
+
+
+def test_duplex_runtime_config_error_defaults_its_code() -> None:
+    assert DuplexRuntimeConfigError("bad").code == "invalid_duplex_runtime_config"
+
+
+@pytest.mark.parametrize(
+    ("payload", "expected"),
+    [
+        ({"duplex_turn_id": 3}, 3),
+        ({"duplex_turn_id": "7"}, 7),
+        ({"model_turn_id": 2}, 2),
+        ({"duplex_turn_id": 5, "model_turn_id": 9}, 5),
+        ({"duplex_turn_id": "not-a-number"}, None),
+        ({}, None),
+        ("turn", None),
+        (None, None),
+    ],
+)
+def test_payload_turn_id_prefers_duplex_turn_id_and_coerces(payload: object, expected: int | None) -> None:
+    assert payload_turn_id(payload) == expected
+
+
+@pytest.mark.parametrize(
+    ("value", "expected"),
+    [(4, 4), ("11", 11), (2.9, 2), (True, 1), (None, None), ("x", None), (object(), None), ([1], None)],
+)
+def test_coerce_int(value: object, expected: int | None) -> None:
+    assert coerce_int(value) == expected
+
+
+# --------------------------------------------------------------------------- #
+# PipelineConfig binding                                                      #
+# --------------------------------------------------------------------------- #
+
+
+def test_pipeline_config_binds_one_duplex_plugin_path() -> None:
+    field_defaults = {f.name: f.default for f in fields(PipelineConfig)}
+
+    assert "duplex_plugin" in field_defaults
+    assert field_defaults["duplex_plugin"] is None
+
+    # The pre-framework fields survive only so that the pipelines of the models
+    # that are not ported yet still construct (RFC vllm-omni#7181 ports them).
+    # Nothing in the duplex framework may read them: a pipeline is a duplex
+    # model iff it declares ``duplex_plugin``.
+    legacy_fields = ("duplex_runtime_extension", "duplex_serving_adapter", "duplex_control_enabled")
+    for legacy_field in legacy_fields:
+        assert legacy_field in field_defaults
+
+    framework_sources = [
+        *(Path("vllm_omni/engine/duplex").glob("*.py")),
+        *(Path("vllm_omni/entrypoints/duplex").glob("*.py")),
+        Path("vllm_omni/engine/duplex_omni_engine.py"),
+        Path("vllm_omni/engine/duplex_orchestrator.py"),
+        Path("vllm_omni/entrypoints/duplex_omni.py"),
+    ]
+    readers = [
+        f"{source}:{legacy_field}"
+        for source in framework_sources
+        for legacy_field in legacy_fields
+        if legacy_field in source.read_text(encoding="utf-8")
+    ]
+    assert readers == []
+
+    # Same rule for the runtime-config knob the framework stopped reading: the
+    # append-retry table it bounded went away with the correlated append RPC.
+    assert "completed_append_cache_size" in {f.name for f in fields(DuplexSessionRuntimeConfig)}
+    assert [
+        str(source)
+        for source in framework_sources
+        if "completed_append_cache_size" in source.read_text(encoding="utf-8")
+    ] == []
diff --git a/tests/engine/duplex/test_duplex_runtime.py b/tests/engine/duplex/test_duplex_runtime.py
deleted file mode 100644
index 9cbf4d6e1..000000000
--- a/tests/engine/duplex/test_duplex_runtime.py
+++ /dev/null
@@ -1,483 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-from dataclasses import FrozenInstanceError
-from types import SimpleNamespace
-
-import pytest
-from vllm.sampling_params import SamplingParams
-
-from vllm_omni.engine.duplex import runtime as duplex_runtime
-from vllm_omni.engine.duplex.contracts import (
-    duplex_data_plane_request_info,
-    duplex_resource_request_belongs_to_session,
-    duplex_resource_request_id,
-)
-from vllm_omni.engine.duplex.messages import DuplexFence
-from vllm_omni.engine.duplex.runtime import (
-    DuplexInputMode,
-    DuplexOutputAction,
-    DuplexOutputDecision,
-    DuplexRuntimeCapabilities,
-    DuplexSessionRuntimeManager,
-)
-from vllm_omni.model_executor.models.minicpmo_4_5.duplex.runtime import (
-    MiniCPMO45DuplexRuntimeExtension,
-    build_duplex_data_plane_prompt,
-    duplex_scheduler_token_budget,
-)
-
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
-
-
-def test_duplex_fence_is_immutable():
-    fence = DuplexFence("session")
-
-    with pytest.raises(FrozenInstanceError):
-        fence.epoch = 1  # type: ignore[misc]
-
-    assert not hasattr(fence, "__dict__")
-
-
-def test_duplex_runtime_tracks_stage_bindings_and_barge_in_epoch():
-    manager = DuplexSessionRuntimeManager()
-    session = manager.open_session(
-        DuplexFence("sid-1"),
-        capabilities=DuplexRuntimeCapabilities(
-            input_modes={DuplexInputMode.APPEND_TOKENS},
-        ),
-    )
-    session.bind_stage_request(stage_id=0, request_id="req-stage0", fence=session.fence)
-    session.bind_stage_request(stage_id=1, request_id="req-stage1", fence=session.fence)
-
-    update = session.append_input(mode=DuplexInputMode.APPEND_TOKENS, fence=session.fence)
-    next_fence = DuplexFence("sid-1", epoch=1)
-    stale_request_ids = session.release_fence(session.fence)
-    session.accept_fence(next_fence)
-
-    assert update.seq == 1
-    assert session.fence == next_fence
-    assert stale_request_ids == ["req-stage0", "req-stage1"]
-    assert session.stage_bindings == {}
-
-
-def test_duplex_runtime_tracks_same_request_id_for_each_pipeline_stage():
-    manager = DuplexSessionRuntimeManager()
-    fence = DuplexFence("sid-shared-pipeline-request")
-    session = manager.open_session(fence)
-
-    session.reserve_stage_request(0, "req-shared", fence=fence)
-    session.bind_stage_request(0, "req-shared", fence=fence)
-    session.bind_stage_request(1, "req-shared", fence=fence)
-
-    assert session.stage_bindings[0].request_id == "req-shared"
-    assert session.stage_bindings[1].request_id == "req-shared"
-    assert session.resource_request_ids() == ["req-shared"]
-    assert session.input_seq == 0
-
-
-def test_duplex_runtime_extension_validation_rejects_missing_methods():
-    class IncompleteExtension:
-        def configure_sampling_params(self, *, runtime_config, defaults):
-            del runtime_config
-            return defaults
-
-    with pytest.raises(TypeError, match="plan_append"):
-        duplex_runtime.validate_duplex_runtime_extension(IncompleteExtension())
-
-
-def test_duplex_runtime_extension_validation_rejects_stage_count_mismatch():
-    class WrongStageCountExtension(MiniCPMO45DuplexRuntimeExtension):
-        def configure_sampling_params(self, *, runtime_config, defaults):
-            del runtime_config
-            return defaults[:1]
-
-    with pytest.raises(ValueError, match="one sampling parameter per stage"):
-        duplex_runtime.validate_duplex_runtime_extension(
-            WrongStageCountExtension(),
-            sampling_defaults=(SamplingParams(), SamplingParams()),
-        )
-
-
-def test_duplex_runtime_extension_validation_rejects_sampling_type_mismatch():
-    class WrongSamplingTypeExtension(MiniCPMO45DuplexRuntimeExtension):
-        def configure_sampling_params(self, *, runtime_config, defaults):
-            del runtime_config
-            return tuple(object() for _ in defaults)
-
-    with pytest.raises(TypeError, match="sampling parameter type"):
-        duplex_runtime.validate_duplex_runtime_extension(
-            WrongSamplingTypeExtension(),
-            sampling_defaults=(SamplingParams(), SamplingParams()),
-        )
-
-
-def test_duplex_output_decision_metadata_is_immutable():
-    decision = DuplexOutputDecision(
-        action=DuplexOutputAction.DIRECT_RESPONSE,
-        metadata={"model_listen": True},
-    )
-
-    with pytest.raises(TypeError):
-        decision.metadata["model_listen"] = False
-
-
-def _decide_minicpmo_output(
-    output: object,
-    *,
-    segment_token_ids: tuple[int, ...] = (),
-    segment_output_metadata: dict | None = None,
-):
-    return MiniCPMO45DuplexRuntimeExtension().decide_output(
-        stage_id=0,
-        final_stage_id=1,
-        segment_finished=True,
-        segment_token_ids=segment_token_ids,
-        segment_output_metadata=segment_output_metadata or {},
-        output=output,
-    )
-
-
-def test_minicpmo_extension_owns_stage_sampling_overrides():
-    defaults = (
-        SamplingParams(max_tokens=4),
-        SamplingParams(max_tokens=8),
-    )
-
-    configured = MiniCPMO45DuplexRuntimeExtension().configure_sampling_params(
-        runtime_config={
-            "duplex_stage_max_tokens": {"0": 20},
-            "duplex_stage_sampling_params": {"1": {"stop_token_ids": [151645]}},
-        },
-        defaults=defaults,
-    )
-
-    assert configured[0].max_tokens == 20
-    assert configured[1].stop_token_ids == [151645]
-    assert defaults[0].max_tokens == 4
-    assert 151645 not in (defaults[1].stop_token_ids or [])
-
-
-def test_minicpmo_output_decision_uses_raw_streaming_token_snapshot():
-    decision = _decide_minicpmo_output(
-        SimpleNamespace(outputs=[SimpleNamespace()]),
-        segment_token_ids=(151705,),
-        segment_output_metadata={"special_token_ids": {"listen_token_id": 151705}},
-    )
-
-    assert decision is not None
-    assert decision.action is DuplexOutputAction.DIRECT_RESPONSE
-    assert decision.metadata["duplex_native_decision"] == "listen"
-    assert decision.metadata["model_listen"] is True
-
-
-@pytest.mark.parametrize("attr", ["token_ids", "cumulative_token_ids"])
-def test_minicpmo_output_decision_ignores_output_level_token_history(attr):
-    output = SimpleNamespace(
-        multimodal_output={"special_token_ids": {"listen_token_id": 151705}},
-        outputs=[SimpleNamespace()],
-        **{attr: [42, 151705]},
-    )
-
-    assert _decide_minicpmo_output(output) is None
-
-
-@pytest.mark.parametrize("attr", ["token_ids", "cumulative_token_ids"])
-def test_minicpmo_output_decision_uses_completion_token_ids(attr):
-    output = SimpleNamespace(
-        multimodal_output={"special_token_ids": {"listen_token_id": 151705}},
-        outputs=[SimpleNamespace(**{attr: [42, 151705]})],
-    )
-
-    assert _decide_minicpmo_output(output) is not None
-
-
-def test_minicpmo_output_decision_uses_completion_stop_reason():
-    output = SimpleNamespace(
-        multimodal_output={"special_token_ids": {"listen_token_id": 151705}},
-        outputs=[SimpleNamespace(stop_reason=151705)],
-    )
-
-    assert _decide_minicpmo_output(output) is not None
-
-
-def test_duplex_runtime_cancel_fence_rejects_late_append_and_accepts_next_epoch():
-    manager = DuplexSessionRuntimeManager()
-    cancelled_fence = DuplexFence("sid-cancel-race")
-    next_fence = DuplexFence("sid-cancel-race", epoch=1)
-    session = manager.open_session(
-        cancelled_fence,
-        capabilities=DuplexRuntimeCapabilities(
-            input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK},
-        ),
-    )
-    session.bind_stage_request(
-        stage_id=0,
-        request_id="req-cancelled",
-        fence=cancelled_fence,
-    )
-
-    stale_request_ids = session.cancel_fence(cancelled_fence, next_fence)
-
-    assert stale_request_ids == ["req-cancelled"]
-    assert session.fence == next_fence
-    assert session.stage_bindings == {}
-    with pytest.raises(RuntimeError, match="fence mismatch"):
-        session.append_input(
-            mode=DuplexInputMode.APPEND_AUDIO_CHUNK,
-            fence=cancelled_fence,
-        )
-    update = session.append_input(
-        mode=DuplexInputMode.APPEND_AUDIO_CHUNK,
-        fence=next_fence,
-    )
-    assert update.seq == 1
-
-
-def test_duplex_runtime_stale_close_preserves_live_session_and_bindings():
-    manager = DuplexSessionRuntimeManager()
-    current_fence = DuplexFence("sid-stale-close", epoch=1)
-    session = manager.open_session(
-        current_fence,
-        capabilities=DuplexRuntimeCapabilities(
-            input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK},
-        ),
-    )
-    session.bind_stage_request(0, "req-live", fence=current_fence)
-
-    with pytest.raises(RuntimeError, match="fence mismatch"):
-        manager.close_session(DuplexFence("sid-stale-close"))
-
-    assert manager.get("sid-stale-close") is session
-    assert session.stage_request_ids() == ["req-live"]
-
-
-def test_duplex_runtime_reopen_rejects_late_append_from_old_incarnation():
-    manager = DuplexSessionRuntimeManager()
-    old_fence = DuplexFence("sid-reopen", incarnation=0)
-    old_session = manager.open_session(
-        old_fence,
-        capabilities=DuplexRuntimeCapabilities(
-            input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK},
-        ),
-    )
-    manager.close_session(old_fence)
-
-    new_fence = DuplexFence("sid-reopen", incarnation=1)
-    new_session = manager.open_session(
-        new_fence,
-        capabilities=old_session.capabilities,
-    )
-
-    with pytest.raises(RuntimeError, match="fence mismatch"):
-        new_session.append_input(
-            mode=DuplexInputMode.APPEND_AUDIO_CHUNK,
-            fence=old_fence,
-        )
-    assert (
-        new_session.append_input(
-            mode=DuplexInputMode.APPEND_AUDIO_CHUNK,
-            fence=new_fence,
-        ).seq
-        == 1
-    )
-
-
-def test_duplex_prompt_expands_incarnation_metadata():
-    fence = DuplexFence("sid-incarnation", incarnation=3)
-
-    prompt = build_duplex_data_plane_prompt(
-        request_id=duplex_resource_request_id(fence, "stage0"),
-        fence=fence,
-        session_config={},
-        runtime_config={},
-        seq=1,
-        turn_seq=1,
-        mode=DuplexInputMode.APPEND_AUDIO_CHUNK,
-        payload={"is_speech": True},
-        final=False,
-    )
-
-    assert prompt["model_intermediate_buffer"]["duplex"]["incarnation"] == 3
-
-
-def test_duplex_runtime_tracks_turn_local_append_sequence():
-    manager = DuplexSessionRuntimeManager()
-    session = manager.open_session(
-        DuplexFence("sid-turn-seq"),
-        capabilities=DuplexRuntimeCapabilities(
-            input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK},
-        ),
-    )
-
-    first = session.append_input(mode=DuplexInputMode.APPEND_AUDIO_CHUNK, fence=session.fence)
-    second = session.append_input(mode=DuplexInputMode.APPEND_AUDIO_CHUNK, fence=session.fence)
-    next_turn = DuplexFence("sid-turn-seq", turn_id=1, response_seq=1)
-    third = session.append_input(
-        mode=DuplexInputMode.APPEND_AUDIO_CHUNK,
-        fence=next_turn,
-    )
-    fourth = session.append_input(
-        mode=DuplexInputMode.APPEND_AUDIO_CHUNK,
-        fence=next_turn,
-    )
-
-    assert [first.seq, second.seq, third.seq, fourth.seq] == [1, 2, 3, 4]
-    assert [first.turn_seq, second.turn_seq, third.turn_seq, fourth.turn_seq] == [1, 2, 1, 2]
-    assert [first.turn_id, second.turn_id, third.turn_id, fourth.turn_id] == [0, 0, 1, 1]
-
-
-def test_duplex_runtime_rejects_unsupported_append_mode():
-    manager = DuplexSessionRuntimeManager()
-    session = manager.open_session(
-        DuplexFence("sid-2"),
-        capabilities=DuplexRuntimeCapabilities(input_modes={DuplexInputMode.TURN_COMMIT_ONLY}),
-    )
-
-    with pytest.raises(ValueError, match="not supported"):
-        session.append_input(mode=DuplexInputMode.APPEND_TOKENS, fence=session.fence)
-
-
-def test_duplex_data_plane_request_info_extracts_structured_stage_result():
-    request_id, response_stage_id = duplex_data_plane_request_info(
-        {
-            "stage_results": [
-                {"result": {"supported": True}},
-                {
-                    "result": {
-                        "data_plane_append": True,
-                        "request_id": "duplex-sid-e0-stage0-s1",
-                        "response_stage_id": 1,
-                    }
-                },
-            ]
-        }
-    )
-
-    assert request_id == "duplex-sid-e0-stage0-s1"
-    assert response_stage_id == 1
-
-
-def test_duplex_data_plane_request_info_rejects_missing_request_id():
-    assert duplex_data_plane_request_info(
-        {
-            "stage_results": [
-                {
-                    "result": {
-                        "data_plane_append": True,
-                        "request_id": "",
-                        "response_stage_id": 1,
-                    }
-                }
-            ]
-        }
-    ) == (None, None)
-
-
-def test_duplex_scheduler_token_budget_estimates_pcm_slots():
-    assert (
-        duplex_scheduler_token_budget(
-            {
-                "audio": "AAAAAA==",
-                "format": "pcm_f32le",
-                "sample_rate_hz": 16000,
-            }
-        )
-        == 16
-    )
-
-
-def test_duplex_scheduler_token_budget_ignores_client_budget_fields():
-    assert (
-        duplex_scheduler_token_budget(
-            {
-                "audio": "AAAAAA==",
-                "format": "pcm_f32le",
-                "duplex_num_input_tokens": 999,
-                "num_input_tokens": 999,
-            }
-        )
-        == 16
-    )
-
-
-def test_resource_state_rejects_fence_regression_and_requires_explicit_fence():
-    current = DuplexFence("sid", epoch=2, turn_id=3, response_seq=4)
-    manager = DuplexSessionRuntimeManager()
-    session = manager.open_session(
-        current,
-        capabilities=DuplexRuntimeCapabilities(input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK}),
-    )
-
-    for stale in (
-        DuplexFence("sid", epoch=1, turn_id=99, response_seq=99),
-        DuplexFence("sid", epoch=2, turn_id=2, response_seq=4),
-        DuplexFence("sid", epoch=2, turn_id=3, response_seq=3),
-    ):
-        with pytest.raises(RuntimeError, match="fence mismatch"):
-            session.accept_fence(stale)
-        assert session.fence == current
-
-    with pytest.raises(TypeError, match="fence"):
-        session.bind_stage_request(0, "request")
-    with pytest.raises(TypeError, match="fence"):
-        session.append_input(mode=DuplexInputMode.APPEND_AUDIO_CHUNK)
-    with pytest.raises(TypeError, match="DuplexFence"):
-        manager.open_session("legacy-session")
-    with pytest.raises(TypeError, match="DuplexFence"):
-        manager.close_session("legacy-session")
-
-
-def test_resource_request_id_is_derived_from_fence_and_role():
-    fence = DuplexFence("sid-with-dashes", epoch=7, turn_id=11, response_seq=13)
-
-    assert duplex_resource_request_id(fence, "stage0") == "duplex-s.c2lkLXdpdGgtZGFzaGVz.i.0.e.7.r.stage0"
-    assert duplex_resource_request_id(fence, "stage1") == "duplex-s.c2lkLXdpdGgtZGFzaGVz.i.0.e.7.r.stage1"
-
-
-def test_resource_request_id_codec_separates_session_id_from_incarnation():
-    embedded_incarnation = duplex_resource_request_id(
-        DuplexFence("foo-i1", incarnation=0),
-        "stage0",
-    )
-    actual_incarnation = duplex_resource_request_id(
-        DuplexFence("foo", incarnation=1),
-        "stage0",
-    )
-
-    assert embedded_incarnation != actual_incarnation
-
-
-def test_resource_request_id_session_membership_uses_encoded_identity():
-    request_id = duplex_resource_request_id(
-        DuplexFence("sid-with-dashes", incarnation=2, epoch=7),
-        "stage0",
-    )
-
-    assert duplex_resource_request_belongs_to_session(request_id, "sid-with-dashes") is True
-    assert duplex_resource_request_belongs_to_session(request_id, "sid") is False
-    assert duplex_resource_request_belongs_to_session("duplex-s.invalid.i.x.e.7.r.stage0", "sid") is False
-
-
-def test_placeholder_budget_is_planned_inside_omni_engine_boundary():
-    fence = DuplexFence("sid", turn_id=1, response_seq=1)
-    prompt = build_duplex_data_plane_prompt(
-        request_id=duplex_resource_request_id(fence, "stage0"),
-        fence=fence,
-        session_config={},
-        runtime_config={},
-        seq=2,
-        turn_seq=1,
-        mode=DuplexInputMode.APPEND_AUDIO_CHUNK,
-        payload={
-            "audio": "AAAAAA==",
-            "format": "pcm_f32le",
-            "duplex_num_input_tokens": 999,
-            "num_input_tokens": 999,
-        },
-        final=False,
-    )
-
-    assert len(prompt["prompt_token_ids"]) == 16
-    assert prompt["model_intermediate_buffer"]["duplex"]["fence"] == fence
-    assert prompt["model_intermediate_buffer"]["duplex"]["scheduler_token_budget"] == 16
diff --git a/tests/engine/duplex/test_engine_session.py b/tests/engine/duplex/test_engine_session.py
new file mode 100644
index 000000000..5ef4ab6b9
--- /dev/null
+++ b/tests/engine/duplex/test_engine_session.py
@@ -0,0 +1,690 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Session-state semantics of the engine-resident duplex session (``DuplexEngineSession``)."""
+
+from __future__ import annotations
+
+from dataclasses import FrozenInstanceError
+
+import pytest
+
+from vllm_omni.engine.duplex.config import (
+    DuplexCapabilities,
+    DuplexConfigError,
+    DuplexOverlapPolicy,
+    DuplexSessionConfig,
+    DuplexTurnEventType,
+    DuplexTurnState,
+    ResponseCreateOptions,
+)
+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,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _session(session_id: str = "duplex-test", config: DuplexSessionConfig | None = None) -> DuplexEngineSession:
+    return DuplexEngineSession(session_id=session_id, config=config or DuplexSessionConfig(model="test-model"))
+
+
+def test_commit_audio_input_does_not_advance_model_turn_identity():
+    session = _session()
+
+    first = session.commit_audio_input(transcript="first chunk")
+    second = session.commit_audio_input(transcript="second chunk")
+
+    assert session.input_commit_seq == 2
+    assert first.input_commit_seq == 1
+    assert second.input_commit_seq == 2
+    assert first.turn_id == second.turn_id == session.turn_id == 0
+    assert first.message["transcript"] == "first chunk"
+    assert first.message["content"] == [
+        {"type": "audio_url", "audio_url": {"url": "native-duplex:input-audio"}, "transcript": "first chunk"}
+    ]
+    assert len(session.history) == 2
+    assert session.turn_state == DuplexTurnState.USER_COMMITTED
+
+
+def test_commit_audio_input_accepts_explicit_turn_id():
+    session = _session()
+
+    committed = session.commit_audio_input(turn_id=4)
+
+    assert committed.turn_id == 4
+    assert session.turn_id == 0
+    assert "transcript" not in committed.message
+
+
+# ---- response options ----
+
+
+def test_response_options_apply_to_one_response_without_mutating_session_defaults():
+    session = _session(config=DuplexSessionConfig(instructions="base", voice="base-voice", max_tokens=64))
+    session.reserve_response_options(
+        ResponseCreateOptions(instructions="one response", voice="override-voice", max_tokens=8)
+    )
+
+    assert session.config.instructions == "base"
+    assert session.config.voice == "base-voice"
+    assert session.response_config is session.config
+    session.begin_response()
+    assert session.config.instructions == "base"
+    assert session.config.voice == "base-voice"
+    assert session.response_config.instructions == "one response"
+    assert session.response_config.voice == "override-voice"
+    assert session.response_config.max_tokens == 8
+
+    session.end_response()
+    assert session.response_config is session.config
+    assert session.config.instructions == "base"
+    assert session.config.voice == "base-voice"
+    assert session.config.max_tokens == 64
+
+
+def test_response_options_cannot_overwrite_an_unconsumed_reservation():
+    session = _session(config=DuplexSessionConfig(instructions="base"))
+    session.reserve_response_options(ResponseCreateOptions(instructions="first"))
+
+    with pytest.raises(RuntimeError, match="already reserved"):
+        session.reserve_response_options(ResponseCreateOptions(instructions="second"))
+
+    session.begin_response()
+    assert session.response_config.instructions == "first"
+
+
+def test_response_options_cannot_be_reserved_while_response_is_active():
+    session = _session(config=DuplexSessionConfig(instructions="base"))
+    session.begin_response()
+
+    with pytest.raises(RuntimeError, match="active"):
+        session.reserve_response_options(ResponseCreateOptions(instructions="too late"))
+
+
+def test_discarded_response_options_do_not_apply():
+    session = _session(config=DuplexSessionConfig(instructions="base"))
+    session.reserve_response_options(ResponseCreateOptions(instructions="dropped"))
+    session.discard_response_options()
+
+    session.begin_response()
+
+    assert session.response_config.instructions == "base"
+
+
+# ---- response / overlap identity ----
+
+
+def test_session_owns_response_and_overlap_identity():
+    session = _session()
+
+    response_id = session.begin_response()
+    assert session.turn_state == DuplexTurnState.ASSISTANT_GENERATING
+    session.accumulate_overlap_speech(320)
+    session.accumulate_overlap_speech(180)
+    session.end_response()
+
+    assert session.active_response_id is None
+    assert session.last_response_id == response_id
+    assert session.overlap_speech_ms == 500
+    assert session.reset_overlap_speech() == 500
+    assert session.overlap_speech_ms == 0
+    assert session.turn_state == DuplexTurnState.IDLE
+
+
+def test_session_composes_single_owner_ledgers_with_immutable_views():
+    session = _session()
+
+    session.bind_request("req-1")
+    response_id = session.begin_response(turn_id=3)
+    session.mark_audio_sent(duration_ms=240)
+
+    assert session.active_request_id == "req-1"
+    assert session.active_response_id == response_id
+    assert session.active_response_turn_id == 3
+    assert session.playback.sent_ms == 240
+    assert session.turn_state == DuplexTurnState.ASSISTANT_PLAYING
+    with pytest.raises(FrozenInstanceError):
+        session.playback.sent_ms = 480  # type: ignore[misc]
+    assert session.playback.sent_ms == 240
+
+
+def test_barge_in_advances_epoch_and_drops_uncommitted_assistant_text():
+    session = _session()
+    response_id = session.begin_response()
+    session.bind_request("chatcmpl-duplex-test")
+    session.append_assistant_text("unplayed answer")
+
+    new_epoch = session.barge_in()
+
+    assert response_id is not None
+    assert new_epoch == 1
+    assert session.epoch == 1
+    assert session.accepted_fence == DuplexFence(session.session_id, epoch=1, turn_id=0)
+    assert session.active_request_id is None
+    assert session.active_response_id is None
+    assert session.assistant_text_buffer == ()
+    assert session.history == ()
+    assert session.turn_state == DuplexTurnState.BARGE_IN
+
+
+# ---- playback ledger ----
+
+
+def test_playback_ack_tracks_committed_cursor_separately():
+    session = _session()
+    session.mark_audio_sent(duration_ms=10_000)
+
+    session.acknowledge_playback(played_ms=2_000)
+
+    assert session.playback.generated_ms == 10_000
+    assert session.playback.sent_ms == 10_000
+    assert session.playback.played_ms == 2_000
+    assert session.playback.committed_ms == 2_000
+    assert session.playback.as_dict() == {
+        "generated_ms": 10_000,
+        "sent_ms": 10_000,
+        "played_ms": 2_000,
+        "committed_ms": 2_000,
+    }
+
+
+def test_playback_ack_is_scoped_per_response():
+    session = _session()
+    first = session.begin_response()
+    session.mark_audio_sent(duration_ms=3_000)
+    session.end_response()
+    second = session.begin_response()
+    session.mark_audio_sent(duration_ms=1_000)
+
+    session.acknowledge_playback(played_ms=2_500, response_id=first)
+
+    assert session.playback_for_response(first).played_ms == 2_500
+    assert session.playback_for_response(second).played_ms == 0
+    assert session.playback.played_ms == 0
+
+
+def test_history_commit_uses_audio_text_alignment_marks():
+    session = _session()
+    session.begin_response()
+
+    session.append_assistant_text("hello ")
+    session.mark_audio_sent(duration_ms=1_000, text_chars=6)
+    session.append_assistant_text("world")
+    session.mark_audio_sent(duration_ms=2_000, text_chars=11)
+    assert [(mark.text_chars, mark.audio_end_ms) for mark in session.assistant_audio_text_marks] == [
+        (6, 1_000),
+        (11, 2_000),
+    ]
+    session.acknowledge_playback(played_ms=1_200, committed_ms=1_200)
+
+    committed = session.end_response(commit_text=True)
+
+    assert committed == {"role": "assistant", "content": "hello w"}
+    assert session.history[-1] == committed
+    assert session.last_assistant_full_message == {"role": "assistant", "content": "hello world"}
+
+
+def test_history_commit_with_ack_only_policy_defers_unacknowledged_text():
+    session = _session(config=DuplexSessionConfig(playback_commit_policy="ack_only"))
+    response_id = session.begin_response()
+    session.append_assistant_text("never played")
+    session.mark_audio_sent(duration_ms=1_000, text_chars=12)
+
+    committed = session.end_response(commit_text=True)
+
+    assert committed is None
+    assert session.history == ()
+    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()
+    session.append_assistant_text("hello ")
+    session.mark_audio_sent(duration_ms=1_000, text_chars=6)
+    session.append_assistant_text("world")
+    session.mark_audio_sent(duration_ms=2_000, text_chars=11)
+    session.acknowledge_playback(played_ms=2_000)
+    committed = session.end_response(commit_text=True)
+    assert committed == {"role": "assistant", "content": "hello world"}
+    item_id = f"item_{response_id}"
+    session.register_history_item(item_id, committed)
+
+    assert session.truncate_history_item(item_id, audio_end_ms=1_000) is True
+
+    assert session.history[-1] == {"role": "assistant", "content": "hello"}
+    assert session.history_item_ids[item_id] == {"role": "assistant", "content": "hello"}
+    assert session.delete_history_item(item_id) is True
+    assert session.history == ()
+
+
+# ---- turn signals / model turns ----
+
+
+@pytest.mark.parametrize(
+    ("event_type", "turn_state"),
+    [
+        (DuplexTurnEventType.USER_STARTED, DuplexTurnState.USER_SPEAKING),
+        (DuplexTurnEventType.USER_COMMITTED, DuplexTurnState.USER_COMMITTED),
+        (DuplexTurnEventType.ASSISTANT_STARTED, DuplexTurnState.ASSISTANT_GENERATING),
+        (DuplexTurnEventType.ASSISTANT_DONE, DuplexTurnState.IDLE),
+        (DuplexTurnEventType.BARGE_IN, DuplexTurnState.BARGE_IN),
+    ],
+)
+def test_signal_turn_transitions_and_returns_typed_turn_event(event_type, turn_state):
+    session = _session()
+
+    event = session.signal_turn(event_type.value)
+
+    assert isinstance(event, TurnEvent)
+    assert session.turn_state == turn_state
+    wire = event.to_realtime()
+    assert wire["type"] == "turn.event"
+    assert wire["event"] == event_type.value
+    assert wire["turn_state"] == turn_state.value
+
+
+def test_signal_turn_playback_ack_updates_cursor_and_close_marks_session_closing():
+    session = _session()
+    session.mark_audio_sent(duration_ms=5_000)
+
+    ack = session.signal_turn("playback_ack", {"played_ms": 1_500, "committed_ms": 1_000})
+    assert ack.event == "playback_ack"
+    assert session.playback.played_ms == 1_500
+    assert session.playback.committed_ms == 1_000
+
+    close = session.signal_turn(DuplexTurnEventType.CLOSE.value)
+    assert close.event == "close"
+    assert session.state.value == "closing"
+
+
+def test_complete_model_turn_advances_turn_id_and_fence():
+    session = _session()
+    assert session.fence == DuplexFence(session.session_id, epoch=0, turn_id=0)
+
+    session.complete_model_turn(0)
+
+    assert session.turn_id == 1
+    assert session.fence == DuplexFence(session.session_id, epoch=0, turn_id=1)
+    assert session.accepted_fence == session.fence
+
+    # A stale terminal for an already-completed turn does not move identity backwards.
+    session.complete_model_turn(0)
+    assert session.turn_id == 1
+    session.complete_model_turn(3)
+    assert session.turn_id == 4
+    assert session.accepted_fence.turn_id == 4
+
+
+# ---- fence validation ----
+
+
+def test_accept_fence_rejects_stale_or_foreign_fences():
+    session = _session("sid-fence")
+    session.complete_model_turn(0)
+
+    with pytest.raises(DuplexFenceMismatchError):
+        session.accept_fence(DuplexFence("sid-fence", epoch=0, turn_id=0))
+    with pytest.raises(DuplexFenceMismatchError):
+        session.accept_fence(DuplexFence("sid-other", epoch=0, turn_id=1))
+
+    session.accept_fence(DuplexFence("sid-fence", epoch=1, turn_id=0))
+    assert session.accepted_fence == DuplexFence("sid-fence", epoch=1, turn_id=0)
+
+
+def test_prepare_and_commit_append_sequence_chunks_per_turn_and_epoch():
+    session = _session("sid-append")
+    fence = session.fence
+
+    first = session.commit_append(session.prepare_append(fence))
+    second = session.commit_append(session.prepare_append(fence))
+    assert (first.seq, first.turn_seq, first.turn_id) == (1, 1, 0)
+    assert (second.seq, second.turn_seq, second.turn_id) == (2, 2, 0)
+
+    session.complete_model_turn(0)
+    third = session.commit_append(session.prepare_append(session.fence))
+    assert (third.seq, third.turn_seq, third.turn_id) == (3, 1, 1)
+
+    # Barge-in advances the epoch (turn_id is kept) and restarts the append sequence.
+    session.barge_in()
+    assert session.fence == DuplexFence("sid-append", epoch=1, turn_id=1)
+    fourth = session.commit_append(session.prepare_append(session.fence))
+    assert (fourth.seq, fourth.turn_seq, fourth.turn_id) == (1, 1, 1)
+    assert session.input_seq == 1
+
+
+def test_commit_append_rejects_stale_reservation():
+    session = _session("sid-append-stale")
+    fence = session.fence
+    reservation = session.prepare_append(fence)
+    session.commit_append(session.prepare_append(fence))
+
+    with pytest.raises(RuntimeError, match="stale"):
+        session.commit_append(reservation)
+
+    with pytest.raises(DuplexFenceMismatchError):
+        session.prepare_append(DuplexFence("sid-other", epoch=0, turn_id=0))
+
+
+def test_cancel_fence_releases_stage_requests_and_advances_identity():
+    session = _session("sid-cancel")
+    cancelled = session.fence
+    session.reserve_stage_request(0, "req-a", fence=cancelled)
+    session.bind_stage_request(1, "req-b", fence=cancelled)
+    assert session.stage_request_submitted(1, "req-b") is True
+    assert session.stage_request_submitted(0, "req-a") is False
+    next_fence = DuplexFence("sid-cancel", epoch=1, turn_id=0)
+
+    stale = session.cancel_fence(cancelled, next_fence)
+
+    assert stale == ["req-a", "req-b"]
+    assert session.resource_request_ids() == []
+    assert session.accepted_fence == next_fence
+
+    with pytest.raises(DuplexFenceMismatchError):
+        session.cancel_fence(next_fence, DuplexFence("sid-cancel", epoch=1, turn_id=1))
+    with pytest.raises(DuplexFenceMismatchError):
+        session.cancel_fence(DuplexFence("sid-other", epoch=1, turn_id=0), DuplexFence("sid-cancel", epoch=2))
+
+
+# ---- public view ----
+
+
+def test_as_public_dict_exposes_identity_capabilities_and_playback():
+    session = _session("duplex-public", config=DuplexSessionConfig(model="m", voice="alloy"))
+    session.mark_audio_sent(duration_ms=100)
+
+    payload = session.as_public_dict()
+
+    assert payload["id"] == "duplex-public"
+    assert payload["model"] == "m"
+    assert payload["voice"] == "alloy"
+    assert payload["state"] == "open"
+    assert payload["turn_state"] == "assistant_playing"
+    assert payload["epoch"] == 0
+    assert payload["turn_id"] == 0
+    assert payload["capabilities"] == DuplexCapabilities().as_dict()
+    assert payload["playback"] == {"generated_ms": 100, "sent_ms": 100, "played_ms": 0, "committed_ms": 0}
+
+
+# ---- DuplexSessionConfig.from_realtime ----
+
+
+def test_from_realtime_rejects_unsupported_audio_formats():
+    with pytest.raises(DuplexConfigError) as excinfo:
+        DuplexSessionConfig.from_realtime({"input_audio_format": "mp3"})
+    assert excinfo.value.code == "unsupported_audio_format"
+
+    with pytest.raises(DuplexConfigError) as excinfo:
+        DuplexSessionConfig.from_realtime({"audio": {"output": {"format": {"type": "audio/opus"}}}})
+    assert excinfo.value.code == "unsupported_audio_format"
+
+
+def test_from_realtime_validates_turn_detection():
+    with pytest.raises(DuplexConfigError) as excinfo:
+        DuplexSessionConfig.from_realtime({"turn_detection": {"type": "semantic_vad"}})
+    assert excinfo.value.code == "unsupported_turn_detection"
+    assert excinfo.value.param == "turn_detection"
+
+    with pytest.raises(DuplexConfigError) as excinfo:
+        DuplexSessionConfig.from_realtime({"overlap_policy": "barge_in_on_speech"})
+    assert excinfo.value.code == "unsupported_turn_detection"
+
+    server_vad = DuplexSessionConfig.from_realtime({"turn_detection": {"type": "server_vad"}})
+    assert server_vad.overlap_policy == DuplexOverlapPolicy.BARGE_IN_ON_SPEECH.value
+    assert server_vad.extra_body["realtime_turn_detection"]["threshold"] == 0.5
+
+    model_owned = DuplexSessionConfig.from_realtime({"turn_detection": None})
+    assert model_owned.overlap_policy == DuplexOverlapPolicy.LISTEN_ONLY.value
+    assert model_owned.extra_body["realtime_turn_detection"] is None
+
+
+def test_from_realtime_maps_wire_fields_and_stores_realtime_keys_in_extra_body():
+    config = DuplexSessionConfig.from_realtime(
+        {
+            "model": "openbmb/MiniCPM-o-4_5",
+            "instructions": "be brief",
+            "output_audio_format": "pcm16",
+            "max_response_output_tokens": "inf",
+            "audio": {"output": {"voice": "alloy", "speed": 1.25}},
+            "tools": [{"type": "function", "name": "lookup"}],
+            "tool_choice": "auto",
+            "metadata": {"tenant": "t1"},
+            "include": ["item.input_audio_transcription.logprobs"],
+            "input_audio_transcription": {"model": "whisper-1"},
+            "extra_body": {"custom": True},
+        }
+    )
+
+    assert config.model == "openbmb/MiniCPM-o-4_5"
+    assert config.instructions == "be brief"
+    assert config.voice == "alloy"
+    assert config.speed == 1.25
+    assert config.max_tokens is None
+    assert config.response_format == "pcm"
+    assert config.modalities == ["text", "audio"]
+    assert config.extra_body["custom"] is True
+    assert config.extra_body["realtime_tools"] == [{"type": "function", "name": "lookup"}]
+    assert config.extra_body["realtime_tool_choice"] == "auto"
+    assert config.extra_body["realtime_metadata"] == {"tenant": "t1"}
+    assert config.extra_body["realtime_include"] == ["item.input_audio_transcription.logprobs"]
+    assert config.extra_body["realtime_input_audio_transcription"] == {"model": "whisper-1"}
+    assert config.extra_body["realtime_audio"] == {"output": {"voice": "alloy", "speed": 1.25}}
+    assert config.extra_body["realtime_output_audio_format"] == "pcm16"
+    assert "extra_body" not in config.extra_body["realtime_session_payload"]
+    assert config.extra_body["realtime_session_payload"]["model"] == "openbmb/MiniCPM-o-4_5"
+
+
+def test_from_realtime_uses_served_model_when_payload_has_none():
+    config = DuplexSessionConfig.from_realtime({}, model="served-model")
+
+    assert config.model == "served-model"
+    assert config.response_format == "pcm"
+    assert config.idle_timeout_s == 300.0
+
+
+def test_from_realtime_ignores_client_chosen_session_ids():
+    config = DuplexSessionConfig.from_realtime({"id": "client-chosen", "session_id": "also-client-chosen"})
+
+    assert not hasattr(config, "session_id")
+    assert "id" not in config.as_dict()
+    session = _session("duplex-engine-allocated", config=config)
+    assert session.as_public_dict()["id"] == "duplex-engine-allocated"
+
+
+# ---- DuplexSessionConfig.apply_realtime_update ----
+
+
+def test_apply_realtime_update_rejects_model_change():
+    config = DuplexSessionConfig(model="served-model")
+
+    with pytest.raises(DuplexConfigError) as excinfo:
+        config.apply_realtime_update({"model": "other-model"}, session_id="sid")
+
+    assert excinfo.value.code == "model_update_unsupported"
+    assert config.model == "served-model"
+
+
+def test_apply_realtime_update_rejects_voice_change_after_audio_started():
+    config = DuplexSessionConfig(model="m", voice="alloy")
+
+    config.apply_realtime_update({"voice": "verse"}, audio_started=False)
+    assert config.voice == "verse"
+    with pytest.raises(DuplexConfigError) as excinfo:
+        config.apply_realtime_update({"audio": {"output": {"voice": "alloy"}}}, audio_started=True)
+    assert excinfo.value.code == "voice_update_after_audio_unsupported"
+    assert config.voice == "verse"
+
+
+def test_apply_realtime_update_rejects_ref_audio_change():
+    config = DuplexSessionConfig(model="m")
+
+    with pytest.raises(DuplexConfigError) as excinfo:
+        config.apply_realtime_update({"ref_audio": "/tmp/voice.wav"})
+
+    assert excinfo.value.code == "ref_audio_update_unsupported"
+    assert config.ref_audio is None
+
+
+def test_apply_realtime_update_patches_fields_and_realtime_keys():
+    config = DuplexSessionConfig(model="m", instructions="old", extra_body={"realtime_tools": [{"name": "x"}]})
+
+    config.apply_realtime_update(
+        {
+            "instructions": "new",
+            "output_audio_format": "g711_ulaw",
+            "max_output_tokens": 32,
+            "tools": None,
+            "metadata": {"k": "v"},
+            "overlap_policy": "not-a-policy",
+        }
+    )
+
+    assert config.instructions == "new"
+    assert config.response_format == "pcm"
+    assert config.max_tokens == 32
+    assert "realtime_tools" not in config.extra_body
+    assert config.extra_body["realtime_metadata"] == {"k": "v"}
+    assert config.overlap_policy == DuplexOverlapPolicy.LISTEN_ONLY.value
+    assert config.extra_body["realtime_session_payload"]["instructions"] == "new"
+
+
+# ---- overlap policy / capabilities ----
+
+
+def test_overlap_policy_defaults_and_invalid_values_to_listen_only():
+    assert DuplexSessionConfig().overlap_policy == DuplexOverlapPolicy.LISTEN_ONLY.value
+    assert DuplexSessionConfig._normalize_overlap_policy("auto") == DuplexOverlapPolicy.LISTEN_ONLY.value
+    assert DuplexSessionConfig._normalize_overlap_policy("not-a-policy") == DuplexOverlapPolicy.LISTEN_ONLY.value
+    assert (
+        DuplexSessionConfig._normalize_overlap_policy(" Barge_In_On_Speech ")
+        == DuplexOverlapPolicy.BARGE_IN_ON_SPEECH.value
+    )
+    assert DuplexSessionConfig.from_event({"session": {"overlap_policy": "bogus"}}).overlap_policy == "listen_only"
+
+
+def test_capabilities_as_dict_reports_declared_implementation():
+    caps = DuplexCapabilities().as_dict()
+
+    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
+    assert "client_event" in caps["signal_sources"]
+    assert set(caps) == set(minicpmo45_native_capabilities().as_dict())
+
+
+def test_minicpmo_native_capabilities_separate_model_state_from_core_kv_lease():
+    caps = minicpmo45_native_capabilities(max_sessions=2).as_dict()
+
+    assert caps["implementation_level"] == "model_native_duplex"
+    assert caps["supports_input_append"] is True
+    assert caps["input_modes"] == ["append_audio_chunk"]
+    assert caps["adapter_patterns"] == ["scheduler_data_plane"]
+    assert caps["supports_model_internal_state"] is True
+    assert caps["requires_model_runner_kv"] is True
+    assert caps["requires_native_stage_role"] is True
+    assert caps["supports_kv_lease"] is False
+    assert caps["supports_core_kv_lease"] is False
+    assert caps["supports_stage_resumption"] is True
+    assert caps["supports_scheduler_native_append"] is False
+    assert caps["supports_core_resumable_request"] is True
+    assert caps["supports_stage_connector_handoff"] is True
+    assert caps["supports_audio_truncate"] is True
+    assert caps["supports_barge_in"] is True
+    assert caps["target_barge_in_latency_ms"] is None
+    assert caps["supports_multi_session"] is True
+    assert caps["supports_multi_session_same_replica"] is True
+    assert caps["supports_session_lease"] is True
+    assert caps["supports_session_resume"] is True
+    assert caps["session_admission_mode"] == "engine_managed"
+    assert caps["stage_handoff_transport"] == "scheduler_data_plane"
+
+
+def test_minicpmo_native_capabilities_do_not_overclaim_single_session_deployment():
+    caps = minicpmo45_native_capabilities(max_sessions=1).as_dict()
+
+    assert caps["supports_multi_session"] is False
+    assert caps["supports_multi_session_same_replica"] is False
diff --git a/tests/engine/duplex/test_overlap_policy.py b/tests/engine/duplex/test_overlap_policy.py
new file mode 100644
index 000000000..096b7c7c9
--- /dev/null
+++ b/tests/engine/duplex/test_overlap_policy.py
@@ -0,0 +1,229 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""The overlap decision, reached directly.
+
+These rules decide what happens when input arrives while the model is speaking.
+They were unreachable except by driving a whole append through the runner, so
+none of them had a test that named the rule it was checking.
+"""
+
+from __future__ import annotations
+
+import base64
+
+import numpy as np
+import pytest
+
+from vllm_omni.engine.duplex.config import DuplexSessionConfig
+from vllm_omni.engine.duplex.session import overlap_policy
+from vllm_omni.engine.duplex.session.engine_session import DuplexEngineSession
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _session(**config: object) -> DuplexEngineSession:
+    values: dict[str, object] = {"model": "fake-model"}
+    values.update(config)
+    return DuplexEngineSession(session_id="sid", config=DuplexSessionConfig(**values))
+
+
+def _pcm16(rms: float, samples: int = 1600) -> str:
+    data = np.full(samples, int(rms * 32768), dtype=np.int16)
+    return base64.b64encode(data.tobytes()).decode("ascii")
+
+
+# --------------------------------------------------------------------------- #
+# Speech detection                                                            #
+# --------------------------------------------------------------------------- #
+
+
+@pytest.mark.parametrize("flag", [True, False])
+def test_an_explicit_is_speech_flag_wins_over_the_audio(flag: bool) -> None:
+    session = _session()
+    payload = {"format": "pcm16", "audio": _pcm16(0.9 if not flag else 0.0)}
+    assert overlap_policy.input_looks_like_speech(session, {"is_speech": flag}, payload) is flag
+
+
+def test_vad_probability_decides_when_no_flag_is_given() -> None:
+    session = _session()
+    payload = {"format": "pcm16", "audio": _pcm16(0.0)}
+    assert overlap_policy.input_looks_like_speech(session, {"vad": {"speech_probability": 0.9}}, payload) is True
+    assert overlap_policy.input_looks_like_speech(session, {"vad": {"speech_probability": 0.1}}, payload) is False
+
+
+def test_quiet_audio_below_the_configured_rms_is_not_speech() -> None:
+    session = _session(overlap_silence_rms=0.05)
+    loud = {"format": "pcm16", "audio": _pcm16(0.5)}
+    quiet = {"format": "pcm16", "audio": _pcm16(0.001)}
+    assert overlap_policy.input_looks_like_speech(session, {}, loud) is True
+    assert overlap_policy.input_looks_like_speech(session, {}, quiet) is False
+
+
+def test_undecodable_audio_is_treated_as_speech() -> None:
+    """Fail toward listening: dropping real speech is worse than a spurious turn."""
+    session = _session()
+    assert overlap_policy.input_looks_like_speech(session, {}, {"format": "pcm16", "audio": "!!not base64!!"}) is True
+
+
+# --------------------------------------------------------------------------- #
+# Barge-in                                                                    #
+# --------------------------------------------------------------------------- #
+
+
+def test_an_explicit_client_overlap_action_requests_barge_in() -> None:
+    session = _session()
+    payload = {"format": "pcm16", "audio": _pcm16(0.5)}
+    decision = overlap_policy.decide(session, {"overlap_action": "barge_in"}, payload, auto_responds=True)
+    assert decision["action"] == "barge_in"
+    assert decision["reason"] == "client_overlap_action"
+
+
+def test_barge_in_is_deferred_when_the_session_cannot_support_it() -> None:
+    session = _session()
+    session.capabilities = type(session.capabilities)(supports_barge_in=False)
+    payload = {"format": "pcm16", "audio": _pcm16(0.5)}
+    decision = overlap_policy.decide(session, {"force_barge_in": True}, payload, auto_responds=True)
+    assert decision["action"] != "barge_in"
+
+
+# --------------------------------------------------------------------------- #
+# Force-listen                                                                #
+# --------------------------------------------------------------------------- #
+
+
+def test_a_short_response_create_is_forced_to_listen() -> None:
+    """A sub-threshold ack should not take the turn from the model."""
+    session = _session(overlap_short_ack_ms=700)
+    short = {"response_create": True, "duration_ms": 200}
+    long = {"response_create": True, "duration_ms": 1500}
+    assert overlap_policy.should_force_listen_for_short_commit(session, short, {}) is True
+    assert overlap_policy.should_force_listen_for_short_commit(session, long, {}) is False
+
+
+def test_force_barge_in_overrides_the_short_ack_rule() -> None:
+    session = _session(overlap_short_ack_ms=700)
+    event = {"response_create": True, "duration_ms": 200, "force_barge_in": True}
+    assert overlap_policy.should_force_listen_for_short_commit(session, event, {}) is False
+
+
+def test_auto_response_overlap_forces_listen_only_when_auto_responding() -> None:
+    event = {"force_listen": True}
+    assert overlap_policy.should_force_listen_for_auto_response_overlap(event, {}, auto_responds=True) is True
+    assert overlap_policy.should_force_listen_for_auto_response_overlap(event, {}, auto_responds=False) is False
+
+
+# --------------------------------------------------------------------------- #
+# Payload merging                                                             #
+# --------------------------------------------------------------------------- #
+
+
+@pytest.mark.parametrize("speech_first", [True, False], ids=["speech-then-silence", "silence-then-speech"])
+def test_merging_two_appends_keeps_speech_if_either_half_was_speech(speech_first: bool) -> None:
+    """Matching rates and decodable audio, so the halves really are concatenated.
+
+    Without a ``sample_rate_hz`` on both, ``merge_audio_payloads`` falls back
+    to the newer chunk before merging, and the speech flag it returned was the
+    second chunk's own -- the test passed without exercising the merge.
+    """
+    speech = {
+        "format": "pcm_f32le",
+        "audio": base64.b64encode(b"\x01" * 8).decode("ascii"),
+        "sample_rate_hz": 16000,
+        "is_speech": True,
+    }
+    silence = {
+        "format": "pcm_f32le",
+        "audio": base64.b64encode(b"\x00" * 8).decode("ascii"),
+        "sample_rate_hz": 16000,
+        "is_speech": False,
+    }
+    first, second = (speech, silence) if speech_first else (silence, speech)
+    merged = overlap_policy.merge_audio_payloads(first, second)
+    assert base64.b64decode(merged["audio"]) == base64.b64decode(first["audio"]) + base64.b64decode(second["audio"])
+    assert merged["sample_rate_hz"] == 16000
+    assert merged["is_speech"] is True
+
+
+@pytest.mark.parametrize(
+    ("first", "second"),
+    [
+        ({"format": "pcm_f32le", "audio": "", "sample_rate_hz": 16000}, {"format": "pcm16", "audio": ""}),
+        (
+            {"format": "pcm_f32le", "audio": "", "sample_rate_hz": 16000},
+            {"format": "pcm_f32le", "audio": "", "sample_rate_hz": 24000},
+        ),
+        (
+            {"format": "pcm_f32le", "audio": "!!not base64!!", "sample_rate_hz": 16000},
+            {"format": "pcm_f32le", "audio": "", "sample_rate_hz": 16000},
+        ),
+    ],
+    ids=["format-mismatch", "rate-mismatch", "undecodable"],
+)
+def test_unmergeable_payloads_fall_back_to_the_newer_one(first: dict, second: dict) -> None:
+    """Whatever cannot be concatenated keeps the newer chunk and drops the older.
+
+    Worth pinning: the fallback discards ``first`` silently, so a bug that makes
+    two mergeable payloads look mismatched loses buffered audio rather than
+    raising.
+    """
+    assert overlap_policy.merge_audio_payloads(first, second) == second
+
+
+def test_mergeable_payloads_are_concatenated_in_order() -> None:
+    head = bytes([1, 2, 3, 4])
+    tail = bytes([5, 6, 7, 8])
+    first = {"format": "pcm_f32le", "audio": base64.b64encode(head).decode(), "sample_rate_hz": 16000}
+    second = {"format": "pcm_f32le", "audio": base64.b64encode(tail).decode(), "sample_rate_hz": 16000}
+    merged = overlap_policy.merge_audio_payloads(first, second)
+    assert base64.b64decode(merged["audio"]) == head + tail
+    assert merged["sample_rate_hz"] == 16000
+
+
+# --------------------------------------------------------------------------- #
+# Server VAD + barge_in_on_speech                                             #
+# --------------------------------------------------------------------------- #
+
+
+def test_server_vad_speech_started_reaches_a_barge_in_decision() -> None:
+    """The configuration this PR introduces must decide, not raise.
+
+    Both call sites read the VAD verdict through the module-level
+    ``vad_speech_started`` helper while binding its result to a local of the
+    same name, which made the name local for the whole scope and raised
+    ``UnboundLocalError`` on the call itself. Every ``server_vad`` +
+    ``barge_in_on_speech`` append hit it, and the client saw ``internal_error``
+    instead of a barge-in. The MiniCPM-o preset is ``listen_only``, so no demo
+    exercised this branch.
+    """
+    session = _session(overlap_policy="barge_in_on_speech")
+    payload = {"format": "pcm16", "audio": _pcm16(0.5)}
+    event = {"vad": {"speech_started": True}}
+
+    decision = overlap_policy.decide(session, event, payload, auto_responds=True)
+
+    assert decision["action"] == "barge_in"
+    assert decision["reason"] == "server_vad_speech_started"
+    assert decision["cancel_reason"] == "turn_detected"
+
+
+def test_server_vad_mid_utterance_keeps_listening_instead_of_barging_in() -> None:
+    """``speech_started`` false means the utterance is already running: not a new turn."""
+    session = _session(overlap_policy="barge_in_on_speech")
+    payload = {"format": "pcm16", "audio": _pcm16(0.5)}
+    event = {"vad": {"speech_started": False}}
+
+    decision = overlap_policy.decide(session, event, payload, auto_responds=True)
+
+    assert decision["action"] != "barge_in"
+
+
+def test_barge_in_on_speech_without_vad_still_barges_in_on_speech() -> None:
+    """No VAD verdict: the policy falls back to its own speech classification."""
+    session = _session(overlap_policy="barge_in_on_speech")
+    payload = {"format": "pcm16", "audio": _pcm16(0.5)}
+
+    decision = overlap_policy.decide(session, {}, payload, auto_responds=True)
+
+    assert decision["action"] == "barge_in"
+    assert decision["reason"] == "barge_in_on_speech"
diff --git a/tests/engine/duplex/test_session_manager.py b/tests/engine/duplex/test_session_manager.py
new file mode 100644
index 000000000..bccce18f1
--- /dev/null
+++ b/tests/engine/duplex/test_session_manager.py
@@ -0,0 +1,1575 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""``DuplexSessionManager``: admission, control RPC, command backpressure, reaper and request cleanup."""
+
+from __future__ import annotations
+
+import asyncio
+import base64
+import logging
+from dataclasses import FrozenInstanceError, dataclass, field
+from typing import Any
+
+import pytest
+
+from vllm_omni.config.stage_config import DuplexSessionRuntimeConfig
+from vllm_omni.engine.duplex.commands import AppendAudio, CloseSession, Commit, DuplexCommand, Heartbeat
+from vllm_omni.engine.duplex.config import DuplexCapabilities, DuplexSessionConfig, DuplexSessionState
+from vllm_omni.engine.duplex.contracts import (
+    DuplexAppendPlan,
+    DuplexFence,
+    DuplexStagePort,
+    DuplexStageRequestContext,
+    DuplexStageSubmission,
+    DuplexStageSubmissionResult,
+    duplex_resource_request_belongs_to_session,
+)
+from vllm_omni.engine.duplex.events import (
+    DuplexEvent,
+    ErrorEvent,
+    SessionClosed,
+    SessionCreated,
+    SessionExpired,
+    SessionHeartbeatAck,
+)
+from vllm_omni.engine.duplex.messages import (
+    CloseDuplexSessionMessage,
+    DuplexControlResultMessage,
+    DuplexSessionCommandMessage,
+    DuplexSessionEventMessage,
+    OpenDuplexSessionMessage,
+    ResumeDuplexSessionMessage,
+    TouchDuplexSessionMessage,
+)
+from vllm_omni.engine.duplex.plugin import (
+    DuplexDataPlane,
+    DuplexModelPlugin,
+    DuplexModelSessionState,
+    DuplexRuntimeConfigError,
+    PcmAppendBuffer,
+    PcmAppendReservation,
+)
+from vllm_omni.engine.duplex.session import manager as session_manager_module
+from vllm_omni.engine.duplex.session.engine_session import DuplexEngineSession
+from vllm_omni.engine.duplex.session.lease import DuplexLeaseActivity
+from vllm_omni.engine.duplex.session.manager import DuplexSessionManager
+from vllm_omni.engine.duplex.session.runner import _Internal
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+# --------------------------------------------------------------------------- #
+# Fakes                                                                       #
+# --------------------------------------------------------------------------- #
+
+
+class FakeClock:
+    def __init__(self, value: float = 0.0) -> None:
+        self.value = value
+
+    def __call__(self) -> float:
+        return self.value
+
+    def advance(self, seconds: float) -> None:
+        self.value += seconds
+
+
+class FakePcmAppendBuffer(PcmAppendBuffer):
+    @property
+    def pending_byte_count(self) -> int:
+        return 0
+
+    def clear(self) -> None:
+        pass
+
+    def clear_force_listen(self) -> None:
+        pass
+
+    def has_pending(self) -> bool:
+        return False
+
+    def has_reserved(self) -> bool:
+        return False
+
+    def prepare_append(self, payload, *, operation_id, chunk_period_ms, allow_emit) -> PcmAppendReservation | None:
+        del payload, operation_id, chunk_period_ms, allow_emit
+        return None
+
+    def prepare_commit(self, *, operation_id, chunk_period_ms) -> PcmAppendReservation:
+        del operation_id, chunk_period_ms
+        raise NotImplementedError("fake buffer never commits")
+
+    def flush(self, *, chunk_period_ms) -> dict[str, object] | None:
+        del chunk_period_ms
+        return None
+
+
+class FakeModelSessionState(DuplexModelSessionState):
+    def __init__(self) -> None:
+        self.audio_buffer = FakePcmAppendBuffer()
+        self.input_since_commit = False
+        self.speech_since_commit = False
+        self.context_locked = False
+        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
+        self.continuation_owner_id = None
+        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
+        self.committed_audio_operation_id = operation_id
+        self.committed_audio_reserved_bytes = reserved_bytes
+
+    def clear_committed_audio(self) -> int:
+        reserved = self.committed_audio_reserved_bytes
+        self.committed_audio_payload = None
+        self.committed_audio_operation_id = None
+        self.committed_audio_reserved_bytes = 0
+        return reserved
+
+    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):
+    def __init__(self) -> None:
+        self.closed_sessions: list[str] = []
+
+    def begin_request(self, request_id: str) -> None:
+        pass
+
+    def is_terminal(self, request_id: str | None) -> bool:
+        return False
+
+    def mark_terminal(self, request_id: str) -> None:
+        pass
+
+    def close_stream(self, request_id: str) -> None:
+        pass
+
+    def close_session(self, session_id: str, *, active_request_id: str | None = None) -> None:
+        self.closed_sessions.append(session_id)
+
+    def project(self, result, *, context=None):
+        del result, context
+        return []
+
+
+class FakePlugin(DuplexModelPlugin):
+    plugin_id = "fake-duplex"
+
+    def __init__(self, encode_audio=None) -> None:
+        super().__init__(encode_audio or (lambda *args: None))
+        self.data_plane = FakeDataPlane()
+        self.runtime_config: dict[str, object] = {"runtime": "test"}
+        self.runtime_config_error: Exception | None = None
+        #: Session ids whose ``prepare_runtime_config`` waits for ``runtime_config_gate``.
+        self.blocked_session_ids: set[str] = set()
+        self.runtime_config_gate = asyncio.Event()
+        self.runtime_config_started = asyncio.Event()
+
+    def configure_sampling_params(self, *, runtime_config, defaults):
+        del runtime_config
+        return tuple(f"configured-{stage_id}" for stage_id, _ in enumerate(defaults))
+
+    def plan_append(self, **kwargs) -> DuplexAppendPlan:
+        del kwargs
+        return DuplexAppendPlan(prompt={"prompt_token_ids": [1, 2, 3]})
+
+    def decide_output(self, **kwargs):
+        del kwargs
+        return None
+
+    def create_session_state(self) -> DuplexModelSessionState:
+        return FakeModelSessionState()
+
+    def capabilities(self, *, max_sessions: int) -> DuplexCapabilities:
+        del max_sessions
+        return DuplexCapabilities(supports_input_append=True, supports_core_resumable_request=True)
+
+    def validate_client_extra_body(self, extra_body: object) -> None:
+        pass
+
+    async def prepare_runtime_config(self, config: DuplexSessionConfig, *, model_config: Any) -> dict[str, object]:
+        del model_config
+        if self.runtime_config_error is not None:
+            raise self.runtime_config_error
+        if config.instructions in self.blocked_session_ids:
+            self.runtime_config_started.set()
+            await self.runtime_config_gate.wait()
+        return dict(self.runtime_config)
+
+    def runtime_config_for_update(self, config, current):
+        del config
+        return dict(current)
+
+    def data_plane_context(self, **kwargs) -> object:
+        return dict(kwargs)
+
+
+class FakeStagePort(DuplexStagePort):
+    def __init__(self, stage_count: int = 2) -> None:
+        self._stage_count = stage_count
+        self.ensure_calls: list[DuplexStageRequestContext] = []
+        self.submit_calls: list[DuplexStageSubmission] = []
+        #: Every cleanup attempt, including the ones that were made to fail.
+        self.cleanup_calls: list[tuple[list[str], bool]] = []
+        self.abort_calls: list[list[str]] = []
+        self.cleanup_failures_remaining = 0
+        self.cleanup_gate: asyncio.Event | None = None
+        self.cleanup_started = asyncio.Event()
+
+    @property
+    def stage_count(self) -> int:
+        return self._stage_count
+
+    def sampling_defaults(self) -> tuple[object, ...]:
+        return tuple(f"default-{stage_id}" for stage_id in range(self._stage_count))
+
+    def ensure_request(self, context: DuplexStageRequestContext) -> None:
+        self.ensure_calls.append(context)
+
+    async def submit(self, submission: DuplexStageSubmission) -> DuplexStageSubmissionResult:
+        self.submit_calls.append(submission)
+        return DuplexStageSubmissionResult(
+            request_id=submission.context.request_id,
+            stage_id=submission.context.stage_id,
+            replica_id=3,
+        )
+
+    async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
+        self.cleanup_calls.append((list(request_ids), abort))
+        self.cleanup_started.set()
+        if self.cleanup_gate is not None:
+            await self.cleanup_gate.wait()
+        if self.cleanup_failures_remaining:
+            self.cleanup_failures_remaining -= 1
+            raise RuntimeError("transient cleanup failure")
+
+    async def abort_requests(self, request_ids: list[str]) -> None:
+        self.abort_calls.append(list(request_ids))
+
+
+# --------------------------------------------------------------------------- #
+# Harness                                                                     #
+# --------------------------------------------------------------------------- #
+
+
+def _runtime_config(**overrides: Any) -> DuplexSessionRuntimeConfig:
+    values: dict[str, Any] = {
+        "idle_ttl_s": 300.0,
+        "disconnect_grace_s": 30.0,
+        "max_sessions": 4,
+        "max_pending_input_bytes_per_session": 1024,
+        "max_pending_turns_per_session": 2,
+    }
+    values.update(overrides)
+    return DuplexSessionRuntimeConfig(**values)
+
+
+def stage0_request_id(session_id: str, *, epoch: int = 0) -> str:
+    encoded = base64.urlsafe_b64encode(session_id.encode("utf-8")).decode("ascii").rstrip("=")
+    return f"duplex-s.{encoded}.e.{epoch}.r.stage0"
+
+
+@dataclass
+class Harness:
+    manager: DuplexSessionManager
+    plugin: FakePlugin
+    stage_port: FakeStagePort
+    clock: FakeClock
+    output_sink: asyncio.Queue = field(default_factory=asyncio.Queue)
+    result_sink: asyncio.Queue = field(default_factory=asyncio.Queue)
+
+    @classmethod
+    def create(
+        cls,
+        *,
+        plugin: FakePlugin | None = None,
+        stage_port: FakeStagePort | None = None,
+        clock: FakeClock | None = None,
+        **runtime_overrides: Any,
+    ) -> Harness:
+        plugin = plugin or FakePlugin()
+        stage_port = stage_port or FakeStagePort()
+        clock = clock or FakeClock()
+        output_sink: asyncio.Queue = asyncio.Queue()
+        result_sink: asyncio.Queue = asyncio.Queue()
+        manager = DuplexSessionManager(
+            plugin=plugin,
+            stage_port=stage_port,
+            output_sink=output_sink,
+            result_sink=result_sink,
+            runtime_config=_runtime_config(**runtime_overrides),
+            model_config=None,
+            clock=clock,
+        )
+        return cls(manager, plugin, stage_port, clock, output_sink, result_sink)
+
+    async def __aenter__(self) -> Harness:
+        return self
+
+    async def __aexit__(self, *exc_info: object) -> None:
+        await self.manager.shutdown()
+
+    async def open(self, session_id: str, config: DuplexSessionConfig | None = None) -> DuplexControlResultMessage:
+        await self.manager.handle(
+            OpenDuplexSessionMessage(
+                control_id=f"open-{session_id}",
+                session_id=session_id,
+                session_config=config or DuplexSessionConfig(model="fake-model"),
+            )
+        )
+        return await self.result()
+
+    async def close(self, session_id: str, *, reason: str = "client_close") -> DuplexControlResultMessage:
+        await self.manager.handle(
+            CloseDuplexSessionMessage(control_id=f"close-{session_id}", session_id=session_id, reason=reason)
+        )
+        return await self.result()
+
+    async def resume(self, session_id: str, *, expected_lease_generation: int) -> DuplexControlResultMessage:
+        await self.manager.handle(
+            ResumeDuplexSessionMessage(
+                control_id=f"resume-{session_id}-{expected_lease_generation}",
+                session_id=session_id,
+                expected_lease_generation=expected_lease_generation,
+            )
+        )
+        return await self.result()
+
+    async def touch(self, session_id: str, activity: str) -> DuplexControlResultMessage:
+        await self.manager.handle(
+            TouchDuplexSessionMessage(
+                control_id=f"touch-{session_id}-{activity}", session_id=session_id, activity=activity
+            )
+        )
+        return await self.result()
+
+    def command(self, session_id: str, command: DuplexCommand) -> None:
+        self.manager.dispatch(DuplexSessionCommandMessage(session_id=session_id, command=command))
+
+    async def result(self) -> DuplexControlResultMessage:
+        result = await asyncio.wait_for(self.result_sink.get(), timeout=2.0)
+        assert isinstance(result, DuplexControlResultMessage)
+        return result
+
+    def events(self, session_id: str | None = None) -> list[DuplexEvent]:
+        events: list[DuplexEvent] = []
+        while not self.output_sink.empty():
+            message = self.output_sink.get_nowait()
+            assert isinstance(message, DuplexSessionEventMessage)
+            assert message.event.session_id == message.session_id
+            if session_id is None or message.session_id == session_id:
+                events.append(message.event)
+        return events
+
+    def session(self, session_id: str) -> DuplexEngineSession:
+        session = self.manager.get(session_id)
+        assert session is not None
+        return session
+
+    def capture_submissions(self, session_id: str) -> list[DuplexCommand]:
+        """Replace the runner mailbox with a list so admitted commands can be inspected."""
+        runner = self.manager.runners[session_id]
+        submitted: list[DuplexCommand] = []
+        runner.submit = submitted.append  # type: ignore[method-assign]
+        return submitted
+
+
+async def _settle() -> None:
+    for _ in range(10):
+        await asyncio.sleep(0)
+
+
+# --------------------------------------------------------------------------- #
+# Open                                                                        #
+# --------------------------------------------------------------------------- #
+
+
+async def test_open_answers_with_capabilities_and_emits_session_created() -> None:
+    async with Harness.create() as harness:
+        config = DuplexSessionConfig(model="fake-model", voice="test")
+        result = await harness.open("sid-open", config)
+
+        assert result.ok is True
+        assert result.operation == "open"
+        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, 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"
+        assert result.error_code is None
+
+        events = harness.events("sid-open")
+        assert isinstance(events[0], SessionCreated)
+        assert events[0].epoch == 0
+        assert events[0].session["id"] == "sid-open"
+        wire = events[0].to_realtime()
+        assert wire["type"] == "session.created"
+        assert "incarnation" not in wire and "incarnation" not in wire["session"]
+
+        session = harness.session("sid-open")
+        assert session.state == DuplexSessionState.OPEN
+        assert session.runtime_config == {"runtime": "test"}
+        assert isinstance(session.model_state, FakeModelSessionState)
+        assert harness.manager.active_count() == 1
+        assert harness.manager.sessions() == {"sid-open": session}
+
+
+async def test_open_reserves_the_fenced_stage0_request_with_a_frozen_context() -> None:
+    async with Harness.create() as harness:
+        await harness.open("sid-context", DuplexSessionConfig(model="fake-model", voice="test"))
+
+        request_id = stage0_request_id("sid-context")
+        context = harness.stage_port.ensure_calls[-1]
+        assert isinstance(context, DuplexStageRequestContext)
+        assert context.request_id == request_id
+        assert context.session_id == "sid-context"
+        assert context.fence == DuplexFence("sid-context")
+        assert context.stage_id == 0
+        assert context.final_stage_id == 1
+        assert context.config_generation == 0
+        assert context.sampling_params == ("configured-0", "configured-1")
+        assert context.stage_sampling_params == "configured-0"
+        assert context.session_config["voice"] == "test"
+        assert context.runtime_config == {"runtime": "test"}
+        with pytest.raises(FrozenInstanceError):
+            context.stage_id = 1  # type: ignore[misc]
+
+        session = harness.session("sid-context")
+        assert session.resource_request_ids() == [request_id]
+        assert session.stage_request_submitted(0, request_id) is False
+        assert harness.manager.runner_for_request_id(request_id) is harness.manager.runners["sid-context"]
+        assert harness.stage_port.submit_calls == []
+
+
+def test_stage_request_id_is_derived_from_the_fence() -> None:
+    fence = DuplexFence("sid/with+special", epoch=2, turn_id=5)
+
+    request_id = DuplexSessionManager.stage_request_id(fence, stage_id=0)
+
+    assert request_id == stage0_request_id("sid/with+special", epoch=2)
+    assert duplex_resource_request_belongs_to_session(request_id, "sid/with+special")
+    assert not duplex_resource_request_belongs_to_session(request_id, "sid/other")
+
+
+async def test_ensure_stage_request_ignores_stages_beyond_the_pipeline() -> None:
+    async with Harness.create() as harness:
+        await harness.open("sid-stages")
+        session = harness.session("sid-stages")
+
+        assert harness.manager.ensure_stage_request(session, stage_id=2) is None
+        context = harness.manager.ensure_stage_request(session, stage_id=1)
+
+        assert context is not None
+        assert context.request_id.endswith(".r.stage1")
+        assert harness.manager.runner_for_request_id(context.request_id) is harness.manager.runners["sid-stages"]
+        assert session.resource_request_ids() == [stage0_request_id("sid-stages"), context.request_id]
+
+
+async def test_sampling_params_for_validates_the_plugin_policy() -> None:
+    class ShortSamplingPlugin(FakePlugin):
+        def configure_sampling_params(self, *, runtime_config, defaults):
+            if runtime_config:
+                return defaults[:1]
+            return tuple(defaults)
+
+    class ListSamplingPlugin(FakePlugin):
+        def configure_sampling_params(self, *, runtime_config, defaults):
+            if runtime_config:
+                return list(defaults)
+            return tuple(defaults)
+
+    async with Harness.create(plugin=ShortSamplingPlugin()) as harness:
+        result = await harness.open("sid-short")
+        assert result.ok is False
+        assert result.error_code == "invalid_argument"
+        assert "one sampling parameter per stage" in str(result.error_message)
+        assert harness.manager.get("sid-short") is None
+        assert harness.manager.active_count() == 0
+
+    async with Harness.create(plugin=ListSamplingPlugin()) as harness:
+        result = await harness.open("sid-list")
+        assert result.ok is False
+        assert result.error_code == "invalid_argument"
+        assert "as a tuple" in str(result.error_message)
+
+
+async def test_duplicate_open_is_rejected_with_session_exists() -> None:
+    async with Harness.create() as harness:
+        assert (await harness.open("sid-dup")).ok is True
+        first_session = harness.session("sid-dup")
+
+        result = await harness.open("sid-dup")
+
+        assert result.ok is False
+        assert result.error_code == "session_exists"
+        assert result.error_retryable is False
+        assert harness.session("sid-dup") is first_session
+        assert harness.manager.active_count() == 1
+        assert len(harness.stage_port.ensure_calls) == 1
+
+
+async def test_capacity_rejection_is_retryable_and_logged_at_info(caplog: pytest.LogCaptureFixture) -> None:
+    manager_logger = session_manager_module.logger
+    manager_logger.addHandler(caplog.handler)
+    try:
+        async with Harness.create(max_sessions=1) as harness:
+            assert (await harness.open("sid-first")).ok is True
+            caplog.clear()
+
+            with caplog.at_level(logging.INFO, logger=manager_logger.name):
+                result = await harness.open("sid-rejected")
+
+            assert result.ok is False
+            assert result.error_code == "resource_exhausted"
+            assert result.error_retryable is True
+            assert harness.manager.get("sid-rejected") is None
+            assert harness.manager.active_count() == 1
+            rejections = [record for record in caplog.records if "rejected" in record.getMessage()]
+            assert rejections and all(record.levelno == logging.INFO for record in rejections)
+            assert not [record for record in caplog.records if record.levelno >= logging.ERROR]
+    finally:
+        manager_logger.removeHandler(caplog.handler)
+
+
+@pytest.mark.parametrize(
+    ("error", "expected_code"),
+    [
+        (ValueError("reference audio not found"), "invalid_duplex_runtime_config"),
+        (DuplexRuntimeConfigError("bad ref", code="unsupported_ref_audio_path"), "unsupported_ref_audio_path"),
+        (DuplexRuntimeConfigError("bad voice", code="invalid_voice"), "invalid_voice"),
+    ],
+)
+async def test_plugin_runtime_config_rejection_rolls_back_the_open(error: Exception, expected_code: str) -> None:
+    plugin = FakePlugin()
+    plugin.runtime_config_error = error
+    async with Harness.create(plugin=plugin) as harness:
+        result = await harness.open("sid-runtime")
+
+        assert result.ok is False
+        assert result.error_code == expected_code
+        assert result.error_message == str(error)
+        assert result.capabilities is None
+        assert harness.manager.get("sid-runtime") is None
+        assert harness.manager.active_count() == 0
+        assert harness.stage_port.ensure_calls == []
+        assert harness.events() == []
+
+        # Nothing was registered under the rejected id and the slot is free again.
+        plugin.runtime_config_error = None
+        assert (await harness.open("sid-runtime")).ok is True
+
+
+# --------------------------------------------------------------------------- #
+# Command dispatch                                                            #
+# --------------------------------------------------------------------------- #
+
+
+async def test_command_for_unknown_session_emits_unknown_session_error() -> None:
+    async with Harness.create() as harness:
+        harness.command("sid-missing", Heartbeat(event_id="evt-hb"))
+
+        events = harness.events("sid-missing")
+        assert len(events) == 1
+        error = events[0]
+        assert isinstance(error, ErrorEvent)
+        assert error.code == "unknown_session"
+        assert error.related_event_id == "evt-hb"
+        assert error.session_id == "sid-missing"
+        assert error.epoch is None
+        assert error.to_realtime()["error"]["code"] == "unknown_session"
+
+
+async def test_command_for_closed_session_emits_unknown_session_error() -> None:
+    async with Harness.create() as harness:
+        await harness.open("sid-closed")
+        assert (await harness.close("sid-closed")).ok is True
+        harness.events()
+
+        harness.command("sid-closed", Heartbeat(event_id="evt-late"))
+
+        events = harness.events("sid-closed")
+        assert [type(event) for event in events] == [ErrorEvent]
+        assert events[0].code == "unknown_session"
+        assert events[0].related_event_id == "evt-late"
+
+
+async def test_admitted_command_reaches_the_session_runner_in_order() -> None:
+    async with Harness.create() as harness:
+        await harness.open("sid-runner")
+        harness.events()
+        harness.clock.advance(5.0)
+
+        harness.command("sid-runner", Heartbeat(event_id="evt-1"))
+        harness.command("sid-runner", Heartbeat(event_id="evt-2"))
+        await _settle()
+
+        events = harness.events("sid-runner")
+        assert [type(event) for event in events] == [SessionHeartbeatAck, SessionHeartbeatAck]
+        assert all(event.epoch == 0 for event in events)
+        assert harness.session("sid-runner").lease.last_activity == 5.0
+
+
+async def test_append_audio_is_backpressured_by_pending_input_bytes() -> None:
+    async with Harness.create(max_pending_input_bytes_per_session=8) as harness:
+        await harness.open("sid-bytes")
+        harness.events()
+        session = harness.session("sid-bytes")
+        submitted = harness.capture_submissions("sid-bytes")
+        assert session.reserve_input_bytes(6, limit=8)
+
+        harness.command("sid-bytes", AppendAudio(audio=b"pcm", event_id="evt-over"))
+        harness.command("sid-bytes", AppendAudio(audio=b"pc", event_id="evt-fits"))
+
+        events = harness.events("sid-bytes")
+        assert len(events) == 1
+        assert isinstance(events[0], ErrorEvent)
+        assert events[0].code == "input_backpressure"
+        assert events[0].related_event_id == "evt-over"
+        assert events[0].epoch == 0
+        assert [command.event_id for command in submitted] == ["evt-fits"]
+        # Admission reserved the wire size of the admitted append; the runner
+        # released it on dequeue and re-reserved the decoded size (2 bytes).
+        assert session.pending_input_bytes == 8
+
+
+async def test_commit_holds_a_pending_turn_reservation_until_the_runner_dequeues_it() -> None:
+    async with Harness.create(max_pending_turns_per_session=1) as harness:
+        await harness.open("sid-turns")
+        harness.events()
+        session = harness.session("sid-turns")
+        submitted = harness.capture_submissions("sid-turns")
+
+        harness.command("sid-turns", Commit(event_id="evt-commit-1"))
+        harness.command("sid-turns", Commit(event_id="evt-commit-2"))
+
+        assert [command.event_id for command in submitted] == ["evt-commit-1"]
+        assert session.pending_input_turns == 1
+        events = harness.events("sid-turns")
+        assert len(events) == 1
+        assert isinstance(events[0], ErrorEvent)
+        assert events[0].code == "input_backpressure"
+        assert events[0].related_event_id == "evt-commit-2"
+
+        # The runner releases the reservation when it dequeues the commit.
+        session.release_pending_turn()
+        harness.command("sid-turns", Commit(event_id="evt-commit-3"))
+        assert [command.event_id for command in submitted] == ["evt-commit-1", "evt-commit-3"]
+        assert harness.events("sid-turns") == []
+
+
+def test_accepts_only_duplex_message_types() -> None:
+    manager = DuplexSessionManager(
+        plugin=FakePlugin(),
+        stage_port=FakeStagePort(),
+        output_sink=asyncio.Queue(),
+        result_sink=asyncio.Queue(),
+        runtime_config=_runtime_config(),
+        model_config=None,
+        clock=FakeClock(),
+    )
+    try:
+        config = DuplexSessionConfig()
+        assert manager.accepts(OpenDuplexSessionMessage(control_id="c", session_id="s", session_config=config))
+        assert manager.accepts(CloseDuplexSessionMessage(control_id="c", session_id="s"))
+        assert manager.accepts(ResumeDuplexSessionMessage(control_id="c", session_id="s", expected_lease_generation=0))
+        assert manager.accepts(TouchDuplexSessionMessage(control_id="c", session_id="s", activity="heartbeat"))
+        assert manager.accepts(DuplexSessionCommandMessage(session_id="s", command=Heartbeat()))
+        assert manager.accepts(type("Lookalike", (), {"type": "open_duplex_session", "session_id": "s"})()) is False
+        assert (
+            manager.accepts(DuplexControlResultMessage(control_id="c", operation="open", session_id="s", ok=True))
+            is False
+        )
+        assert manager.accepts(Heartbeat()) is False
+        with pytest.raises(TypeError, match="Unsupported duplex control message"):
+            manager.dispatch(object())
+    finally:
+        manager.executor.shutdown(wait=False)
+
+
+# --------------------------------------------------------------------------- #
+# Close / resume / touch                                                      #
+# --------------------------------------------------------------------------- #
+
+
+async def test_close_releases_stage_resources_and_is_idempotent() -> None:
+    async with Harness.create() as harness:
+        await harness.open("sid-close")
+        harness.events()
+        session = harness.session("sid-close")
+        request_id = stage0_request_id("sid-close")
+        session.bind_stage_request(0, request_id, fence=session.fence)
+        reserved_context = harness.manager.ensure_stage_request(session, stage_id=1)
+        assert reserved_context is not None
+
+        result = await harness.close("sid-close", reason="client_close")
+
+        assert result.ok is True
+        assert result.operation == "close"
+        assert result.lease_generation == 1
+        assert result.public_session is not None and result.public_session["state"] == "closed"
+        assert session.state == DuplexSessionState.CLOSED
+        assert session.lease.terminal_reason == "client_close"
+        assert session.resource_request_ids() == []
+        assert harness.manager.get("sid-close") is None
+        assert harness.manager.active_count() == 0
+        assert harness.manager.runner_for_request_id(request_id) is None
+        assert harness.stage_port.cleanup_calls == [([request_id], True), ([reserved_context.request_id], False)]
+        assert harness.plugin.data_plane.closed_sessions == ["sid-close"]
+        closed = [event for event in harness.events("sid-close") if isinstance(event, SessionClosed)]
+        assert len(closed) == 1
+        assert closed[0].reason == "client_close"
+        assert closed[0].is_terminal is True
+
+        again = await harness.close("sid-close")
+        assert again.ok is True
+        assert again.lease_generation is None
+        assert again.public_session is None
+        assert harness.stage_port.cleanup_calls[2:] == []
+        assert harness.events() == []
+
+
+async def test_close_retains_the_admission_slot_until_stage_cleanup_succeeds() -> None:
+    async with Harness.create(max_sessions=1) as harness:
+        await harness.open("sid-close-retry")
+        session = harness.session("sid-close-retry")
+        session.bind_stage_request(0, stage0_request_id("sid-close-retry"), fence=session.fence)
+        harness.stage_port.cleanup_failures_remaining = 1
+
+        result = await harness.close("sid-close-retry")
+
+        # The session is closed from the client's point of view; only the
+        # stage cleanup is outstanding and the reaper retries it.
+        assert result.ok is True
+        assert harness.manager.get("sid-close-retry") is None
+        assert session.state == DuplexSessionState.CLOSED
+        assert (await harness.open("sid-replacement")).error_code == "resource_exhausted"
+
+        assert await harness.manager.reap_expired() == 1
+        assert harness.stage_port.cleanup_calls == [([stage0_request_id("sid-close-retry")], True)] * 2
+        assert (await harness.open("sid-replacement")).ok is True
+
+
+async def test_resume_requires_the_expected_lease_generation() -> None:
+    async with Harness.create() as harness:
+        await harness.open("sid-resume")
+        session = harness.session("sid-resume")
+        harness.clock.advance(3.0)
+        assert (await harness.touch("sid-resume", DuplexLeaseActivity.DETACH.value)).ok is True
+        assert session.lease.detached_at == 3.0
+
+        harness.clock.advance(1.0)
+        result = await harness.resume("sid-resume", expected_lease_generation=0)
+
+        assert result.ok is True
+        assert result.operation == "resume"
+        assert result.lease_generation == 1
+        assert result.public_session is not None and result.public_session["id"] == "sid-resume"
+        assert session.lease_generation == 1
+        assert session.lease.detached_at is None
+        assert session.lease.last_activity == 4.0
+
+        stale = await harness.resume("sid-resume", expected_lease_generation=0)
+        assert stale.ok is False
+        assert stale.error_code == "session_resume_conflict"
+        assert stale.lease_generation == 1
+        assert session.lease_generation == 1
+
+        unknown = await harness.resume("sid-unknown", expected_lease_generation=0)
+        assert unknown.ok is False
+        assert unknown.error_code == "unknown_session"
+        assert unknown.lease_generation is None
+
+
+async def test_touch_records_activity_and_detach_marks_the_lease_detached() -> None:
+    async with Harness.create() as harness:
+        await harness.open("sid-touch")
+        session = harness.session("sid-touch")
+        assert session.lease.last_activity == 0.0
+
+        harness.clock.advance(2.0)
+        result = await harness.touch("sid-touch", DuplexLeaseActivity.HEARTBEAT.value)
+        assert result.ok is True
+        assert result.operation == "touch"
+        assert session.lease.last_activity == 2.0
+        assert session.lease.detached_at is None
+
+        harness.clock.advance(1.0)
+        assert (await harness.touch("sid-touch", DuplexLeaseActivity.DETACH.value)).ok is True
+        assert session.lease.last_activity == 3.0
+        assert session.lease.detached_at == 3.0
+
+        harness.clock.advance(1.0)
+        assert (await harness.touch("sid-touch", DuplexLeaseActivity.ATTACH.value)).ok is True
+        assert session.lease.last_activity == 4.0
+        # Only resume clears a detach.
+        assert session.lease.detached_at == 3.0
+
+        invalid = await harness.touch("sid-touch", "bogus")
+        assert invalid.ok is False
+        assert invalid.error_code == "invalid_argument"
+
+        unknown = await harness.touch("sid-unknown", DuplexLeaseActivity.HEARTBEAT.value)
+        assert unknown.ok is False
+        assert unknown.error_code == "unknown_session"
+        assert harness.stage_port.submit_calls == []
+
+
+# --------------------------------------------------------------------------- #
+# Reaper                                                                      #
+# --------------------------------------------------------------------------- #
+
+
+async def test_reaper_expires_idle_sessions_and_emits_session_expired() -> None:
+    async with Harness.create(idle_ttl_s=2.0, disconnect_grace_s=1.0) as harness:
+        await harness.open("sid-idle")
+        await harness.open("sid-active")
+        harness.events()
+        harness.clock.advance(1.0)
+        assert (await harness.touch("sid-active", DuplexLeaseActivity.HEARTBEAT.value)).ok is True
+        harness.clock.advance(1.1)
+
+        assert await harness.manager.reap_expired() == 1
+
+        assert harness.manager.get("sid-idle") is None
+        assert harness.manager.get("sid-active") is not None
+        assert harness.manager.active_count() == 1
+        expired = harness.events("sid-idle")
+        assert len(expired) == 1
+        assert isinstance(expired[0], SessionExpired)
+        assert expired[0].reason == "idle_ttl_expired"
+        assert expired[0].to_realtime() == {
+            "type": "session.expired",
+            "event_id": expired[0].event_id,
+            "session_id": "sid-idle",
+            "reason": "idle_ttl_expired",
+        }
+        assert harness.events("sid-active") == []
+        assert harness.stage_port.cleanup_calls == [([stage0_request_id("sid-idle")], False)]
+        assert harness.result_sink.empty()
+
+        assert await harness.manager.reap_expired() == 0
+
+
+async def test_reaper_expires_detached_sessions_after_the_disconnect_grace() -> None:
+    async with Harness.create(idle_ttl_s=300.0, disconnect_grace_s=1.0) as harness:
+        await harness.open("sid-detached")
+        harness.events()
+        assert (await harness.touch("sid-detached", DuplexLeaseActivity.DETACH.value)).ok is True
+        harness.clock.advance(0.5)
+        assert await harness.manager.reap_expired() == 0
+        harness.clock.advance(0.5)
+
+        assert await harness.manager.reap_expired() == 1
+
+        assert harness.manager.get("sid-detached") is None
+        expired = harness.events("sid-detached")
+        assert [type(event) for event in expired] == [SessionExpired]
+        assert expired[0].reason == "disconnect_grace_expired"
+        assert (await harness.resume("sid-detached", expected_lease_generation=0)).error_code == "unknown_session"
+
+
+async def test_session_closed_is_emitted_only_after_stage_cleanup_so_a_reopen_is_admitted() -> None:
+    async with Harness.create(max_sessions=1) as harness:
+        await harness.open("sid-closing")
+        harness.events()
+        session = harness.session("sid-closing")
+        session.bind_stage_request(0, stage0_request_id("sid-closing"), fence=session.fence)
+        harness.stage_port.cleanup_gate = asyncio.Event()
+
+        close_task = asyncio.create_task(harness.close("sid-closing"))
+        await asyncio.wait_for(harness.stage_port.cleanup_started.wait(), timeout=1.0)
+        # The runner is gone but the stage request is still being aborted:
+        # no session.closed yet, so a client cannot race the admission slot.
+        assert harness.events("sid-closing") == []
+
+        harness.stage_port.cleanup_gate.set()
+        assert (await close_task).ok is True
+        events = harness.events("sid-closing")
+        assert [type(event) for event in events] == [SessionClosed]
+        assert events[0].reason == "client_close"
+        assert (await harness.open("sid-replacement")).ok is True
+
+
+async def test_wire_close_command_frees_the_slot_before_session_closed() -> None:
+    async with Harness.create(max_sessions=1) as harness:
+        await harness.open("sid-wire-close")
+        harness.events()
+        session = harness.session("sid-wire-close")
+        request_id = stage0_request_id("sid-wire-close")
+        session.bind_stage_request(0, request_id, fence=session.fence)
+        harness.stage_port.cleanup_gate = asyncio.Event()
+
+        harness.command("sid-wire-close", CloseSession(reason="client_close"))
+        await asyncio.wait_for(harness.stage_port.cleanup_started.wait(), timeout=1.0)
+        assert harness.manager.get("sid-wire-close") is None
+        assert harness.events("sid-wire-close") == []
+
+        harness.stage_port.cleanup_gate.set()
+        for _ in range(50):
+            if harness.manager._admission_count() == 0:
+                break
+            await asyncio.sleep(0.01)
+        assert harness.stage_port.cleanup_calls == [([request_id], True)]
+        events = harness.events("sid-wire-close")
+        assert [type(event) for event in events] == [SessionClosed]
+        assert events[0].reason == "client_close"
+        assert (await harness.open("sid-replacement")).ok is True
+
+
+async def test_wire_close_stops_the_worker_and_refuses_later_control_ops() -> None:
+    async with Harness.create(max_sessions=1) as harness:
+        await harness.open("sid-wire")
+        harness.events()
+        runner = harness.manager.runners["sid-wire"]
+        worker = runner._worker
+        assert worker is not None
+        harness.stage_port.cleanup_gate = asyncio.Event()
+
+        harness.command("sid-wire", CloseSession(reason="client_close"))
+        await asyncio.wait_for(harness.stage_port.cleanup_started.wait(), timeout=1.0)
+        # Control operations issued while the close is in flight are refused,
+        # not silently accepted on a half-torn session.
+        resumed = await harness.resume("sid-wire", expected_lease_generation=0)
+        assert resumed.ok is False
+        assert resumed.error_code in {"session_closed", "unknown_session"}
+        harness.command("sid-wire", Heartbeat())
+
+        harness.stage_port.cleanup_gate.set()
+        for _ in range(50):
+            if worker.done() and harness.manager._admission_count() == 0:
+                break
+            await asyncio.sleep(0.01)
+        assert worker.done(), "the mailbox worker must exit after a wire close"
+        events = harness.events("sid-wire")
+        assert [type(event) for event in events] == [ErrorEvent, SessionClosed] or [
+            type(event) for event in events
+        ] == [SessionClosed, ErrorEvent]
+        assert (await harness.open("sid-after")).ok is True
+
+
+async def test_concurrent_opens_cannot_exceed_max_sessions() -> None:
+    async with Harness.create(max_sessions=1) as harness:
+        harness.plugin.blocked_session_ids.add("first")
+        first = asyncio.create_task(
+            harness.open("first", DuplexSessionConfig(model="fake-model", instructions="first"))
+        )
+        await asyncio.wait_for(harness.plugin.runtime_config_started.wait(), timeout=1.0)
+
+        # The first open holds the only slot while it awaits the plugin.
+        second = await harness.open("second", DuplexSessionConfig(model="fake-model", instructions="second"))
+        assert second.ok is False
+        assert second.error_code == "resource_exhausted"
+
+        harness.plugin.runtime_config_gate.set()
+        assert (await first).ok is True
+        assert harness.manager.active_count() == 1
+
+
+async def test_runtime_close_without_stage_requests_frees_the_slot() -> None:
+    async with Harness.create(max_sessions=1) as harness:
+        await harness.open("sid-runtime")
+        harness.events()
+        runner = harness.manager.runners["sid-runtime"]
+        runner.session.release_all_requests()
+
+        await runner._close_from_runtime("model_failed")
+        for _ in range(50):
+            if harness.manager._admission_count() == 0:
+                break
+            await asyncio.sleep(0.01)
+
+        assert harness.manager.get("sid-runtime") is None
+        assert [type(event) for event in harness.events("sid-runtime")] == [SessionClosed]
+        assert (await harness.open("sid-next")).ok is True
+
+
+async def test_close_of_a_forgotten_session_is_idempotent() -> None:
+    async with Harness.create(max_sessions=1) as harness:
+        result = await harness.close("never-opened")
+
+        assert result.ok is True
+
+
+async def test_append_bytes_are_reserved_at_admission_until_the_runner_dequeues() -> None:
+    async with Harness.create(max_sessions=1, max_pending_input_bytes_per_session=8) as harness:
+        await harness.open("sid-bytes")
+        harness.events()
+        session = harness.session("sid-bytes")
+        runner = harness.manager.runners["sid-bytes"]
+        # Park the worker so admitted commands stay in the mailbox.
+        gate = asyncio.Event()
+        runner._mailbox.put_nowait(_Internal("wait", {"gate": gate}))
+        runner._on_internal = lambda item: gate.wait()  # type: ignore[method-assign]
+        await asyncio.sleep(0)
+
+        harness.command("sid-bytes", AppendAudio(audio=b"12345"))
+        assert session.pending_input_bytes == 5
+        harness.command("sid-bytes", AppendAudio(audio=b"12345"))
+        errors = [event for event in harness.events("sid-bytes") if isinstance(event, ErrorEvent)]
+        assert [error.code for error in errors] == ["input_backpressure"]
+        gate.set()
+
+
+async def test_expired_session_retains_the_admission_slot_until_cleanup_succeeds() -> None:
+    async with Harness.create(max_sessions=1, idle_ttl_s=1.0) as harness:
+        await harness.open("sid-expired")
+        harness.events()
+        session = harness.session("sid-expired")
+        request_id = stage0_request_id("sid-expired")
+        session.bind_stage_request(0, request_id, fence=session.fence)
+        harness.stage_port.cleanup_failures_remaining = 1
+        harness.clock.advance(2.0)
+
+        assert await harness.manager.reap_expired() == 0
+
+        assert harness.manager.get("sid-expired") is None
+        assert session.state == DuplexSessionState.CLOSED
+        assert [type(event) for event in harness.events("sid-expired")] == [SessionExpired]
+        assert (await harness.open("sid-replacement")).error_code == "resource_exhausted"
+
+        assert await harness.manager.reap_expired() == 1
+
+        assert harness.stage_port.cleanup_calls == [([request_id], True)] * 2
+        assert session.resource_request_ids() == []
+        assert harness.events("sid-expired") == []
+        assert (await harness.open("sid-replacement")).ok is True
+
+
+async def test_expired_session_holds_the_admission_slot_while_cleanup_is_blocked() -> None:
+    async with Harness.create(max_sessions=1, idle_ttl_s=1.0) as harness:
+        await harness.open("sid-blocked")
+        session = harness.session("sid-blocked")
+        session.bind_stage_request(0, stage0_request_id("sid-blocked"), fence=session.fence)
+        harness.stage_port.cleanup_gate = asyncio.Event()
+        harness.clock.advance(2.0)
+
+        reap_task = asyncio.create_task(harness.manager.reap_expired())
+        await asyncio.wait_for(harness.stage_port.cleanup_started.wait(), timeout=1.0)
+        assert (await harness.open("sid-replacement")).error_code == "resource_exhausted"
+
+        harness.stage_port.cleanup_gate.set()
+        assert await reap_task == 1
+        assert (await harness.open("sid-replacement")).ok is True
+
+
+async def test_expired_cleanup_failure_does_not_block_other_sessions() -> None:
+    class OneStuckStagePort(FakeStagePort):
+        async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
+            await super().cleanup(request_ids, abort=abort)
+            if request_ids == [stage0_request_id("sid-stuck")]:
+                raise RuntimeError("stuck expiry cleanup")
+
+    async with Harness.create(stage_port=OneStuckStagePort(), idle_ttl_s=1.0) as harness:
+        await harness.open("sid-stuck")
+        await harness.open("sid-fine")
+        harness.events()
+        harness.clock.advance(2.0)
+
+        assert await harness.manager.reap_expired() == 1
+
+        assert harness.manager.active_count() == 0
+        assert {type(event) for event in harness.events()} == {SessionExpired}
+        assert (await harness.open("sid-fine")).ok is True
+        assert (await harness.open("sid-stuck")).error_code == "session_exists"
+
+
+# --------------------------------------------------------------------------- #
+# Request-triggered cleanup (orchestrator error paths)                        #
+# --------------------------------------------------------------------------- #
+
+
+async def test_close_sessions_for_request_ids_expires_the_owner_and_retries_cleanup() -> None:
+    async with Harness.create(max_sessions=1) as harness:
+        await harness.open("sid-request")
+        harness.events()
+        session = harness.session("sid-request")
+        request_id = stage0_request_id("sid-request")
+        session.bind_stage_request(0, request_id, fence=session.fence)
+        harness.stage_port.cleanup_failures_remaining = 1
+
+        closed = harness.manager.close_sessions_for_request_ids([request_id, "req-unrelated"], abort=True)
+
+        assert closed == {"sid-request": [request_id]}
+        assert harness.manager.get("sid-request") is None
+        assert session.lease.terminal_reason == "request_cleanup"
+        await _settle()
+        expired = harness.events("sid-request")
+        assert [type(event) for event in expired] == [SessionExpired]
+        assert expired[0].reason == "request_cleanup"
+        assert session.state == DuplexSessionState.CLOSED
+        # The stage resources are still owned by the pending cleanup.
+        assert session.resource_request_ids() == [request_id]
+        assert (await harness.open("sid-replacement")).error_code == "resource_exhausted"
+
+        assert await harness.manager.reap_expired() == 0
+        assert harness.stage_port.cleanup_calls == [([request_id], True)]
+        assert (await harness.open("sid-replacement")).error_code == "resource_exhausted"
+
+        assert await harness.manager.reap_expired() == 1
+        assert harness.stage_port.cleanup_calls == [([request_id], True)] * 2
+        assert session.resource_request_ids() == []
+        assert harness.manager.runner_for_request_id(request_id) is None
+        assert (await harness.open("sid-replacement")).ok is True
+        assert harness.manager.close_sessions_for_request_ids([request_id], abort=True) == {}
+
+
+async def test_in_progress_request_cleanup_is_finalized_by_the_orchestrator_not_the_reaper() -> None:
+    async with Harness.create(max_sessions=1) as harness:
+        await harness.open("sid-in-progress")
+        session = harness.session("sid-in-progress")
+        request_id = stage0_request_id("sid-in-progress")
+        session.bind_stage_request(0, request_id, fence=session.fence)
+
+        closed = harness.manager.close_sessions_for_request_ids([request_id], abort=True, cleanup_in_progress=True)
+        assert closed == {"sid-in-progress": [request_id]}
+
+        # The orchestrator owns this cleanup: the reaper neither retries nor releases it.
+        assert await harness.manager.reap_expired() == 0
+        assert harness.stage_port.cleanup_calls == []
+        assert (await harness.open("sid-replacement")).error_code == "resource_exhausted"
+
+        harness.manager.finalize_closed_sessions(["sid-in-progress"])
+
+        assert session.resource_request_ids() == []
+        assert session.state == DuplexSessionState.CLOSED
+        assert harness.manager.runner_for_request_id(request_id) is None
+        assert await harness.manager.reap_expired() == 0
+        assert harness.stage_port.cleanup_calls == []
+        assert (await harness.open("sid-replacement")).ok is True
+
+
+async def test_deferred_request_cleanup_is_retried_by_the_reaper() -> None:
+    async with Harness.create(max_sessions=1) as harness:
+        await harness.open("sid-deferred")
+        session = harness.session("sid-deferred")
+        request_id = stage0_request_id("sid-deferred")
+        session.bind_stage_request(0, request_id, fence=session.fence)
+        harness.manager.close_sessions_for_request_ids([request_id], abort=True, cleanup_in_progress=True)
+        assert await harness.manager.reap_expired() == 0
+        assert harness.stage_port.cleanup_calls == []
+
+        # The orchestrator's own cleanup failed: hand the retry to the reaper.
+        harness.manager.defer_request_cleanups(["sid-deferred"])
+
+        assert await harness.manager.reap_expired() == 1
+        assert harness.stage_port.cleanup_calls == [([request_id], True)]
+        assert session.resource_request_ids() == []
+        assert (await harness.open("sid-replacement")).ok is True
+
+
+async def test_request_cleanup_closes_the_owner_of_any_of_its_stage_requests() -> None:
+    async with Harness.create() as harness:
+        await harness.open("sid-merge")
+        session = harness.session("sid-merge")
+        stage0 = stage0_request_id("sid-merge")
+        session.bind_stage_request(0, stage0, fence=session.fence)
+        stage1 = harness.manager.ensure_stage_request(session, stage_id=1)
+        assert stage1 is not None
+
+        closed = harness.manager.close_sessions_for_request_ids([stage1.request_id])
+
+        assert closed == {"sid-merge": [stage0, stage1.request_id]}
+        assert harness.manager.close_sessions_for_request_ids([stage0]) == {}
+        assert await harness.manager.reap_expired() == 1
+        assert harness.stage_port.cleanup_calls == [([stage0, stage1.request_id], False)]
+
+
+# --------------------------------------------------------------------------- #
+# Dispatch ordering / shutdown                                                #
+# --------------------------------------------------------------------------- #
+
+
+async def test_control_dispatch_is_ordered_per_session_without_blocking_other_sessions() -> None:
+    plugin = FakePlugin()
+    plugin.blocked_session_ids.add("sid-blocked")
+    async with Harness.create(plugin=plugin) as harness:
+        manager = harness.manager
+        blocked_config = DuplexSessionConfig(model="fake-model", instructions="sid-blocked")
+
+        manager.dispatch(
+            OpenDuplexSessionMessage(control_id="blocked-open", session_id="sid-blocked", session_config=blocked_config)
+        )
+        await asyncio.wait_for(plugin.runtime_config_started.wait(), timeout=1.0)
+        manager.dispatch(
+            TouchDuplexSessionMessage(
+                control_id="blocked-touch",
+                session_id="sid-blocked",
+                activity=DuplexLeaseActivity.HEARTBEAT.value,
+            )
+        )
+        manager.dispatch(
+            OpenDuplexSessionMessage(
+                control_id="independent-open",
+                session_id="sid-independent",
+                session_config=DuplexSessionConfig(model="fake-model"),
+            )
+        )
+        manager.dispatch(
+            TouchDuplexSessionMessage(
+                control_id="independent-touch",
+                session_id="sid-independent",
+                activity=DuplexLeaseActivity.HEARTBEAT.value,
+            )
+        )
+
+        assert [(await harness.result()).control_id for _ in range(2)] == ["independent-open", "independent-touch"]
+        assert harness.result_sink.empty()
+        assert manager.get("sid-blocked") is None
+
+        plugin.runtime_config_gate.set()
+        results = [await harness.result() for _ in range(2)]
+        assert [result.control_id for result in results] == ["blocked-open", "blocked-touch"]
+        assert all(result.ok for result in results)
+        assert manager.active_count() == 2
+
+
+async def test_shutdown_closes_every_runner_and_stops_dispatch_tasks() -> None:
+    harness = Harness.create()
+    await harness.open("sid-a")
+    await harness.open("sid-b")
+    sessions = [harness.session("sid-a"), harness.session("sid-b")]
+    harness.events()
+
+    await harness.manager.shutdown()
+
+    assert harness.manager.active_count() == 0
+    assert harness.manager.runners == {}
+    assert all(session.state == DuplexSessionState.CLOSED for session in sessions)
+    assert harness.manager.runner_for_request_id(stage0_request_id("sid-b")) is None
+    # Shutdown is silent: no session.closed / session.expired is emitted.
+    assert harness.events() == []
+    assert harness.stage_port.cleanup_calls == []
+
+
+def test_manager_rejects_a_plugin_whose_sampling_policy_mismatches_the_stages() -> None:
+    class WrongStageCountPlugin(FakePlugin):
+        def configure_sampling_params(self, *, runtime_config, defaults):
+            del runtime_config
+            return defaults[:1]
+
+    with pytest.raises(ValueError, match="one sampling parameter per stage"):
+        DuplexSessionManager(
+            plugin=WrongStageCountPlugin(),
+            stage_port=FakeStagePort(),
+            output_sink=asyncio.Queue(),
+            result_sink=asyncio.Queue(),
+            runtime_config=_runtime_config(),
+            model_config=None,
+        )
+
+
+# --------------------------------------------------------------------------- #
+# Admission bookkeeping                                                       #
+# --------------------------------------------------------------------------- #
+
+
+async def test_duplicate_open_in_flight_does_not_release_the_first_opens_slot() -> None:
+    """A duplicate id arriving mid-flight must not free the slot the first open holds.
+
+    The rejection runs the same ``finally`` as a successful open, so without a
+    guard it discards an ``_admitting`` entry it never added, and the next open
+    of a *different* id sails past ``max_sessions``. Server-allocated ids make
+    this a guard rather than a live path, which is exactly why a sequential
+    duplicate cannot exercise it.
+    """
+    async with Harness.create(max_sessions=1) as harness:
+        harness.plugin.blocked_session_ids.add("dup")
+        first = asyncio.create_task(harness.open("dup", DuplexSessionConfig(model="fake-model", instructions="dup")))
+        await asyncio.wait_for(harness.plugin.runtime_config_started.wait(), timeout=1.0)
+
+        duplicate = await harness.open("dup", DuplexSessionConfig(model="fake-model", instructions="dup"))
+        assert duplicate.ok is False
+        assert duplicate.error_code == "session_exists"
+
+        # The in-flight open still holds the only slot.
+        overflow = await harness.open("other", DuplexSessionConfig(model="fake-model", instructions="other"))
+        assert overflow.ok is False
+        assert overflow.error_code == "resource_exhausted"
+
+        harness.plugin.runtime_config_gate.set()
+        assert (await first).ok is True
+        assert harness.manager.active_count() == 1
+
+
+async def test_expiry_emits_a_terminal_event_even_when_a_close_deferred_it() -> None:
+    """Every session ends with exactly one terminal event, whoever tears it down.
+
+    A wire ``session.close`` defers its ``session.closed`` to the manager. If a
+    stage failure then takes the runner away from the manager (the orchestrator
+    cleanup path), nobody would emit the deferred event unless ``expire``
+    upgrades it.
+    """
+    async with Harness.create() as harness:
+        await harness.open("sid-deferred")
+        runner = harness.manager.runners["sid-deferred"]
+        # What the runner does for a wire close: tear down, defer the terminal.
+        await runner.close("client_close", emit_closed=False)
+        harness.events("sid-deferred")
+
+        await runner.expire("request_cleanup", emit_expired=True)
+
+        terminal = [
+            event for event in harness.events("sid-deferred") if isinstance(event, SessionClosed | SessionExpired)
+        ]
+        assert len(terminal) == 1, terminal
+        assert isinstance(terminal[0], SessionExpired)
+        assert terminal[0].reason == "request_cleanup"
+
+
+async def test_an_open_abandoned_by_its_caller_does_not_hold_the_admission_slot() -> None:
+    """A control-RPC timeout must not leave the engine holding a session.
+
+    The caller's timeout unregisters its RPC waiter but cannot cancel the
+    manager's open, which is already past the capacity check. Without the
+    compensating close, that session lands, keeps its slot and its Stage0
+    reservation, and with ``max_sessions=1`` the next open is refused until
+    idle expiry.
+    """
+    async with Harness.create(max_sessions=1) as harness:
+        harness.plugin.blocked_session_ids.add("blocked")
+        config = DuplexSessionConfig(model="fake-model", instructions="blocked")
+
+        open_task = asyncio.create_task(harness.open("sid-abandoned", config))
+        await asyncio.wait_for(harness.plugin.runtime_config_started.wait(), timeout=1.0)
+
+        # The caller gave up: DuplexOmni sends the compensating close while the
+        # open is still awaiting the plugin.
+        await harness.close("sid-abandoned", reason="open_abandoned")
+
+        harness.plugin.runtime_config_gate.set()
+        await open_task
+
+        assert "sid-abandoned" not in harness.manager.runners
+        # The slot came back, so a replacement is admitted.
+        assert (await harness.open("sid-replacement")).ok is True
+
+
+async def test_a_runtime_close_racing_a_manager_close_still_emits_one_terminal() -> None:
+    """Two teardown drivers, one terminal event.
+
+    The window is inside ``runner.close()``: ``cancel_append_tasks()`` is awaited
+    *before* the terminal is deferred, so an append task that dies there finds
+    the session merely CLOSING with neither ``closed_emitted`` nor
+    ``closed_deferred`` set, and emits ``session.closed`` itself. The manager
+    decided to emit before any of this and must re-check, or the session ends
+    with two terminal events.
+    """
+    async with Harness.create(max_sessions=1) as harness:
+        await harness.open("sid-race")
+        harness.events()
+        session = harness.session("sid-race")
+        session.bind_stage_request(0, stage0_request_id("sid-race"), fence=session.fence)
+        runner = harness.manager.runners["sid-race"]
+
+        async def dying_append() -> bool:
+            try:
+                await asyncio.Event().wait()
+            except asyncio.CancelledError:
+                # What AppendAttempt does when its submit fails mid-teardown.
+                await runner._close_from_runtime("runtime_append_task_failed")
+                raise
+            return True
+
+        task = asyncio.ensure_future(dying_append())
+        await asyncio.sleep(0)
+        runner.tasks.track_append_task(task, epoch=session.epoch, final=True, response_bound=True)
+
+        await harness.close("sid-race")
+
+        terminal = [event for event in harness.events("sid-race") if isinstance(event, SessionClosed | SessionExpired)]
+        assert len(terminal) == 1, terminal
+
+
+async def test_a_terminal_event_is_emitted_once_even_if_expiry_runs_twice() -> None:
+    async with Harness.create() as harness:
+        await harness.open("sid-once")
+        runner = harness.manager.runners["sid-once"]
+
+        await runner.expire("idle_ttl_expired", emit_expired=True)
+        await runner.expire("idle_ttl_expired", emit_expired=True)
+
+        terminal = [event for event in harness.events("sid-once") if isinstance(event, SessionClosed | SessionExpired)]
+        assert len(terminal) == 1, terminal
+
+
+# --------------------------------------------------------------------------- #
+# Resume and takeover lifecycle                                               #
+# --------------------------------------------------------------------------- #
+
+
+async def test_resume_inside_the_grace_window_stops_the_reaper_expiring_the_session() -> None:
+    """Resuming clears the disconnect deadline, not just the lease generation.
+
+    The reaper decides expiry from ``lease.detached_at``. A resume that bumped
+    the generation without clearing it would let the reaper kill a session a
+    client had already come back to.
+    """
+    async with Harness.create(disconnect_grace_s=30.0) as harness:
+        await harness.open("sid-grace")
+        session = harness.session("sid-grace")
+        assert (await harness.touch("sid-grace", DuplexLeaseActivity.DETACH.value)).ok is True
+        harness.clock.advance(10.0)
+
+        assert (await harness.resume("sid-grace", expected_lease_generation=0)).ok is True
+        assert session.lease.detached_at is None
+
+        # Past the original deadline: the session survives because it is attached.
+        harness.clock.advance(25.0)
+        assert await harness.manager.reap_expired() == 0
+        assert harness.manager.get("sid-grace") is not None
+
+
+async def test_resume_after_the_grace_window_reports_unknown_session() -> None:
+    """Once the reaper has expired a detached session, resume has nothing to attach to."""
+    async with Harness.create(disconnect_grace_s=5.0) as harness:
+        await harness.open("sid-late")
+        assert (await harness.touch("sid-late", DuplexLeaseActivity.DETACH.value)).ok is True
+        harness.clock.advance(6.0)
+        assert await harness.manager.reap_expired() == 1
+
+        late = await harness.resume("sid-late", expected_lease_generation=0)
+
+        assert late.ok is False
+        assert late.error_code == "unknown_session"
+
+
+async def test_takeover_invalidates_the_generation_the_replaced_client_held() -> None:
+    """Two clients cannot both hold the session: the first one's generation goes stale.
+
+    This is the engine half of a websocket takeover — the transport picks the
+    winning socket, and the lease generation is what stops the loser from
+    resuming behind it.
+    """
+    async with Harness.create() as harness:
+        await harness.open("sid-takeover")
+        session = harness.session("sid-takeover")
+        assert (await harness.touch("sid-takeover", DuplexLeaseActivity.DETACH.value)).ok is True
+
+        winner = await harness.resume("sid-takeover", expected_lease_generation=0)
+        assert winner.ok is True
+        assert winner.lease_generation == 1
+
+        # The replaced client still believes it holds generation 0.
+        loser = await harness.resume("sid-takeover", expected_lease_generation=0)
+        assert loser.ok is False
+        assert loser.error_code == "session_resume_conflict"
+        assert session.lease_generation == 1
+
+        # The winner can still act on the session it took over.
+        assert (await harness.touch("sid-takeover", DuplexLeaseActivity.HEARTBEAT.value)).ok is True
+
+
+async def test_resume_is_refused_once_a_close_has_begun() -> None:
+    async with Harness.create() as harness:
+        await harness.open("sid-closing")
+        await harness.close("sid-closing")
+
+        resumed = await harness.resume("sid-closing", expected_lease_generation=0)
+
+        assert resumed.ok is False
+        assert resumed.error_code == "unknown_session"
+
+
+async def test_wire_close_of_an_idle_session_still_emits_session_closed() -> None:
+    """The protocol smoke shape: open, send nothing, close.
+
+    A session that never bound a stage request has nothing for the reaper to
+    clean up, so the terminal event is the only thing the client ever gets
+    back for its ``session.close``. Regression guard for a close path that
+    only emitted after a cleanup it never performed.
+    """
+    async with Harness.create(max_sessions=1) as harness:
+        await harness.open("sid-idle-close")
+        harness.events()
+
+        harness.command("sid-idle-close", CloseSession(reason="client_close"))
+        events: list[DuplexEvent] = []
+        for _ in range(200):
+            events.extend(harness.events("sid-idle-close"))
+            if events:
+                break
+            await asyncio.sleep(0.01)
+
+        assert [type(event) for event in events] == [SessionClosed]
+        assert events[0].reason == "client_close"
+        assert harness.manager.get("sid-idle-close") is None
+        assert (await harness.open("sid-idle-replacement")).ok is True
+
+
+# --------------------------------------------------------------------------- #
+# Reaper loop                                                                 #
+# --------------------------------------------------------------------------- #
+
+
+async def test_reaper_loop_waits_between_ticks() -> None:
+    """The loop paces itself; it does not spin on the expiry check.
+
+    Ported from the pre-framework ``Orchestrator._duplex_reaper_loop`` tests:
+    the loop moved to the session manager with the sessions it reaps.
+    """
+    manager = object.__new__(DuplexSessionManager)
+    calls = 0
+
+    async def reap_expired(now: float | None = None) -> int:
+        nonlocal calls
+        calls += 1
+        return 0
+
+    manager.reap_expired = reap_expired  # type: ignore[method-assign]
+    manager.runtime_config = DuplexSessionRuntimeConfig(reaper_interval_s=0.01)
+    shutdown = asyncio.Event()
+
+    task = asyncio.create_task(manager.reaper_loop(shutdown))
+    await asyncio.sleep(0.035)
+    shutdown.set()
+    await asyncio.wait_for(task, timeout=5.0)
+
+    assert 2 <= calls <= 5
+
+
+@pytest.mark.parametrize("first_cleanup_delay", [0.0, 0.05], ids=["immediate", "delayed"])
+async def test_reaper_loop_survives_one_cleanup_failure(first_cleanup_delay: float) -> None:
+    """A failed expiry sweep is retried on the next tick, not fatal to the loop."""
+    recovered = asyncio.Event()
+    calls = 0
+
+    manager = object.__new__(DuplexSessionManager)
+
+    async def reap_expired(now: float | None = None) -> int:
+        nonlocal calls
+        calls += 1
+        if calls == 1:
+            await asyncio.sleep(first_cleanup_delay)
+            raise RuntimeError("transient cleanup failure")
+        recovered.set()
+        return 0
+
+    manager.reap_expired = reap_expired  # type: ignore[method-assign]
+    manager.runtime_config = DuplexSessionRuntimeConfig(reaper_interval_s=0.01)
+    shutdown = asyncio.Event()
+
+    task = asyncio.create_task(manager.reaper_loop(shutdown))
+    try:
+        await asyncio.wait_for(recovered.wait(), timeout=5.0)
+        assert calls >= 2
+    finally:
+        shutdown.set()
+        await asyncio.wait_for(task, timeout=5.0)
diff --git a/tests/engine/duplex/test_session_runner.py b/tests/engine/duplex/test_session_runner.py
new file mode 100644
index 000000000..51711f52a
--- /dev/null
+++ b/tests/engine/duplex/test_session_runner.py
@@ -0,0 +1,1195 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Engine-resident session runner scenarios (the old serving handler tests, re-homed).
+
+The runner is driven exactly the way ``DuplexOrchestrator`` drives it: typed
+commands go through ``DuplexSessionManager.dispatch``, stage outputs are pushed
+with ``runner.on_stage_output`` and everything the session says is read back
+from the manager's output sink as typed events. The stage port is a recording
+fake; the model plugin is the real MiniCPM-o 4.5 one so append planning and
+output projection are exercised end to end.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import base64
+import struct
+from collections.abc import Sequence
+from dataclasses import dataclass, field
+from types import SimpleNamespace
+from typing import Any
+
+import numpy as np
+import pytest
+from vllm.sampling_params import SamplingParams
+
+from vllm_omni.config.stage_config import DuplexSessionRuntimeConfig
+from vllm_omni.engine.duplex import commands
+from vllm_omni.engine.duplex.commands import DuplexCommand
+from vllm_omni.engine.duplex.config import DuplexSessionConfig, DuplexSessionState
+from vllm_omni.engine.duplex.contracts import (
+    DuplexOutputContext,
+    DuplexRequestIdentity,
+    DuplexStagePort,
+    DuplexStageRequestContext,
+    DuplexStageSubmission,
+    DuplexStageSubmissionResult,
+    duplex_resource_request_id,
+)
+from vllm_omni.engine.duplex.events import DuplexEvent
+from vllm_omni.engine.duplex.messages import (
+    CloseDuplexSessionMessage,
+    DuplexControlResultMessage,
+    DuplexSessionCommandMessage,
+    DuplexSessionEventMessage,
+    OpenDuplexSessionMessage,
+)
+from vllm_omni.engine.duplex.session.manager import DuplexSessionManager
+from vllm_omni.engine.duplex.session.runner import DuplexSessionRunner
+from vllm_omni.metrics.stats import StageRequestStats, StageStats
+from vllm_omni.model_executor.models.minicpmo_4_5.duplex.plugin import MiniCPMO45DuplexPlugin
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+SESSION_ID = "duplex-test"
+LISTEN_TOKEN_ID = 7
+
+
+# --------------------------------------------------------------------------- #
+# Fakes                                                                       #
+# --------------------------------------------------------------------------- #
+
+
+class RecordingStagePort(DuplexStagePort):
+    """Records what the runner asks of the orchestrator; never talks to a stage."""
+
+    def __init__(self, *, stage_count: int = 2) -> None:
+        self._stage_count = stage_count
+        self.ensured: list[DuplexStageRequestContext] = []
+        self.submissions: list[DuplexStageSubmission] = []
+        self.cleanups: list[tuple[list[str], bool]] = []
+        self.aborts: list[list[str]] = []
+        self.fail_submit: Exception | None = None
+
+    @property
+    def stage_count(self) -> int:
+        return self._stage_count
+
+    def sampling_defaults(self) -> tuple[object, ...]:
+        return tuple(SamplingParams(max_tokens=8) for _ in range(self._stage_count))
+
+    def ensure_request(self, context: DuplexStageRequestContext) -> None:
+        self.ensured.append(context)
+
+    async def submit(self, submission: DuplexStageSubmission) -> DuplexStageSubmissionResult:
+        if self.fail_submit is not None:
+            raise self.fail_submit
+        self.submissions.append(submission)
+        return DuplexStageSubmissionResult(
+            request_id=submission.context.request_id,
+            stage_id=submission.context.stage_id,
+            replica_id=0,
+        )
+
+    async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
+        self.cleanups.append((list(request_ids), abort))
+
+    async def abort_requests(self, request_ids: list[str]) -> None:
+        self.aborts.append(list(request_ids))
+
+
+def _fake_encode_audio(audio: object, sample_rate_hz: int, response_format: str, speed: float | None) -> str | None:
+    del sample_rate_hz, response_format, speed
+    if audio is None:
+        return None
+    samples = int(np.asarray(audio, dtype=np.float32).size)
+    return f"wav-{samples}" if samples > 0 else None
+
+
+@dataclass
+class Harness:
+    manager: DuplexSessionManager
+    port: RecordingStagePort
+    output: asyncio.Queue[Any]
+    results: asyncio.Queue[Any]
+    runner: DuplexSessionRunner
+    events: list[DuplexEvent] = field(default_factory=list)
+
+    @property
+    def session(self):
+        return self.runner.session
+
+    def submit(self, command: DuplexCommand) -> None:
+        self.manager.dispatch(DuplexSessionCommandMessage(session_id=SESSION_ID, command=command))
+
+    async def settle(self, *, idle_s: float = 0.05, timeout_s: float = 3.0) -> list[DuplexEvent]:
+        """Run the loop until the runner mailbox and append tasks are quiet; return new events."""
+        loop = asyncio.get_running_loop()
+        deadline = loop.time() + timeout_s
+        quiet_since: float | None = None
+        collected: list[DuplexEvent] = []
+        while True:
+            drained = False
+            while not self.output.empty():
+                message = self.output.get_nowait()
+                if isinstance(message, DuplexSessionEventMessage):
+                    collected.append(message.event)
+                    drained = True
+            busy = (
+                drained
+                or not self.runner._mailbox.empty()
+                or any(not task.done() for task in self.runner.tasks.append_tasks)
+                or any(not task.done() for task in self.runner._background_tasks)
+            )
+            now = loop.time()
+            if busy:
+                quiet_since = None
+            elif quiet_since is None:
+                quiet_since = now
+            elif now - quiet_since >= idle_s:
+                break
+            if now >= deadline:
+                break
+            await asyncio.sleep(0.005)
+        self.events.extend(collected)
+        return collected
+
+    async def run(self, command: DuplexCommand) -> list[DuplexEvent]:
+        self.submit(command)
+        return await self.settle()
+
+    def deliver(
+        self,
+        output: object,
+        *,
+        stage_id: int = 1,
+        segment_finished: bool = False,
+        segment_output_metadata: dict[str, Any] | None = None,
+        segment_token_ids: Sequence[int] = (),
+        epoch: int | None = None,
+        metrics: Any = None,
+    ) -> bool:
+        session = self.session
+        fence = session.fence if epoch is None else session.fence.__class__(SESSION_ID, epoch=epoch)
+        context = DuplexOutputContext(
+            identity=DuplexRequestIdentity(session_id=SESSION_ID, fence=fence),
+            final_stage_id=self.port.stage_count - 1,
+            segment_finished=segment_finished,
+            segment_token_ids=tuple(segment_token_ids),
+            segment_output_metadata=dict(segment_output_metadata or {}),
+        )
+        return self.runner.on_stage_output(stage_id, output, metrics, request_id=output.request_id, context=context)
+
+    async def deliver_and_settle(self, output: object, **kwargs: Any) -> list[DuplexEvent]:
+        self.deliver(output, **kwargs)
+        return await self.settle()
+
+    def stage0_request_id(self, epoch: int | None = None) -> str:
+        fence = self.session.fence if epoch is None else self.session.fence.__class__(SESSION_ID, epoch=epoch)
+        return duplex_resource_request_id(fence, "stage0")
+
+
+async def open_harness(
+    *,
+    auto_response: bool = True,
+    modalities: Sequence[str] = ("text",),
+    extra_body: dict[str, object] | None = None,
+    runtime_config: DuplexSessionRuntimeConfig | None = None,
+    stage_count: int = 2,
+    clock: Any = None,
+) -> Harness:
+    plugin = MiniCPMO45DuplexPlugin(_fake_encode_audio)
+    port = RecordingStagePort(stage_count=stage_count)
+    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=runtime_config or DuplexSessionRuntimeConfig(),
+        model_config=None,
+        clock=clock,
+    )
+    body: dict[str, object] = {"auto_response": auto_response, **(extra_body or {})}
+    config = DuplexSessionConfig(
+        model="openbmb/MiniCPM-o-4_5",
+        modalities=list(modalities),
+        instructions="You are a concise assistant.",
+        extra_body=body,
+    )
+    await manager.handle(OpenDuplexSessionMessage(control_id="c-open", session_id=SESSION_ID, session_config=config))
+    result = await asyncio.wait_for(results.get(), timeout=2.0)
+    assert isinstance(result, DuplexControlResultMessage) and result.ok, result
+    harness = Harness(manager=manager, port=port, output=output, results=results, runner=manager.runners[SESSION_ID])
+    await harness.settle()
+    return harness
+
+
+async def close_harness(harness: Harness) -> None:
+    await harness.manager.shutdown()
+
+
+# --------------------------------------------------------------------------- #
+# Payload / output builders                                                   #
+# --------------------------------------------------------------------------- #
+
+
+def pcm_f32(samples: int, *, value: float = 0.05) -> bytes:
+    return struct.pack(f"<{samples}f", *([value] * samples))
+
+
+def append_audio(
+    samples: int = 16000,
+    *,
+    value: float = 0.05,
+    is_speech: bool | None = True,
+    event_id: str | None = None,
+) -> commands.AppendAudio:
+    return commands.AppendAudio(
+        audio=pcm_f32(samples, value=value),
+        format="pcm_f32le",
+        sample_rate_hz=16000,
+        is_speech=is_speech,
+        event_id=event_id,
+    )
+
+
+def stage_stats(
+    *,
+    stage_id: int,
+    request_id: str,
+    num_tokens_out: int,
+    itls_ms: list[float] | None = None,
+) -> StageRequestStats:
+    """The per-request stats the orchestrator hands to the runner with an output."""
+    return StageRequestStats(
+        batch_id=0,
+        batch_size=1,
+        num_tokens_in=7,
+        num_tokens_out=num_tokens_out,
+        stage_gen_time_ms=120.0,
+        rx_transfer_bytes=0,
+        rx_decode_time_ms=0.0,
+        rx_in_flight_time_ms=0.0,
+        stage_stats=StageStats(),
+        stage_id=stage_id,
+        request_id=request_id,
+        final_output_type="text",
+        vllm_itls_ms=list(itls_ms or []),
+    )
+
+
+def tts_output(
+    request_id: str,
+    *,
+    samples: int = 24000,
+    finished: bool = False,
+    text: str = "hello",
+    tts_is_last_chunk: bool = False,
+    turn_end: bool = False,
+    turn_id: int = 0,
+    epoch: int = 0,
+) -> SimpleNamespace:
+    """A Stage1 (TTS) output the way the orchestrator hands it to the runner."""
+    return SimpleNamespace(
+        request_id=request_id,
+        finished=finished,
+        outputs=[SimpleNamespace(text=text, token_ids=[], multimodal_output={})],
+        multimodal_output={
+            "audio": np.zeros(samples, dtype=np.float32),
+            "sr": 24000,
+            "meta.tts_is_last_chunk": np.array([int(tts_is_last_chunk)], dtype=np.int32),
+            "meta.turn_end": np.array([int(turn_end)], dtype=np.int32),
+            "meta.duplex_turn_id": np.array([turn_id], dtype=np.int32),
+            "meta.duplex_epoch": np.array([epoch], dtype=np.int32),
+        },
+    )
+
+
+def listen_output(request_id: str) -> SimpleNamespace:
+    """A finished Stage0 segment that ends with the listen token."""
+    return SimpleNamespace(
+        request_id=request_id,
+        finished=True,
+        outputs=[
+            SimpleNamespace(
+                text="",
+                token_ids=[11, 12, LISTEN_TOKEN_ID],
+                stop_reason=LISTEN_TOKEN_ID,
+                multimodal_output={},
+            )
+        ],
+        multimodal_output={"meta.listen_token_id": LISTEN_TOKEN_ID},
+    )
+
+
+def types(events: Sequence[DuplexEvent]) -> list[str]:
+    return [event.type for event in events]
+
+
+def find(events: Sequence[DuplexEvent], wire_type: str) -> DuplexEvent:
+    for event in events:
+        if event.type == wire_type:
+            return event
+    raise AssertionError(f"no {wire_type!r} in {types(events)}")
+
+
+def b64(data: bytes) -> str:
+    return base64.b64encode(data).decode("ascii")
+
+
+# --------------------------------------------------------------------------- #
+# Session lifecycle                                                           #
+# --------------------------------------------------------------------------- #
+
+
+@pytest.mark.asyncio
+async def test_open_announces_the_session_and_reserves_the_stage0_request() -> None:
+    h = await open_harness()
+    try:
+        assert types(h.events) == ["session.created", "session.updated"]
+        created = h.events[0]
+        assert created.session_id == SESSION_ID
+        assert created.session["id"] == SESSION_ID
+        assert created.session["capabilities"]["supports_input_append"] is True
+        assert created.to_realtime()["type"] == "session.created"
+        assert "incarnation" not in created.to_realtime()
+        assert h.session.state == DuplexSessionState.OPEN
+        # Admission reserves the resumable Stage0 request atomically with the open.
+        assert [context.request_id for context in h.port.ensured] == [h.stage0_request_id(epoch=0)]
+        assert h.stage0_request_id(epoch=0) == "duplex-s.ZHVwbGV4LXRlc3Q.e.0.r.stage0"
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_close_emits_session_closed_and_releases_stage_requests() -> None:
+    h = await open_harness()
+    await h.run(append_audio())
+    request_id = h.stage0_request_id()
+    await h.manager.handle(
+        CloseDuplexSessionMessage(control_id="c-close", session_id=SESSION_ID, reason="client_close")
+    )
+    result = await asyncio.wait_for(h.results.get(), timeout=2.0)
+    events = await h.settle()
+
+    assert result.ok and result.operation == "close"
+    assert types(events) == ["session.closed"]
+    assert events[0].reason == "client_close"
+    assert events[0].is_terminal
+    assert h.session.state == DuplexSessionState.CLOSED
+    assert h.port.cleanups == [([request_id], True)]
+    assert SESSION_ID not in h.manager.runners
+    await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_idle_expiry_emits_session_expired() -> None:
+    clock = {"now": 100.0}
+    h = await open_harness(runtime_config=DuplexSessionRuntimeConfig(idle_ttl_s=1.0), clock=lambda: clock["now"])
+    clock["now"] += 2.0
+    assert await h.manager.reap_expired() == 1
+    events = await h.settle()
+
+    assert types(events) == ["session.expired"]
+    assert events[0].reason == "idle_ttl_expired"
+    assert events[0].is_terminal
+    assert SESSION_ID not in h.manager.runners
+    assert not h.manager._closing
+    await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_commands_for_a_closed_session_are_answered_with_unknown_session() -> None:
+    h = await open_harness()
+    await h.manager.handle(CloseDuplexSessionMessage(control_id="c-close", session_id=SESSION_ID, reason="bye"))
+    await h.results.get()
+    await h.settle()
+
+    h.submit(commands.Heartbeat(event_id="evt-late"))
+    events = await h.settle()
+
+    assert types(events) == ["error"]
+    assert events[0].code == "unknown_session"
+    assert events[0].related_event_id == "evt-late"
+    await close_harness(h)
+
+
+# --------------------------------------------------------------------------- #
+# Input path                                                                  #
+# --------------------------------------------------------------------------- #
+
+
+@pytest.mark.asyncio
+async def test_append_plans_and_submits_one_model_unit_in_wire_order() -> None:
+    h = await open_harness()
+    try:
+        events = await h.run(append_audio())
+        assert types(events) == ["input_audio_buffer.speech_started"]
+        assert len(h.port.submissions) == 1
+        first = h.port.submissions[0]
+        assert first.context.request_id == h.stage0_request_id(epoch=0)
+        assert first.context.stage_id == 0
+        assert first.already_submitted is False
+        duplex = first.prompt["model_intermediate_buffer"]["duplex"]
+        assert duplex["session_id"] == SESSION_ID
+        assert (duplex["epoch"], duplex["seq"], duplex["turn_id"], duplex["turn_seq"]) == (0, 1, 0, 1)
+        assert duplex["final"] is False
+        assert "incarnation" not in duplex
+        assert len(base64.b64decode(duplex["payload"]["audio"])) == 16000 * 4
+        assert duplex["payload"]["is_speech"] is True
+        assert h.session.input_seq == 1
+        assert h.session.stage_request_submitted(0, first.context.request_id)
+
+        await h.run(append_audio())
+        second = h.port.submissions[1]
+        assert second.already_submitted is True
+        assert second.prompt["model_intermediate_buffer"]["duplex"]["seq"] == 2
+        assert h.session.input_seq == 2
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_partial_units_are_buffered_until_a_whole_chunk_is_available() -> None:
+    h = await open_harness()
+    try:
+        await h.run(append_audio(samples=8000))
+        assert h.port.submissions == []
+        assert h.runner.model_state.audio_buffer.has_pending()
+
+        await h.run(append_audio(samples=8000))
+        assert len(h.port.submissions) == 1
+        assert not h.runner.model_state.audio_buffer.has_pending()
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_input_backpressure_is_rejected_before_the_buffer_is_touched() -> None:
+    h = await open_harness(runtime_config=DuplexSessionRuntimeConfig(max_pending_input_bytes_per_session=1000))
+    try:
+        events = await h.run(append_audio(event_id="evt-big"))
+        assert types(events) == ["error"]
+        assert events[0].code == "input_backpressure"
+        assert events[0].related_event_id == "evt-big"
+        assert h.port.submissions == []
+        assert not h.runner.model_state.audio_buffer.has_pending()
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_text_append_is_not_supported_by_the_native_runtime() -> None:
+    h = await open_harness()
+    try:
+        events = await h.run(commands.AppendText(text="hello", event_id="evt-text"))
+        assert types(events) == ["error"]
+        assert events[0].code == "native_text_append_unsupported"
+        assert events[0].related_event_id == "evt-text"
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_clear_input_drops_buffered_audio() -> None:
+    h = await open_harness()
+    try:
+        await h.run(append_audio(samples=8000))
+        assert h.runner.model_state.audio_buffer.has_pending()
+        events = await h.run(commands.ClearInput())
+        assert types(events) == ["input_audio_buffer.cleared"]
+        assert not h.runner.model_state.audio_buffer.has_pending()
+        assert h.session.pending_input_bytes == 0
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_commit_without_audio_is_rejected() -> None:
+    h = await open_harness()
+    try:
+        events = await h.run(commands.Commit(event_id="evt-commit"))
+        assert types(events) == ["error"]
+        assert events[0].code == "input_audio_buffer_empty"
+        assert events[0].related_event_id == "evt-commit"
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_commit_projects_the_user_item_and_does_not_resubmit_consumed_audio() -> None:
+    h = await open_harness()
+    try:
+        await h.run(append_audio())
+        events = await h.run(commands.Commit())
+        assert types(events) == [
+            "input_audio_buffer.speech_stopped",
+            "conversation.item.added",
+            "conversation.item.created",
+            "input_audio_buffer.committed",
+            "conversation.item.done",
+        ]
+        committed = find(events, "input_audio_buffer.committed")
+        assert committed.item_id == find(events, "conversation.item.added").item_id
+        # The unit already reached Stage0; a commit is only a turn marker here.
+        assert len(h.port.submissions) == 1
+        assert h.session.input_commit_seq == 1
+        assert h.session.history[-1]["role"] == "user"
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_heartbeat_touches_the_lease_and_acks() -> None:
+    clock = {"now": 100.0}
+    h = await open_harness(clock=lambda: clock["now"])
+    try:
+        clock["now"] = 150.0
+        events = await h.run(commands.Heartbeat())
+        assert types(events) == ["session.heartbeat_ack"]
+        assert h.session.lease.last_activity == 150.0
+    finally:
+        await close_harness(h)
+
+
+# --------------------------------------------------------------------------- #
+# Model output path                                                           #
+# --------------------------------------------------------------------------- #
+
+
+@pytest.mark.asyncio
+async def test_stage1_audio_opens_a_response_and_streams_deltas() -> None:
+    h = await open_harness()
+    try:
+        await h.run(append_audio())
+        request_id = h.stage0_request_id()
+
+        events = await h.deliver_and_settle(tts_output(request_id, samples=24000, text="he"))
+        assert types(events) == [
+            "response.created",
+            "conversation.item.added",
+            "conversation.item.created",
+            "response.output_item.added",
+            "response.speak",
+            "response.content_part.added",
+            "response.output_audio.delta",
+            "response.output_audio_transcript.delta",
+        ]
+        response_id = find(events, "response.created").response_id
+        assert response_id == h.session.active_response_id
+        assert h.session.active_request_id == request_id
+        delta = find(events, "response.output_audio.delta")
+        assert (delta.delta, delta.format, delta.sample_rate_hz) == ("wav-24000", "wav", 24000)
+        assert delta.response_id == response_id
+        assert find(events, "response.output_audio_transcript.delta").delta == "he"
+        assert h.session.playback.sent_ms == 1000
+
+        # Cumulative Stage1 audio is sliced to the new samples only.
+        events = await h.deliver_and_settle(tts_output(request_id, samples=48000, text="hello"))
+        assert types(events) == ["response.output_audio.delta", "response.output_audio_transcript.delta"]
+        assert find(events, "response.output_audio.delta").delta == "wav-24000"
+        assert find(events, "response.output_audio_transcript.delta").delta == "llo"
+        assert h.session.playback.sent_ms == 2000
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_turn_end_completes_the_response_and_advances_the_model_turn() -> None:
+    h = await open_harness()
+    try:
+        await h.run(append_audio())
+        request_id = h.stage0_request_id()
+        await h.deliver_and_settle(tts_output(request_id, samples=24000, text="hello"))
+
+        events = await h.deliver_and_settle(tts_output(request_id, samples=24000, text="hello", turn_end=True))
+        assert types(events) == [
+            "response.output_audio.done",
+            "response.output_audio_transcript.done",
+            "response.content_part.done",
+            "response.output_item.done",
+            "conversation.item.done",
+            "response.done",
+            "rate_limits.updated",
+        ]
+        done = find(events, "response.done")
+        assert done.status == "completed"
+        assert find(events, "response.output_audio_transcript.done").transcript == "hello"
+        assert h.session.active_response_id is None
+        assert h.session.turn_id == 1
+        # Ack-only playback: the assistant text enters history on playback ack.
+        assert h.session.history == ()
+
+        ack = await h.run(commands.AckPlayback(played_ms=1000, response_id=done.response_id))
+        assert types(ack) == ["playback.acknowledged"]
+        assert ack[0].details["history_committed"] is True
+        assert ack[0].details["playback"]["committed_ms"] == 1000
+        assert h.session.history == ({"role": "assistant", "content": "hello"},)
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_playback_ack_for_an_unknown_response_is_rejected() -> None:
+    h = await open_harness()
+    try:
+        events = await h.run(commands.AckPlayback(played_ms=10, response_id="resp-unknown", event_id="evt-ack"))
+        assert types(events) == ["error"]
+        assert events[0].code == "playback_item_not_found"
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_stale_epoch_output_is_dropped_after_barge_in() -> None:
+    h = await open_harness()
+    try:
+        await h.run(append_audio())
+        request_id = h.stage0_request_id()
+        await h.deliver_and_settle(tts_output(request_id, samples=24000, text="he"))
+
+        events = await h.run(commands.BargeIn())
+        assert h.session.epoch == 1
+        assert h.session.active_response_id is None
+        assert h.port.aborts == [[request_id]]
+        assert h.port.cleanups == [([request_id], True)]
+        done = find(events, "response.done")
+        assert done.status == "cancelled"
+        assert types(events)[: types(events).index("response.done")] == [
+            "response.output_audio.done",
+            "response.output_audio_transcript.done",
+            "response.content_part.done",
+            "response.output_item.done",
+            "conversation.item.done",
+        ]
+
+        late = tts_output(request_id, samples=48000, text="hello", epoch=0)
+        assert h.deliver(late, epoch=0) is True  # consumed, never forwarded
+        assert await h.settle() == []
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_cancel_response_without_active_response_is_rejected() -> None:
+    h = await open_harness()
+    try:
+        events = await h.run(commands.CancelResponse(event_id="evt-cancel"))
+        assert types(events) == ["error"]
+        assert events[0].code == "response_not_active"
+        assert events[0].related_event_id == "evt-cancel"
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_cancel_response_aborts_the_stage_request_and_reports_playback() -> None:
+    h = await open_harness()
+    try:
+        await h.run(append_audio())
+        request_id = h.stage0_request_id()
+        await h.deliver_and_settle(tts_output(request_id, samples=24000, text="hello"))
+        await h.run(commands.AckPlayback(played_ms=400, response_id=h.session.active_response_id))
+
+        events = await h.run(commands.CancelResponse())
+        done = find(events, "response.done")
+        assert done.status == "cancelled"
+        assert done.response["status_details"]["reason"] == "client_cancelled"
+        assert h.port.aborts == [[request_id]]
+        assert h.session.epoch == 1
+        # Only the played prefix of the cancelled answer is kept in history.
+        assert h.session.history == ({"role": "assistant", "content": "he"},)
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_listen_decision_is_consumed_and_never_forwarded_to_tts() -> None:
+    h = await open_harness()
+    try:
+        await h.run(append_audio())
+        request_id = h.stage0_request_id()
+        # An unfinished Stage0 segment is plain text for the TTS stage: forwarded.
+        text_output = SimpleNamespace(
+            request_id=request_id,
+            finished=False,
+            outputs=[SimpleNamespace(text="hi", token_ids=[11], multimodal_output={})],
+            multimodal_output={},
+        )
+        assert h.deliver(text_output, stage_id=0) is False
+
+        consumed = h.deliver(
+            listen_output(request_id),
+            stage_id=0,
+            segment_finished=True,
+            segment_token_ids=[11, 12, LISTEN_TOKEN_ID],
+            segment_output_metadata={"meta.listen_token_id": LISTEN_TOKEN_ID},
+        )
+        events = await h.settle()
+        assert consumed is True
+        assert types(events) == ["response.listen"]
+        assert events[0].details["reason"] == "model_listen"
+        assert events[0].details["model_listen"] is True
+        assert events[0].to_realtime()["response"]["status"] == "listening"
+        assert h.session.active_response_id is None
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_listen_decision_on_a_resumable_request_closes_the_bounded_response() -> None:
+    """A live stage-0 request is resumable: its output never says ``finished``,
+    only its segment does. The listen that answers the last continuation unit
+    must still close the response, or the session sits forever with no
+    terminal event (the live-client E2E hang)."""
+    h = await open_harness()
+    try:
+        await h.run(append_audio())
+        request_id = h.stage0_request_id()
+        await h.deliver_and_settle(tts_output(request_id, samples=24000, text="hello"))
+        response_id = h.session.active_response_id
+        assert response_id is not None
+        # The continuation budget is spent: the unit being answered was the forced listen.
+        model_state = h.runner.model_state
+        model_state.continuation_owner_id = f"response:{response_id}"
+        model_state.continuation_units = h.runner.model._AUTO_RESPONSE_MAX_CONTINUATION_UNITS
+
+        listen = listen_output(request_id)
+        listen.finished = False
+        events = await h.deliver_and_settle(
+            listen,
+            stage_id=0,
+            segment_finished=True,
+            segment_token_ids=[11, 12, LISTEN_TOKEN_ID],
+            segment_output_metadata={"meta.listen_token_id": LISTEN_TOKEN_ID},
+        )
+
+        assert types(events)[0] == "response.listen"
+        assert events[0].details["model_listen"] is True
+        assert find(events, "response.done").response_id == response_id
+        assert h.session.active_response_id is None
+        assert model_state.continuation_units == 0
+        assert len(h.port.submissions) == 1  # no further silence unit was scheduled
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_listen_decision_on_a_resumable_request_keeps_the_turn_going() -> None:
+    """Same unfinished listen, budget left: it must schedule the next unit.
+
+    A non-terminal auto-response listen is answered with the next silence
+    unit, not with a ``response.listen`` event, so the submission is the
+    observable. Before the fix the projector saw ``finished=False`` and
+    yielded nothing: no silence unit, the response left open with nothing in
+    flight -- the same hang, one unit earlier.
+    """
+    h = await open_harness()
+    try:
+        await h.run(append_audio())
+        request_id = h.stage0_request_id()
+        await h.deliver_and_settle(tts_output(request_id, samples=24000, text="hello"))
+        response_id = h.session.active_response_id
+        assert response_id is not None
+        submissions_before = len(h.port.submissions)
+
+        listen = listen_output(request_id)
+        listen.finished = False
+        events = await h.deliver_and_settle(
+            listen,
+            stage_id=0,
+            segment_finished=True,
+            segment_token_ids=[11, 12, LISTEN_TOKEN_ID],
+            segment_output_metadata={"meta.listen_token_id": LISTEN_TOKEN_ID},
+        )
+
+        assert not [event for event in events if event.type == "error"], types(events)
+        assert len(h.port.submissions) == submissions_before + 1, "the next silence unit was not scheduled"
+        assert h.runner.model_state.continuation_units == 1
+        assert h.session.active_response_id == response_id
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_tts_segment_end_schedules_a_silence_continuation_unit() -> None:
+    h = await open_harness()
+    try:
+        await h.run(append_audio())
+        request_id = h.stage0_request_id()
+        await h.deliver_and_settle(tts_output(request_id, samples=24000, text="hello"))
+        await h.deliver_and_settle(
+            tts_output(request_id, samples=48000, text="hello", tts_is_last_chunk=True, finished=True)
+        )
+
+        assert len(h.port.submissions) == 2
+        silence = h.port.submissions[1]
+        assert silence.already_submitted is True
+        duplex = silence.prompt["model_intermediate_buffer"]["duplex"]
+        assert duplex["seq"] == 2
+        assert duplex["payload"]["duplex_turn_id"] == 0
+        assert set(base64.b64decode(duplex["payload"]["audio"])) == {0}
+        assert h.runner.model_state.continuation_units == 1
+        # The response stays open across the segment boundary.
+        assert h.session.active_response_id is not None
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_stage_failure_fails_the_active_response() -> None:
+    h = await open_harness()
+    try:
+        await h.run(append_audio())
+        request_id = h.stage0_request_id()
+        await h.deliver_and_settle(tts_output(request_id, samples=24000, text="hello"))
+
+        h.runner.on_stage_failure(1, RuntimeError("boom"))
+        events = await h.settle()
+        assert types(events)[0] == "error"
+        assert events[0].code == "runtime_data_plane_stream_failed"
+        done = find(events, "response.done")
+        assert done.status == "failed"
+        assert done.response["status_details"]["reason"] == "runtime_data_plane_stream_failed"
+        assert h.session.active_response_id is None
+    finally:
+        await close_harness(h)
+
+
+# --------------------------------------------------------------------------- #
+# Turn mode (no auto response)                                                #
+# --------------------------------------------------------------------------- #
+
+
+@pytest.mark.asyncio
+async def test_turn_mode_skips_silent_chunks() -> None:
+    h = await open_harness(auto_response=False)
+    try:
+        events = await h.run(append_audio(is_speech=False, value=0.0))
+        assert types(events) == ["response.listen"]
+        assert events[0].details["reason"] == "silence_or_noise"
+        assert h.port.submissions == []
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_turn_mode_commit_with_response_create_starts_one_response() -> None:
+    h = await open_harness(auto_response=False)
+    try:
+        events = await h.run(append_audio())
+        assert types(events) == ["input_audio_buffer.speech_started"]
+        assert h.port.submissions == []  # buffered until the commit
+
+        events = await h.run(commands.Commit(create_response=True))
+        assert "input_audio_buffer.committed" in types(events)
+        assert "response.created" in types(events)
+        assert len(h.port.submissions) == 1
+        final = h.port.submissions[0]
+        assert final.prompt["model_intermediate_buffer"]["duplex"]["final"] is True
+        request_id = final.context.request_id
+        response_id = h.session.active_response_id
+        assert response_id is not None
+
+        events = await h.deliver_and_settle(tts_output(request_id, samples=24000, text="sure"))
+        assert types(events)[-2:] == ["response.output_audio.delta", "response.output_audio_transcript.delta"]
+        events = await h.deliver_and_settle(tts_output(request_id, samples=24000, text="sure", finished=True))
+        done = find(events, "response.done")
+        assert done.response_id == response_id
+        assert done.status == "completed"
+        assert h.session.active_response_id is None
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_response_create_with_no_input_at_all_is_rejected() -> None:
+    """Nothing committed and no items: refuse rather than emit an empty turn."""
+    h = await open_harness(auto_response=False)
+    try:
+        events = await h.run(commands.CreateResponse(event_id="evt-resp"))
+        assert types(events) == ["error"]
+        assert events[0].code == "response_create_without_input"
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_an_item_only_response_create_is_refused_not_left_hanging() -> None:
+    """Items are context, not a turn, and the refusal must be immediate.
+
+    A model-native model decides to speak from the audio it hears, so a turn
+    with no audio in it is one it never answers. Opening a response anyway
+    submits work that never completes, and the caller only finds out when the
+    session idles out -- observed as a 300-second HTTP 500 against a real
+    server. Refusing costs the same information and none of the wait.
+    """
+    h = await open_harness(auto_response=False)
+    try:
+        await h.run(
+            commands.CreateItem(
+                item={
+                    "id": "item_prompt",
+                    "type": "message",
+                    "role": "user",
+                    "content": [{"type": "input_text", "text": "What is 2+2?"}],
+                }
+            )
+        )
+        events = await h.run(commands.CreateResponse(event_id="evt-resp"))
+        assert types(events) == ["error"], events
+        assert events[0].code == "text_only_turn_unsupported"
+        assert not h.port.submissions, "nothing may be submitted for a turn the model cannot answer"
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_conversation_items_are_consumed_by_the_turn_they_start() -> None:
+    """The items belong to the turn that answered them, not to the next one.
+
+    Without this, a session that once received an item would let every later
+    ``response.create`` start an empty turn off the same stale input.
+    """
+    h = await open_harness(auto_response=False)
+    try:
+        await h.run(
+            commands.CreateItem(
+                item={
+                    "id": "item_hi",
+                    "type": "message",
+                    "role": "user",
+                    "content": [{"type": "input_text", "text": "hi"}],
+                }
+            )
+        )
+        assert h.session.unanswered_user_items() == 1
+        # Consumed by the response.create that refused them: a later one must
+        # not see the same stale input and refuse for a second time.
+        await h.run(commands.CreateResponse(event_id="evt-first"))
+        assert h.session.unanswered_user_items() == 0
+        events = await h.run(commands.CreateResponse(event_id="evt-second"))
+        assert events[0].code == "response_create_without_input"
+    finally:
+        await close_harness(h)
+
+
+# --------------------------------------------------------------------------- #
+# Session update and conversation items                                       #
+# --------------------------------------------------------------------------- #
+
+
+@pytest.mark.asyncio
+async def test_session_update_rejects_instruction_changes_after_the_context_is_locked() -> None:
+    h = await open_harness()
+    try:
+        await h.run(append_audio())
+        assert h.runner.model_state.context_locked
+        events = await h.run(commands.UpdateSession(patch={"instructions": "changed"}, event_id="evt-upd"))
+        assert types(events) == ["error"]
+        assert events[0].code == "instructions_update_unsupported"
+        assert events[0].related_event_id == "evt-upd"
+        assert h.session.config.instructions == "You are a concise assistant."
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_session_update_replaces_config_and_runtime_config_together() -> None:
+    h = await open_harness()
+    try:
+        generation = h.session.config_generation
+        events = await h.run(commands.UpdateSession(patch={"temperature": 0.3}))
+        assert types(events) == ["session.updated"]
+        assert events[0].session["temperature"] == 0.3
+        assert h.session.config.temperature == 0.3
+        assert h.session.runtime_config["duplex_stage_sampling_params"]["0"]["temperature"] == 0.3
+        assert h.session.config_generation == generation + 2
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_conversation_items_can_be_injected_and_deleted() -> None:
+    h = await open_harness()
+    try:
+        item = {"id": "item_hist", "type": "message", "role": "user", "content": [{"type": "input_text", "text": "hi"}]}
+        events = await h.run(commands.CreateItem(item=item))
+        assert types(events) == ["conversation.item.added", "conversation.item.created", "conversation.item.done"]
+        assert h.session.history == ({"role": "user", "content": "hi"},)
+
+        events = await h.run(commands.DeleteItem(item_id="item_hist"))
+        assert types(events) == ["conversation.item.deleted"]
+        assert h.session.history == ()
+
+        events = await h.run(commands.DeleteItem(item_id="item_missing", event_id="evt-del"))
+        assert types(events) == ["error"]
+        assert events[0].code == "item_not_found"
+    finally:
+        await close_harness(h)
+
+
+def _stage_metrics_of(event: object) -> dict[str, dict[str, object]]:
+    """Per-stage engine metrics as the client reads them off one wire event."""
+    payload = event.to_realtime()
+    metadata = payload.get("metadata")
+    assert isinstance(metadata, dict), payload
+    vllm_omni = metadata.get("vllm_omni")
+    assert isinstance(vllm_omni, dict), metadata
+    stage_metrics = vllm_omni.get("stage_metrics")
+    assert isinstance(stage_metrics, dict), vllm_omni
+    return stage_metrics
+
+
+@pytest.mark.asyncio
+async def test_stage0_metrics_reach_the_response_even_though_its_output_feeds_tts() -> None:
+    """A pass-through Stage0 output still has to report its tokens.
+
+    Stage0 text with no decision is forwarded to the TTS stage rather than
+    consumed, and before sessions moved into the engine the orchestrator
+    published its metrics separately. Returning ``False`` here must not also
+    throw the metrics away, or every response reports no engine token count and
+    the benchmark cannot compute TPOT.
+    """
+    h = await open_harness()
+    try:
+        await h.run(append_audio())
+        request_id = h.stage0_request_id()
+        text_output = SimpleNamespace(
+            request_id=request_id,
+            finished=False,
+            outputs=[SimpleNamespace(text="hi", token_ids=[11], multimodal_output={})],
+            multimodal_output={},
+        )
+        forwarded = h.deliver(
+            text_output,
+            stage_id=0,
+            metrics=stage_stats(stage_id=0, request_id=request_id, num_tokens_out=3, itls_ms=[9.0, 11.0]),
+        )
+        assert forwarded is False
+        assert await h.settle() == []
+
+        events = await h.deliver_and_settle(tts_output(request_id, samples=24000, text="hi"))
+        stage_metrics = _stage_metrics_of(find(events, "response.output_audio.delta"))
+        assert stage_metrics["0"]["num_tokens_out"] == 3
+        assert stage_metrics["0"]["vllm_itls_ms"] == [9.0, 11.0]
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_stage0_metrics_from_several_units_are_summed_into_one_response() -> None:
+    """Two pass-through segments before the first audio are one response's tokens."""
+    h = await open_harness()
+    try:
+        await h.run(append_audio())
+        request_id = h.stage0_request_id()
+        for tokens in (3, 4):
+            h.deliver(
+                SimpleNamespace(
+                    request_id=request_id,
+                    finished=False,
+                    outputs=[SimpleNamespace(text="hi", token_ids=[11], multimodal_output={})],
+                    multimodal_output={},
+                ),
+                stage_id=0,
+                metrics=stage_stats(stage_id=0, request_id=request_id, num_tokens_out=tokens),
+            )
+        assert await h.settle() == []
+
+        events = await h.deliver_and_settle(tts_output(request_id, samples=24000, text="hi"))
+        stage_metrics = _stage_metrics_of(find(events, "response.output_audio.delta"))
+        assert stage_metrics["0"]["num_tokens_out"] == 7
+    finally:
+        await close_harness(h)
+
+
+# --------------------------------------------------------------------------- #
+# Server VAD                                                                  #
+# --------------------------------------------------------------------------- #
+
+
+class _ScriptedDetector:
+    """A turn detector that answers each appended chunk with a pre-decided result."""
+
+    def __init__(self, results: list[object]) -> None:
+        self._results = list(results)
+        self.resets = 0
+
+    def process(self, base64_audio: str, *, fmt: str, sample_rate_hz: int | None, audio_end_ms: int | None = None):
+        del base64_audio, fmt, sample_rate_hz, audio_end_ms
+        return self._results.pop(0)
+
+    def reset(self) -> None:
+        self.resets += 1
+
+
+def _speech_then_stop() -> _ScriptedDetector:
+    from vllm_omni.engine.duplex.turn_detection import TurnDetectionResult
+
+    return _ScriptedDetector(
+        [
+            TurnDetectionResult(is_speech=True, speech_active=True, speech_started=True, speech_probability=0.9),
+            TurnDetectionResult(
+                is_speech=False,
+                speech_active=False,
+                speech_stopped=True,
+                speech_probability=0.05,
+                should_commit=True,
+                create_response=True,
+            ),
+        ]
+    )
+
+
+def _final_submissions(h: Harness) -> list[object]:
+    return [s for s in h.port.submissions if s.prompt["model_intermediate_buffer"]["duplex"].get("final") is True]
+
+
+@pytest.mark.asyncio
+async def test_server_vad_speech_stopped_does_not_end_the_turn_of_an_auto_response_session() -> None:
+    """A model-native session keeps its turn open past the detector's stop.
+
+    Committing at ``speech_stopped`` cut the utterance short: the model
+    listened on that early final unit, the trailing silence became a second,
+    near-empty turn, and the client's own commit answered nothing (the
+    server-VAD hard-interrupt E2E timed out waiting for the follow-up
+    response). The old translator synthesized that commit for turn-based
+    server VAD only.
+    """
+    h = await open_harness()
+    try:
+        h.runner.control._detector = _speech_then_stop()
+        first = await h.run(append_audio())
+        assert "input_audio_buffer.speech_started" in types(first)
+        # A partial unit, like the trailing silence of a real utterance: it is
+        # what a commit here would submit as the turn's final append.
+        second = await h.run(append_audio(samples=8000, is_speech=False, value=0.0))
+        assert "input_audio_buffer.speech_stopped" in types(second)
+        assert "input_audio_buffer.committed" not in types(first) + types(second)
+        assert _final_submissions(h) == [], "the detector must not close a model-native turn"
+
+        events = await h.run(commands.Commit())
+        assert types(events).count("input_audio_buffer.committed") == 1
+        assert len(_final_submissions(h)) == 1, "the client's commit closes the turn exactly once"
+    finally:
+        await close_harness(h)
+
+
+@pytest.mark.asyncio
+async def test_server_vad_speech_stopped_still_commits_a_turn_mode_session() -> None:
+    """Turn-based server VAD keeps the contract the old translator implemented."""
+    h = await open_harness(auto_response=False)
+    try:
+        h.runner.control._detector = _speech_then_stop()
+        await h.run(append_audio())
+        events = await h.run(append_audio(is_speech=False, value=0.0))
+        assert "input_audio_buffer.speech_stopped" in types(events)
+        assert "input_audio_buffer.committed" in types(events)
+        assert len(_final_submissions(h)) == 1, "the detector's stop commits the turn and starts the response"
+    finally:
+        await close_harness(h)
diff --git a/tests/engine/duplex/test_vad_backend.py b/tests/engine/duplex/test_vad_backend.py
new file mode 100644
index 000000000..f3163ff4e
--- /dev/null
+++ b/tests/engine/duplex/test_vad_backend.py
@@ -0,0 +1,398 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""The engine-side Silero VAD: backend selection and endpoint rules.
+
+The endpoint rules are the part worth pinning hardest. They were reimplemented
+when turn detection moved into the engine, and drifted from upstream's
+``ThresholdEndpointPolicy`` in two ways that only show up mid-utterance: a loud
+frame used to cancel an in-progress silence timer, and ``audio_end_ms`` used to
+exclude the trailing silence OpenAI says it should include. The parity cases
+below hold upstream's own outputs, so neither can come back unnoticed.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import sys
+import threading
+from concurrent.futures import ThreadPoolExecutor
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+
+from vllm_omni.engine.duplex.turn_detection import validate_realtime_turn_detection
+from vllm_omni.engine.duplex.vad import (
+    SILERO_VAD_SHA256,
+    ServerVADUnavailableError,
+    SileroStreamingVAD,
+    SileroVADBackend,
+    SileroVADBackendProvider,
+    SileroVADConfig,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+FRAME = 512
+SAMPLE_RATE_HZ = 16_000
+
+
+def _drive(config: SileroVADConfig, probabilities: list[float]) -> list[tuple[str, int | None]]:
+    """Feed one probability per frame and collect the endpoint events."""
+    scores = iter(probabilities)
+    vad = SileroStreamingVAD(config, frame_scorer=lambda _frame: next(scores))
+    events: list[tuple[str, int | None]] = []
+    for _ in probabilities:
+        result = vad.process(np.zeros(FRAME, dtype=np.float32))
+        if result.speech_started:
+            events.append(("start", result.speech_start_ms))
+        if result.speech_stopped:
+            events.append(("stop", result.speech_end_ms))
+    return events
+
+
+# --------------------------------------------------------------------------- #
+# Parity with the serving-side policy this was ported from                    #
+# --------------------------------------------------------------------------- #
+
+#: Probability sequences with the endpoint events upstream's
+#: ``ThresholdEndpointPolicy`` produced for them, captured from
+#: ``entrypoints/duplex/server_vad.py`` at `e2d2617f` before that module was
+#: removed. Golden rather than computed because the oracle no longer ships: the
+#: serving layer is transport only, so the VAD it used to carry is gone. Any
+#: drift in the engine's rules still breaks these.
+_PARITY_CASES = {
+    "one utterance": (
+        [0.0, 0.9, 0.9, 0.9, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        {"threshold": 0.5, "prefix_padding_ms": 0, "silence_duration_ms": 100, "min_speech_duration_ms": 32},
+        [("start", 32), ("stop", 256)],
+    ),
+    "prefix padding reaches back": (
+        [0.0, 0.9, 0.9, 0.0, 0.0, 0.0, 0.0],
+        {"threshold": 0.5, "prefix_padding_ms": 300, "silence_duration_ms": 64, "min_speech_duration_ms": 32},
+        [("start", 0), ("stop", 160)],
+    ),
+    "loud frames inside the silence timer": (
+        [0.9, 0.9, 0.1, 0.45, 0.1, 0.1, 0.1],
+        {"threshold": 0.5, "prefix_padding_ms": 0, "silence_duration_ms": 96, "min_speech_duration_ms": 32},
+        [("start", 0), ("stop", 160)],
+    ),
+    "min speech duration rejects a blip": (
+        [0.9, 0.0, 0.9, 0.9, 0.9, 0.0, 0.0, 0.0, 0.0],
+        {"threshold": 0.5, "prefix_padding_ms": 0, "silence_duration_ms": 64, "min_speech_duration_ms": 96},
+        [("start", 64), ("stop", 224)],
+    ),
+    "negative threshold floor at a low threshold": (
+        [0.9, 0.9, 0.1, 0.1, 0.1, 0.1],
+        {"threshold": 0.16, "prefix_padding_ms": 0, "silence_duration_ms": 64, "min_speech_duration_ms": 32},
+        [("start", 0)],
+    ),
+}
+
+
+@pytest.mark.parametrize(("probabilities", "options", "expected"), _PARITY_CASES.values(), ids=list(_PARITY_CASES))
+def test_endpoint_decisions_match_the_serving_side_policy(
+    probabilities: list[float],
+    options: dict[str, object],
+    expected: list[tuple[str, int | None]],
+) -> None:
+    """The engine detector reproduces the policy server VAD shipped with upstream."""
+    assert _drive(SileroVADConfig(**options), probabilities) == expected
+
+
+# --------------------------------------------------------------------------- #
+# The two rules that had drifted                                              #
+# --------------------------------------------------------------------------- #
+
+
+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
+    who trails off unevenly never gets their turn committed.
+    """
+    config = SileroVADConfig(threshold=0.5, prefix_padding_ms=0, silence_duration_ms=96, min_speech_duration_ms=32)
+    assert _drive(config, [0.9, 0.9, 0.1, 0.45, 0.1, 0.1]) == [("start", 0), ("stop", 160)]
+
+
+def test_audio_end_ms_includes_the_trailing_silence() -> None:
+    """OpenAI defines audio_end_ms as the end of the audio sent to the model.
+
+    That includes the silence spent deciding the turn was over, so it is the
+    frame boundary the detector stopped on, not where speech last was.
+    """
+    config = SileroVADConfig(threshold=0.5, prefix_padding_ms=0, silence_duration_ms=100, min_speech_duration_ms=32)
+    events = _drive(config, [0.0, 0.9, 0.9, 0.9, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0])
+    stop_ms = next(ms for kind, ms in events if kind == "stop")
+    # 8 frames consumed when the timer expires: 8 * 512 / 16 kHz = 256 ms.
+    assert stop_ms == 256
+
+
+def test_reset_keeps_the_session_clock_and_clamps_the_prefix() -> None:
+    """A barge-in resets the detector but not the session's timeline.
+
+    Timestamps have to stay comparable with the rest of the session, and prefix
+    padding must not reach back into audio the reset discarded.
+    """
+    config = SileroVADConfig(threshold=0.5, prefix_padding_ms=300, silence_duration_ms=64, min_speech_duration_ms=32)
+    scores = iter([0.0] * 10 + [0.9, 0.9, 0.9])
+    vad = SileroStreamingVAD(config, frame_scorer=lambda _frame: next(scores))
+    for _ in range(10):
+        vad.process(np.zeros(FRAME, dtype=np.float32))
+
+    stream_start_ms = round(10 * FRAME * 1000 / SAMPLE_RATE_HZ)
+    vad.reset()
+    result = vad.process(np.zeros(FRAME * 3, dtype=np.float32))
+
+    assert result.speech_started
+    # Without the clock the start would land at 0; without the clamp, 300 ms of
+    # prefix would reach back before the reset.
+    assert result.speech_start_ms == stream_start_ms
+
+
+# --------------------------------------------------------------------------- #
+# Input handling                                                              #
+# --------------------------------------------------------------------------- #
+
+
+def _pcm16_b64(samples: np.ndarray) -> str:
+    return base64.b64encode((samples * 32767).astype("<i2").tobytes()).decode("ascii")
+
+
+def test_pcm16_input_is_accepted_alongside_float32() -> None:
+    config = SileroVADConfig(threshold=0.5)
+    tone: np.ndarray = np.zeros(FRAME * 2, dtype=np.float32)
+    seen: list[int] = []
+
+    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]
+
+
+def test_an_odd_pcm16_byte_count_is_rejected() -> None:
+    vad = SileroStreamingVAD(SileroVADConfig(), frame_scorer=lambda _frame: 0.0)
+    with pytest.raises(ValueError, match="incomplete pcm16"):
+        vad.process_base64(base64.b64encode(b"\x00\x01\x02").decode(), fmt="pcm16", sample_rate_hz=SAMPLE_RATE_HZ)
+
+
+def test_resampling_keeps_the_frame_grid_from_drifting() -> None:
+    """The 24 kHz remainder carries across chunks, so frame boundaries cannot drift.
+
+    This is a weaker claim than upstream's ``StreamingAudioResampler``: the
+    interpolation is per chunk, so values near a chunk edge differ slightly.
+    What must hold is the frame *count* and alignment, which is what the
+    endpoint timestamps are derived from.
+    """
+    source = np.sin(np.linspace(0, 40 * np.pi, 24_000, dtype=np.float32))
+
+    def frames_for(chunk_sizes: list[int]) -> int:
+        frames = 0
+
+        def count(_frame: np.ndarray) -> float:
+            nonlocal frames
+            frames += 1
+            return 0.0
+
+        vad = SileroStreamingVAD(SileroVADConfig(), frame_scorer=count)
+        offset = 0
+        for size in chunk_sizes:
+            vad.process_base64(_pcm16_b64(source[offset : offset + size]), fmt="pcm16", sample_rate_hz=24_000)
+            offset += size
+        assert offset == source.size
+        return frames
+
+    whole = frames_for([source.size])
+    split = frames_for([7, 13, 511, 512, 513, source.size - 1_556])
+    assert whole == split == 16_000 // FRAME
+
+
+def test_a_sample_rate_change_mid_stream_is_rejected() -> None:
+    vad = SileroStreamingVAD(SileroVADConfig(), frame_scorer=lambda _frame: 0.0)
+    chunk = _pcm16_b64(np.zeros(1_024, dtype=np.float32))
+    vad.process_base64(chunk, fmt="pcm16", sample_rate_hz=24_000)
+    with pytest.raises(ValueError, match="sample rate cannot change"):
+        vad.process_base64(chunk, fmt="pcm16", sample_rate_hz=48_000)
+
+
+# --------------------------------------------------------------------------- #
+# Backend selection                                                           #
+# --------------------------------------------------------------------------- #
+
+
+def test_a_configured_model_path_that_does_not_exist_is_an_error() -> None:
+    """An operator who names an artifact gets told it is missing, not a fallback."""
+    provider = SileroVADBackendProvider(model_path="/nonexistent/silero_vad.onnx")
+    with pytest.raises(ServerVADUnavailableError, match="does not exist"):
+        provider.get()
+
+
+def test_a_configured_model_with_the_wrong_checksum_is_refused(tmp_path) -> None:
+    """A different Silero revision changes endpointing, so the pin is enforced."""
+    impostor = tmp_path / "silero_vad.onnx"
+    impostor.write_bytes(b"not the pinned model")
+    provider = SileroVADBackendProvider(model_path=str(impostor))
+    with pytest.raises(ServerVADUnavailableError, match="checksum mismatch"):
+        provider.get()
+    assert hashlib.sha256(impostor.read_bytes()).hexdigest() != SILERO_VAD_SHA256
+
+
+def test_the_onnx_backend_is_shared_by_every_session() -> None:
+    """One ONNX session for the whole engine: its state is passed in, not held."""
+    provider = SileroVADBackendProvider()
+    try:
+        backend = provider.get()
+    except ServerVADUnavailableError as exc:
+        pytest.skip(f"no Silero backend available here: {exc}")
+    if not isinstance(backend, SileroVADBackend):
+        pytest.skip("no local ONNX artifact; the torch fallback is per-session by design")
+
+    assert provider.get() is backend
+    # State is the caller's, so two sessions on one backend cannot interfere.
+    first, second = backend.new_state(), backend.new_state()
+    assert first is not second
+    probability, next_state = backend.infer(np.zeros(FRAME, dtype=np.float32), first)
+    assert 0.0 <= probability <= 1.0
+    assert next_state is not first
+
+
+def test_the_onnx_backend_holds_the_upstream_silero_v62_contract(monkeypatch, tmp_path) -> None:
+    """Pin the ONNX call shape without needing the real artifact or runtime.
+
+    The context carry is the part worth pinning: Silero v6.2 is fed 64 samples
+    of the previous frame ahead of the current 512, and that tail travels in the
+    caller's state rather than inside the session -- which is exactly what lets
+    one session serve every duplex session at once.
+    """
+    sessions: list[FakeInferenceSession] = []
+
+    class FakeSessionOptions:
+        inter_op_num_threads = 0
+        intra_op_num_threads = 0
+
+    class FakeInferenceSession:
+        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]] = []
+            self.run_barrier: threading.Barrier | None = None
+            sessions.append(self)
+
+        def get_inputs(self) -> list[SimpleNamespace]:
+            return [SimpleNamespace(name=name) for name in ("input", "state", "sr")]
+
+        def run(self, _outputs: object, inputs: dict[str, np.ndarray]) -> list[np.ndarray]:
+            self.calls.append({name: np.array(value, copy=True) for name, value in inputs.items()})
+            if self.run_barrier is not None:
+                self.run_barrier.wait(timeout=5)
+            return [
+                np.asarray([[0.75]], dtype=np.float32),
+                np.full((2, 1, 128), len(self.calls), dtype=np.float32),
+            ]
+
+    monkeypatch.setitem(
+        sys.modules,
+        "onnxruntime",
+        SimpleNamespace(SessionOptions=FakeSessionOptions, InferenceSession=FakeInferenceSession),
+    )
+
+    model_path = tmp_path / "silero_vad.onnx"
+    model_path.write_bytes(b"fake-model")
+    backend = SileroVADBackend(model_path)
+    session = sessions[0]
+
+    # Single-threaded on purpose: many sessions share this one ORT session, so
+    # it must not fan out per call.
+    assert session.providers == ["CPUExecutionProvider"]
+    assert session.sess_options.inter_op_num_threads == 1
+    assert session.sess_options.intra_op_num_threads == 1
+    # Warm-up already ran: 64 context + 512 frame.
+    assert session.calls[0]["input"].shape == (1, 576)
+    assert session.calls[0]["state"].shape == (2, 1, 128)
+    assert session.calls[0]["sr"].item() == SAMPLE_RATE_HZ
+
+    state = backend.new_state()
+    first_frame: np.ndarray = np.arange(backend.frame_samples, dtype=np.float32)
+    probability, state = backend.infer(first_frame, state)
+    first_call = session.calls[1]
+
+    assert probability == pytest.approx(0.75)
+    np.testing.assert_array_equal(
+        first_call["input"][:, : backend.context_samples],
+        np.zeros((1, backend.context_samples), dtype=np.float32),
+    )
+    np.testing.assert_array_equal(first_call["input"][:, backend.context_samples :], first_frame[None, :])
+
+    second_frame = -first_frame
+    backend.infer(second_frame, state)
+    second_call = session.calls[2]
+    # The previous frame's tail becomes this frame's context.
+    np.testing.assert_array_equal(
+        second_call["input"][:, : backend.context_samples],
+        first_frame[None, -backend.context_samples :],
+    )
+    np.testing.assert_array_equal(second_call["state"], np.full((2, 1, 128), 2, dtype=np.float32))
+
+    # Two sessions may enter the shared ORT session at the same time.
+    session.run_barrier = threading.Barrier(2)
+    with ThreadPoolExecutor(max_workers=2) as executor:
+        futures = [
+            executor.submit(backend.infer, first_frame, backend.new_state()),
+            executor.submit(backend.infer, second_frame, backend.new_state()),
+        ]
+        assert [future.result()[0] for future in futures] == pytest.approx([0.75, 0.75])
+
+
+# --------------------------------------------------------------------------- #
+# Session payload validation                                                  #
+# --------------------------------------------------------------------------- #
+
+
+def test_an_unknown_server_vad_field_is_refused() -> None:
+    """A misspelled knob that silently does nothing is worse than a refusal.
+
+    The endpointing would still look configured while running on defaults.
+    """
+    error = validate_realtime_turn_detection({"turn_detection": {"type": "server_vad", "semantic_eagerness": "high"}})
+    assert error is not None
+    assert "semantic_eagerness" in error
+
+
+def test_the_documented_server_vad_fields_are_all_accepted() -> None:
+    assert (
+        validate_realtime_turn_detection(
+            {
+                "turn_detection": {
+                    "type": "server_vad",
+                    "threshold": 0.6,
+                    "prefix_padding_ms": 200,
+                    "silence_duration_ms": 400,
+                    "create_response": True,
+                    "interrupt_response": True,
+                    "min_speech_duration_ms": 120,
+                },
+                "overlap_policy": "barge_in_on_speech",
+            }
+        )
+        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..7132d7512 100644
--- a/tests/engine/test_arg_utils.py
+++ b/tests/engine/test_arg_utils.py
@@ -539,7 +539,7 @@ 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
diff --git a/tests/engine/test_async_omni_engine_abort_ack.py b/tests/engine/test_async_omni_engine_abort_ack.py
index 86276ec66..366e640f6 100644
--- a/tests/engine/test_async_omni_engine_abort_ack.py
+++ b/tests/engine/test_async_omni_engine_abort_ack.py
@@ -54,7 +54,7 @@ def test_abort_async_waits_for_ack(mocker: MockerFixture):
     rpc_q: queue.Queue = queue.Queue()
     engine = _make_engine(request_q, rpc_q)
     mocker.patch(
-        "vllm_omni.engine.async_omni_engine.uuid.uuid4",
+        "vllm_omni.engine.omni_engine_base.uuid.uuid4",
         return_value=SimpleNamespace(hex="abort-rpc-1"),
     )
 
@@ -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())
@@ -81,7 +82,7 @@ def test_abort_async_raises_on_orchestrator_error(mocker: MockerFixture):
     rpc_q: queue.Queue = queue.Queue()
     engine = _make_engine(request_q, rpc_q)
     mocker.patch(
-        "vllm_omni.engine.async_omni_engine.uuid.uuid4",
+        "vllm_omni.engine.omni_engine_base.uuid.uuid4",
         return_value=SimpleNamespace(hex="abort-rpc-err"),
     )
 
@@ -109,7 +110,7 @@ def test_abort_async_times_out_without_result(mocker: MockerFixture):
     rpc_q: queue.Queue = queue.Queue()
     engine = _make_engine(request_q, rpc_q)
     mocker.patch(
-        "vllm_omni.engine.async_omni_engine.uuid.uuid4",
+        "vllm_omni.engine.omni_engine_base.uuid.uuid4",
         return_value=SimpleNamespace(hex="abort-rpc-timeout"),
     )
 
@@ -139,7 +140,7 @@ def test_abort_async_preserves_request_queue_backpressure(mocker: MockerFixture)
     rpc_q: queue.Queue = queue.Queue()
     engine = _make_engine(request_q, rpc_q)
     mocker.patch(
-        "vllm_omni.engine.async_omni_engine.uuid.uuid4",
+        "vllm_omni.engine.omni_engine_base.uuid.uuid4",
         return_value=SimpleNamespace(hex="blocked-abort"),
     )
 
diff --git a/tests/engine/test_async_omni_engine_outputs.py b/tests/engine/test_async_omni_engine_outputs.py
index 6b0d6a188..425a16fc1 100644
--- a/tests/engine/test_async_omni_engine_outputs.py
+++ b/tests/engine/test_async_omni_engine_outputs.py
@@ -7,7 +7,6 @@ Focuses on the critical behavior: when the orchestrator thread dies,
 subsequent attempts to collect output raise RuntimeError.
 """
 
-import asyncio
 import queue
 import threading
 from concurrent.futures import ThreadPoolExecutor
@@ -18,16 +17,6 @@ from pytest_mock import MockerFixture
 
 from vllm_omni.engine.async_engine_utils import weak_shutdown_async_omni_engine
 from vllm_omni.engine.async_omni_engine import AsyncOmniEngine
-from vllm_omni.engine.duplex.control_client import (
-    DuplexControlClient,
-    DuplexControlRequestError,
-)
-from vllm_omni.engine.duplex.messages import (
-    AppendDuplexInputMessage,
-    DuplexControlResultMessage,
-    DuplexFence,
-    SignalDuplexTurnMessage,
-)
 from vllm_omni.engine.messages import (
     CollectiveRPCResultMessage,
     ErrorMessage,
@@ -166,9 +155,9 @@ def test_output_remains_on_shared_output_path(mocker: MockerFixture):
     raw_queue = queue.Queue()
     raw_queue.put_nowait(
         OutputMessage(
-            request_id="legacy-duplex-request",
+            request_id="shared-path-request",
             stage_id=0,
-            engine_outputs=OmniRequestOutput(request_id="legacy-duplex-request"),
+            engine_outputs=OmniRequestOutput(request_id="shared-path-request"),
             finished=False,
         )
     )
@@ -176,293 +165,7 @@ def test_output_remains_on_shared_output_path(mocker: MockerFixture):
 
     output = engine.try_get_output(timeout=0.01)
 
-    assert output.request_id == "legacy-duplex-request"
-
-
-def test_duplex_control_client_uses_engine_owned_correlated_transport():
-    engine = object.__new__(AsyncOmniEngine)
-    engine._duplex_control_client = None
-    engine._correlated_rpc_client = CorrelatedRpcClient(queue.Queue(), queue.Queue())
-
-    try:
-        client = engine._get_duplex_control_client()
-
-        assert isinstance(client, DuplexControlClient)
-        assert client._transport is engine._correlated_rpc_client
-        assert not hasattr(engine, "_submit_rpc_and_wait")
-    finally:
-        engine._correlated_rpc_client.close()
-
-
-def test_duplex_control_api_requires_explicit_fence():
-    engine = object.__new__(AsyncOmniEngine)
-
-    with pytest.raises(TypeError, match="fence"):
-        engine.open_duplex_session("sid")
-    with pytest.raises(TypeError, match="fence"):
-        engine.append_duplex_input("sid", mode="append_audio_chunk", payload={})
-    with pytest.raises(TypeError, match="fence"):
-        engine.signal_duplex_turn("sid", event="turn.end")
-    with pytest.raises(TypeError, match="fence"):
-        engine.close_duplex_session("sid")
-
-
-def test_open_duplex_session_waits_for_control_ack(mocker: MockerFixture):
-    request_q = queue.Queue()
-    rpc_q = queue.Queue()
-    control_result = DuplexControlResultMessage(
-        control_id="ctrl-1",
-        fence=DuplexFence("sid"),
-        operation="open",
-        session_id="sid",
-        ok=False,
-        stage_results=[{"stage_id": 0, "replica_id": 0, "result": {"supported": False}}],
-        unsupported_count=1,
-        error_count=0,
-    )
-
-    engine = object.__new__(AsyncOmniEngine)
-    engine.request_queue = SimpleNamespace(sync_q=request_q)
-    engine.rpc_output_queue = SimpleNamespace(sync_q=rpc_q)
-    engine._correlated_rpc_client = CorrelatedRpcClient(request_q, rpc_q)
-    engine._duplex_control_client = None
-    mocker.patch("vllm_omni.engine.async_omni_engine.uuid.uuid4", return_value=SimpleNamespace(hex="ctrl-1"))
-
-    with ThreadPoolExecutor(max_workers=1) as executor:
-        pending = executor.submit(engine.open_duplex_session, "sid", fence=DuplexFence("sid"), timeout=1)
-        msg = request_q.get(timeout=1)
-        assert msg.type == "open_duplex_session"
-        assert msg.control_id == "ctrl-1"
-        rpc_q.put(control_result)
-        with pytest.raises(DuplexControlRequestError) as exc_info:
-            pending.result(timeout=1)
-
-    assert exc_info.value.result["unsupported_count"] == 1
-    assert exc_info.value.result["stage_results"][0]["result"]["supported"] is False
-    engine._correlated_rpc_client.close()
-
-
-def test_signal_duplex_turn_message_carries_next_fence(mocker: MockerFixture):
-    request_q = queue.Queue()
-    rpc_q = queue.Queue()
-    cancelled_fence = DuplexFence("sid-cancel", epoch=4, turn_id=2)
-    next_fence = DuplexFence("sid-cancel", epoch=5, turn_id=2)
-    control_result = DuplexControlResultMessage(
-        control_id="ctrl-signal",
-        fence=cancelled_fence,
-        operation="signal",
-        session_id="sid-cancel",
-        ok=True,
-        stage_results=[],
-    )
-
-    engine = object.__new__(AsyncOmniEngine)
-    engine.request_queue = SimpleNamespace(sync_q=request_q)
-    engine.rpc_output_queue = SimpleNamespace(sync_q=rpc_q)
-    engine._correlated_rpc_client = CorrelatedRpcClient(request_q, rpc_q)
-    engine._duplex_control_client = None
-    mocker.patch("vllm_omni.engine.async_omni_engine.uuid.uuid4", return_value=SimpleNamespace(hex="ctrl-signal"))
-
-    with ThreadPoolExecutor(max_workers=1) as executor:
-        pending = executor.submit(
-            engine.signal_duplex_turn,
-            "sid-cancel",
-            event="input.cancel",
-            fence=cancelled_fence,
-            next_fence=next_fence,
-            session_config={"temperature": 0.0},
-            timeout=1,
-        )
-        msg = request_q.get(timeout=1)
-        assert isinstance(msg, SignalDuplexTurnMessage)
-        assert msg.fence == cancelled_fence
-        assert msg.next_fence == next_fence
-        assert msg.session_config == {"temperature": 0.0}
-        rpc_q.put(control_result)
-        assert pending.result(timeout=1)["ok"] is True
-
-    engine._correlated_rpc_client.close()
-
-
-@pytest.mark.asyncio
-async def test_cancelled_async_append_does_not_stop_executor_callable(mocker: MockerFixture):
-    entered = threading.Event()
-    release = threading.Event()
-    completed = threading.Event()
-    engine = object.__new__(AsyncOmniEngine)
-
-    def blocking_append(*args, **kwargs):
-        del args, kwargs
-        entered.set()
-        release.wait(timeout=1)
-        completed.set()
-        return {}
-
-    mocker.patch.object(engine, "append_duplex_input", side_effect=blocking_append)
-    task = asyncio.create_task(
-        engine.append_duplex_input_async(
-            "sid-executor-cancel",
-            mode="append_audio_chunk",
-            payload=b"audio",
-            fence=DuplexFence("sid-executor-cancel"),
-        )
-    )
-    assert await asyncio.to_thread(entered.wait, 1)
-
-    task.cancel()
-    with pytest.raises(asyncio.CancelledError):
-        await task
-    release.set()
-
-    assert await asyncio.to_thread(completed.wait, 1)
-
-
-def test_duplex_controls_route_out_of_order_without_global_lock():
-    request_q = queue.Queue()
-    rpc_q = queue.Queue()
-    engine = object.__new__(AsyncOmniEngine)
-    engine.request_queue = SimpleNamespace(sync_q=request_q)
-    engine.rpc_output_queue = SimpleNamespace(sync_q=rpc_q)
-    engine._correlated_rpc_client = CorrelatedRpcClient(request_q, rpc_q)
-    engine._duplex_control_client = None
-    first_fence = DuplexFence("sid", epoch=1)
-    second_fence = DuplexFence("sid", epoch=2)
-    first = AppendDuplexInputMessage(
-        control_id="first",
-        fence=first_fence,
-        session_id="sid",
-        expected_epoch=1,
-        mode="audio",
-        payload=b"first",
-    )
-    second = AppendDuplexInputMessage(
-        control_id="second",
-        fence=second_fence,
-        session_id="sid",
-        expected_epoch=2,
-        mode="audio",
-        payload=b"second",
-    )
-
-    with ThreadPoolExecutor(max_workers=2) as executor:
-        client = engine._get_duplex_control_client()
-        first_result = executor.submit(client.execute, first, timeout=1)
-        second_result = executor.submit(client.execute, second, timeout=1)
-        submitted = {request_q.get(timeout=1).control_id, request_q.get(timeout=1).control_id}
-        assert submitted == {"first", "second"}
-        rpc_q.put(
-            DuplexControlResultMessage(
-                control_id="second",
-                fence=second_fence,
-                operation="append",
-                session_id="sid",
-                ok=True,
-                stage_results=[],
-            )
-        )
-        rpc_q.put(
-            DuplexControlResultMessage(
-                control_id="first",
-                fence=first_fence,
-                operation="append",
-                session_id="sid",
-                ok=True,
-                stage_results=[],
-            )
-        )
-
-        assert first_result.result(timeout=1)["fence"] == first_fence
-        assert second_result.result(timeout=1)["fence"] == second_fence
-
-    assert not hasattr(engine, "_rpc_lock")
-    engine._correlated_rpc_client.close()
-
-
-def test_terminal_rpc_router_rejects_without_enqueuing_new_control():
-    request_q = queue.Queue()
-    rpc_q = queue.Queue()
-    engine = object.__new__(AsyncOmniEngine)
-    engine.request_queue = SimpleNamespace(sync_q=request_q)
-    engine.rpc_output_queue = SimpleNamespace(sync_q=rpc_q)
-    engine._correlated_rpc_client = CorrelatedRpcClient(request_q, rpc_q)
-    engine._duplex_control_client = None
-    pending_message = AppendDuplexInputMessage(
-        control_id="pending",
-        fence=DuplexFence("sid"),
-        session_id="sid",
-        mode="audio",
-        payload=b"audio",
-    )
-    message = AppendDuplexInputMessage(
-        control_id="after-fatal",
-        fence=DuplexFence("sid"),
-        session_id="sid",
-        mode="audio",
-        payload=b"audio",
-    )
-
-    try:
-        with ThreadPoolExecutor(max_workers=1) as executor:
-            pending = executor.submit(engine._get_duplex_control_client().execute, pending_message, timeout=1)
-            assert request_q.get(timeout=1).control_id == "pending"
-            rpc_q.put(ErrorMessage(error="orchestrator failed", fatal=True))
-            with pytest.raises(RuntimeError, match="orchestrator failed"):
-                pending.result(timeout=1)
-
-        with pytest.raises(RuntimeError, match="orchestrator failed"):
-            engine._get_duplex_control_client().execute(message, timeout=1)
-
-        assert request_q.empty()
-    finally:
-        engine._correlated_rpc_client.close()
-
-
-def test_collective_and_duplex_results_share_router_without_swapping(mocker: MockerFixture):
-    request_q = queue.Queue()
-    rpc_q = queue.Queue()
-    engine = object.__new__(AsyncOmniEngine)
-    engine.request_queue = SimpleNamespace(sync_q=request_q)
-    engine.rpc_output_queue = SimpleNamespace(sync_q=rpc_q)
-    engine._correlated_rpc_client = CorrelatedRpcClient(request_q, rpc_q)
-    engine._duplex_control_client = None
-    fence = DuplexFence("sid")
-    duplex = AppendDuplexInputMessage(
-        control_id="duplex-control",
-        fence=fence,
-        session_id="sid",
-        mode="audio",
-        payload=b"audio",
-    )
-    mocker.patch("vllm_omni.engine.async_omni_engine.uuid.uuid4", return_value=SimpleNamespace(hex="collective-rpc"))
-
-    with ThreadPoolExecutor(max_workers=2) as executor:
-        duplex_result = executor.submit(engine._get_duplex_control_client().execute, duplex, timeout=1)
-        collective_result = executor.submit(engine.collective_rpc, "health", timeout=1)
-        submitted_types = {request_q.get(timeout=1).type, request_q.get(timeout=1).type}
-        assert submitted_types == {"append_duplex_input", "collective_rpc"}
-        rpc_q.put(
-            CollectiveRPCResultMessage(
-                rpc_id="collective-rpc",
-                method="health",
-                stage_ids=[0],
-                results=["healthy"],
-            )
-        )
-        rpc_q.put(
-            DuplexControlResultMessage(
-                control_id="duplex-control",
-                fence=fence,
-                operation="append",
-                session_id="sid",
-                ok=True,
-                stage_results=[],
-            )
-        )
-
-        assert collective_result.result(timeout=1) == ["healthy"]
-        assert duplex_result.result(timeout=1)["fence"] == fence
-
-    engine._correlated_rpc_client.close()
+    assert output.request_id == "shared-path-request"
 
 
 def test_collective_rpc_preserves_request_queue_backpressure(mocker: MockerFixture):
@@ -483,8 +186,7 @@ def test_collective_rpc_preserves_request_queue_backpressure(mocker: MockerFixtu
     engine.request_queue = SimpleNamespace(sync_q=request_q)
     engine.rpc_output_queue = SimpleNamespace(sync_q=rpc_q)
     engine._correlated_rpc_client = CorrelatedRpcClient(request_q, rpc_q)
-    engine._duplex_control_client = None
-    mocker.patch("vllm_omni.engine.async_omni_engine.uuid.uuid4", return_value=SimpleNamespace(hex="blocked-rpc"))
+    mocker.patch("vllm_omni.engine.omni_engine_base.uuid.uuid4", return_value=SimpleNamespace(hex="blocked-rpc"))
 
     with ThreadPoolExecutor(max_workers=1) as executor:
         pending = executor.submit(engine.collective_rpc, "health", timeout=1)
@@ -506,36 +208,6 @@ def test_collective_rpc_preserves_request_queue_backpressure(mocker: MockerFixtu
     engine._correlated_rpc_client.close()
 
 
-def test_open_duplex_session_raises_on_stage_control_error(mocker: MockerFixture):
-    request_q = queue.Queue()
-    rpc_q = queue.Queue()
-    control_result = DuplexControlResultMessage(
-        control_id="ctrl-error",
-        fence=DuplexFence("sid"),
-        operation="open",
-        session_id="sid",
-        ok=False,
-        stage_results=[{"stage_id": 0, "replica_id": 0, "result": {"supported": False, "error": "boom"}}],
-        unsupported_count=1,
-        error_count=1,
-    )
-
-    engine = object.__new__(AsyncOmniEngine)
-    engine.request_queue = SimpleNamespace(sync_q=request_q)
-    engine.rpc_output_queue = SimpleNamespace(sync_q=rpc_q)
-    engine._correlated_rpc_client = CorrelatedRpcClient(request_q, rpc_q)
-    engine._duplex_control_client = None
-    mocker.patch("vllm_omni.engine.async_omni_engine.uuid.uuid4", return_value=SimpleNamespace(hex="ctrl-error"))
-
-    with ThreadPoolExecutor(max_workers=1) as executor:
-        pending = executor.submit(engine.open_duplex_session, "sid", fence=DuplexFence("sid"), timeout=1)
-        request_q.get(timeout=1)
-        rpc_q.put(control_result)
-        with pytest.raises(RuntimeError, match="duplex open failed"):
-            pending.result(timeout=1)
-    engine._correlated_rpc_client.close()
-
-
 def test_shutdown_does_not_race_runtime_cleanup_with_live_orchestrator(mocker: MockerFixture):
     engine = object.__new__(AsyncOmniEngine)
     engine._shutdown_called = False
diff --git a/tests/engine/test_async_omni_engine_stage_init.py b/tests/engine/test_async_omni_engine_stage_init.py
index 27677bd54..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 async_omni_engine as async_omni_engine_module
+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,8 +229,8 @@ 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):
-    import vllm_omni.engine.async_omni_engine as engine_mod
+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)
     engine.stage_configs = [types.SimpleNamespace()]
@@ -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_diffusion_streaming_output_kwarg.py b/tests/engine/test_diffusion_streaming_output_kwarg.py
index a6f3dff02..8bc00f587 100644
--- a/tests/engine/test_diffusion_streaming_output_kwarg.py
+++ b/tests/engine/test_diffusion_streaming_output_kwarg.py
@@ -33,7 +33,7 @@ def _resolve(monkeypatch, kwargs: dict[str, Any]) -> dict[str, Any]:
         return "config.yaml", [], None
 
     monkeypatch.setattr(
-        "vllm_omni.engine.async_omni_engine.load_and_resolve_stage_configs",
+        "vllm_omni.engine.omni_engine_base.load_and_resolve_stage_configs",
         _fake_load,
     )
     engine = SimpleNamespace(
diff --git a/tests/engine/test_duplex_import_boundary.py b/tests/engine/test_duplex_import_boundary.py
index f30266d28..1da513182 100644
--- a/tests/engine/test_duplex_import_boundary.py
+++ b/tests/engine/test_duplex_import_boundary.py
@@ -45,27 +45,62 @@ def test_isolated_import_ignores_conflicting_gpu_visibility(monkeypatch: pytest.
     _assert_isolated_import_succeeds("import vllm_omni.outputs")
 
 
-def test_stable_engine_imports_load_duplex_kernel_eagerly() -> None:
-    # The duplex kernel is imported eagerly by the stable engine modules.
-    # Model-specific duplex adapters must still load only via the
-    # dotted-string plugin paths, and the client-side vllm_omni.clients
-    # package must never enter the stable runtime import graph.
+def test_turn_based_stack_has_no_duplex_vocabulary() -> None:
+    # The generic bases and the turn-based siblings (AsyncOmni / AsyncOmniEngine /
+    # Orchestrator) carry no duplex code: importing them must not load the
+    # engine-side duplex package, the model plugins or the client library.
     _assert_isolated_import_succeeds("""
 import sys
 
 import vllm_omni.engine.async_omni_engine
+import vllm_omni.engine.omni_engine_base
 import vllm_omni.engine.orchestrator
 import vllm_omni.entrypoints.async_omni
+import vllm_omni.entrypoints.async_omni_base
+
+forbidden_prefixes = (
+    "vllm_omni.engine.duplex",
+    "vllm_omni.engine.duplex_omni_engine",
+    "vllm_omni.engine.duplex_orchestrator",
+    "vllm_omni.entrypoints.duplex",
+    "vllm_omni.entrypoints.duplex_omni",
+    "vllm_omni.clients",
+    "vllm_omni.model_executor.models.minicpmo_4_5.duplex",
+    "vllm_omni.model_executor.models.nemotron_voicechat.duplex",
+    "vllm_omni.model_executor.models.personaplex.duplex",
+)
+loaded = sorted(
+    name
+    for name in sys.modules
+    if any(name == prefix or name.startswith(prefix + ".") for prefix in forbidden_prefixes)
+)
+if loaded:
+    raise SystemExit("turn-based imports loaded duplex modules: " + ", ".join(loaded))
+""")
+
+
+def test_duplex_stack_loads_the_framework_but_not_the_model_plugins() -> None:
+    # The duplex siblings import the engine-side duplex framework eagerly;
+    # model plugins still load only through PipelineConfig.duplex_plugin, and
+    # the client-side package never enters the server import graph.
+    _assert_isolated_import_succeeds("""
+import sys
+
+import vllm_omni.engine.duplex_omni_engine
+import vllm_omni.engine.duplex_orchestrator
+import vllm_omni.entrypoints.duplex_omni
+import vllm_omni.entrypoints.duplex.serving
 
 expected_eager = (
-    "vllm_omni.engine.duplex.contracts",
-    "vllm_omni.engine.duplex.control_plane",
-    "vllm_omni.entrypoints.duplex_request_client",
-    "vllm_omni.outputs.duplex",
+    "vllm_omni.engine.duplex.commands",
+    "vllm_omni.engine.duplex.events",
+    "vllm_omni.engine.duplex.session.engine_session",
+    "vllm_omni.engine.duplex.session.manager",
+    "vllm_omni.engine.duplex.plugin",
 )
 missing = sorted(name for name in expected_eager if name not in sys.modules)
 if missing:
-    raise SystemExit("duplex kernel modules not imported eagerly: " + ", ".join(missing))
+    raise SystemExit("duplex framework modules not imported eagerly: " + ", ".join(missing))
 
 forbidden_prefixes = (
     "vllm_omni.clients",
@@ -79,7 +114,7 @@ loaded = sorted(
     if any(name == prefix or name.startswith(prefix + ".") for prefix in forbidden_prefixes)
 )
 if loaded:
-    raise SystemExit("stable imports loaded plugin-only duplex modules: " + ", ".join(loaded))
+    raise SystemExit("duplex imports loaded plugin-only or client modules: " + ", ".join(loaded))
 """)
 
 
@@ -122,8 +157,8 @@ from vllm_omni.clients.duplex import EventCollector
 collector = EventCollector()
 chunk = base64.b64encode(b"\\x00\\x00" * 2400).decode("ascii")
 collector.add({"type": "response.created", "response_id": "r1"}, received_at_s=1.0)
-collector.add({"type": "response.audio.delta", "response_id": "r1", "delta": chunk}, received_at_s=1.1)
-collector.add({"type": "response.audio.delta", "response_id": "r1", "delta": chunk}, received_at_s=1.2)
+collector.add({"type": "response.output_audio.delta", "response_id": "r1", "delta": chunk}, received_at_s=1.1)
+collector.add({"type": "response.output_audio.delta", "response_id": "r1", "delta": chunk}, received_at_s=1.2)
 summary = collector.timing_summary(after_s=0.0, response_id="r1")
 if "audio_output" not in summary or "request_metrics" not in summary:
     raise SystemExit("timing_summary produced no audio_output/request_metrics sections")
@@ -190,16 +225,32 @@ def test_engine_duplex_uses_canonical_contract_module_names() -> None:
     core_dir = REPO_ROOT / "vllm_omni" / "experimental" / "fullduplex" / "core"
 
     for name in (
+        "commands.py",
         "contracts.py",
-        "lease.py",
+        "events.py",
         "messages.py",
-        "session.py",
-        "control_plane.py",
-        "control_client.py",
-        "runtime.py",
+        "plugin.py",
         "intermediate.py",
     ):
         assert (engine_dir / name).is_file()
+    # one session and everything that runs it lives in the session subpackage
+    for name in (
+        "__init__.py",
+        "engine_session.py",
+        "manager.py",
+        "runner.py",
+        "context.py",
+        "emitter.py",
+        "model_channel.py",
+        "control.py",
+        "append_task.py",
+        "helpers.py",
+        "lease.py",
+    ):
+        assert (engine_dir / "session" / name).is_file()
+    assert not (engine_dir / "session.py").exists()
+    for removed in ("control_plane.py", "control_client.py", "runtime.py"):
+        assert not (engine_dir / removed).exists()
     # the duplex_ prefix is dropped inside the duplex package
     assert not (engine_dir / "duplex_session.py").exists()
     assert not (engine_dir / "duplex_lease.py").exists()
diff --git a/tests/engine/test_duplex_omni_engine.py b/tests/engine/test_duplex_omni_engine.py
new file mode 100644
index 000000000..06af9e7af
--- /dev/null
+++ b/tests/engine/test_duplex_omni_engine.py
@@ -0,0 +1,210 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""``DuplexOmniEngine``: the session message surface over the generic engine base."""
+
+from __future__ import annotations
+
+import asyncio
+import queue
+from types import SimpleNamespace
+from typing import Any
+
+import pytest
+
+from vllm_omni.engine.duplex.commands import Heartbeat
+from vllm_omni.engine.duplex.config import DuplexCapabilities, DuplexSessionConfig
+from vllm_omni.engine.duplex.messages import (
+    CloseDuplexSessionMessage,
+    DuplexControlResultMessage,
+    DuplexSessionCommandMessage,
+    DuplexSessionError,
+    OpenDuplexSessionMessage,
+    ResumeDuplexSessionMessage,
+    TouchDuplexSessionMessage,
+)
+from vllm_omni.engine.duplex_omni_engine import DuplexOmniEngine
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _FakeRpcClient:
+    def __init__(self, result: Any) -> None:
+        self.result = result
+        self.calls: list[tuple[tuple[str, str], Any, float | None]] = []
+        #: Control RPCs must block rather than raise a raw queue.Full.
+        self.block_on_submit_flags: list[bool] = []
+
+    def execute(self, key, message, *, timeout=None, timeout_message=None, block_on_submit=False):
+        self.calls.append((key, message, timeout))
+        self.block_on_submit_flags.append(block_on_submit)
+        if isinstance(self.result, BaseException):
+            raise self.result
+        return self.result
+
+
+class _FakeSyncQueue:
+    def __init__(self, *, full: bool = False) -> None:
+        self.items: list[Any] = []
+        self.full = full
+
+    def put(self, item: Any, timeout: float | None = None) -> None:
+        if self.full:
+            raise queue.Full
+        self.items.append(item)
+
+
+def _engine(result: Any, *, alive: bool = True, full: bool = False) -> DuplexOmniEngine:
+    engine = object.__new__(DuplexOmniEngine)
+    engine._correlated_rpc_client = _FakeRpcClient(result)
+    engine.request_queue = SimpleNamespace(sync_q=_FakeSyncQueue(full=full))
+    engine.is_alive = lambda: alive
+    engine.plugin = None
+    return engine
+
+
+def _ok(operation: str, **fields: Any) -> DuplexControlResultMessage:
+    return DuplexControlResultMessage(control_id="c", operation=operation, session_id="sid", ok=True, **fields)
+
+
+@pytest.mark.asyncio
+async def test_open_session_runs_the_correlated_rpc_with_the_typed_config() -> None:
+    result = _ok("open", capabilities=DuplexCapabilities(), public_session={"id": "sid"}, lease_generation=0)
+    engine = _engine(result)
+    config = DuplexSessionConfig(model="m")
+
+    returned = await engine.open_session_async("sid", config, timeout=3.0)
+
+    assert returned is result
+    ((key, message, timeout),) = engine.rpc_client.calls
+    assert key == ("duplex", message.control_id)
+    assert isinstance(message, OpenDuplexSessionMessage)
+    assert message.session_id == "sid" and message.session_config is config
+    assert timeout == 3.0
+    # A momentarily full request queue is backpressure, not a failed open: the
+    # control RPC blocks rather than raising an untyped queue.Full at the caller.
+    assert engine.rpc_client.block_on_submit_flags == [True]
+
+
+@pytest.mark.asyncio
+async def test_close_resume_and_touch_build_their_messages_without_incarnation() -> None:
+    engine = _engine(_ok("close"))
+    await engine.close_session_async("sid", reason="bye")
+    await engine.resume_session_async("sid", expected_lease_generation=4)
+    await engine.touch_session_async("sid", activity="detach")
+
+    close, resume, touch = (call[1] for call in engine.rpc_client.calls)
+    assert isinstance(close, CloseDuplexSessionMessage) and close.reason == "bye"
+    assert isinstance(resume, ResumeDuplexSessionMessage) and resume.expected_lease_generation == 4
+    assert isinstance(touch, TouchDuplexSessionMessage) and touch.activity == "detach"
+    for message in (close, resume, touch):
+        assert message.session_id == "sid"
+        assert not hasattr(message, "incarnation")
+
+
+@pytest.mark.asyncio
+async def test_failed_control_result_maps_to_a_typed_session_error() -> None:
+    engine = _engine(
+        DuplexControlResultMessage(
+            control_id="c",
+            operation="open",
+            session_id="sid",
+            ok=False,
+            error_code="resource_exhausted",
+            error_message="duplex_session_capacity_exhausted: limit=1",
+            error_retryable=True,
+        )
+    )
+    with pytest.raises(DuplexSessionError) as excinfo:
+        await engine.open_session_async("sid", DuplexSessionConfig())
+    assert excinfo.value.code == "resource_exhausted"
+    assert excinfo.value.retryable is True
+    assert excinfo.value.session_id == "sid"
+
+
+@pytest.mark.asyncio
+async def test_engine_error_and_timeout_map_to_session_errors() -> None:
+    # The correlated RPC client raises RuntimeError for a closed router or a
+    # terminal orchestrator error; both become a typed engine_error.
+    engine = _engine(RuntimeError("orchestrator exploded"))
+    with pytest.raises(DuplexSessionError, match="orchestrator exploded") as excinfo:
+        await engine.close_session_async("sid")
+    assert excinfo.value.code == "engine_error"
+
+    engine = _engine(TimeoutError("duplex open timed out for session sid"))
+    with pytest.raises(DuplexSessionError) as excinfo:
+        await engine.open_session_async("sid", DuplexSessionConfig())
+    assert excinfo.value.code == "timeout" and excinfo.value.retryable is True
+
+
+@pytest.mark.asyncio
+async def test_submit_command_is_one_way_on_the_request_queue() -> None:
+    engine = _engine(None)
+    command = Heartbeat(event_id="evt-1")
+
+    await engine.submit_command_async("sid", command)
+
+    (message,) = engine.request_queue.sync_q.items
+    assert isinstance(message, DuplexSessionCommandMessage)
+    assert message.session_id == "sid" and message.command is command
+    assert engine.rpc_client.calls == []
+
+
+@pytest.mark.asyncio
+async def test_submit_command_rejects_dead_engine_and_full_queue() -> None:
+    with pytest.raises(DuplexSessionError) as excinfo:
+        await _engine(None, alive=False).submit_command_async("sid", Heartbeat())
+    assert excinfo.value.code == "engine_dead"
+
+    with pytest.raises(DuplexSessionError) as excinfo:
+        await _engine(None, full=True).submit_command_async("sid", Heartbeat())
+    assert excinfo.value.code == "engine_backpressure" and excinfo.value.retryable is True
+
+
+def test_duplex_capabilities_come_from_the_loaded_plugin() -> None:
+    engine = object.__new__(DuplexOmniEngine)
+    engine.plugin = None
+    with pytest.raises(RuntimeError, match="not loaded"):
+        engine.duplex_capabilities
+    capabilities = DuplexCapabilities(supports_barge_in=False)
+    engine.plugin = SimpleNamespace(capabilities=lambda *, max_sessions: capabilities)
+    engine.duplex_session_config = SimpleNamespace(max_sessions=3)
+    assert engine.duplex_capabilities is capabilities
+
+
+def test_validate_deployment_requires_a_plugin_and_duplex_session_mode() -> None:
+    engine = object.__new__(DuplexOmniEngine)
+    engine.model = "plain-model"
+    engine.pipeline_config = SimpleNamespace(duplex_plugin=None)
+    engine.deploy_config = SimpleNamespace(session_mode="duplex")
+    with pytest.raises(ValueError, match="not a duplex model"):
+        engine._validate_deployment()
+
+    engine.pipeline_config = SimpleNamespace(duplex_plugin="pkg.mod.Plugin")
+    engine.deploy_config = SimpleNamespace(session_mode="turn")
+    with pytest.raises(ValueError, match="session_mode: duplex"):
+        engine._validate_deployment()
+
+    engine.deploy_config = None
+    with pytest.raises(ValueError, match="none resolved"):
+        engine._validate_deployment()
+
+
+@pytest.mark.asyncio
+async def test_async_wrappers_run_the_blocking_calls_off_the_event_loop() -> None:
+    loop = asyncio.get_running_loop()
+    engine = _engine(_ok("touch"))
+    seen: list[bool] = []
+    original = engine.rpc_client.execute
+
+    def execute(*args, **kwargs):
+        # Called from the default executor thread, never on the event loop thread.
+        try:
+            seen.append(asyncio.get_running_loop() is loop)
+        except RuntimeError:
+            seen.append(False)
+        return original(*args, **kwargs)
+
+    engine.rpc_client.execute = execute
+    await engine.touch_session_async("sid", activity="heartbeat")
+    assert seen == [False]
diff --git a/tests/engine/test_duplex_orchestrator.py b/tests/engine/test_duplex_orchestrator.py
new file mode 100644
index 000000000..703af6a35
--- /dev/null
+++ b/tests/engine/test_duplex_orchestrator.py
@@ -0,0 +1,562 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""``DuplexOrchestrator``: the template seams and the stage port around ``OrchestratorBase``."""
+
+from __future__ import annotations
+
+import asyncio
+import struct
+from types import SimpleNamespace
+from typing import Any
+
+import numpy as np
+import pytest
+from vllm.v1.engine.exceptions import EngineDeadError
+
+from tests.engine.test_orchestrator import (
+    FakeOutputProcessor,
+    FakeRunningCounter,
+    FakeStageClient,
+    _build_stage_pools,
+)
+from vllm_omni.config.stage_config import DuplexSessionRuntimeConfig
+from vllm_omni.engine.duplex import commands
+from vllm_omni.engine.duplex.config import DuplexSessionConfig, DuplexSessionState
+from vllm_omni.engine.duplex.contracts import DuplexFence, duplex_resource_request_id
+from vllm_omni.engine.duplex.messages import (
+    CloseDuplexSessionMessage,
+    DuplexControlResultMessage,
+    DuplexSessionCommandMessage,
+    OpenDuplexSessionMessage,
+)
+from vllm_omni.engine.duplex_orchestrator import DuplexOrchestrator, DuplexOrchestratorRequestState
+from vllm_omni.engine.messages import AbortRequestMessage, ShutdownRequestMessage
+from vllm_omni.engine.orchestrator import Orchestrator
+from vllm_omni.model_executor.models.minicpmo_4_5.duplex.plugin import MiniCPMO45DuplexPlugin
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+SESSION_ID = "duplex-orch"
+
+
+def _encode_audio(audio: object, sample_rate_hz: int, response_format: str, speed: float | None) -> str | None:
+    del sample_rate_hz, response_format, speed
+    samples = int(np.asarray(audio, dtype=np.float32).size) if audio is not None else 0
+    return f"wav-{samples}" if samples > 0 else None
+
+
+def _stage_configs(count: int) -> list[object]:
+    return [SimpleNamespace(model_config=SimpleNamespace(max_model_len=4096)) for _ in range(count)]
+
+
+def _build(
+    *,
+    stages: int = 1,
+    running_counter: FakeRunningCounter | None = None,
+    runtime_config: DuplexSessionRuntimeConfig | None = None,
+) -> tuple[DuplexOrchestrator, list[FakeStageClient], asyncio.Queue, asyncio.Queue]:
+    clients = [FakeStageClient(stage_type="llm", final_output=index == stages - 1) for index in range(stages)]
+    pools = _build_stage_pools(
+        [[client] for client in clients],
+        output_processors=[FakeOutputProcessor() for _ in clients],
+        stage_vllm_configs=_stage_configs(stages),
+    )
+    rpc_q: asyncio.Queue = asyncio.Queue()
+    output_q: asyncio.Queue = asyncio.Queue()
+    orchestrator = DuplexOrchestrator(
+        request_async_queue=asyncio.Queue(),
+        output_async_queue=output_q,
+        rpc_async_queue=rpc_q,
+        stage_pools=pools,
+        running_counter=running_counter,
+        plugin=MiniCPMO45DuplexPlugin(_encode_audio),
+        duplex_session_config=runtime_config or DuplexSessionRuntimeConfig(reaper_interval_s=0.01),
+        model_config=None,
+    )
+    return orchestrator, clients, rpc_q, output_q
+
+
+def _open_message(extra_body: dict[str, object] | None = None) -> OpenDuplexSessionMessage:
+    return OpenDuplexSessionMessage(
+        control_id=f"open-{SESSION_ID}",
+        session_id=SESSION_ID,
+        session_config=DuplexSessionConfig(
+            model="openbmb/MiniCPM-o-4_5",
+            modalities=["text"],
+            instructions="public instructions",
+            extra_body={"auto_response": True, **(extra_body or {})},
+        ),
+    )
+
+
+async def _open(orchestrator: DuplexOrchestrator, rpc_q: asyncio.Queue, **kwargs: Any) -> DuplexControlResultMessage:
+    await orchestrator._dispatch_message(_open_message(**kwargs))
+    result = await asyncio.wait_for(rpc_q.get(), timeout=2.0)
+    assert isinstance(result, DuplexControlResultMessage)
+    return result
+
+
+async def _close(orchestrator: DuplexOrchestrator, rpc_q: asyncio.Queue) -> DuplexControlResultMessage:
+    await orchestrator._dispatch_message(
+        CloseDuplexSessionMessage(control_id=f"close-{SESSION_ID}", session_id=SESSION_ID, reason="test")
+    )
+    result = await asyncio.wait_for(rpc_q.get(), timeout=2.0)
+    await _settle(orchestrator)
+    return result
+
+
+def _stage0_request_id(epoch: int = 0) -> str:
+    return duplex_resource_request_id(DuplexFence(SESSION_ID, epoch=epoch), "stage0")
+
+
+def _append_audio(samples: int = 16000) -> commands.AppendAudio:
+    return commands.AppendAudio(
+        audio=struct.pack(f"<{samples}f", *([0.05] * samples)),
+        format="pcm_f32le",
+        sample_rate_hz=16000,
+        is_speech=True,
+    )
+
+
+async def _submit(orchestrator: DuplexOrchestrator, command: commands.DuplexCommand) -> None:
+    assert await orchestrator._dispatch_message(DuplexSessionCommandMessage(session_id=SESSION_ID, command=command))
+    await _settle(orchestrator)
+
+
+async def _settle(orchestrator: DuplexOrchestrator, *, timeout_s: float = 3.0) -> None:
+    """Let the session runner drain its mailbox and append tasks."""
+    loop = asyncio.get_running_loop()
+    deadline = loop.time() + timeout_s
+    quiet = 0
+    while loop.time() < deadline:
+        runner = orchestrator.session_manager.runners.get(SESSION_ID)
+        busy = runner is not None and (
+            not runner._mailbox.empty()
+            or any(not task.done() for task in runner.tasks.append_tasks)
+            or any(not task.done() for task in runner._background_tasks)
+        )
+        busy = busy or any(not task.done() for task in orchestrator.session_manager._dispatched_control_tasks)
+        quiet = 0 if busy else quiet + 1
+        if quiet >= 5:
+            return
+        await asyncio.sleep(0.01)
+
+
+def _tts_output(request_id: str, *, samples: int = 24000, text: str = "hello") -> SimpleNamespace:
+    return SimpleNamespace(
+        request_id=request_id,
+        finished=False,
+        outputs=[SimpleNamespace(text=text, token_ids=[], multimodal_output={})],
+        multimodal_output={
+            "audio": np.zeros(samples, dtype=np.float32),
+            "sr": 24000,
+            "meta.duplex_turn_id": np.array([0], dtype=np.int32),
+            "meta.duplex_epoch": np.array([0], dtype=np.int32),
+        },
+    )
+
+
+# --------------------------------------------------------------------------- #
+# Message dispatch and session lifecycle                                      #
+# --------------------------------------------------------------------------- #
+
+
+def test_turn_based_orchestrator_has_no_session_manager() -> None:
+    orchestrator = Orchestrator(
+        request_async_queue=asyncio.Queue(),
+        output_async_queue=asyncio.Queue(),
+        rpc_async_queue=asyncio.Queue(),
+        stage_pools=[],
+    )
+    assert not hasattr(orchestrator, "session_manager")
+
+
+@pytest.mark.asyncio
+async def test_duplex_messages_are_dispatched_and_generic_ones_are_not() -> None:
+    orchestrator, _, rpc_q, _ = _build()
+    assert await orchestrator._dispatch_message(AbortRequestMessage(request_ids=["x"])) is False
+    assert await orchestrator._dispatch_message(ShutdownRequestMessage()) is False
+    assert await orchestrator._dispatch_message(_open_message()) is True
+    assert (await asyncio.wait_for(rpc_q.get(), timeout=2.0)).ok is True
+    await orchestrator.session_manager.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_open_preregisters_the_stage0_request_and_close_releases_it() -> None:
+    counter = FakeRunningCounter()
+    orchestrator, clients, rpc_q, _ = _build(running_counter=counter)
+    result = await _open(orchestrator, rpc_q)
+    assert result.ok is True
+    assert result.public_session["id"] == SESSION_ID
+    assert result.capabilities is not None and result.capabilities.supports_input_append
+
+    request_id = _stage0_request_id()
+    request_state = orchestrator.request_states[request_id]
+    assert isinstance(request_state, DuplexOrchestratorRequestState)
+    assert request_state.session_owned is True
+    assert request_state.session_id == SESSION_ID
+    assert request_state.fence == DuplexFence(SESSION_ID)
+    assert request_state.streaming.enabled is True
+    # Preregistration reserves the id; nothing is running until an append submits.
+    assert counter.value == 0
+    assert clients[0].add_request_calls == []
+    assert orchestrator.session_manager.runner_for_request_id(request_id) is not None
+
+    closed = await _close(orchestrator, rpc_q)
+    assert closed.ok is True
+    assert request_id not in orchestrator.request_states
+    assert orchestrator.session_manager.runner_for_request_id(request_id) is None
+    assert counter.value == 0
+    assert orchestrator.session_manager.active_count() == 0
+
+
+@pytest.mark.asyncio
+async def test_open_failure_rolls_back_session_and_reserved_request() -> None:
+    orchestrator, _, rpc_q, _ = _build()
+    # Server-owned runtime keys may not come from the client.
+    result = await _open(orchestrator, rpc_q, extra_body={"duplex_stage_max_tokens": {"0": 99}})
+
+    assert result.ok is False
+    assert result.error_code == "invalid_duplex_runtime_config"
+    assert orchestrator.request_states == {}
+    assert orchestrator.session_manager.active_count() == 0
+
+
+@pytest.mark.asyncio
+async def test_open_fails_cleanly_when_a_stage_has_no_live_replica() -> None:
+    orchestrator, _, rpc_q, _ = _build(stages=2)
+    orchestrator.stage_pools[1].evict_replica(0)
+
+    result = await _open(orchestrator, rpc_q)
+
+    assert result.ok is False
+    assert "stage 1 has no live replica" in (result.error_message or "")
+    assert orchestrator.request_states == {}
+    assert orchestrator.session_manager.active_count() == 0
+
+
+@pytest.mark.asyncio
+async def test_bridge_state_keeps_public_and_runtime_config_separate() -> None:
+    orchestrator, _, rpc_q, _ = _build()
+    await _open(orchestrator, rpc_q)
+    request_state = orchestrator.request_states[_stage0_request_id()]
+    bridge = request_state.streaming.bridge_states["duplex"]
+
+    assert bridge["session_id"] == SESSION_ID
+    assert bridge["fence"] == DuplexFence(SESSION_ID)
+    assert (bridge["epoch"], bridge["turn_id"], bridge["model_turn_id"]) == (0, 0, 0)
+    assert "incarnation" not in bridge
+    assert bridge["session_config"]["instructions"] == "public instructions"
+    assert "duplex_stage_sampling_params" not in bridge["session_config"]
+    assert bridge["runtime_config"]["instructions"] == "public instructions"
+    assert bridge["runtime_config"]["duplex_stage_max_tokens"] == {"0": 20, "1": 8192}
+    # The plugin's sampling policy is applied to the preregistered request.
+    assert request_state.sampling_params_list[0].max_tokens == 20
+    await orchestrator.session_manager.shutdown()
+
+
+# --------------------------------------------------------------------------- #
+# Stage port                                                                  #
+# --------------------------------------------------------------------------- #
+
+
+@pytest.mark.asyncio
+async def test_append_submits_the_resumable_stage0_request_and_counts_it_running() -> None:
+    counter = FakeRunningCounter()
+    orchestrator, clients, rpc_q, _ = _build(running_counter=counter)
+    await _open(orchestrator, rpc_q)
+    request_id = _stage0_request_id()
+
+    await _submit(orchestrator, _append_audio())
+    assert len(clients[0].add_request_calls) == 1
+    submitted = clients[0].add_request_calls[0][0]
+    assert submitted.request_id == request_id
+    assert submitted.resumable is True
+    assert submitted.sampling_params.max_tokens == 20
+    request_state = orchestrator.request_states[request_id]
+    assert request_state.stage_fences[0] == DuplexFence(SESSION_ID)
+    assert 0 in request_state.stage_submit_ts
+    assert counter.value == 1
+    session = orchestrator.session_manager.get(SESSION_ID)
+    assert session is not None and session.stage_request_submitted(0, request_id)
+
+    # Later units update the same resumable request; the counter stays at one.
+    await _submit(orchestrator, _append_audio())
+    assert len(clients[0].add_request_calls) == 2
+    assert clients[0].add_request_calls[1][0].request_id == request_id
+    assert counter.value == 1
+
+    await _close(orchestrator, rpc_q)
+    assert clients[0].abort_calls == [[request_id]]
+    assert counter.value == 0
+
+
+@pytest.mark.asyncio
+async def test_session_update_refreshes_the_next_append_sampling_params() -> None:
+    orchestrator, clients, rpc_q, _ = _build()
+    await _open(orchestrator, rpc_q)
+    request_state = orchestrator.request_states[_stage0_request_id()]
+    assert request_state.sampling_params_list[0].max_tokens == 20
+
+    await _submit(orchestrator, commands.UpdateSession(patch={"max_output_tokens": 7}))
+    await _submit(orchestrator, _append_audio())
+
+    assert request_state.sampling_params_list[0].max_tokens == 7
+    assert clients[0].add_request_calls[-1][0].sampling_params.max_tokens == 7
+    await orchestrator.session_manager.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_forwarded_stage_requests_are_bound_and_barge_in_aborts_them() -> None:
+    orchestrator, clients, rpc_q, _ = _build(stages=2)
+    await _open(orchestrator, rpc_q)
+    request_id = _stage0_request_id()
+    await _submit(orchestrator, _append_audio())
+    request_state = orchestrator.request_states[request_id]
+    session = orchestrator.session_manager.get(SESSION_ID)
+    assert session is not None
+
+    # The base forwards Stage0 text to the TTS stage and reports the submission.
+    forwarded = SimpleNamespace(request_id=request_id, prompt_token_ids=[1, 2], resumable=True)
+    replica_id = await orchestrator.stage_pools[1].submit_initial(request_id, request_state, forwarded)
+    orchestrator._on_stage_submitted(1, request_id, replica_id, request_state)
+    assert request_state.stage_fences[1] == DuplexFence(SESSION_ID)
+    assert session.stage_request_submitted(1, request_id)
+
+    await _submit(orchestrator, commands.BargeIn())
+    assert session.epoch == 1
+    assert clients[0].abort_calls == [[request_id]]
+    assert clients[1].abort_calls == [[request_id]]
+    assert request_id not in orchestrator.request_states
+    assert session.resource_request_ids() == []
+    await orchestrator.session_manager.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_session_owned_outputs_reach_the_runner_and_never_the_client_queue() -> None:
+    orchestrator, _, rpc_q, output_q = _build(stages=2)
+    await _open(orchestrator, rpc_q)
+    request_id = _stage0_request_id()
+    await _submit(orchestrator, _append_audio())
+    request_state = orchestrator.request_states[request_id]
+    while not output_q.empty():
+        output_q.get_nowait()
+
+    consumed = await orchestrator._intercept_stage_output(1, 0, _tts_output(request_id), request_state, None, None)
+    await _settle(orchestrator)
+
+    assert consumed is True
+    session = orchestrator.session_manager.get(SESSION_ID)
+    assert session is not None and session.active_response_id is not None
+    types = [message.event.type for message in [output_q.get_nowait() for _ in range(output_q.qsize())]]
+    assert "response.created" in types and "response.output_audio.delta" in types
+
+    orphan = DuplexOrchestratorRequestState(
+        request_id="duplex-s.b3RoZXI.e.0.r.stage0",
+        prompt=None,
+        sampling_params_list=[],
+        final_stage_id=1,
+        session_owned=True,
+        session_id="other",
+        fence=DuplexFence("other"),
+    )
+    assert await orchestrator._intercept_stage_output(1, 0, _tts_output(orphan.request_id), orphan, None, None)
+    await orchestrator.session_manager.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_forward_failure_closes_the_owning_session() -> None:
+    orchestrator, clients, rpc_q, output_q = _build(stages=2)
+    await _open(orchestrator, rpc_q)
+    request_id = _stage0_request_id()
+    await _submit(orchestrator, _append_audio())
+    request_state = orchestrator.request_states[request_id]
+    session = orchestrator.session_manager.get(SESSION_ID)
+    assert session is not None
+
+    absorbed = await orchestrator._handle_forward_failure(request_id, 1, request_state, ValueError("bad thinker"))
+    await _settle(orchestrator)
+
+    assert absorbed is True
+    assert request_id not in orchestrator.request_states
+    assert clients[0].abort_calls == [[request_id]]
+    assert SESSION_ID not in orchestrator.session_manager.runners
+    assert session.state == DuplexSessionState.CLOSED
+    assert orchestrator.session_manager.active_count() == 0
+    types = [message.event.type for message in [output_q.get_nowait() for _ in range(output_q.qsize())]]
+    # The stage failure is reported before the session expires, never after.
+    assert types.index("error") < types.index("session.expired")
+    assert types[-1] == "session.expired"
+
+
+@pytest.mark.asyncio
+async def test_request_cleanup_failure_is_deferred_and_retried_by_the_reaper(monkeypatch) -> None:
+    orchestrator, clients, rpc_q, _ = _build()
+    await _open(orchestrator, rpc_q)
+    request_id = _stage0_request_id()
+    await _submit(orchestrator, _append_audio())
+    manager = orchestrator.session_manager
+
+    async def failing_abort(request_ids: list[str]) -> None:
+        raise RuntimeError("stage abort failed")
+
+    monkeypatch.setattr(clients[0], "abort_requests_async", failing_abort)
+    with pytest.raises(RuntimeError, match="stage abort failed"):
+        await orchestrator._cleanup_request_ids([request_id], abort=True, release_owners=True)
+    await _settle(orchestrator)
+
+    assert SESSION_ID not in manager.runners
+    assert SESSION_ID in manager._closing  # admission slot retained
+    assert manager._pending_request_cleanups and not manager._request_cleanups_in_progress
+    assert manager.active_count() == 0 and manager._admission_count() == 1
+
+    monkeypatch.undo()
+    assert await manager.reap_expired() >= 1
+    assert manager._pending_request_cleanups == {}
+    assert manager._admission_count() == 0
+    assert request_id not in orchestrator.request_states
+
+
+@pytest.mark.asyncio
+async def test_reaper_runs_as_a_background_task_and_survives_one_failure(monkeypatch) -> None:
+    orchestrator, _, _, _ = _build(runtime_config=DuplexSessionRuntimeConfig(reaper_interval_s=0.01))
+    calls = {"count": 0}
+
+    async def reap_expired(now: float | None = None) -> int:
+        calls["count"] += 1
+        if calls["count"] == 1:
+            raise RuntimeError("transient cleanup failure")
+        return 0
+
+    monkeypatch.setattr(orchestrator.session_manager, "reap_expired", reap_expired)
+    tasks = orchestrator._background_tasks()
+    assert len(tasks) == 1
+    task = asyncio.create_task(tasks[0])
+    await asyncio.sleep(0.05)
+    orchestrator._shutdown_event.set()
+    await task
+    assert calls["count"] >= 2
+    await orchestrator._shutdown_extensions()
+
+
+# --------------------------------------------------------------------------- #
+# The hierarchy the two surfaces depend on                                    #
+# --------------------------------------------------------------------------- #
+
+
+def test_the_duplex_stack_extends_the_turn_based_one() -> None:
+    """One engine serves a session and an ordinary request, so duplex must extend turn-based.
+
+    Pinned because it is the kind of relationship a later tidy-up turns back
+    into siblings over a shared base. If it does, a duplex server silently
+    stops serving /v1/chat/completions: the chat service needs a real
+    EngineClient with generate(), which only the turn-based side provides.
+    """
+    from vllm_omni.engine.async_omni_engine import AsyncOmniEngine
+    from vllm_omni.engine.duplex_omni_engine import DuplexOmniEngine
+    from vllm_omni.engine.orchestrator import Orchestrator
+    from vllm_omni.entrypoints.async_omni import AsyncOmni
+    from vllm_omni.entrypoints.duplex_omni import DuplexOmni
+
+    assert issubclass(DuplexOrchestrator, Orchestrator)
+    assert issubclass(DuplexOmniEngine, AsyncOmniEngine)
+    assert issubclass(DuplexOmni, AsyncOmni)
+    # What the chat route actually needs off the engine client.
+    assert hasattr(DuplexOmni, "generate")
+
+
+@pytest.mark.asyncio
+async def test_an_unrecognised_message_reaches_the_turn_based_handler() -> None:
+    """The duplex orchestrator consumes session messages and passes the rest down.
+
+    Without the fall-through, an ordinary add_request on a duplex engine is
+    silently dropped and the chat request that sent it hangs forever.
+    """
+    orchestrator, _clients, _rpc_q, _output_q = _build()
+    handled: list[str] = []
+
+    async def _turn_based(msg: object) -> None:
+        handled.append(getattr(msg, "type", ""))
+
+    orchestrator._handle_add_request = _turn_based  # type: ignore[method-assign]
+    msg = SimpleNamespace(type="add_request")
+
+    assert await orchestrator._dispatch_message(msg) is True
+    assert handled == ["add_request"], "an add_request must reach Orchestrator, not be dropped"
+
+
+@pytest.mark.asyncio
+async def test_a_dead_replica_closes_the_sessions_it_was_serving() -> None:
+    """A session outlives its stage request, so replica death has to release the owner.
+
+    ``_handle_dead_replica`` cleaned the stage request but not the runner that
+    owned it: the session stayed alive holding an admission slot, and the client
+    was told nothing — the request-scoped ``ErrorMessage`` it emits has no
+    frontend ``request_states`` entry to land in for a session-owned request, so
+    the frontend drops it. Heartbeats would then keep an unusable session
+    occupying capacity.
+    """
+    orchestrator, clients, rpc_q, output_q = _build()
+    await _open(orchestrator, rpc_q)
+    request_id = _stage0_request_id()
+    await _submit(orchestrator, _append_audio())
+    session = orchestrator.session_manager.get(SESSION_ID)
+    assert session is not None
+    assert orchestrator.session_manager.active_count() == 1
+
+    await orchestrator._handle_dead_replica(0, 0, EngineDeadError("stage 0 replica 0 died"))
+    await _settle(orchestrator)
+
+    assert request_id not in orchestrator.request_states
+    assert SESSION_ID not in orchestrator.session_manager.runners
+    assert session.state == DuplexSessionState.CLOSED
+    assert orchestrator.session_manager.active_count() == 0, "the admission slot must come back"
+    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 aa4f25ded..4bbca2515 100644
--- a/tests/engine/test_orchestrator.py
+++ b/tests/engine/test_orchestrator.py
@@ -21,20 +21,8 @@ from vllm.v1.engine import EngineCoreOutput, EngineCoreOutputs, FinishReason
 from vllm.v1.engine.exceptions import EngineDeadError
 from vllm.v1.metrics.stats import IterationStats
 
-from vllm_omni.engine.duplex.control_plane import DuplexControlPlane
-from vllm_omni.engine.duplex.messages import (
-    AppendDuplexInputMessage,
-    CloseDuplexSessionMessage,
-    DuplexFence,
-    OpenDuplexSessionMessage,
-    SignalDuplexTurnMessage,
-)
-from vllm_omni.engine.duplex.runtime import (
-    DuplexInputMode,
-    DuplexRuntimeCapabilities,
-    DuplexSessionRuntimeState,
-    duplex_resource_request_id,
-)
+from vllm_omni.engine import OmniEngineCoreOutput
+from vllm_omni.engine.errors import NativeKVHandoffError
 from vllm_omni.engine.messages import (
     AbortRequestMessage,
     AbortResultMessage,
@@ -54,7 +42,6 @@ from vllm_omni.engine.orchestrator import (
 )
 from vllm_omni.engine.stage_pool import StagePool
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
-from vllm_omni.model_executor.models.minicpmo_4_5.duplex.runtime import MiniCPMO45DuplexRuntimeExtension
 from vllm_omni.outputs import OmniRequestOutput
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
@@ -324,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(
@@ -333,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},
     )
 
@@ -533,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(
@@ -543,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(),
@@ -802,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"
@@ -1118,778 +1111,6 @@ async def test_handle_abort_emits_error_result_on_failure() -> None:
     assert "cleanup exploded" in (result.error or "")
 
 
-def _duplex_open_message(
-    session_id: str,
-    *,
-    incarnation: int = 0,
-    session_config: dict[str, object] | None = None,
-    runtime_config: dict[str, object] | None = None,
-) -> OpenDuplexSessionMessage:
-    return OpenDuplexSessionMessage(
-        control_id=f"open-{session_id}",
-        fence=DuplexFence(session_id, incarnation=incarnation),
-        session_id=session_id,
-        capabilities={
-            "input_modes": [DuplexInputMode.APPEND_AUDIO_CHUNK.value],
-            "implementation_level": "model_native_duplex",
-        },
-        session_config=session_config or {},
-        runtime_config=runtime_config or {},
-    )
-
-
-async def _handle_duplex(orchestrator: Orchestrator, message: object) -> None:
-    await orchestrator._require_duplex_control_plane().handle(message)
-
-
-def _duplex_request_state(
-    orchestrator: Orchestrator,
-    session: DuplexSessionRuntimeState,
-    *,
-    stage_id: int,
-) -> OrchestratorRequestState | None:
-    context = orchestrator._require_duplex_control_plane().ensure_stage_request(
-        session,
-        stage_id=stage_id,
-    )
-    if context is None:
-        return None
-    return orchestrator.request_states.get(context.request_id)
-
-
-@pytest.mark.asyncio
-async def test_duplex_control_plane_keeps_public_and_runtime_config_separate() -> None:
-    stage0 = FakeStageClient(stage_type="llm", final_output=True)
-    rpc_q: asyncio.Queue = asyncio.Queue()
-    orchestrator = Orchestrator(
-        request_async_queue=asyncio.Queue(),
-        output_async_queue=asyncio.Queue(),
-        rpc_async_queue=rpc_q,
-        stage_pools=_build_stage_pools([[stage0]]),
-        duplex_runtime_extension=MiniCPMO45DuplexRuntimeExtension(),
-        enable_duplex_control=True,
-    )
-    open_message = _duplex_open_message(
-        "sid-config-channels",
-        incarnation=3,
-        session_config={
-            "instructions": "public instructions",
-            "extra_body": {"duplex_stage_max_tokens": {"0": 99}},
-        },
-        runtime_config={
-            "duplex_stage_max_tokens": {"0": 3},
-            "duplex_stage_sampling_params": {"0": {"stop_token_ids": [151705]}},
-        },
-    )
-
-    await _handle_duplex(orchestrator, open_message)
-
-    assert rpc_q.get_nowait().ok is True
-    session = orchestrator.duplex_sessions.require(open_message.session_id)
-    request_state = _duplex_request_state(orchestrator, session, stage_id=0)
-    assert request_state.sampling_params_list[0].max_tokens == 3
-    assert request_state.sampling_params_list[0].stop_token_ids == [151705]
-    bridge = request_state.streaming.bridge_states["duplex"]
-    assert bridge["incarnation"] == open_message.fence.incarnation
-    assert bridge["session_config"] == open_message.session_config
-    assert bridge["runtime_config"] == open_message.runtime_config
-
-
-@pytest.mark.asyncio
-async def test_duplex_control_plane_preserves_turn_commit_without_model_extension() -> None:
-    rpc_q: asyncio.Queue = asyncio.Queue()
-    orchestrator = Orchestrator(
-        request_async_queue=asyncio.Queue(),
-        output_async_queue=asyncio.Queue(),
-        rpc_async_queue=rpc_q,
-        stage_pools=[],
-        duplex_runtime_extension=None,
-        enable_duplex_control=True,
-    )
-    assert isinstance(orchestrator.duplex_control_plane, DuplexControlPlane)
-
-    message = OpenDuplexSessionMessage(
-        control_id="open-turn-commit",
-        fence=DuplexFence("sid-turn-commit"),
-        session_id="sid-turn-commit",
-        capabilities={"input_modes": [DuplexInputMode.TURN_COMMIT_ONLY.value]},
-        session_config={},
-    )
-    await _handle_duplex(orchestrator, message)
-
-    result = rpc_q.get_nowait()
-    assert result.ok is True
-    assert result.stage_results[0]["result"]["scheduler_request_context"] is False
-
-
-def test_ordinary_orchestrator_bypasses_duplex_control_plane() -> None:
-    orchestrator = Orchestrator(
-        request_async_queue=asyncio.Queue(),
-        output_async_queue=asyncio.Queue(),
-        rpc_async_queue=asyncio.Queue(),
-        stage_pools=[],
-        duplex_runtime_extension=MiniCPMO45DuplexRuntimeExtension(),
-    )
-
-    assert orchestrator.duplex_control_plane is None
-
-
-@pytest.mark.asyncio
-async def test_duplex_close_cleans_preregistered_request_without_append() -> None:
-    stage0 = FakeStageClient(stage_type="llm", final_output=True)
-    rpc_q: asyncio.Queue = asyncio.Queue()
-    running_counter = FakeRunningCounter()
-    orchestrator = Orchestrator(
-        request_async_queue=asyncio.Queue(),
-        output_async_queue=asyncio.Queue(),
-        rpc_async_queue=rpc_q,
-        stage_pools=_build_stage_pools([[stage0]]),
-        duplex_runtime_extension=MiniCPMO45DuplexRuntimeExtension(),
-        enable_duplex_control=True,
-        running_counter=running_counter,
-    )
-    open_message = _duplex_open_message("sid-preregister-close")
-
-    await _handle_duplex(orchestrator, open_message)
-    open_result = rpc_q.get_nowait()
-    request_id = open_result.stage_results[0]["result"]["request_id"]
-    assert request_id in orchestrator.request_states
-
-    await _handle_duplex(
-        orchestrator,
-        CloseDuplexSessionMessage(
-            control_id="close-preregistered",
-            fence=open_message.fence,
-            session_id=open_message.session_id,
-        ),
-    )
-
-    assert rpc_q.get_nowait().ok is True
-    assert request_id not in orchestrator.request_states
-    assert orchestrator.duplex_sessions.get(open_message.session_id) is None
-    assert running_counter.value == 0
-
-
-@pytest.mark.asyncio
-async def test_duplex_open_failure_rolls_back_session_and_reserved_request() -> None:
-    stage0 = FakeStageClient(stage_type="llm", final_output=True)
-    rpc_q: asyncio.Queue = asyncio.Queue()
-    orchestrator = Orchestrator(
-        request_async_queue=asyncio.Queue(),
-        output_async_queue=asyncio.Queue(),
-        rpc_async_queue=rpc_q,
-        stage_pools=_build_stage_pools([[stage0]]),
-        duplex_runtime_extension=MiniCPMO45DuplexRuntimeExtension(),
-        enable_duplex_control=True,
-    )
-    open_message = _duplex_open_message(
-        "sid-open-rollback",
-        runtime_config={
-            "duplex_stage_sampling_params": {
-                "0": {"stop_token_ids": 123},
-            }
-        },
-    )
-
-    await _handle_duplex(orchestrator, open_message)
-
-    assert rpc_q.get_nowait().ok is False
-    assert orchestrator.duplex_sessions.get(open_message.session_id) is None
-    assert orchestrator.request_states == {}
-
-
-@pytest.mark.asyncio
-async def test_duplex_running_counter_tracks_only_submitted_request() -> None:
-    stage0 = FakeStageClient(stage_type="llm", final_output=True)
-    rpc_q: asyncio.Queue = asyncio.Queue()
-    running_counter = FakeRunningCounter()
-    orchestrator = Orchestrator(
-        request_async_queue=asyncio.Queue(),
-        output_async_queue=asyncio.Queue(),
-        rpc_async_queue=rpc_q,
-        stage_pools=_build_stage_pools([[stage0]]),
-        duplex_runtime_extension=MiniCPMO45DuplexRuntimeExtension(),
-        enable_duplex_control=True,
-        running_counter=running_counter,
-    )
-    open_message = _duplex_open_message("sid-duplex-counter")
-    await _handle_duplex(orchestrator, open_message)
-    assert rpc_q.get_nowait().ok is True
-    assert running_counter.value == 0
-
-    await _handle_duplex(
-        orchestrator,
-        AppendDuplexInputMessage(
-            control_id="append-duplex-counter",
-            fence=open_message.fence,
-            session_id=open_message.session_id,
-            mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
-            payload={"is_speech": True},
-        ),
-    )
-    assert rpc_q.get_nowait().ok is True
-    assert running_counter.value == 1
-
-    await _handle_duplex(
-        orchestrator,
-        CloseDuplexSessionMessage(
-            control_id="close-duplex-counter",
-            fence=open_message.fence,
-            session_id=open_message.session_id,
-        ),
-    )
-    assert rpc_q.get_nowait().ok is True
-    assert running_counter.value == 0
-
-
-@pytest.mark.asyncio
-async def test_duplex_failed_append_does_not_advance_sequence_or_fence() -> None:
-    class FailingPlanExtension(MiniCPMO45DuplexRuntimeExtension):
-        def plan_append(self, **kwargs):
-            raise RuntimeError("planned append failure")
-
-    stage0 = FakeStageClient(stage_type="llm", final_output=True)
-    rpc_q: asyncio.Queue = asyncio.Queue()
-    orchestrator = Orchestrator(
-        request_async_queue=asyncio.Queue(),
-        output_async_queue=asyncio.Queue(),
-        rpc_async_queue=rpc_q,
-        stage_pools=_build_stage_pools([[stage0]]),
-        duplex_runtime_extension=FailingPlanExtension(),
-        enable_duplex_control=True,
-    )
-    fence = DuplexFence("sid-append-rollback", turn_id=1)
-    session = orchestrator.duplex_sessions.open_session(
-        DuplexFence("sid-append-rollback"),
-        capabilities=DuplexRuntimeCapabilities(
-            input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK},
-        ),
-    )
-
-    await _handle_duplex(
-        orchestrator,
-        AppendDuplexInputMessage(
-            control_id="append-rollback",
-            fence=fence,
-            session_id=fence.session_id,
-            mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
-            payload={"is_speech": True},
-        ),
-    )
-
-    result = rpc_q.get_nowait()
-    assert result.ok is False
-    assert session.fence == DuplexFence("sid-append-rollback")
-    assert session.input_seq == 0
-    assert session.input_turn_seq == 0
-    assert stage0.add_request_calls == []
-
-
-@pytest.mark.asyncio
-async def test_duplex_duplicate_append_operation_is_submitted_once() -> None:
-    stage0 = FakeStageClient(stage_type="llm", final_output=True)
-    rpc_q: asyncio.Queue = asyncio.Queue()
-    orchestrator = Orchestrator(
-        request_async_queue=asyncio.Queue(),
-        output_async_queue=asyncio.Queue(),
-        rpc_async_queue=rpc_q,
-        stage_pools=_build_stage_pools([[stage0]]),
-        duplex_runtime_extension=MiniCPMO45DuplexRuntimeExtension(),
-        enable_duplex_control=True,
-    )
-    fence = DuplexFence("sid-idempotent-append")
-    session = orchestrator.duplex_sessions.open_session(
-        fence,
-        capabilities=DuplexRuntimeCapabilities(
-            input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK},
-        ),
-    )
-
-    for control_id in ("append-first", "append-timeout-retry"):
-        await _handle_duplex(
-            orchestrator,
-            AppendDuplexInputMessage(
-                control_id=control_id,
-                operation_id="physical-input-1",
-                fence=fence,
-                session_id=fence.session_id,
-                mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
-                payload={"is_speech": True},
-            ),
-        )
-
-    first = rpc_q.get_nowait()
-    retry = rpc_q.get_nowait()
-    assert first.ok is True
-    assert retry.ok is True
-    assert first.stage_results == retry.stage_results
-    assert len(stage0.add_request_calls) == 1
-    assert session.input_seq == 1
-
-
-@pytest.mark.asyncio
-async def test_duplex_barge_in_aborts_bound_stage_requests_before_releasing_fence() -> None:
-    stage0 = FakeStageClient(stage_type="llm", final_output=False)
-    stage1 = FakeStageClient(stage_type="llm", final_output=True)
-    stage_pools = _build_stage_pools(
-        [[stage0], [stage1]],
-        output_processors=[FakeOutputProcessor(), FakeOutputProcessor()],
-        stage_vllm_configs=[
-            SimpleNamespace(model_config=SimpleNamespace(max_model_len=64)),
-            SimpleNamespace(model_config=SimpleNamespace(max_model_len=64)),
-        ],
-    )
-    rpc_q: asyncio.Queue = asyncio.Queue()
-    orchestrator = Orchestrator(
-        request_async_queue=asyncio.Queue(),
-        output_async_queue=asyncio.Queue(),
-        rpc_async_queue=rpc_q,
-        stage_pools=stage_pools,
-        duplex_runtime_extension=MiniCPMO45DuplexRuntimeExtension(),
-        enable_duplex_control=True,
-    )
-    session = orchestrator.duplex_sessions.open_session(
-        DuplexFence("sid-stage-signal"),
-        capabilities=DuplexRuntimeCapabilities(
-            input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK},
-        ),
-    )
-    session.bind_stage_request(0, "req-stage0", fence=session.fence)
-    session.bind_stage_request(1, "req-stage1", fence=session.fence)
-    assert stage_pools[0].select_replica_id("req-stage0") == 0
-    assert stage_pools[1].select_replica_id("req-stage1") == 0
-    session.append_input(
-        mode=DuplexInputMode.APPEND_AUDIO_CHUNK,
-        fence=session.fence,
-    )
-    await _handle_duplex(
-        orchestrator,
-        SignalDuplexTurnMessage(
-            control_id="ctrl-signal",
-            fence=session.fence,
-            next_fence=DuplexFence("sid-stage-signal", epoch=1),
-            session_id="sid-stage-signal",
-            event="barge_in",
-        ),
-    )
-
-    assert stage0.abort_calls == [["req-stage0"]]
-    assert stage1.abort_calls == [["req-stage1"]]
-    assert stage0.collective_rpc_calls == []
-    assert stage1.collective_rpc_calls == []
-    assert session.stage_bindings == {}
-    assert session.fence == DuplexFence("sid-stage-signal", epoch=1)
-    result = rpc_q.get_nowait()
-    assert result.ok is True
-
-
-@pytest.mark.asyncio
-async def test_duplex_late_barge_in_releases_only_cancelled_fence_bindings() -> None:
-    stage0 = FakeStageClient(stage_type="llm", final_output=False)
-    stage1 = FakeStageClient(stage_type="llm", final_output=True)
-    stage_pools = _build_stage_pools(
-        [[stage0], [stage1]],
-        output_processors=[FakeOutputProcessor(), FakeOutputProcessor()],
-        stage_vllm_configs=[
-            SimpleNamespace(model_config=SimpleNamespace(max_model_len=64)),
-            SimpleNamespace(model_config=SimpleNamespace(max_model_len=64)),
-        ],
-    )
-    rpc_q: asyncio.Queue = asyncio.Queue()
-    orchestrator = Orchestrator(
-        request_async_queue=asyncio.Queue(),
-        output_async_queue=asyncio.Queue(),
-        rpc_async_queue=rpc_q,
-        stage_pools=stage_pools,
-        enable_duplex_control=True,
-    )
-    cancelled_fence = DuplexFence("sid-late-stage-signal")
-    session = orchestrator.duplex_sessions.open_session(
-        cancelled_fence,
-        capabilities=DuplexRuntimeCapabilities(
-            input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK},
-        ),
-    )
-    session.bind_stage_request(0, "req-stage0", fence=cancelled_fence)
-    session.bind_stage_request(1, "req-stage1", fence=cancelled_fence)
-    assert stage_pools[0].select_replica_id("req-stage0") == 0
-    assert stage_pools[1].select_replica_id("req-stage1") == 0
-    current_fence = DuplexFence("sid-late-stage-signal", epoch=1)
-    session.accept_fence(current_fence)
-
-    await _handle_duplex(
-        orchestrator,
-        SignalDuplexTurnMessage(
-            control_id="ctrl-late-signal",
-            fence=cancelled_fence,
-            next_fence=current_fence,
-            session_id="sid-late-stage-signal",
-            event="barge_in",
-        ),
-    )
-
-    assert stage0.abort_calls == [["req-stage0"]]
-    assert stage1.abort_calls == [["req-stage1"]]
-    assert session.stage_bindings == {}
-    assert session.fence == current_fence
-    result = rpc_q.get_nowait()
-    assert result.ok is True
-
-
-@pytest.mark.asyncio
-async def test_duplex_cancel_without_next_fence_is_rejected_without_releasing_bindings() -> None:
-    stage0 = FakeStageClient(stage_type="llm", final_output=True)
-    stage_pools = _build_stage_pools(
-        [[stage0]],
-        output_processors=[FakeOutputProcessor()],
-        stage_vllm_configs=[SimpleNamespace(model_config=SimpleNamespace(max_model_len=64))],
-    )
-    rpc_q: asyncio.Queue = asyncio.Queue()
-    orchestrator = Orchestrator(
-        request_async_queue=asyncio.Queue(),
-        output_async_queue=asyncio.Queue(),
-        rpc_async_queue=rpc_q,
-        stage_pools=stage_pools,
-        enable_duplex_control=True,
-    )
-    fence = DuplexFence("sid-cancel-contract")
-    session = orchestrator.duplex_sessions.open_session(fence)
-    session.bind_stage_request(0, "req-live", fence=fence)
-
-    await _handle_duplex(
-        orchestrator,
-        SignalDuplexTurnMessage(
-            control_id="cancel-without-next",
-            fence=fence,
-            session_id=fence.session_id,
-            event="input.cancel",
-        ),
-    )
-
-    result = rpc_q.get_nowait()
-    assert result.ok is False
-    assert result.error_count == 1
-    assert "next_fence" in result.stage_results[0]["result"]["error"]
-    assert session.fence == fence
-    assert session.stage_request_ids() == ["req-live"]
-    assert stage0.abort_calls == []
-
-
-@pytest.mark.asyncio
-async def test_duplex_session_update_replaces_runtime_config() -> None:
-    rpc_q: asyncio.Queue = asyncio.Queue()
-    orchestrator = Orchestrator(
-        request_async_queue=asyncio.Queue(),
-        output_async_queue=asyncio.Queue(),
-        rpc_async_queue=rpc_q,
-        stage_pools=[],
-        enable_duplex_control=True,
-    )
-    fence = DuplexFence("sid-update-config")
-    session = orchestrator.duplex_sessions.open_session(
-        fence,
-        session_config={"temperature": 0.7},
-    )
-
-    await _handle_duplex(
-        orchestrator,
-        SignalDuplexTurnMessage(
-            control_id="update-config",
-            fence=fence,
-            session_id=fence.session_id,
-            event="session.update",
-            session_config={"temperature": 0.0, "instructions": "updated"},
-        ),
-    )
-
-    result = rpc_q.get_nowait()
-    assert result.ok is True
-    assert session.session_config == {"temperature": 0.0, "instructions": "updated"}
-
-
-@pytest.mark.asyncio
-async def test_duplex_session_update_refreshes_next_append_sampling_params() -> None:
-    stage0 = FakeStageClient(stage_type="llm", final_output=True)
-    stage_pools = _build_stage_pools(
-        [[stage0]],
-        output_processors=[FakeOutputProcessor()],
-        stage_vllm_configs=[SimpleNamespace(model_config=SimpleNamespace(max_model_len=64))],
-    )
-    rpc_q: asyncio.Queue = asyncio.Queue()
-    orchestrator = Orchestrator(
-        request_async_queue=asyncio.Queue(),
-        output_async_queue=asyncio.Queue(),
-        rpc_async_queue=rpc_q,
-        stage_pools=stage_pools,
-        duplex_runtime_extension=MiniCPMO45DuplexRuntimeExtension(),
-        enable_duplex_control=True,
-    )
-    fence = DuplexFence("sid-update-policy")
-    session = orchestrator.duplex_sessions.open_session(
-        fence,
-        capabilities=DuplexRuntimeCapabilities(
-            input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK},
-        ),
-        runtime_config={
-            "duplex_stage_max_tokens": {"0": 2},
-            "duplex_stage_sampling_params": {"0": {"stop_token_ids": [151645]}},
-        },
-    )
-    req_state = _duplex_request_state(orchestrator, session, stage_id=0)
-    assert req_state is not None
-    assert req_state.sampling_params_list[0].max_tokens == 2
-
-    await _handle_duplex(
-        orchestrator,
-        SignalDuplexTurnMessage(
-            control_id="update-policy",
-            fence=fence,
-            session_id=fence.session_id,
-            event="session.update",
-            runtime_config={
-                "duplex_stage_max_tokens": {"0": 7},
-                "duplex_stage_sampling_params": {"0": {"stop_token_ids": [151705]}},
-            },
-        ),
-    )
-    assert rpc_q.get_nowait().ok is True
-
-    await _handle_duplex(
-        orchestrator,
-        AppendDuplexInputMessage(
-            control_id="append-updated-policy",
-            fence=fence,
-            session_id=fence.session_id,
-            mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
-            payload={"is_speech": True},
-        ),
-    )
-
-    assert rpc_q.get_nowait().ok is True
-    assert req_state.sampling_params_list[0].max_tokens == 7
-    assert req_state.sampling_params_list[0].stop_token_ids == [151705]
-    submitted_request = stage0.add_request_calls[0][0]
-    assert submitted_request.sampling_params.stop_token_ids == [151705]
-    assert submitted_request.sampling_params.max_tokens == 7
-
-
-@pytest.mark.asyncio
-async def test_duplex_invalid_session_update_preserves_previous_config() -> None:
-    stage0 = FakeStageClient(stage_type="llm", final_output=True)
-    rpc_q: asyncio.Queue = asyncio.Queue()
-    orchestrator = Orchestrator(
-        request_async_queue=asyncio.Queue(),
-        output_async_queue=asyncio.Queue(),
-        rpc_async_queue=rpc_q,
-        stage_pools=_build_stage_pools([[stage0]]),
-        duplex_runtime_extension=MiniCPMO45DuplexRuntimeExtension(),
-        enable_duplex_control=True,
-    )
-    fence = DuplexFence("sid-invalid-update")
-    original_runtime_config = {
-        "duplex_stage_sampling_params": {"0": {"stop_token_ids": [151645]}},
-    }
-    session = orchestrator.duplex_sessions.open_session(
-        fence,
-        runtime_config=original_runtime_config,
-    )
-
-    await _handle_duplex(
-        orchestrator,
-        SignalDuplexTurnMessage(
-            control_id="invalid-update",
-            fence=fence,
-            session_id=fence.session_id,
-            event="session.update",
-            runtime_config={
-                "duplex_stage_sampling_params": {"0": {"stop_token_ids": 123}},
-            },
-        ),
-    )
-
-    result = rpc_q.get_nowait()
-    assert result.ok is False
-    assert session.runtime_config == original_runtime_config
-    assert session.config_generation == 0
-
-
-@pytest.mark.asyncio
-async def test_duplex_arbitrary_non_cancel_signal_is_rejected() -> None:
-    rpc_q: asyncio.Queue = asyncio.Queue()
-    orchestrator = Orchestrator(
-        request_async_queue=asyncio.Queue(),
-        output_async_queue=asyncio.Queue(),
-        rpc_async_queue=rpc_q,
-        stage_pools=[],
-        enable_duplex_control=True,
-    )
-    fence = DuplexFence("sid-unsupported-signal")
-    orchestrator.duplex_sessions.open_session(fence)
-
-    await _handle_duplex(
-        orchestrator,
-        SignalDuplexTurnMessage(
-            control_id="unsupported-signal",
-            fence=fence,
-            session_id=fence.session_id,
-            event="turn.end",
-        ),
-    )
-
-    result = rpc_q.get_nowait()
-    assert result.ok is False
-    assert "unsupported duplex runtime signal" in result.stage_results[0]["result"]["error"]
-
-
-@pytest.mark.asyncio
-async def test_duplex_cancel_rejects_late_old_append_and_accepts_next_epoch() -> None:
-    stage0 = FakeStageClient(stage_type="llm", final_output=True)
-    stage_pools = _build_stage_pools(
-        [[stage0]],
-        output_processors=[FakeOutputProcessor()],
-        stage_vllm_configs=[SimpleNamespace(model_config=SimpleNamespace(max_model_len=64))],
-    )
-    rpc_q: asyncio.Queue = asyncio.Queue()
-    orchestrator = Orchestrator(
-        request_async_queue=asyncio.Queue(),
-        output_async_queue=asyncio.Queue(),
-        rpc_async_queue=rpc_q,
-        stage_pools=stage_pools,
-        duplex_runtime_extension=MiniCPMO45DuplexRuntimeExtension(),
-        enable_duplex_control=True,
-    )
-    cancelled_fence = DuplexFence("sid-cancel-late-append")
-    next_fence = DuplexFence("sid-cancel-late-append", epoch=1)
-    session = orchestrator.duplex_sessions.open_session(
-        cancelled_fence,
-        capabilities=DuplexRuntimeCapabilities(
-            input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK},
-        ),
-    )
-
-    await _handle_duplex(
-        orchestrator,
-        SignalDuplexTurnMessage(
-            control_id="cancel-old-fence",
-            fence=cancelled_fence,
-            next_fence=next_fence,
-            session_id=session.session_id,
-            event="input.cancel",
-        ),
-    )
-
-    cancel_result = rpc_q.get_nowait()
-    assert cancel_result.ok is True
-    assert session.fence == next_fence
-
-    await _handle_duplex(
-        orchestrator,
-        AppendDuplexInputMessage(
-            control_id="late-old-append",
-            fence=cancelled_fence,
-            session_id=session.session_id,
-            mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
-            payload={"is_speech": True},
-        ),
-    )
-
-    stale_result = rpc_q.get_nowait()
-    assert stale_result.ok is False
-    assert stage0.add_request_calls == []
-    assert session.stage_bindings == {}
-
-    await _handle_duplex(
-        orchestrator,
-        AppendDuplexInputMessage(
-            control_id="next-epoch-append",
-            fence=next_fence,
-            session_id=session.session_id,
-            mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
-            payload={"is_speech": True},
-        ),
-    )
-
-    next_result = rpc_q.get_nowait()
-    assert next_result.ok is True
-    assert len(stage0.add_request_calls) == 1
-    assert session.stage_bindings[0].fence == next_fence
-
-
-@pytest.mark.asyncio
-async def test_duplex_append_updates_bridge_turn_id_on_long_lived_stage0_request() -> None:
-    stage0 = FakeStageClient(stage_type="llm", final_output=True)
-    stage_pools = _build_stage_pools(
-        [[stage0]],
-        output_processors=[FakeOutputProcessor()],
-        stage_vllm_configs=[SimpleNamespace(model_config=SimpleNamespace(max_model_len=64))],
-    )
-    orchestrator = Orchestrator(
-        request_async_queue=asyncio.Queue(),
-        output_async_queue=asyncio.Queue(),
-        rpc_async_queue=asyncio.Queue(),
-        stage_pools=stage_pools,
-        duplex_runtime_extension=MiniCPMO45DuplexRuntimeExtension(),
-        enable_duplex_control=True,
-    )
-    session = orchestrator.duplex_sessions.open_session(
-        DuplexFence("sid-bridge-turn"),
-        capabilities=DuplexRuntimeCapabilities(
-            input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK},
-        ),
-        session_config={
-            "voice": "test",
-        },
-        runtime_config={
-            "duplex_stage_sampling_params": {
-                "0": {"stop_token_ids": [151645]},
-            },
-        },
-    )
-
-    await _handle_duplex(
-        orchestrator,
-        AppendDuplexInputMessage(
-            control_id="append-1",
-            fence=DuplexFence("sid-bridge-turn"),
-            session_id="sid-bridge-turn",
-            mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
-            payload={"is_speech": True},
-        ),
-    )
-    req_state1 = _duplex_request_state(orchestrator, session, stage_id=0)
-    assert req_state1 is not None
-    duplex_state1 = req_state1.streaming.bridge_states["duplex"]
-    assert duplex_state1["session_id"] == "sid-bridge-turn"
-    assert duplex_state1["epoch"] == 0
-    assert duplex_state1["turn_id"] == 0
-    assert duplex_state1["session_config"] == session.session_config
-    assert req_state1.sampling_params_list[0].stop_token_ids == [151645]
-    submitted_request = stage0.add_request_calls[0][0]
-    assert submitted_request.sampling_params.stop_token_ids == [151645]
-    assert submitted_request.sampling_params.max_tokens == 1
-
-    await _handle_duplex(
-        orchestrator,
-        AppendDuplexInputMessage(
-            control_id="append-2",
-            fence=DuplexFence("sid-bridge-turn", turn_id=1, response_seq=1),
-            session_id="sid-bridge-turn",
-            mode=DuplexInputMode.APPEND_AUDIO_CHUNK.value,
-            payload={"is_speech": True, "new_user_turn": True},
-        ),
-    )
-    req_state2 = _duplex_request_state(orchestrator, session, stage_id=0)
-    assert req_state2 is req_state1
-    duplex_state2 = req_state2.streaming.bridge_states["duplex"]
-    assert duplex_state2["turn_id"] == 1
-    assert duplex_state2["epoch"] == 0
-    expected_request_id = duplex_resource_request_id(DuplexFence("sid-bridge-turn"), "stage0")
-    assert [call[0].request_id for call in stage0.add_request_calls] == [
-        expected_request_id,
-        expected_request_id,
-    ]
-
-
 # ---------------------------------------------------------------------------
 # Multi-replica tests
 # ---------------------------------------------------------------------------
@@ -2200,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:
@@ -2641,61 +1961,6 @@ async def test_stage_pool_process_llm_raw_outputs_mutates_iteration_stats() -> N
     assert iteration_stats.num_generation_tokens == 3
 
 
-@pytest.mark.asyncio
-async def test_duplex_reaper_loop_waits_between_ticks():
-    class _Plane:
-        def __init__(self) -> None:
-            self.calls = 0
-
-        async def reap_expired(self) -> int:
-            self.calls += 1
-            return 0
-
-    orchestrator = object.__new__(Orchestrator)
-    orchestrator.duplex_control_plane = _Plane()
-    orchestrator._duplex_reaper_interval_s = 0.01
-    orchestrator._shutdown_event = asyncio.Event()
-
-    task = asyncio.create_task(orchestrator._duplex_reaper_loop())
-    await asyncio.sleep(0.035)
-    orchestrator._shutdown_event.set()
-    await task
-
-    assert 2 <= orchestrator.duplex_control_plane.calls <= 5
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("first_cleanup_delay", [0.0, 0.05], ids=["immediate", "delayed"])
-async def test_duplex_reaper_loop_survives_one_cleanup_failure(first_cleanup_delay: float) -> None:
-    recovered = asyncio.Event()
-
-    class _Plane:
-        def __init__(self) -> None:
-            self.calls = 0
-
-        async def reap_expired(self) -> int:
-            self.calls += 1
-            if self.calls == 1:
-                await asyncio.sleep(first_cleanup_delay)
-                raise RuntimeError("transient cleanup failure")
-            recovered.set()
-            return 0
-
-    orchestrator = object.__new__(Orchestrator)
-    orchestrator.duplex_control_plane = _Plane()
-    orchestrator._duplex_reaper_interval_s = 0.01
-    orchestrator._shutdown_event = asyncio.Event()
-
-    task = asyncio.create_task(orchestrator._duplex_reaper_loop())
-    try:
-        # Wait for recovery itself, including when cleanup exceeds the old 35 ms window.
-        await asyncio.wait_for(recovered.wait(), timeout=5.0)
-        assert orchestrator.duplex_control_plane.calls >= 2
-    finally:
-        orchestrator._shutdown_event.set()
-        await asyncio.wait_for(task, timeout=5.0)
-
-
 @pytest.mark.asyncio
 async def test_abort_retry_does_not_repeat_successful_stage_abort():
     class _Pool:
@@ -2736,45 +2001,58 @@ async def test_abort_retry_does_not_repeat_successful_stage_abort():
 
 
 @pytest.mark.asyncio
-async def test_request_cleanup_failure_is_deferred_to_control_plane():
-    class _FailingPool:
-        async def abort_requests(self, request_ids: list[str]) -> None:
-            raise RuntimeError("stage abort failed")
+async def test_duplex_session_request_error_finish_is_delivered_as_request_error() -> None:
+    """A session-owned request the scheduler finished with FinishReason.ERROR
+    (e.g. its prompt could not grow past max_model_len) must reach the
+    session's consumer as a request-scoped error, not vanish: its terminal
+    outputs are not processed like other requests, and the output processor
+    may already have dropped the request state."""
+    output_queue: asyncio.Queue = asyncio.Queue()
+    orchestrator = Orchestrator(
+        request_async_queue=asyncio.Queue(),
+        output_async_queue=output_queue,
+        rpc_async_queue=asyncio.Queue(),
+        stage_pools=[],
+    )
+    duplex_state = OrchestratorRequestState(request_id="duplex-req", session_owned=True)
+    plain_state = OrchestratorRequestState(request_id="plain-req")
+    reason = "context_length_exceeded: streaming session prompt would grow to 8220 tokens, above max_model_len 8192"
 
-        def release_bindings(self, request_ids: list[str]) -> None:
-            pass
+    await orchestrator._report_duplex_session_request_error(
+        0,
+        0,
+        OmniEngineCoreOutput(
+            request_id="duplex-req", new_token_ids=[], finish_reason=FinishReason.ERROR, stop_reason=reason
+        ),
+        duplex_state,
+    )
+    error = output_queue.get_nowait()
+    assert isinstance(error, ErrorMessage)
+    assert error.request_id == "duplex-req"
+    assert error.stage_id == 0
+    assert error.fatal is False
+    assert error.error == reason
 
-    class _Plane:
-        def __init__(self) -> None:
-            self.deferred: list[str] = []
-            self.finalized: list[str] = []
-
-        def close_sessions_for_request_ids(self, request_ids: list[str], **kwargs):
-            assert kwargs == {"abort": True, "cleanup_in_progress": True}
-            return {"sid-cleanup": ["req-a"]}
-
-        def defer_request_cleanups(self, session_ids: list[str]) -> None:
-            self.deferred.extend(session_ids)
-
-        def finalize_closed_sessions(self, session_ids: list[str]) -> None:
-            self.finalized.extend(session_ids)
-
-    from vllm_omni.engine.cfg_companion_tracker import CfgCompanionTracker
-
-    orchestrator = object.__new__(Orchestrator)
-    orchestrator.stage_pools = [_FailingPool()]
-    orchestrator.duplex_control_plane = _Plane()
-    orchestrator._pd_kv_params = {}
-    orchestrator.request_states = {}
-    orchestrator._running_counter = None
-    orchestrator._cfg_tracker = CfgCompanionTracker()
-
-    with pytest.raises(RuntimeError, match="stage abort failed"):
-        await orchestrator._cleanup_request_ids(
-            ["req-a"],
-            abort=True,
-            close_duplex_sessions=True,
-        )
-
-    assert orchestrator.duplex_control_plane.deferred == ["sid-cleanup"]
-    assert orchestrator.duplex_control_plane.finalized == []
+    # An ordinary segment stop, a segment-finished error and a request that is
+    # not session-owned produce nothing.
+    await orchestrator._report_duplex_session_request_error(
+        0,
+        0,
+        OmniEngineCoreOutput(request_id="duplex-req", new_token_ids=[], finish_reason=FinishReason.STOP),
+        duplex_state,
+    )
+    await orchestrator._report_duplex_session_request_error(
+        0,
+        0,
+        OmniEngineCoreOutput(
+            request_id="duplex-req", new_token_ids=[], finish_reason=FinishReason.ERROR, is_segment_finished=True
+        ),
+        duplex_state,
+    )
+    await orchestrator._report_duplex_session_request_error(
+        0,
+        0,
+        OmniEngineCoreOutput(request_id="plain-req", new_token_ids=[], finish_reason=FinishReason.ERROR),
+        plain_state,
+    )
+    assert output_queue.empty()
diff --git a/tests/engine/test_orchestrator_error_handling.py b/tests/engine/test_orchestrator_error_handling.py
index eaa246072..b8949786e 100644
--- a/tests/engine/test_orchestrator_error_handling.py
+++ b/tests/engine/test_orchestrator_error_handling.py
@@ -1054,7 +1054,7 @@ async def test_streaming_input_processor_client_error_does_not_forward_terminal_
         final_stage_id=1,
     )
     state.streaming.enabled = True
-    assert state.duplex_identity is None
+    assert state.session_owned is False
     orchestrator.request_states[state.request_id] = state
     try:
         await orchestrator._route_output(0, 0, _build_request_output(state.request_id), state, stage_metrics=None)
@@ -1074,34 +1074,14 @@ async def test_streaming_input_processor_client_error_does_not_forward_terminal_
             q.close()
 
 
-@pytest.mark.asyncio
-async def test_duplex_input_processor_failure_is_request_scoped(orchestrator_factory, monkeypatch) -> None:
-    class FailingStage(FakeStageClient):
-        def process_engine_inputs(self, *_args, **_kwargs):
-            raise ValueError("No latent or hidden_states found in thinker output")
-
-    fixture = orchestrator_factory(
-        [FakeStageClient(stage_type="llm"), FailingStage(stage_type="llm", final_output=True)]
-    )
-    state = OrchestratorRequestState(
-        request_id="bad",
-        prompt=SimpleNamespace(request_id="bad", prompt_token_ids=[1]),
-        sampling_params_list=[_sampling_params(), _sampling_params()],
-        final_stage_id=1,
-        duplex_identity=SimpleNamespace(),
-    )
-
-    async def no_cleanup(*_args, **_kwargs):
-        pass
-
-    monkeypatch.setattr(fixture.orchestrator, "_cleanup_request_ids", no_cleanup)
-    try:
-        await fixture.orchestrator._forward_to_next_stage_unguarded("bad", 0, _build_request_output("raw"), state)
-        error = await _wait_for_error_message(fixture, request_id="bad")
-        assert error.fatal is False
-    finally:
-        fixture.request_sync_q.put_nowait(ShutdownRequestMessage())
-        fixture.thread.join(timeout=5)
+# ``test_duplex_input_processor_failure_is_request_scoped`` lived here upstream,
+# where one Orchestrator served both turn-based and duplex requests. Duplex
+# request ownership now belongs to DuplexOrchestrator, and the base
+# ``_handle_forward_failure`` deliberately absorbs nothing, so the equivalent
+# assertion is
+# ``tests/engine/test_duplex_orchestrator.py::test_forward_failure_closes_the_owning_session``
+# -- which also checks the stage abort, the session teardown and the
+# error-before-session.expired ordering.
 
 
 @pytest.mark.asyncio
diff --git a/tests/engine/test_orchestrator_kv_sender_info.py b/tests/engine/test_orchestrator_kv_sender_info.py
index e3f58c129..25e662d27 100644
--- a/tests/engine/test_orchestrator_kv_sender_info.py
+++ b/tests/engine/test_orchestrator_kv_sender_info.py
@@ -1,13 +1,22 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 import asyncio
+from collections.abc import Callable
 from types import SimpleNamespace
+from typing import Any
 
 import pytest
 from vllm import SamplingParams
+from vllm.v1.engine.core_client import AsyncMPClient, DPLBAsyncMPClient
 
 from vllm_omni.engine.cfg_companion_tracker import CfgCompanionTracker
 from vllm_omni.engine.messages import OutputMessage
 from vllm_omni.engine.orchestrator import Orchestrator, OrchestratorRequestState
-from vllm_omni.engine.stage_engine_core_client import StageEngineCoreClient
+from vllm_omni.engine.stage_engine_core_client import (
+    DPLBStageEngineCoreClient,
+    StageEngineCoreClient,
+)
 from vllm_omni.engine.stage_pool import StagePool
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 
@@ -28,7 +37,7 @@ class _DummySenderStage:
 class _DummyDiffusionStage:
     stage_type = "diffusion"
     final_output = True
-    custom_process_input_func = None
+    custom_process_input_func: Callable[..., Any] | None = None
 
     def __init__(self, engine_input_source=None):
         self.engine_input_source = engine_input_source or [0]
@@ -54,6 +63,97 @@ def _build_sender_pool(stage_id: int, sender_info: dict[str, object]) -> StagePo
     )
 
 
+@pytest.mark.parametrize(
+    ("client_class", "base_client_class"),
+    [
+        (StageEngineCoreClient, AsyncMPClient),
+        (DPLBStageEngineCoreClient, DPLBAsyncMPClient),
+    ],
+)
+def test_stage_engine_core_client_builds_payload_sender_info_after_base_init(
+    monkeypatch, client_class, base_client_class
+):
+    vllm_config = SimpleNamespace(
+        model_config=SimpleNamespace(
+            omni_kv_config=None,
+            hf_config=None,
+            stage_connector_config=None,
+        )
+    )
+    metadata = SimpleNamespace(
+        stage_id=0,
+        replica_id=0,
+        stage_type="llm",
+        model_stage="main",
+        is_comprehension=False,
+        requires_multimodal_data=False,
+        engine_input_source=[],
+        final_output=False,
+        final_output_type=None,
+        default_sampling_params=None,
+        prompt_transform_func=None,
+        prompt_expand_func=None,
+        custom_process_input_func=None,
+    )
+
+    def fake_base_init(self, config, *_args, **_kwargs):
+        self.vllm_config = config
+        self.resources = SimpleNamespace(engine_dead=False)
+
+    monkeypatch.setattr(base_client_class, "__init__", fake_base_init)
+
+    client = client_class(vllm_config, object, metadata=metadata)
+
+    assert client.vllm_config is vllm_config
+    assert client.get_payload_sender_info() is None
+
+
+@pytest.mark.parametrize("outgoing", [False, True])
+@pytest.mark.parametrize("base_port", [None, 48000])
+def test_payload_sender_endpoint_matches_resolver_with_unequal_replicas(outgoing, base_port):
+    from vllm_omni.distributed.omni_connectors.utils.config import ConnectorSpec
+    from vllm_omni.distributed.omni_connectors.utils.initialization import resolve_connector_spec
+
+    edge = {"host": "10.0.0.2", "from_stage": 1}
+    if base_port is not None:
+        edge["zmq_port"] = base_port
+    extra = (
+        {
+            "role": "receiver",
+            "host": "10.0.0.1",
+            "zmq_port": 47000,
+            "from_stage": 0,
+            "outgoing": edge,
+        }
+        if outgoing
+        else {"role": "sender", **edge}
+    )
+    client = object.__new__(StageEngineCoreClient)
+    client.stage_id = 1
+    client.replica_id = 3
+    client.vllm_config = SimpleNamespace(
+        model_config=SimpleNamespace(stage_connector_config={"name": "NixlConnector", "extra": extra})
+    )
+    producer = resolve_connector_spec(
+        ConnectorSpec(name="NixlConnector", extra=extra),
+        stage_id=1,
+        role=extra["role"],
+        replica_id=client.replica_id,
+    )
+    consumer = resolve_connector_spec(
+        ConnectorSpec(name="NixlConnector", extra=edge), stage_id=2, role="receiver", replica_id=7
+    )
+
+    sender_info = client._build_payload_sender_info()
+
+    assert sender_info == {
+        "host": "10.0.0.2",
+        "zmq_port": (50051 if base_port is None else base_port) + 3 * 1024 + 1,
+    }
+    assert sender_info["zmq_port"] == producer.extra["zmq_port"]
+    assert sender_info["zmq_port"] != consumer.extra["sender_zmq_port"]
+
+
 def test_stage_engine_core_client_builds_kv_sender_info_from_tcp_address():
     client = object.__new__(StageEngineCoreClient)
     client.stage_id = 0
@@ -259,3 +359,122 @@ def test_prewarm_diffusion_attaches_kv_sender_info():
         0: {"host": "10.0.0.3", "zmq_port": 50151},
     }
     assert req_state.stage_submit_ts[1] > 0
+
+
+def test_prewarm_submits_bound_payload_endpoint_for_concurrent_replicas():
+    orchestrator = object.__new__(Orchestrator)
+    endpoints = {"a": {"host": "10.0.0.2", "zmq_port": 52099}, "b": {"host": "10.0.0.3", "zmq_port": 54147}}
+    source = SimpleNamespace(
+        get_bound_client=lambda key: SimpleNamespace(get_payload_sender_info=lambda: endpoints[key]),
+        get_bound_replica_id=lambda key: {"a": 2, "b": 4}[key],
+    )
+    submitted = {}
+
+    async def submit(key, state, request, **kwargs):
+        await asyncio.sleep(0)
+        submitted[key] = request
+
+    target = SimpleNamespace(
+        stage_type="llm",
+        stage_client=SimpleNamespace(engine_input_source=[0]),
+        stage_vllm_config=SimpleNamespace(model_config=SimpleNamespace(hf_config=None, max_model_len=64)),
+        submit_initial=submit,
+        get_bound_replica_id=lambda key: {"a": 7, "b": 1}[key],
+    )
+    orchestrator.stage_pools = [source, target]
+    orchestrator._stage_receives_async_chunks = lambda stage: True
+    orchestrator._record_duplex_stage_submission = lambda *args: None
+    orchestrator._emit_tx_edge = lambda **kwargs: None
+
+    async def dispatch(callback, **kwargs):
+        await callback()
+        return True
+
+    orchestrator._dispatch_or_fail_request = dispatch
+
+    async def run():
+        await asyncio.gather(
+            *[
+                orchestrator._prewarm_async_chunk_stages(
+                    key,
+                    SimpleNamespace(prompt_token_ids=[1]),
+                    OrchestratorRequestState(
+                        request_id=key,
+                        prompt={},
+                        sampling_params_list=[SamplingParams(), SamplingParams()],
+                        final_stage_id=1,
+                    ),
+                )
+                for key in endpoints
+            ]
+        )
+
+    asyncio.run(run())
+    from vllm_omni.engine import OmniEngineCoreRequest
+
+    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_segment_stage_keying.py b/tests/engine/test_orchestrator_segment_stage_keying.py
index 5d3952e4b..9c5290245 100644
--- a/tests/engine/test_orchestrator_segment_stage_keying.py
+++ b/tests/engine/test_orchestrator_segment_stage_keying.py
@@ -2,10 +2,13 @@
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Streaming segment-boundary state must be keyed by stage.
 
-``Orchestrator._orchestration_loop`` polls every stage into the same
+``OrchestratorBase._orchestration_loop`` polls every stage into the same
 ``OrchestratorRequestState``. While the segment-boundary fields lived in a single
 flat slot per request, whichever stage polled most recently overwrote the others,
 and the per-stage consumers then read back a different stage's boundary.
+
+The duplex consumer of the per-stage segment (``DuplexOrchestrator``'s output
+context) is covered in ``test_duplex_orchestrator.py``.
 """
 
 from __future__ import annotations
@@ -15,8 +18,6 @@ from dataclasses import dataclass, field
 import pytest
 from vllm.sampling_params import SamplingParams
 
-from vllm_omni.engine.duplex.contracts import DuplexRequestIdentity
-from vllm_omni.engine.duplex.messages import DuplexFence
 from vllm_omni.engine.orchestrator import (
     Orchestrator,
     OrchestratorRequestState,
@@ -54,22 +55,19 @@ class _RecordingPool:
         return _StageMetrics()
 
 
-def _duplex_req_state(request_id: str = "req-duplex") -> OrchestratorRequestState:
+def _streaming_req_state(request_id: str = "req-streaming") -> OrchestratorRequestState:
     req_state = OrchestratorRequestState(
         request_id=request_id,
         sampling_params_list=[SamplingParams(max_tokens=1), SamplingParams(max_tokens=1)],
         final_stage_id=TALKER_STAGE,
+        session_owned=True,
     )
     req_state.streaming.enabled = True
-    req_state.duplex_identity = DuplexRequestIdentity(
-        session_id="session-1",
-        fence=DuplexFence(session_id="session-1"),
-    )
     return req_state
 
 
-def test_duplex_output_context_reads_only_its_own_stage_segment() -> None:
-    req_state = _duplex_req_state()
+def test_segment_accessor_reads_only_its_own_stage() -> None:
+    req_state = _streaming_req_state()
     req_state.streaming.segments[THINKER_STAGE] = StreamingSegmentState(
         finished=True,
         token_ids=[11, 22],
@@ -78,26 +76,28 @@ def test_duplex_output_context_reads_only_its_own_stage_segment() -> None:
     # The talker polls after the thinker and is still mid-segment.
     req_state.streaming.segments[TALKER_STAGE] = StreamingSegmentState(finished=False)
 
-    thinker = Orchestrator._duplex_output_context(req_state, stage_id=THINKER_STAGE)
-    talker = Orchestrator._duplex_output_context(req_state, stage_id=TALKER_STAGE)
-
-    assert thinker is not None
-    assert talker is not None
+    thinker = req_state.streaming.segment(THINKER_STAGE)
+    talker = req_state.streaming.segment(TALKER_STAGE)
 
     # These are the assertions that fail on the flat field: the talker is written
     # second, so the thinker loses its boundary to whichever stage polled last.
-    assert thinker.segment_finished is True
-    assert thinker.segment_token_ids == (11, 22)
-    assert thinker.segment_output_metadata == {"stage": "thinker"}
+    assert thinker.finished is True
+    assert thinker.token_ids == [11, 22]
+    assert thinker.output_metadata == {"stage": "thinker"}
 
-    assert talker.segment_finished is False
-    assert talker.segment_token_ids == ()
-    assert talker.segment_output_metadata == {}
+    assert talker.finished is False
+    assert talker.token_ids == []
+    assert talker.output_metadata == {}
+
+    # A stage that never reported a boundary gets a fresh, unshared segment.
+    unreported = req_state.streaming.segment(2)
+    unreported.output_metadata["poisoned"] = True
+    assert req_state.streaming.segment(2).output_metadata == {}
 
 
 @pytest.mark.asyncio
 async def test_segment_boundary_on_one_stage_does_not_build_metrics_on_another() -> None:
-    req_state = _duplex_req_state()
+    req_state = _streaming_req_state()
     req_state.streaming.segments[THINKER_STAGE] = StreamingSegmentState(finished=True)
 
     talker_pool = _RecordingPool()
diff --git a/tests/engine/test_orchestrator_stage_input_bridge.py b/tests/engine/test_orchestrator_stage_input_bridge.py
index 68836e2a4..842824c2d 100644
--- a/tests/engine/test_orchestrator_stage_input_bridge.py
+++ b/tests/engine/test_orchestrator_stage_input_bridge.py
@@ -7,23 +7,17 @@ import asyncio
 import queue
 from types import SimpleNamespace
 from typing import Any
-from unittest.mock import ANY, AsyncMock, MagicMock
+from unittest.mock import AsyncMock, MagicMock
 
 import janus
 import pytest
 from vllm.outputs import CompletionOutput, RequestOutput
 from vllm.sampling_params import SamplingParams
 
-from vllm_omni.engine.duplex.contracts import (
-    DuplexStageRequestContext,
-    DuplexStageSubmission,
-)
-from vllm_omni.engine.duplex.messages import DuplexFence
 from vllm_omni.engine.orchestrator import (
     Orchestrator,
     OrchestratorRequestState,
     StreamingSegmentState,
-    _OrchestratorDuplexStagePort,
 )
 from vllm_omni.engine.stage_pool import StagePool
 
@@ -104,9 +98,13 @@ class FakeInputProcessor:
 
 
 class FakePrewarmPool:
+    """Single-replica pool double that binds requests only on submission."""
+
     stage_type = "llm"
 
     def __init__(self, role: str) -> None:
+        self.stage_client = SimpleNamespace()
+        self._bound_request_ids: set[str] = set()
         self.stage_vllm_config = SimpleNamespace(
             model_config=SimpleNamespace(
                 max_model_len=64,
@@ -115,70 +113,16 @@ class FakePrewarmPool:
         )
         self.submitted: list[Any] = []
 
-    async def submit_initial(self, _request_id, _req_state, request, prompt_text=None):
+    async def submit_initial(self, request_id, _req_state, request, prompt_text=None):
         self.submitted.append(request)
+        self._bound_request_ids.add(request_id)
         return 0
 
-    def get_bound_replica_id(self, _request_id):
-        return 0
+    def get_bound_replica_id(self, request_id):
+        return 0 if request_id in self._bound_request_ids else None
 
-
-def _duplex_stage_port_submission():
-    stage_pools = []
-    for stage_id in range(3):
-        pool = SimpleNamespace(
-            stage_client=SimpleNamespace(default_sampling_params=SamplingParams(max_tokens=1)),
-            stage_vllm_config=SimpleNamespace(model_config=SimpleNamespace(max_model_len=64)),
-            submit_initial=AsyncMock(return_value=stage_id + 10),
-            submit_update=AsyncMock(return_value=stage_id + 20),
-        )
-        stage_pools.append(pool)
-    request_states: dict[str, OrchestratorRequestState] = {}
-    prewarm = AsyncMock()
-    port = _OrchestratorDuplexStagePort(
-        stage_pools=stage_pools,
-        request_states=request_states,
-        running_counter=None,
-        cleanup_request_ids=AsyncMock(),
-        async_chunk=True,
-        prewarm_async_chunk_stages=prewarm,
-    )
-    context = DuplexStageRequestContext(
-        request_id="req-duplex",
-        session_id="session-duplex",
-        fence=DuplexFence("session-duplex"),
-        stage_id=0,
-        final_stage_id=2,
-        config_generation=0,
-        sampling_params=tuple(SamplingParams(max_tokens=1) for _ in range(3)),
-    )
-    port.ensure_request(context)
-    submission = DuplexStageSubmission(
-        context=context,
-        prompt={"prompt_token_ids": [1, 2]},
-        already_submitted=False,
-    )
-    return port, stage_pools, request_states, prewarm, submission
-
-
-def test_duplex_bridge_state_catches_up_after_serving_turn_boundary() -> None:
-    port, _, request_states, _, submission = _duplex_stage_port_submission()
-    request_state = request_states[submission.context.request_id]
-    bridge_state = request_state.streaming.bridge_states["duplex"]
-    bridge_state["model_turn_id"] = 0
-
-    next_context = DuplexStageRequestContext(
-        request_id=submission.context.request_id,
-        session_id=submission.context.session_id,
-        fence=DuplexFence(submission.context.session_id, turn_id=1),
-        stage_id=submission.context.stage_id,
-        final_stage_id=submission.context.final_stage_id,
-        config_generation=submission.context.config_generation,
-        sampling_params=submission.context.sampling_params,
-    )
-    port.ensure_request(next_context)
-
-    assert bridge_state["model_turn_id"] == 1
+    def get_bound_client(self, request_id):
+        return self.stage_client if self.get_bound_replica_id(request_id) is not None else None
 
 
 def _request_output(request_id: str) -> RequestOutput:
@@ -261,20 +205,22 @@ async def test_forward_text_prompt_uses_target_stage_input_processor() -> None:
 
 
 @pytest.mark.asyncio
-async def test_async_prewarm_skips_outgoing_only_stage() -> None:
+@pytest.mark.parametrize("payload_sender_info", [None, {"host": "10.0.0.2", "zmq_port": 52099}])
+async def test_async_prewarm_skips_outgoing_only_stage(payload_sender_info) -> None:
     orchestrator = object.__new__(Orchestrator)
     stage0 = FakePrewarmPool("sender")
     stage1 = FakePrewarmPool("sender")
     stage2 = FakePrewarmPool("receiver")
+    if payload_sender_info is not None:
+        stage1.stage_client.get_payload_sender_info = MagicMock(return_value=payload_sender_info)
     orchestrator.stage_pools = [stage0, stage1, stage2]
     orchestrator._emit_tx_edge = lambda **_kwargs: None
-    orchestrator._record_duplex_stage_submission = MagicMock()
+    orchestrator._on_stage_submitted = MagicMock()
     req_state = OrchestratorRequestState(
         request_id="req-prewarm",
         prompt={"prompt_token_ids": [1, 2]},
         sampling_params_list=[SamplingParams(max_tokens=1) for _ in range(3)],
         final_stage_id=2,
-        duplex_identity=SimpleNamespace(),
     )
 
     prewarmed = await orchestrator._prewarm_async_chunk_stages(
@@ -285,10 +231,17 @@ async def test_async_prewarm_skips_outgoing_only_stage() -> None:
 
     assert prewarmed is True
     assert stage1.submitted == []
+    assert stage1.get_bound_client("req-prewarm") is None
     assert len(stage2.submitted) == 1
+    assert stage2.get_bound_client("req-prewarm") is stage2.stage_client
+    assert stage2.submitted[0].payload_sender_info == payload_sender_info
+    if payload_sender_info is not None:
+        stage1.stage_client.get_payload_sender_info.assert_called_once_with()
+    assert stage2.submitted[0].external_req_id == "req-prewarm"
+    assert stage2.submitted[0].resumable is True
     assert 1 not in req_state.stage_submit_ts
     assert 2 in req_state.stage_submit_ts
-    orchestrator._record_duplex_stage_submission.assert_called_once_with(
+    orchestrator._on_stage_submitted.assert_called_once_with(
         2,
         "req-prewarm",
         0,
@@ -296,42 +249,6 @@ async def test_async_prewarm_skips_outgoing_only_stage() -> None:
     )
 
 
-@pytest.mark.asyncio
-async def test_duplex_prewarm_runs_after_first_stage0_submission() -> None:
-    port, stage_pools, request_states, prewarm, submission = _duplex_stage_port_submission()
-    prewarm.return_value = True
-
-    result = await port.submit(submission)
-
-    assert result.stage_id == 0
-    stage_pools[0].submit_initial.assert_awaited_once()
-    prewarm.assert_awaited_once_with("req-duplex", ANY, request_states["req-duplex"])
-
-
-@pytest.mark.asyncio
-async def test_duplex_submit_bails_out_when_prewarm_failed_the_request() -> None:
-    """A failed prewarm has already aborted the request and popped its state.
-
-    Returning a success result here would hand the control plane a replica for a
-    request that no longer exists, and the trailing bookkeeping would re-register
-    a running counter the cleanup just released -- a leak that never decrements.
-    """
-    port, stage_pools, request_states, prewarm, submission = _duplex_stage_port_submission()
-    counter = MagicMock()
-    port._running_counter = counter
-    prewarm.return_value = False
-    request_state = request_states["req-duplex"]
-
-    with pytest.raises(RuntimeError, match="prewarm failed"):
-        await port.submit(submission)
-
-    prewarm.assert_awaited_once()
-    assert request_state.duplex_stage_fences == {}
-    assert request_state.stage_submit_ts == {}
-    assert request_state.running_counter_registered is False
-    counter.increment.assert_not_called()
-
-
 @pytest.mark.asyncio
 async def test_async_route_forwards_to_outgoing_only_stage() -> None:
     orchestrator = object.__new__(Orchestrator)
diff --git a/tests/engine/test_output_metadata_snapshots.py b/tests/engine/test_output_metadata_snapshots.py
new file mode 100644
index 000000000..9670994c4
--- /dev/null
+++ b/tests/engine/test_output_metadata_snapshots.py
@@ -0,0 +1,143 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Snapshot metadata must not accumulate as if it were generated content."""
+
+import pytest
+import torch
+from vllm.outputs import PoolingRequestOutput
+from vllm.sampling_params import RequestOutputKind
+from vllm.v1.engine import FinishReason
+
+from vllm_omni.outputs.mm_outputs import MultimodalPayload
+from vllm_omni.outputs.output_modality import OutputModality
+from vllm_omni.outputs.output_processor import MultimodalOutputProcessor, OmniRequestState
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+RATE_KEYS = ("sr", "sample_rate", "audio_sample_rate")
+
+
+def _state(kind: RequestOutputKind) -> OmniRequestState:
+    return OmniRequestState(
+        request_id="audio",
+        external_req_id="audio",
+        parent_req=None,
+        request_index=0,
+        lora_request=None,
+        prompt=None,
+        prompt_token_ids=[0],
+        prompt_embeds=None,
+        logprobs_processor=None,
+        detokenizer=None,
+        max_tokens_param=None,
+        arrival_time=0.0,
+        queue=None,
+        log_stats=False,
+        stream_interval=1,
+        output_kind=kind,
+    )
+
+
+@pytest.mark.parametrize("key", RATE_KEYS)
+@pytest.mark.parametrize("representation", ["integer", "scalar_tensor", "vector_tensor", "metadata_tensor"])
+def test_rate_is_latest_snapshot_before_consolidation(key, representation):
+    payload = MultimodalPayload()
+    for index, rate in enumerate((16000, 24000, 48000)):
+        value = (
+            rate if representation == "integer" else torch.tensor([rate] if representation == "vector_tensor" else rate)
+        )
+        incoming = (
+            MultimodalPayload(tensors={"audio": torch.full((2,), index)}, metadata={key: value})
+            if representation == "metadata_tensor"
+            else MultimodalPayload.from_dict({"audio": torch.full((2,), index), key: value})
+        )
+        assert incoming is not None
+        payload = payload.merged_with(incoming)
+        snapshot = payload[key]
+        assert not isinstance(snapshot, list)
+        assert int(snapshot) == rate
+        assert payload.get(key) is payload.to_dict()[key]
+    payload = payload.merged_with(MultimodalPayload(tensors={"audio": torch.full((2,), 3)}))
+    assert int(payload[key]) == 48000  # Missing metadata means retain, not clear.
+    payload.consolidate_tensors(OutputModality.AUDIO)
+    payload.consolidate_metadata()
+    torch.testing.assert_close(payload["audio"], torch.arange(4).repeat_interleave(2))
+
+
+@pytest.mark.parametrize("key", RATE_KEYS)
+@pytest.mark.parametrize("tensor_first", [False, True])
+def test_rate_representation_change_removes_stale_partition(key, tensor_first):
+    first = torch.tensor(16000) if tensor_first else 16000
+    last = 24000 if tensor_first else torch.tensor(24000)
+    payload = MultimodalPayload.from_dict({key: first})
+    incoming = MultimodalPayload.from_dict({key: last})
+    assert payload is not None and incoming is not None
+    incoming_keys = (set(incoming.tensors), set(incoming.metadata))
+    payload = payload.merged_with(incoming)
+    assert int(payload[key]) == 24000
+    assert payload[key] is payload.to_dict()[key]
+    assert (key in payload.tensors) != (key in payload.metadata)
+    assert incoming[key] is last
+    assert incoming_keys == (set(incoming.tensors), set(incoming.metadata))
+
+
+@pytest.mark.parametrize("key", RATE_KEYS)
+def test_self_merge_retains_snapshot_and_content(key):
+    payload = MultimodalPayload.from_dict({key: torch.tensor(24000), "audio": torch.tensor([1.0, 2.0])})
+    assert payload is not None
+    payload = payload.merged_with(payload)
+    assert int(payload[key]) == 24000
+    payload.consolidate_tensors(OutputModality.AUDIO)
+    torch.testing.assert_close(payload["audio"], torch.tensor([1.0, 2.0, 1.0, 2.0]))
+
+
+@pytest.mark.parametrize("key", RATE_KEYS)
+@pytest.mark.parametrize("kind", [RequestOutputKind.DELTA, RequestOutputKind.CUMULATIVE])
+def test_long_stream_keeps_rate_bounded_without_losing_audio(key, kind):
+    state = _state(kind)
+    for index in range(1000):
+        state.add_multimodal_tensor(
+            {"model_outputs": torch.full((3,), index / 1000), key: torch.tensor(24000)}, "audio"
+        )
+        output = state.make_request_output([], None, None, None)
+        assert output is not None and not isinstance(output, PoolingRequestOutput)
+        payload = output.outputs[0].multimodal_output
+        assert isinstance(payload[key], torch.Tensor) and payload[key].numel() == 1
+        audio = payload["audio"]
+        assert audio.numel() == (3 if kind == RequestOutputKind.DELTA else 3 * (index + 1))
+        torch.testing.assert_close(audio[-3:], torch.full((3,), index / 1000))
+        assert ("audio" in state.mm_accumulated) is (kind == RequestOutputKind.CUMULATIVE)
+    final = state.make_request_output([], None, FinishReason.STOP, None)
+    assert final is not None and final.finished
+    if kind == RequestOutputKind.DELTA:
+        assert "audio" not in final.outputs[0].multimodal_output
+
+
+@pytest.mark.parametrize("pending", [0, 3])
+def test_abort_flushes_only_pending_content_with_latest_rate(pending):
+    state = _state(RequestOutputKind.DELTA)
+    processor = MultimodalOutputProcessor(tokenizer=None, log_stats=False, output_modality=OutputModality.AUDIO)
+    processor.request_states[state.request_id] = state
+    processor.external_req_ids[state.external_req_id] = [state.request_id]
+    for rate in (16000, 24000):
+        state.add_multimodal_tensor({"model_outputs": torch.ones(3), "sr": torch.tensor(rate)}, "audio")
+        output = state.make_request_output([], None, None, None)
+        assert output is not None
+    if pending:
+        state.add_multimodal_tensor({"model_outputs": torch.ones(pending)}, "audio")
+    aborted, outputs = processor.abort_requests_collecting_outputs([state.request_id], internal=True)
+    assert aborted == [state.request_id] and len(outputs) == 1 and outputs[0].finished
+    payload = outputs[0].outputs[0].multimodal_output
+    assert int(payload["sr"]) == 24000
+    assert (payload["audio"].numel() if "audio" in payload else 0) == pending
+    assert state.request_id not in processor.request_states
+
+
+def test_non_snapshot_tensors_still_accumulate_and_empty_merge_keeps_identity():
+    first = MultimodalPayload.from_dict({"latent": torch.tensor([1.0]), "audio": torch.tensor([2.0])})
+    second = MultimodalPayload.from_dict({"latent": torch.tensor([3.0]), "audio": torch.tensor([4.0])})
+    assert first is not None and second is not None
+    assert MultimodalPayload().merged_with(first) is first
+    merged = first.merged_with(second)
+    merged.consolidate_tensors(OutputModality.AUDIO)
+    torch.testing.assert_close(merged["latent"], torch.tensor([1.0, 3.0]))
+    torch.testing.assert_close(merged["audio"], torch.tensor([2.0, 4.0]))
diff --git a/tests/engine/test_output_modality.py b/tests/engine/test_output_modality.py
index ff15e5824..e5c5d36c1 100644
--- a/tests/engine/test_output_modality.py
+++ b/tests/engine/test_output_modality.py
@@ -41,6 +41,7 @@ _mm_mod = _load_module(
 OutputModality = _om_mod.OutputModality
 TensorAccumulationStrategy = _om_mod.TensorAccumulationStrategy
 get_accumulation_strategy = _om_mod.get_accumulation_strategy
+register_key_accumulation_strategy = _om_mod.register_key_accumulation_strategy
 MultimodalPayload = _mm_mod.MultimodalPayload
 MultimodalCompletionOutput = _mm_mod.MultimodalCompletionOutput
 
@@ -156,3 +157,90 @@ def test_output_modality_printed_examples(capsys):
     captured = capsys.readouterr()
     assert "OutputModality Parsing" in captured.out
     assert "MultimodalPayload" in captured.out
+
+
+def test_get_accumulation_strategy_key_override_precedence():
+    """A registered per-key override wins over the modality-wide default;
+    any other key under the same modality keeps using that default."""
+    assert get_accumulation_strategy(OutputModality.AUDIO, "unregistered.key") == TensorAccumulationStrategy.CONCAT_LAST
+
+    register_key_accumulation_strategy("__test_override__.frames", TensorAccumulationStrategy.CONCAT_DIM0)
+    assert (
+        get_accumulation_strategy(OutputModality.AUDIO, "__test_override__.frames")
+        == TensorAccumulationStrategy.CONCAT_DIM0
+    )
+    # A plain waveform key under the same AUDIO modality is unaffected.
+    assert get_accumulation_strategy(OutputModality.AUDIO, "waveform") == TensorAccumulationStrategy.CONCAT_LAST
+    assert get_accumulation_strategy(OutputModality.AUDIO) == TensorAccumulationStrategy.CONCAT_LAST
+
+
+def _talker_codec_frame_payload(audio_key: str, ref_key: str) -> MultimodalPayload:
+    """Synthetic stand-in for a TTS talker's accumulated per-step output.
+
+    ``audio_key`` grows one ``[1, num_codebooks]`` row per decode step on top
+    of a ``[5, num_codebooks]`` prefill block (Qwen3-TTS's ``codes.audio``);
+    ``ref_key`` re-emits the same constant ``[100, num_codebooks]``
+    reference-context matrix unchanged at every step (Qwen3-TTS's
+    ``codes.ref``). Neither is a waveform chunk.
+    """
+    payload = MultimodalPayload()
+    payload.tensors[audio_key] = [
+        torch.zeros(5, 16),
+        torch.full((1, 16), 1.0),
+        torch.full((1, 16), 2.0),
+        torch.full((1, 16), 3.0),
+    ]
+    ref_block = torch.arange(100 * 16, dtype=torch.float32).reshape(100, 16)
+    payload.tensors[ref_key] = [ref_block.clone(), ref_block.clone(), ref_block.clone()]
+    return payload
+
+
+def test_consolidate_tensors_default_audio_strategy_corrupts_codec_frame_keys():
+    """Reproduces both failure modes of forcing codec-frame keys through the
+    AUDIO modality's waveform-tuned default (CONCAT_LAST) with no per-key
+    override registered: the audio-frames key's dim-0 growth makes
+    CONCAT_LAST's dim=-1 concat raise (mismatched dim 0), which the
+    flatten-chunks fallback turns into a 1-D blob instead of the intended
+    ``[8, 16]``; the ref-frames key's matching last dim lets CONCAT_LAST
+    "succeed" by silently concatenating three identical ``[100, 16]`` blocks
+    into ``[100, 48]`` instead of keeping a single copy.
+    """
+    payload = _talker_codec_frame_payload("unregistered.codes.audio", "unregistered.codes.ref")
+
+    payload.consolidate_tensors(OutputModality.AUDIO)
+
+    assert tuple(payload.tensors["unregistered.codes.audio"].shape) != (8, 16)
+    assert tuple(payload.tensors["unregistered.codes.ref"].shape) == (100, 48)
+
+
+def test_consolidate_tensors_with_qwen3_tts_key_overrides_is_correct():
+    """With the per-key overrides Qwen3-TTS's pipeline module registers
+    (``codes.audio`` -> CONCAT_DIM0, ``codes.ref`` -> REPLACE), both keys
+    consolidate correctly under the AUDIO modality despite not being
+    waveform chunks."""
+    register_key_accumulation_strategy("codes.audio", TensorAccumulationStrategy.CONCAT_DIM0)
+    register_key_accumulation_strategy("codes.ref", TensorAccumulationStrategy.REPLACE)
+
+    payload = _talker_codec_frame_payload("codes.audio", "codes.ref")
+    expected_ref = payload.tensors["codes.ref"][0]
+
+    payload.consolidate_tensors(OutputModality.AUDIO)
+
+    assert tuple(payload.tensors["codes.audio"].shape) == (8, 16)
+    assert tuple(payload.tensors["codes.ref"].shape) == (100, 16)
+    assert torch.equal(payload.tensors["codes.ref"], expected_ref)
+
+
+def test_consolidate_tensors_raises_with_key_name_instead_of_silently_keeping_last():
+    """A concat failure under a non-CONCAT_LAST strategy must be surfaced
+    with the offending key name rather than resolved by silently keeping
+    only the last chunk. Previously the except-branch only special-cased
+    the literal key ``"audio"``, so any other mismatched key (e.g. a
+    codec-frame key routed to CONCAT_DIM0) was corrupted instead of
+    failing loudly.
+    """
+    payload = MultimodalPayload()
+    payload.tensors["latent.frames"] = [torch.zeros(2, 8), torch.zeros(3, 9)]
+
+    with pytest.raises(RuntimeError, match="latent.frames"):
+        payload.consolidate_tensors(OutputModality.LATENT)
diff --git a/tests/engine/test_output_processor.py b/tests/engine/test_output_processor.py
index 62ed8334b..9fbecc1c1 100644
--- a/tests/engine/test_output_processor.py
+++ b/tests/engine/test_output_processor.py
@@ -2,6 +2,7 @@
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Regression tests for OmniRequestState multimodal DELTA drain and consolidation guard."""
 
+from dataclasses import dataclass
 from types import SimpleNamespace
 from unittest.mock import MagicMock
 
@@ -38,6 +39,21 @@ _DETOK = MagicMock(
 )
 _LOGPROBS = MagicMock(logprobs=None, cumulative_logprob=None, prompt_logprobs=None)
 
+
+@dataclass
+class _StreamingUpdate:
+    final: bool
+    prompt: object | None
+    prompt_token_ids: list[int]
+    arrival_time: float
+
+
+@dataclass
+class _FinishedRequestMetric:
+    request_id: str
+    mean_time_per_output_token: float
+
+
 _DEFAULT_STATE_KWARGS = dict(
     request_id="r",
     external_req_id="r",
@@ -130,6 +146,130 @@ def test_native_text_metrics_include_segment_generation_token_count(monkeypatch)
     assert processor.pop_native_text_metrics("r")["num_generation_tokens"] == 27
 
 
+def test_native_text_metrics_exclude_cross_segment_gap(monkeypatch):
+    monkeypatch.setattr(VLLMOutputProcessor, "_update_stats_from_output", lambda *args, **kwargs: None)
+    processor = object.__new__(MultimodalOutputProcessor)
+    processor._native_text_metrics_by_request = {}
+    processor.lora_states = {}
+    state = _make_state(RequestOutputKind.DELTA)
+    iteration_stats = MagicMock()
+
+    def update_segment(_output, timestamp, _was_prefilling, native_stats, *_args):
+        native_stats.num_generation_tokens = 2 if timestamp == 10.03 else 1
+        native_stats.first_token_ts = 10.02 if timestamp == 10.03 else timestamp
+        native_stats.last_token_ts = timestamp
+        native_stats.first_token_latency = 0.01
+
+    iteration_stats.update_from_output.side_effect = update_segment
+    processor._update_stats_from_output(
+        state,
+        MagicMock(),
+        10.0,
+        iteration_stats,
+    )
+    first_segment = processor.pop_native_text_metrics("r")
+    assert first_segment["vllm_tpot_ms"] == 0.0
+    assert first_segment["vllm_itls_ms"] == []
+
+    state.apply_streaming_update(
+        _StreamingUpdate(
+            final=False,
+            prompt=None,
+            prompt_token_ids=[],
+            arrival_time=10.01,
+        )
+    )
+    state.is_prefilling = True
+    processor._update_stats_from_output(
+        state,
+        MagicMock(),
+        10.02,
+        iteration_stats,
+    )
+    state.is_prefilling = False
+    processor._update_stats_from_output(
+        state,
+        MagicMock(),
+        10.03,
+        iteration_stats,
+    )
+    second_segment = processor.pop_native_text_metrics("r")
+
+    assert second_segment["num_generation_tokens"] == 2
+    assert second_segment["vllm_itls_ms"] == pytest.approx([10.0])
+    assert second_segment["vllm_tpot_ms"] == pytest.approx(10.0)
+
+
+def test_native_text_tpot_weights_multi_token_engine_output(monkeypatch):
+    monkeypatch.setattr(VLLMOutputProcessor, "_update_stats_from_output", lambda *args, **kwargs: None)
+    processor = object.__new__(MultimodalOutputProcessor)
+    processor._native_text_metrics_by_request = {}
+    processor.lora_states = {}
+    state = _make_state(RequestOutputKind.DELTA)
+    iteration_stats = MagicMock()
+
+    def update_segment(_output, timestamp, _was_prefilling, native_stats, *_args):
+        native_stats.num_generation_tokens = 1 if timestamp == 10.0 else 4
+        native_stats.first_token_ts = 10.0
+        native_stats.last_token_ts = timestamp
+        native_stats.first_token_latency = 0.01
+
+    iteration_stats.update_from_output.side_effect = update_segment
+    state.is_prefilling = True
+    processor._update_stats_from_output(state, MagicMock(), 10.0, iteration_stats)
+    state.is_prefilling = False
+    processor._update_stats_from_output(state, MagicMock(), 10.03, iteration_stats)
+    record = processor.pop_native_text_metrics("r")
+
+    assert record["num_generation_tokens"] == 4
+    assert record["vllm_itls_ms"] == pytest.approx([30.0])
+    assert record["vllm_itl_ms"] == pytest.approx(30.0)
+    assert record["vllm_tpot_ms"] == pytest.approx(10.0)
+    assert "_tpot_elapsed_ms" not in record
+    assert "_tpot_intervals" not in record
+
+
+@pytest.mark.parametrize(
+    ("finished_tpot_s", "expected_tpot_ms"),
+    [(0.0, 19.0), (0.023, 23.0)],
+)
+def test_native_text_tpot_only_accepts_positive_finished_metric(
+    monkeypatch,
+    finished_tpot_s,
+    expected_tpot_ms,
+):
+    monkeypatch.setattr(VLLMOutputProcessor, "_update_stats_from_finished", lambda *args, **kwargs: None)
+    processor = object.__new__(MultimodalOutputProcessor)
+    processor._native_text_metrics_by_request = {"r": {"vllm_tpot_ms": 19.0}}
+    state = _make_state(RequestOutputKind.DELTA)
+    iteration_stats = MagicMock()
+    iteration_stats.finished_requests = [
+        _FinishedRequestMetric(
+            request_id="r",
+            mean_time_per_output_token=finished_tpot_s,
+        )
+    ]
+
+    processor._update_stats_from_finished(
+        state,
+        FinishReason.STOP,
+        iteration_stats,
+    )
+
+    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)
@@ -487,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,
     )
@@ -502,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",
@@ -531,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,
@@ -759,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 675a0650b..2e01e910b 100644
--- a/tests/engine/test_single_stage_mode.py
+++ b/tests/engine/test_single_stage_mode.py
@@ -16,7 +16,8 @@ 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
+from vllm_omni.config.omni_config import VllmOmniARStageConfig, VllmOmniDiffusionStageConfig
+from vllm_omni.config.stage_config import DuplexSessionRuntimeConfig, 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 +58,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 +103,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",
@@ -389,7 +404,7 @@ class TestSingleStageModeDetection:
                 return_value=None,
             )
             mocker.patch(
-                "vllm_omni.engine.async_omni_engine.load_deploy_config",
+                "vllm_omni.engine.omni_engine_base.load_deploy_config",
                 return_value=SimpleNamespace(duplex_session=DuplexSessionRuntimeConfig()),
             )
         mocker.patch.object(
@@ -446,11 +461,11 @@ class TestSingleStageModeDetection:
     def test_deploy_config_loads_duplex_runtime_config(self, mocker: MockerFixture):
         duplex_session = DuplexSessionRuntimeConfig(max_sessions=2)
         get_pipeline_config = mocker.patch(
-            "vllm_omni.engine.async_omni_engine.StageConfigFactory.get_pipeline_config",
+            "vllm_omni.engine.omni_engine_base.StageConfigFactory.get_pipeline_config",
             return_value=None,
         )
         load_deploy_config = mocker.patch(
-            "vllm_omni.engine.async_omni_engine.load_deploy_config",
+            "vllm_omni.engine.omni_engine_base.load_deploy_config",
             return_value=SimpleNamespace(duplex_session=duplex_session),
         )
 
@@ -467,7 +482,8 @@ class TestSingleStageModeDetection:
             deploy_config_path="/fake/duplex.yaml",
         )
         load_deploy_config.assert_called_once_with("/fake/duplex.yaml")
-        assert engine.duplex_session_config is duplex_session
+        # The turn-based engine only keeps the resolved deploy profile for introspection.
+        assert engine.deploy_config.duplex_session is duplex_session
 
     def test_auto_discovered_deploy_loads_duplex_runtime_config(
         self,
@@ -476,11 +492,11 @@ class TestSingleStageModeDetection:
         deploy_path = "/resolved/qwen3_omni_moe.yaml"
         duplex_session = DuplexSessionRuntimeConfig(server_vad_model_path="/models/silero_vad.onnx")
         mocker.patch(
-            "vllm_omni.engine.async_omni_engine.StageConfigFactory.get_pipeline_config",
+            "vllm_omni.engine.omni_engine_base.StageConfigFactory.get_pipeline_config",
             return_value=None,
         )
         load_deploy_config = mocker.patch(
-            "vllm_omni.engine.async_omni_engine.load_deploy_config",
+            "vllm_omni.engine.omni_engine_base.load_deploy_config",
             return_value=SimpleNamespace(duplex_session=duplex_session),
         )
 
@@ -557,7 +573,7 @@ class TestEndpointRestrictionsTrustRemoteCode:
 
     def _make_engine_no_thread(self, mocker: MockerFixture, **kwargs: Any) -> AsyncOmniEngine:
         mocker.patch(
-            "vllm_omni.engine.async_omni_engine.load_deploy_config",
+            "vllm_omni.engine.omni_engine_base.load_deploy_config",
             return_value=SimpleNamespace(duplex_session=DuplexSessionRuntimeConfig()),
         )
         mocker.patch.object(
@@ -959,6 +975,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):
@@ -1124,11 +1141,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",
@@ -1145,6 +1160,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
@@ -1377,7 +1393,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,
@@ -1412,7 +1428,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,
@@ -1438,7 +1454,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,
@@ -1450,7 +1466,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
 
@@ -1491,7 +1508,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(),
@@ -1568,7 +1585,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 250aff884..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,11 +84,15 @@ _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",
         "devices",
         "disable_autocast",
+        "enable_broadcast_weight_load",
         "enable_multithread_weight_load",
         "env",
         "has_sampling_extra_args",
@@ -94,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",
@@ -365,6 +377,59 @@ 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)
+
+    pipeline = OMNI_PIPELINES["mammoth_moda2"]
+    deploy = load_deploy_config(_DEPLOY_DIR / "mammoth_moda2_fp8_kv.yaml")
+    legacy_stages, omni_config = _legacy_and_typed_stages(
+        pipeline,
+        deploy,
+        model="test-model",
+    )
+
+    assert deploy.stages[0].engine_extras["kv_cache_dtype"] == "fp8_e4m3"
+    assert "kv_cache_dtype" not in deploy.stages[1].engine_extras
+
+    legacy_args = [build_legacy_engine_args_dict(stage, "test-model") for stage in legacy_stages]
+    typed_args = [
+        build_engine_args_dict_from_omni_stage_config(
+            omni_config.stage_by_id(stage_id),
+            "test-model",
+        )
+        for stage_id in (0, 1)
+    ]
+
+    ar_stage = omni_config.stage_by_id(0)
+    dit_stage = omni_config.stage_by_id(1)
+
+    assert ar_stage.stage_pipeline_config.execution_type == StageExecutionType.LLM_AR
+    assert legacy_args[0]["kv_cache_dtype"] == "fp8_e4m3"
+    assert ar_stage.cache_config.cache_dtype == "fp8_e4m3"
+    assert "cache_dtype" in ar_stage.cache_config._omni_explicit_fields
+    assert typed_args[0]["kv_cache_dtype"] == "fp8_e4m3"
+
+    assert "kv_cache_dtype" not in legacy_args[1]
+    assert dit_stage.cache_config.cache_dtype == "auto"
+    assert "cache_dtype" not in dit_stage.cache_config._omni_explicit_fields
+    assert "kv_cache_dtype" not in typed_args[1]
+
+
 def test_typed_llm_projection_rejects_explicit_fields_owned_by_another_boundary():
     stage_config = VllmOmniARStageConfig(
         stage_pipeline_config=StagePipelineConfig(stage_id=0, model_stage="test"),
@@ -512,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"
 
 
@@ -545,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/duplex/test_duplex_serving.py b/tests/entrypoints/duplex/test_duplex_serving.py
new file mode 100644
index 000000000..dde616d94
--- /dev/null
+++ b/tests/entrypoints/duplex/test_duplex_serving.py
@@ -0,0 +1,609 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""The thin websocket handler: handshake, command translation, event pump, resume/takeover."""
+
+from __future__ import annotations
+
+import asyncio
+import base64
+import json
+from contextlib import suppress
+from typing import Any
+
+import pytest
+from fastapi import WebSocketDisconnect
+
+from vllm_omni.config.stage_config import DuplexSessionRuntimeConfig
+from vllm_omni.engine.duplex import commands
+from vllm_omni.engine.duplex.config import DuplexCapabilities
+from vllm_omni.engine.duplex.events import AudioDelta, DuplexEvent, SessionClosed, SessionCreated
+from vllm_omni.engine.duplex.messages import DuplexSessionError
+from vllm_omni.entrypoints.duplex.realtime_input import RealtimeEnvelope, parse_resume_request
+from vllm_omni.entrypoints.duplex.serving import OmniDuplexSessionHandler
+from vllm_omni.entrypoints.duplex.websocket import MAX_EVENT_BYTES
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+_DISCONNECT = object()
+
+
+class FakeWebSocket:
+    def __init__(self, query: dict[str, str] | None = None) -> None:
+        self.query_params = dict(query or {})
+        self.sent: list[dict[str, Any]] = []
+        self.accepted = False
+        self.closed: list[tuple[int, str]] = []
+        self._send_failure: str | None = None
+        self._inbound: asyncio.Queue[Any] = asyncio.Queue()
+
+    async def accept(self) -> None:
+        self.accepted = True
+
+    async def send_json(self, payload: dict[str, Any]) -> None:
+        if self.closed or self._send_failure is not None:
+            raise RuntimeError(
+                self._send_failure or "Unexpected ASGI message 'websocket.send', after sending 'websocket.close'."
+            )
+        self.sent.append(json.loads(json.dumps(payload)))
+
+    async def receive_text(self) -> str:
+        item = await self._inbound.get()
+        if item is _DISCONNECT:
+            raise WebSocketDisconnect(code=1000)
+        return item
+
+    async def close(self, code: int = 1000, reason: str = "") -> None:
+        self.closed.append((code, reason))
+        # A closed socket ends the reader exactly like a client disconnect.
+        self._inbound.put_nowait(_DISCONNECT)
+
+    # ---- test helpers ----
+
+    def feed(self, payload: dict[str, Any] | str) -> None:
+        self._inbound.put_nowait(payload if isinstance(payload, str) else json.dumps(payload))
+
+    def disconnect(self) -> None:
+        self._inbound.put_nowait(_DISCONNECT)
+
+    def break_sends(self) -> None:
+        """Kill the write half only: the reader stays parked, as it does in practice."""
+        self._send_failure = "Unexpected ASGI message 'websocket.send', after sending 'websocket.close'."
+
+    def types(self) -> list[str]:
+        return [payload["type"] for payload in self.sent]
+
+    async def wait_for(self, wire_type: str, *, timeout_s: float = 2.0) -> dict[str, Any]:
+        loop = asyncio.get_running_loop()
+        deadline = loop.time() + timeout_s
+        while loop.time() < deadline:
+            for payload in self.sent:
+                if payload["type"] == wire_type:
+                    return payload
+            await asyncio.sleep(0.005)
+        raise AssertionError(f"no {wire_type!r} in {self.types()}")
+
+
+class FakeHandle:
+    def __init__(self, session_id: str, capabilities: DuplexCapabilities, *, idle_timeout_s: float = 300) -> None:
+        self.session_id = session_id
+        self.capabilities = capabilities
+        self.public_session: dict[str, Any] = {"id": session_id, "idle_timeout_s": idle_timeout_s}
+        self.lease_generation = 0
+        self.closed = False
+        self.close_reasons: list[str] = []
+        self.commands: list[commands.DuplexCommand] = []
+        self._outbox: asyncio.Queue[DuplexEvent] = asyncio.Queue()
+
+    def deliver(self, event: DuplexEvent) -> None:
+        self._outbox.put_nowait(event)
+
+    async def submit(self, command: commands.DuplexCommand) -> None:
+        if self.closed:
+            raise DuplexSessionError("closed", code="session_closed", session_id=self.session_id)
+        self.commands.append(command)
+
+    async def events(self):
+        while True:
+            event = await self._outbox.get()
+            yield event
+            if event.is_terminal:
+                return
+
+    async def close(self, *, reason: str = "client_close", timeout: float | None = None) -> None:
+        self.close_reasons.append(reason)
+        if self.closed:
+            return
+        self.closed = True
+        self.deliver(SessionClosed(session_id=self.session_id, reason=reason))
+
+
+class FakeOmni:
+    def __init__(
+        self, *, resumable: bool = True, replay_max_bytes: int = 64 * 1024, idle_timeout_s: float = 300
+    ) -> None:
+        self.duplex_session_config = DuplexSessionRuntimeConfig(
+            resume_replay_ttl_s=60.0, resume_replay_max_bytes_per_session=replay_max_bytes
+        )
+        self.capabilities = DuplexCapabilities(supports_session_resume=resumable)
+        self.idle_timeout_s = idle_timeout_s
+        self.opened: list[dict[str, Any]] = []
+        self.handles: dict[str, FakeHandle] = {}
+        self.resumed: list[tuple[str, int]] = []
+        self.detached: list[str] = []
+        self.open_error: DuplexSessionError | None = None
+
+    async def open_session(self, config: Any) -> FakeHandle:
+        self.opened.append(dict(config))
+        if self.open_error is not None:
+            raise self.open_error
+        session_id = f"duplex-{len(self.handles) + 1:032x}"
+        handle = FakeHandle(session_id, self.capabilities, idle_timeout_s=self.idle_timeout_s)
+        self.handles[session_id] = handle
+        handle.deliver(SessionCreated(session_id=session_id, session={"id": session_id, "model": config.get("model")}))
+        return handle
+
+    def get_session(self, session_id: str) -> FakeHandle | None:
+        return self.handles.get(session_id)
+
+    async def resume_session(self, session_id: str, *, expected_lease_generation: int) -> FakeHandle:
+        self.resumed.append((session_id, expected_lease_generation))
+        handle = self.handles[session_id]
+        handle.lease_generation = expected_lease_generation + 1
+        return handle
+
+    async def detach_session(self, session_id: str) -> None:
+        self.detached.append(session_id)
+
+
+def _handler(omni: FakeOmni, **kwargs: Any) -> OmniDuplexSessionHandler:
+    kwargs.setdefault("config_timeout_s", 1.0)
+    kwargs.setdefault("idle_timeout_s", 5.0)
+    return OmniDuplexSessionHandler(duplex_omni=omni, **kwargs)
+
+
+def _session_update(**session: Any) -> dict[str, Any]:
+    return {"type": "session.update", "session": {"model": "test-model", "modalities": ["audio", "text"], **session}}
+
+
+async def _open(
+    handler: OmniDuplexSessionHandler, omni: FakeOmni, **session: Any
+) -> tuple[FakeWebSocket, FakeHandle, asyncio.Task]:
+    ws = FakeWebSocket({"duplex": "1", "autostart": "0"})
+    task = asyncio.create_task(handler.handle_realtime_session(ws))
+    ws.feed(_session_update(**session))
+    created = await ws.wait_for("session.created")
+    handle = omni.handles[created["session"]["id"]]
+    return ws, handle, task
+
+
+# --------------------------------------------------------------------------- #
+# Handshake and commands                                                      #
+# --------------------------------------------------------------------------- #
+
+
+@pytest.mark.asyncio
+async def test_session_update_opens_a_session_and_announces_the_server_id() -> None:
+    omni = FakeOmni()
+    handler = _handler(omni)
+    ws, handle, task = await _open(handler, omni, session_id="mine", instructions="hi")
+
+    assert ws.accepted
+    created = ws.sent[0]
+    assert created["type"] == "session.created"
+    assert created["session"]["id"] == handle.session_id != "mine"
+    assert created["attachment_generation"] == 1
+    assert isinstance(created["resume_token"], str) and created["resume_token"]
+    assert "incarnation" not in created
+    assert "server_event_seq" not in created
+    # The whole session object went to open_session; the id inside it is ignored there.
+    assert omni.opened == [
+        {"model": "test-model", "modalities": ["audio", "text"], "session_id": "mine", "instructions": "hi"}
+    ]
+
+    ws.feed({"type": "input_audio_buffer.append", "audio": base64.b64encode(b"\x00\x01" * 8).decode("ascii")})
+    ws.feed({"type": "input_audio_buffer.commit", "event_id": "evt-c"})
+    await asyncio.sleep(0.05)
+    assert [type(command) for command in handle.commands] == [commands.AppendAudio, commands.Commit]
+    assert handle.commands[1].event_id == "evt-c"
+
+    ws.disconnect()
+    await asyncio.wait_for(task, timeout=2.0)
+    # A resumable session is detached (engine-owned grace), not closed.
+    assert omni.detached == [handle.session_id]
+    assert handle.close_reasons == []
+
+
+@pytest.mark.asyncio
+async def test_session_events_are_journaled_and_sent_in_order() -> None:
+    omni = FakeOmni()
+    handler = _handler(omni)
+    ws, handle, task = await _open(handler, omni)
+
+    handle.deliver(AudioDelta(session_id=handle.session_id, response_id="r1", delta="aGk="))
+    delta = await ws.wait_for("response.output_audio.delta")
+    assert delta["delta"] == "aGk=" and delta["server_event_seq"] == 1
+
+    ws.feed({"type": "session.event_ack", "server_event_seq": 1})
+    ws.feed({"type": "session.event_ack", "server_event_seq": 9, "event_id": "evt-ack"})
+    error = await ws.wait_for("error")
+    assert error["error"]["code"] == "invalid_event_ack" and error["error"]["event_id"] == "evt-ack"
+
+    await handle.close(reason="client_close")
+    closed = await ws.wait_for("session.closed")
+    assert closed["reason"] == "client_close"
+    await asyncio.wait_for(task, timeout=2.0)
+    assert ws.closed[0][1] == "client_close"
+
+
+@pytest.mark.asyncio
+async def test_envelope_errors_are_answered_locally_without_touching_the_session() -> None:
+    omni = FakeOmni()
+    handler = _handler(omni)
+    ws, handle, task = await _open(handler, omni)
+
+    ws.feed("not json")
+    ws.feed("x" * (MAX_EVENT_BYTES + 1))
+    ws.feed({"type": "totally.unknown", "event_id": "evt-u"})
+    ws.feed({"type": "session.resume", "event_id": "evt-r"})
+    ws.feed({"type": "playback.ack", "event_id": "evt-p"})  # played_ms missing
+    await asyncio.sleep(0.1)
+
+    codes = [payload["error"]["code"] for payload in ws.sent if payload["type"] == "error"]
+    assert codes == ["invalid_json", "event_too_large", "unknown_event", "unsupported_session_resume", "bad_event"]
+    errors = [payload for payload in ws.sent if payload["type"] == "error"]
+    assert errors[2]["error"]["event_id"] == "evt-u"
+    assert errors[4]["error"]["event_id"] == "evt-p"
+    assert handle.commands == []
+    ws.disconnect()
+    await asyncio.wait_for(task, timeout=2.0)
+
+
+@pytest.mark.asyncio
+async def test_open_rejection_is_reported_and_the_socket_ends() -> None:
+    omni = FakeOmni()
+    omni.open_error = DuplexSessionError("no room", code="resource_exhausted", retryable=True)
+    handler = _handler(omni)
+    ws = FakeWebSocket({"duplex": "1"})
+    task = asyncio.create_task(handler.handle_realtime_session(ws))
+    ws.feed(_session_update())
+    await asyncio.wait_for(task, timeout=2.0)
+    assert ws.types() == ["error"]
+    assert ws.sent[0]["error"]["code"] == "resource_exhausted"
+
+
+@pytest.mark.asyncio
+async def test_config_timeout_and_first_message_validation() -> None:
+    omni = FakeOmni()
+    handler = _handler(omni, config_timeout_s=0.05)
+    ws = FakeWebSocket({"duplex": "1"})
+    await asyncio.wait_for(handler.handle_realtime_session(ws), timeout=2.0)
+    assert ws.sent[0]["error"]["code"] == "config_timeout"
+
+    ws = FakeWebSocket({"duplex": "1"})
+    task = asyncio.create_task(handler.handle_realtime_session(ws))
+    ws.feed("{not json")
+    await asyncio.wait_for(task, timeout=2.0)
+    assert ws.sent[0]["error"]["code"] == "invalid_json"
+    assert omni.opened == []
+
+
+@pytest.mark.asyncio
+async def test_idle_timeout_detaches_a_resumable_session_like_a_disconnect() -> None:
+    omni = FakeOmni(idle_timeout_s=0.05)
+    handler = _handler(omni, idle_timeout_s=0.05)
+    ws, handle, task = await _open(handler, omni)
+
+    await asyncio.wait_for(task, timeout=2.0)
+    # Serving makes no session-lifetime decision: the engine lease decides
+    # whether a silent, detached session expires.
+    assert handle.close_reasons == []
+    assert omni.detached == [handle.session_id]
+
+
+@pytest.mark.asyncio
+async def test_idle_timeout_closes_a_non_resumable_session() -> None:
+    omni = FakeOmni(idle_timeout_s=0.05, resumable=False)
+    handler = _handler(omni, idle_timeout_s=0.05)
+    ws, handle, task = await _open(handler, omni)
+
+    await asyncio.wait_for(task, timeout=2.0)
+    assert handle.close_reasons == ["disconnect"]
+    assert omni.detached == []
+
+
+@pytest.mark.asyncio
+async def test_transport_send_failure_detaches_the_session_instead_of_closing_it() -> None:
+    omni = FakeOmni()
+    handler = _handler(omni)
+    ws, handle, task = await _open(handler, omni)
+
+    # Only the write half dies, so the pump's send is the one and only report
+    # of the broken socket (the reader is still parked on receive).
+    ws.break_sends()
+    handle.deliver(AudioDelta(session_id=handle.session_id, response_id="r1", delta="aGk="))
+    await asyncio.sleep(0.05)
+
+    # The engine session is alive and resumable, so this is a disconnect of
+    # the current attachment, not a session close; the pump keeps journaling.
+    assert handle.close_reasons == []
+    assert omni.detached == [handle.session_id]
+    assert not handler._pumps[handle.session_id].done()
+
+    # The reader sees the same broken socket a moment later. The attachment is
+    # already gone, so this must not detach a second time: another detach would
+    # restart the engine's disconnect grace window.
+    ws.disconnect()
+    await asyncio.wait_for(task, timeout=2.0)
+    assert omni.detached == [handle.session_id]
+    assert handle.close_reasons == []
+
+    handle.deliver(SessionClosed(session_id=handle.session_id, reason="client_close"))
+    await asyncio.sleep(0.05)
+    assert handle.session_id not in handler._pumps
+
+
+@pytest.mark.asyncio
+async def test_non_resumable_session_is_closed_on_disconnect() -> None:
+    omni = FakeOmni(resumable=False)
+    handler = _handler(omni)
+    ws, handle, task = await _open(handler, omni)
+    assert "resume_token" not in ws.sent[0]
+
+    ws.disconnect()
+    await asyncio.wait_for(task, timeout=2.0)
+    assert handle.close_reasons == ["disconnect"]
+    assert omni.detached == []
+
+
+@pytest.mark.asyncio
+async def test_a_client_close_still_delivers_session_closed_before_the_socket_goes() -> None:
+    """The read loop must not outrun the pump's terminal event.
+
+    ``DuplexSessionHandle._deliver`` queues ``SessionClosed`` and marks the
+    handle closed in one synchronous step, so ``handle.closed`` is already true
+    while the event is still sitting in the outbox. ``_read_loop`` loops on
+    exactly that flag: it returned, the endpoint returned, and the ASGI server
+    tore the socket down with ``session.closed`` unsent -- the client saw an
+    abrupt close (no close frame) instead of the terminal event it was waiting
+    for.
+
+    The teardown is what makes this observable, so it is modelled here: a real
+    connection stops accepting writes the moment the endpoint returns, which is
+    why a pump that is merely *still scheduled* is already too late.
+    """
+    omni = FakeOmni()
+    handler = _handler(omni)
+    ws = FakeWebSocket({"duplex": "1", "autostart": "0"})
+
+    async def serve() -> None:
+        try:
+            await handler.handle_realtime_session(ws)
+        finally:
+            # The ASGI server drops the connection when the endpoint returns;
+            # anything the pump writes after this never reaches the client.
+            ws.break_sends()
+
+    task = asyncio.create_task(serve())
+    ws.feed(_session_update())
+    created = await ws.wait_for("session.created")
+    handle = omni.handles[created["session"]["id"]]
+    submit = handle.submit
+
+    async def closing_submit(command: commands.DuplexCommand) -> None:
+        await submit(command)
+        if isinstance(command, commands.CloseSession):
+            # Same order as the real handle: queue the event, then flip the flag.
+            handle.deliver(SessionClosed(session_id=handle.session_id, reason="client_close"))
+            handle.closed = True
+
+    handle.submit = closing_submit  # type: ignore[method-assign]
+
+    ws.feed({"type": "session.close"})
+    await asyncio.wait_for(task, timeout=2.0)
+
+    assert ws.types()[-1] == "session.closed", f"terminal event never reached the wire: {ws.types()}"
+    assert ws.closed and ws.closed[0][0] == 1000, "the socket must close with a normal close frame"
+
+
+# --------------------------------------------------------------------------- #
+# Resume and takeover                                                         #
+# --------------------------------------------------------------------------- #
+
+
+async def _resume(
+    handler: OmniDuplexSessionHandler,
+    session_id: str,
+    token: str,
+    *,
+    last_seq: int = 0,
+) -> tuple[FakeWebSocket, asyncio.Task]:
+    ws = FakeWebSocket({"duplex": "1", "resume": "1"})
+    task = asyncio.create_task(handler.handle_realtime_session(ws))
+    ws.feed(
+        {
+            "type": "session.resume",
+            "session_id": session_id,
+            "resume_token": token,
+            "last_received_server_event_seq": last_seq,
+        }
+    )
+    return ws, task
+
+
+@pytest.mark.asyncio
+async def test_resume_after_disconnect_replays_missed_events_and_rotates_the_token() -> None:
+    omni = FakeOmni()
+    handler = _handler(omni)
+    ws, handle, task = await _open(handler, omni)
+    token = ws.sent[0]["resume_token"]
+    handle.deliver(AudioDelta(session_id=handle.session_id, response_id="r1", delta="one"))
+    await ws.wait_for("response.output_audio.delta")
+    ws.disconnect()
+    await asyncio.wait_for(task, timeout=2.0)
+    assert omni.detached == [handle.session_id]
+    # Emitted while detached: journaled for replay only.
+    handle.deliver(AudioDelta(session_id=handle.session_id, response_id="r1", delta="two"))
+    await asyncio.sleep(0.05)
+
+    ws2, task2 = await _resume(handler, handle.session_id, token, last_seq=1)
+    resumed = await ws2.wait_for("session.resumed")
+    assert resumed["session_id"] == handle.session_id
+    assert resumed["attachment_generation"] == 2
+    assert resumed["resume_token"] != token
+    assert "incarnation" not in resumed
+    replayed = await ws2.wait_for("response.output_audio.delta")
+    assert replayed["delta"] == "two" and replayed["server_event_seq"] == 2
+    assert omni.resumed == [(handle.session_id, 0)]
+
+    # The old token is revoked by the rotation.
+    ws3, task3 = await _resume(handler, handle.session_id, token)
+    await asyncio.wait_for(task3, timeout=2.0)
+    assert ws3.sent[0]["error"]["code"] == "invalid_resume_token"
+
+    ws2.feed({"type": "session.close"})
+    await asyncio.sleep(0.05)
+    ws2.disconnect()
+    await asyncio.wait_for(task2, timeout=2.0)
+
+
+@pytest.mark.asyncio
+async def test_resume_takes_over_a_live_attachment() -> None:
+    omni = FakeOmni()
+    handler = _handler(omni)
+    ws, handle, task = await _open(handler, omni)
+    token = ws.sent[0]["resume_token"]
+
+    ws2, task2 = await _resume(handler, handle.session_id, token)
+    await ws2.wait_for("session.resumed")
+    replaced = await ws.wait_for("session.replaced")
+    assert replaced["attachment_generation"] == 1
+    assert ws.closed and ws.closed[0][1] == "session_replaced"
+    # The replaced socket's later input is ignored; the new one drives the session.
+    ws.feed({"type": "input_audio_buffer.clear"})
+    ws2.feed({"type": "input_audio_buffer.clear", "event_id": "evt-new"})
+    await asyncio.sleep(0.05)
+    assert [command.event_id for command in handle.commands] == ["evt-new"]
+    await asyncio.wait_for(task, timeout=2.0)
+
+    ws2.disconnect()
+    await asyncio.wait_for(task2, timeout=2.0)
+    assert omni.detached == [handle.session_id]
+
+
+@pytest.mark.asyncio
+async def test_resume_validation_errors() -> None:
+    omni = FakeOmni()
+    handler = _handler(omni)
+    ws = FakeWebSocket({"duplex": "1", "resume": "1"})
+    task = asyncio.create_task(handler.handle_realtime_session(ws))
+    ws.feed({"type": "session.resume", "session_id": "duplex-x"})
+    await asyncio.wait_for(task, timeout=2.0)
+    assert ws.sent[0]["error"]["code"] == "invalid_session_resume"
+
+    ws, task = await _resume(handler, "duplex-unknown", "token")
+    await asyncio.wait_for(task, timeout=2.0)
+    assert ws.sent[0]["error"]["code"] == "session_resume_expired"
+
+
+@pytest.mark.asyncio
+async def test_journal_overflow_degrades_to_live_delivery_with_resync_required() -> None:
+    omni = FakeOmni(replay_max_bytes=256)
+    handler = _handler(omni)
+    ws, handle, task = await _open(handler, omni)
+
+    handle.deliver(AudioDelta(session_id=handle.session_id, response_id="r1", delta="x" * 400))
+    resync = await ws.wait_for("session.resync_required")
+    assert resync["reason"] == "journal_overflow"
+    delta = await ws.wait_for("response.output_audio.delta")
+    assert "server_event_seq" not in delta
+    assert ws.types().index("session.resync_required") < ws.types().index("response.output_audio.delta")
+
+    ws.disconnect()
+    await asyncio.wait_for(task, timeout=2.0)
+
+
+# --------------------------------------------------------------------------- #
+# Envelope helpers                                                            #
+# --------------------------------------------------------------------------- #
+
+
+def test_realtime_envelope_query_rules() -> None:
+    envelope = RealtimeEnvelope.from_query_params({"model": "m"})
+    assert envelope.initial_open_payload() == {"model": "m"}
+    assert envelope.initial_open_payload() is None  # autostart happens once
+
+    envelope = RealtimeEnvelope.from_query_params({"model": "m", "autostart": "0"})
+    assert envelope.resume_only is True
+    assert envelope.initial_open_payload() is None
+    assert RealtimeEnvelope.from_query_params({"resume": "1"}).resume_only is True
+    assert RealtimeEnvelope.from_query_params({"session_id": "mine"}).default_session_payload() == {"model": None}
+
+
+def test_realtime_envelope_first_message_classification() -> None:
+    envelope = RealtimeEnvelope.from_query_params({"model": "m", "autostart": "0"})
+    resume = envelope.first_message({"type": "session.resume", "session_id": "s"})
+    assert resume.kind == "resume" and resume.resume_payload["session_id"] == "s"
+
+    envelope = RealtimeEnvelope.from_query_params({"model": "m", "autostart": "0"})
+    opened = envelope.first_message({"type": "session.update", "session": {"model": "x", "instructions": "hi"}})
+    assert opened.kind == "open" and opened.session_payload == {"model": "x", "instructions": "hi"}
+    assert opened.pending_command_payload is None
+
+    envelope = RealtimeEnvelope.from_query_params({"model": "m", "autostart": "0"})
+    autostarted = envelope.first_message({"type": "input_audio_buffer.commit"})
+    assert autostarted.kind == "open" and autostarted.session_payload == {"model": "m"}
+    assert autostarted.pending_command_payload == {"type": "input_audio_buffer.commit"}
+
+
+def test_parse_resume_request_requires_the_three_fields_only() -> None:
+    request = parse_resume_request({"session_id": "s", "resume_token": "t", "last_received_server_event_seq": 3})
+    assert request is not None
+    assert (request.session_id, request.resume_token, request.last_received_server_event_seq) == ("s", "t", 3)
+    assert parse_resume_request({"session_id": "s", "resume_token": "t"}).last_received_server_event_seq == 0
+    assert parse_resume_request({"session_id": "s", "resume_token": "t", "incarnation": 1}) is not None
+    assert parse_resume_request({"session_id": "s"}) is None
+    assert parse_resume_request({"session_id": "s", "resume_token": "t", "last_received_server_event_seq": -1}) is None
+
+
+@pytest.mark.asyncio
+async def test_a_resume_that_fails_to_activate_does_not_detach_the_live_attachment() -> None:
+    """A rejected resume must roll back only what it owns.
+
+    Two reconnects can both authenticate and both complete the engine resume;
+    only one activates. The loser's activation raises, and the rollback used to
+    detach the *session*, starting the engine's disconnect grace for the winner
+    -- a grace ordinary heartbeats do not clear.
+
+    The activation failure is injected rather than raced for: what is under test
+    is the rollback's precondition, not the window that produces it.
+    """
+    omni = FakeOmni()
+    handler = _handler(omni)
+    ws, handle, task = await _open(handler, omni)
+    token = ws.sent[0]["resume_token"]
+    registry = handler._attachment_registry
+    try:
+        assert await registry.has_attachment(handle.session_id), "the opener is attached"
+        detached_before = list(omni.detached)
+
+        async def failing_resume(*args, **kwargs):
+            raise RuntimeError("transport activation lost the race")
+
+        original_resume = registry.resume
+        registry.resume = failing_resume  # type: ignore[method-assign]
+        try:
+            ws_lose, task_lose = await _resume(handler, handle.session_id, token)
+            error = await ws_lose.wait_for("error")
+        finally:
+            registry.resume = original_resume  # type: ignore[method-assign]
+
+        assert error["error"]["code"] == "session_resume_conflict"
+        assert omni.detached == detached_before, "the loser must not detach the winner"
+        assert await registry.has_attachment(handle.session_id), "the winner is still attached"
+    finally:
+        for pending in (task, locals().get("task_lose")):
+            if pending is not None:
+                pending.cancel()
+                with suppress(asyncio.CancelledError, Exception):
+                    await pending
diff --git a/tests/entrypoints/duplex/test_runtime_adapter_boundary.py b/tests/entrypoints/duplex/test_runtime_adapter_boundary.py
deleted file mode 100644
index cb90e4bd5..000000000
--- a/tests/entrypoints/duplex/test_runtime_adapter_boundary.py
+++ /dev/null
@@ -1,145 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-from __future__ import annotations
-
-import subprocess
-import sys
-from pathlib import Path
-from types import SimpleNamespace
-
-import pytest
-
-from vllm_omni.entrypoints.duplex.runtime_adapter import (
-    validate_serving_runtime_adapter,
-)
-
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
-
-
-@pytest.mark.parametrize(
-    "module_name",
-    [
-        "vllm_omni.entrypoints.duplex.session_runner",
-        "vllm_omni.entrypoints.duplex.runtime_bridge",
-        "vllm_omni.entrypoints.duplex.serving",
-    ],
-)
-def test_generic_openai_runtime_import_does_not_load_model_adapters(module_name: str) -> None:
-    repo_root = Path(__file__).resolve().parents[3]
-    script = f"""
-import sys
-
-import {module_name}
-
-model_duplex_prefixes = (
-    "vllm_omni.model_executor.models.minicpmo_4_5.duplex",
-    "vllm_omni.model_executor.models.nemotron_voicechat.duplex",
-    "vllm_omni.model_executor.models.personaplex.duplex",
-)
-loaded = sorted(
-    name
-    for name in sys.modules
-    if any(
-        name == prefix or name.startswith(prefix + ".")
-        for prefix in model_duplex_prefixes
-    )
-)
-if loaded:
-    raise SystemExit("generic OpenAI runtime loaded model duplex modules: " + ", ".join(loaded))
-"""
-
-    result = subprocess.run(
-        [sys.executable, "-c", script],
-        cwd=repo_root,
-        capture_output=True,
-        text=True,
-        timeout=60,
-        check=False,
-    )
-
-    assert result.returncode == 0, result.stderr
-
-
-def test_generic_handler_supports_adapterless_chat_fallback() -> None:
-    repo_root = Path(__file__).resolve().parents[3]
-    script = """
-from types import SimpleNamespace
-
-from vllm_omni.entrypoints.duplex.serving import OmniDuplexSessionHandler
-
-chat_service = SimpleNamespace(
-    engine_client=SimpleNamespace(),
-    model_config=SimpleNamespace(model="test-model"),
-)
-handler = OmniDuplexSessionHandler(chat_service=chat_service)
-if handler._serving_runtime_adapter is not None:
-    raise SystemExit("generic handler silently selected a model serving adapter")
-"""
-
-    result = subprocess.run(
-        [sys.executable, "-c", script],
-        cwd=repo_root,
-        capture_output=True,
-        text=True,
-        timeout=60,
-        check=False,
-    )
-
-    assert result.returncode == 0, result.stderr
-
-
-def _valid_runtime_adapter() -> SimpleNamespace:
-    data_plane = SimpleNamespace(
-        begin_request=lambda request_id: None,
-        is_terminal=lambda request_id: False,
-        mark_terminal=lambda request_id: None,
-        close_stream=lambda request_id: None,
-        close_session=lambda session_id, **kwargs: None,
-        project=lambda result, **kwargs: (),
-    )
-    return SimpleNamespace(
-        adapter_id="test-adapter",
-        session_states={},
-        data_plane=data_plane,
-        clean_response_done_prefix="clean",
-        interrupted_tts_prefix="interrupted",
-        private_runtime_config_keys=frozenset({"private_key"}),
-        create_session_state=lambda: object(),
-        session_state=lambda session_id: object(),
-        remove_session_state=lambda session_id: None,
-        is_enabled=lambda config: True,
-        capabilities=lambda **kwargs: object(),
-        validate_client_extra_body=lambda extra_body: None,
-        prepare_runtime_config=lambda config, **kwargs: {},
-        runtime_config_for_update=lambda config, current: {},
-        data_plane_context=lambda **kwargs: object(),
-    )
-
-
-@pytest.mark.parametrize(
-    ("attribute", "invalid_value"),
-    [
-        ("session_states", None),
-        ("clean_response_done_prefix", None),
-        ("interrupted_tts_prefix", None),
-        ("private_runtime_config_keys", {"private_key"}),
-    ],
-)
-def test_runtime_adapter_validator_rejects_invalid_protocol_attributes(
-    attribute: str,
-    invalid_value: object,
-) -> None:
-    adapter = _valid_runtime_adapter()
-    setattr(adapter, attribute, invalid_value)
-
-    with pytest.raises(TypeError, match=attribute):
-        validate_serving_runtime_adapter(adapter)
-
-
-def test_runtime_adapter_validator_rejects_incomplete_data_plane() -> None:
-    adapter = _valid_runtime_adapter()
-    adapter.data_plane.close_session = None
-
-    with pytest.raises(TypeError, match="data_plane.*close_session"):
-        validate_serving_runtime_adapter(adapter)
diff --git a/tests/entrypoints/duplex/test_runtime_control_redaction.py b/tests/entrypoints/duplex/test_runtime_control_redaction.py
deleted file mode 100644
index cfc5b68c5..000000000
--- a/tests/entrypoints/duplex/test_runtime_control_redaction.py
+++ /dev/null
@@ -1,115 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-"""Regression tests for duplex ``runtime_control`` payload redaction.
-
-The redacted result is emitted on the WebSocket (for example
-``session.created.runtime_control``), so it must always survive
-``json.dumps``. Control results carry typed values straight from the engine --
-``fence`` and ``accepted_fence`` are ``DuplexFence`` instances added by
-``DuplexControlClient.execute`` -- which previously reached
-``WebSocket.send_json`` unconverted and killed the session at handshake.
-"""
-
-from __future__ import annotations
-
-import json
-from dataclasses import dataclass
-from enum import Enum
-
-import pytest
-
-from vllm_omni.engine.duplex.messages import DuplexFence
-from vllm_omni.entrypoints.duplex.runtime_bridge import NativeRuntimeBridgeMixin
-
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
-
-_redact = NativeRuntimeBridgeMixin._redact_runtime_control_result
-
-
-def _control_result() -> dict[str, object]:
-    """The shape ``DuplexControlClient.execute`` returns for an open."""
-    return {
-        "ok": True,
-        "operation": "open",
-        "session_id": "sess-1",
-        "fence": DuplexFence("sess-1", epoch=0, turn_id=0, response_seq=0, incarnation=0),
-        "accepted_fence": DuplexFence("sess-1", epoch=1, turn_id=2, response_seq=3, incarnation=4),
-        "stage_results": [{"stage_id": -1, "replica_id": -1, "result": {"supported": True}}],
-    }
-
-
-def test_redacted_control_result_is_json_serializable() -> None:
-    """The whole payload must serialize the way send_json does."""
-    redacted = _redact(_control_result())
-    # Must not raise.
-    json.dumps({"type": "session.created", "runtime_control": redacted})
-
-
-def test_fences_are_converted_to_plain_dicts() -> None:
-    redacted = _redact(_control_result())
-    assert redacted["fence"] == {
-        "session_id": "sess-1",
-        "epoch": 0,
-        "turn_id": 0,
-        "response_seq": 0,
-        "incarnation": 0,
-    }
-    # Field values are preserved, not just the type.
-    assert redacted["accepted_fence"]["epoch"] == 1
-    assert redacted["accepted_fence"]["turn_id"] == 2
-    assert redacted["accepted_fence"]["response_seq"] == 3
-    assert redacted["accepted_fence"]["incarnation"] == 4
-
-
-def test_nested_dataclasses_are_converted() -> None:
-    """Fences can appear inside stage results, not only at the top level."""
-    redacted = _redact(
-        {
-            "stage_results": [
-                {"stage_id": 0, "result": {"fence": DuplexFence("sess-2", epoch=7)}},
-            ]
-        }
-    )
-    json.dumps(redacted)
-    assert redacted["stage_results"][0]["result"]["fence"]["epoch"] == 7
-
-
-def test_enums_are_reduced_to_values() -> None:
-    class _Mode(str, Enum):
-        APPEND = "append_audio_chunk"
-
-    redacted = _redact({"mode": _Mode.APPEND})
-    json.dumps(redacted)
-    assert redacted["mode"] == "append_audio_chunk"
-
-
-def test_redaction_still_drops_heavy_payload_keys() -> None:
-    """The pre-existing contract must be preserved."""
-    redacted = _redact(
-        {
-            "ok": True,
-            "stage_handoff": object(),
-            "tts_handoff": object(),
-            "omni_payload": object(),
-            "tts_hidden_states": object(),
-            "tts_token_ids": object(),
-            "traceback": "long trace",
-        }
-    )
-    assert redacted == {"ok": True}
-
-
-def test_plain_values_pass_through_unchanged() -> None:
-    payload = {"ok": True, "count": 3, "name": "x", "missing": None, "items": [1, "two"]}
-    assert _redact(payload) == payload
-
-
-def test_dataclass_types_are_not_treated_as_instances() -> None:
-    """A class object is not a dataclass instance and must not be asdict'd."""
-
-    @dataclass
-    class _Shape:
-        x: int = 1
-
-    assert _redact(_Shape) is _Shape
diff --git a/tests/entrypoints/duplex/test_websocket_actor.py b/tests/entrypoints/duplex/test_websocket_actor.py
deleted file mode 100644
index 9bdb73667..000000000
--- a/tests/entrypoints/duplex/test_websocket_actor.py
+++ /dev/null
@@ -1,145 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-import asyncio
-
-import pytest
-
-from vllm_omni.entrypoints.duplex.websocket import (
-    DuplexWebSocketActor,
-    normalize_duplex_input_event,
-)
-
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
-
-
-class FakeWebSocket:
-    def __init__(self) -> None:
-        self.sent: list[dict[str, object]] = []
-
-    async def send_json(self, payload: dict[str, object]) -> None:
-        self.sent.append(dict(payload))
-
-
-@pytest.mark.parametrize(
-    ("event", "expected"),
-    [
-        ({"type": "signal_turn", "event": "barge_in"}, {"type": "turn.signal", "event": "barge_in"}),
-        ({"type": "close_session"}, {"type": "session.close"}),
-        ({"type": "audio.playback_ack", "played_ms": 1}, {"type": "playback.ack", "played_ms": 1}),
-        ({"type": "input_text.append", "text": "a"}, {"type": "input.text.append", "text": "a"}),
-        ({"type": "push_text", "text": "b"}, {"type": "input.text.append", "text": "b"}),
-        (
-            {"type": "input.audio.append", "audio": "wav"},
-            {"type": "input_audio_buffer.append", "audio": "wav", "format": "wav"},
-        ),
-        (
-            {"type": "push_chunk", "audio": "wav", "format": "pcm_f32le"},
-            {"type": "input_audio_buffer.append", "audio": "wav", "format": "pcm_f32le"},
-        ),
-    ],
-)
-def test_input_aliases_normalize_once_at_mailbox_boundary(event, expected):
-    assert normalize_duplex_input_event(event) == expected
-
-
-def test_actor_uses_one_fifo_mailbox_for_inbound_events():
-    actor = DuplexWebSocketActor(FakeWebSocket())
-
-    assert isinstance(actor.mailbox, asyncio.Queue)
-    assert not isinstance(actor.mailbox, asyncio.PriorityQueue)
-    assert not hasattr(actor, "control_queue")
-    assert not hasattr(actor, "input_queue")
-    assert not hasattr(actor, "event_queue")
-    assert not hasattr(actor, "lifecycle_state")
-    assert not hasattr(actor, "last_response_id")
-    assert not hasattr(actor, "overlap_speech_ms")
-    assert not hasattr(actor, "transition")
-    assert not hasattr(actor, "output_generation_in_flight")
-    assert not hasattr(actor, "session")
-    assert not hasattr(actor, "runtime_opened")
-    assert not hasattr(actor, "runtime_closed")
-    assert not hasattr(actor, "drain_input_queue")
-    assert not hasattr(actor, "control_events_seen")
-    assert not hasattr(actor, "input_events_seen")
-    assert not hasattr(actor, "cancel_count")
-
-
-@pytest.mark.asyncio
-async def test_control_event_does_not_overtake_earlier_audio_input():
-    actor = DuplexWebSocketActor(FakeWebSocket())
-    await actor.enqueue_event({"type": "input_audio_buffer.append", "audio": "pcm"})
-    await actor.enqueue_event({"type": "response.cancel"})
-
-    assert await actor.next_event() == {"type": "input_audio_buffer.append", "audio": "pcm"}
-    assert await actor.next_event() == {"type": "response.cancel"}
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("event_type", ["input.cancel", "session.close", "close_session"])
-async def test_terminal_control_preserves_wire_order(event_type: str):
-    actor = DuplexWebSocketActor(FakeWebSocket())
-    await actor.enqueue_event({"type": "input_audio_buffer.append", "audio": "pcm"})
-    await actor.enqueue_event({"type": event_type})
-
-    assert await actor.next_event() == {"type": "input_audio_buffer.append", "audio": "pcm"}
-    assert await actor.next_event() == {"type": event_type}
-
-
-@pytest.mark.asyncio
-async def test_mailbox_delivers_every_enqueued_event_exactly_once():
-    actor = DuplexWebSocketActor(FakeWebSocket())
-    events = [
-        {"type": "input_audio_buffer.append", "audio": str(index)}
-        if index % 2
-        else {"type": "response.created", "response_id": f"resp-{index}"}
-        for index in range(20)
-    ]
-
-    await asyncio.gather(*(actor.enqueue_event(dict(event)) for event in events))
-    received = [await actor.next_event() for _ in events]
-
-    assert sorted(received, key=repr) == sorted(events, key=repr)
-
-
-@pytest.mark.asyncio
-async def test_writer_is_single_owner_of_websocket_send():
-    websocket = FakeWebSocket()
-    actor = DuplexWebSocketActor(websocket)
-    writer = asyncio.create_task(actor.writer_loop())
-
-    await actor.send_json({"type": "one"})
-    await actor.send_json({"type": "two"})
-    await actor.close_writer()
-    await writer
-
-    assert websocket.sent == [{"type": "one"}, {"type": "two"}]
-
-
-@pytest.mark.asyncio
-async def test_stale_fence_payload_is_dropped_before_websocket_send():
-    websocket = FakeWebSocket()
-    actor = DuplexWebSocketActor(websocket, current_epoch=lambda: 2)
-    writer = asyncio.create_task(actor.writer_loop())
-
-    await actor.send_json({"type": "response.audio.delta", "epoch": 1})
-    await actor.send_json({"type": "response.audio.delta", "epoch": 2})
-    await actor.close_writer()
-    await writer
-
-    assert websocket.sent == [{"type": "response.audio.delta", "epoch": 2}]
-    assert actor.stale_output_dropped == 1
-
-
-@pytest.mark.asyncio
-async def test_writer_does_not_revoke_accepted_terminal_after_close_starts():
-    websocket = FakeWebSocket()
-    actor = DuplexWebSocketActor(websocket, current_epoch=lambda: 1)
-    await actor.send_json({"type": "response.done", "epoch": 1, "response_id": "resp-1"})
-    actor.closing = True
-    await actor.close_writer()
-
-    await actor.writer_loop()
-
-    assert websocket.sent == [{"type": "response.done", "epoch": 1, "response_id": "resp-1"}]
-    assert actor.stale_output_dropped == 0
diff --git a/tests/entrypoints/openai/test_duplex_protocol.py b/tests/entrypoints/openai/test_duplex_protocol.py
deleted file mode 100644
index e5f3becbc..000000000
--- a/tests/entrypoints/openai/test_duplex_protocol.py
+++ /dev/null
@@ -1,553 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-import asyncio
-import json
-
-import pytest
-
-from vllm_omni.entrypoints.duplex.protocol import (
-    DuplexOverlapPolicy,
-    DuplexSession,
-    DuplexSessionConfig,
-    DuplexSessionRegistry,
-    DuplexTurnController,
-    DuplexTurnEventType,
-    DuplexTurnState,
-    ResponseCreateOptions,
-)
-from vllm_omni.entrypoints.duplex.realtime_session import (
-    NativeRealtimeSessionProtocol,
-)
-from vllm_omni.entrypoints.duplex.realtime_state import RealtimeStateOwner
-from vllm_omni.model_executor.models.minicpmo_4_5.duplex.capabilities import (
-    minicpmo45_native_capabilities,
-)
-
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
-
-
-def test_realtime_state_owner_uses_explicit_bindings_not_dynamic_attribute_proxy():
-    assert "__getattr__" not in RealtimeStateOwner.__dict__
-    assert "__setattr__" not in RealtimeStateOwner.__dict__
-
-
-class _ProtocolWebSocket:
-    def __init__(self, *events: dict[str, object]) -> None:
-        self._events = asyncio.Queue()
-        for event in events:
-            self._events.put_nowait(json.dumps(event))
-
-    async def receive_text(self) -> str:
-        return await self._events.get()
-
-
-def test_duplex_session_commits_text_and_audio_as_one_turn():
-    registry = DuplexSessionRegistry()
-    session = registry.create(DuplexSessionConfig(model="test-model"))
-
-    session.append_text("hello")
-    session.append_audio("YWJj", fmt="wav", sample_rate_hz=16000)
-    committed = session.commit_user_input()
-
-    assert committed is not None
-    assert committed.turn_id == 0
-    assert committed.input_commit_seq == 1
-    assert committed.epoch == 0
-    assert len(session.history) == 1
-    content = session.history[0]["content"]
-    assert isinstance(content, list)
-    assert content[0] == {"type": "text", "text": "hello"}
-    assert content[1]["type"] == "audio_url"
-    assert content[1]["audio_url"]["url"] == "data:audio/wav;base64,YWJj"
-    assert session.turn_state == DuplexTurnState.USER_COMMITTED
-
-
-def test_response_options_apply_to_one_response_without_mutating_session_defaults():
-    session = DuplexSession(
-        session_id="sid-response-options",
-        config=DuplexSessionConfig(instructions="base", voice="base-voice", max_tokens=64),
-    )
-    session.reserve_response_options(
-        ResponseCreateOptions(
-            instructions="one response",
-            voice="override-voice",
-            max_tokens=8,
-        )
-    )
-
-    assert session.config.instructions == "base"
-    assert session.config.voice == "base-voice"
-    session.begin_response()
-    assert session.config.instructions == "base"
-    assert session.config.voice == "base-voice"
-    assert session.response_config.instructions == "one response"
-    assert session.response_config.voice == "override-voice"
-    assert session.response_config.max_tokens == 8
-
-    session.end_response()
-    assert session.config.instructions == "base"
-    assert session.config.voice == "base-voice"
-    assert session.config.max_tokens == 64
-
-
-def test_response_options_cannot_overwrite_an_unconsumed_reservation():
-    session = DuplexSession(
-        session_id="sid-response-options-pending",
-        config=DuplexSessionConfig(instructions="base"),
-    )
-    session.reserve_response_options(ResponseCreateOptions(instructions="first"))
-
-    with pytest.raises(RuntimeError, match="already reserved"):
-        session.reserve_response_options(ResponseCreateOptions(instructions="second"))
-
-    session.begin_response()
-    assert session.response_config.instructions == "first"
-
-
-def test_response_options_cannot_be_reserved_while_response_is_active():
-    session = DuplexSession(
-        session_id="sid-response-options-active",
-        config=DuplexSessionConfig(instructions="base"),
-    )
-    session.begin_response()
-
-    with pytest.raises(RuntimeError, match="active"):
-        session.reserve_response_options(ResponseCreateOptions(instructions="too late"))
-
-
-def test_realtime_model_name_does_not_implicitly_enable_native_duplex():
-    protocol = NativeRealtimeSessionProtocol({})
-
-    event = protocol._session_create_from_realtime({"model": "openbmb/MiniCPM-o-4_5"})
-
-    assert "native_duplex" not in event["session"]["extra_body"]
-    assert "minicpmo45_native_duplex" not in event["session"]["extra_body"]
-
-
-def test_realtime_explicit_native_duplex_flag_is_preserved():
-    protocol = NativeRealtimeSessionProtocol({})
-
-    event = protocol._session_create_from_realtime(
-        {
-            "model": "openbmb/MiniCPM-o-4_5",
-            "extra_body": {"native_duplex": True},
-        }
-    )
-
-    assert event["session"]["extra_body"]["native_duplex"] is True
-
-
-def test_realtime_legacy_native_duplex_alias_is_normalized():
-    # The deprecated model-prefixed spelling still opts in, but everything
-    # downstream (and every session echo) sees only the canonical key.
-    protocol = NativeRealtimeSessionProtocol({})
-
-    event = protocol._session_create_from_realtime(
-        {
-            "model": "openbmb/MiniCPM-o-4_5",
-            "extra_body": {"minicpmo45_native_duplex": True},
-        }
-    )
-
-    assert event["session"]["extra_body"]["native_duplex"] is True
-    assert "minicpmo45_native_duplex" not in event["session"]["extra_body"]
-
-
-def test_realtime_explicit_query_native_duplex_flag_is_available_before_autostart():
-    protocol = NativeRealtimeSessionProtocol(
-        {
-            "model": "openbmb/MiniCPM-o-4_5",
-            "native_duplex": "1",
-        }
-    )
-
-    event = json.loads(asyncio.run(protocol.receive_internal_event_text(None)))
-
-    assert event["type"] == "session.create"
-    assert event["session"]["extra_body"]["native_duplex"] is True
-
-
-def test_realtime_legacy_query_native_duplex_alias_seeds_canonical_key():
-    protocol = NativeRealtimeSessionProtocol(
-        {
-            "model": "openbmb/MiniCPM-o-4_5",
-            "minicpmo45_native_duplex": "1",
-        }
-    )
-
-    event = json.loads(asyncio.run(protocol.receive_internal_event_text(None)))
-
-    assert event["type"] == "session.create"
-    assert event["session"]["extra_body"]["native_duplex"] is True
-    assert "minicpmo45_native_duplex" not in event["session"]["extra_body"]
-
-
-@pytest.mark.asyncio
-async def test_realtime_resume_heartbeat_and_event_ack_translate_without_session_autostart():
-    protocol = NativeRealtimeSessionProtocol(
-        {
-            "model": "openbmb/MiniCPM-o-4_5",
-            "native_duplex": "1",
-        }
-    )
-
-    resume = await protocol._to_duplex_event(
-        {
-            "type": "session.resume",
-            "session_id": "sid-resume",
-            "incarnation": 3,
-            "resume_token": "opaque-token",
-            "last_received_server_event_seq": 17,
-        }
-    )
-    heartbeat = await protocol._to_duplex_event(
-        {
-            "type": "session.heartbeat",
-            "event_id": "event-heartbeat",
-        }
-    )
-    event_ack = await protocol._to_duplex_event(
-        {
-            "type": "session.event_ack",
-            "server_event_seq": 19,
-        }
-    )
-
-    assert resume == {
-        "type": "session.resume",
-        "session_id": "sid-resume",
-        "incarnation": 3,
-        "resume_token": "opaque-token",
-        "last_received_server_event_seq": 17,
-    }
-    assert heartbeat == {
-        "type": "session.heartbeat",
-        "event_id": "event-heartbeat",
-    }
-    assert event_ack == {
-        "type": "session.event_ack",
-        "server_event_seq": 19,
-    }
-    assert protocol._opened is False
-
-    wire_protocol = NativeRealtimeSessionProtocol({})
-    first_wire_event = json.loads(
-        await wire_protocol.receive_internal_event_text(
-            _ProtocolWebSocket(
-                {
-                    "type": "session.resume",
-                    "session_id": "sid-resume",
-                    "incarnation": 3,
-                    "resume_token": "opaque-token",
-                    "last_received_server_event_seq": 17,
-                }
-            )
-        )
-    )
-
-    assert first_wire_event["type"] == "session.resume"
-
-
-@pytest.mark.asyncio
-async def test_realtime_resume_query_suppresses_model_autostart_on_same_url():
-    protocol = NativeRealtimeSessionProtocol(
-        {
-            "model": "openbmb/MiniCPM-o-4_5",
-            "native_duplex": "1",
-            "resume": "1",
-        }
-    )
-    resume = {
-        "type": "session.resume",
-        "session_id": "sid-resume",
-        "incarnation": 3,
-        "resume_token": "opaque-token",
-        "last_received_server_event_seq": 17,
-    }
-
-    first_wire_event = json.loads(await protocol.receive_internal_event_text(_ProtocolWebSocket(resume)))
-
-    assert first_wire_event == resume
-    assert protocol._autostarted_default_session is False
-
-
-def test_realtime_projects_resume_lifecycle_events_without_duplex_prefix():
-    protocol = NativeRealtimeSessionProtocol({})
-
-    created = protocol.encode_outbound_event(
-        {
-            "type": "session.created",
-            "session": {"id": "sid-resume"},
-            "incarnation": 3,
-            "attachment_generation": 1,
-            "resume_token": "first-token",
-        }
-    )[0]
-    resumed = protocol.encode_outbound_event(
-        {
-            "type": "session.resumed",
-            "session_id": "sid-resume",
-            "incarnation": 3,
-            "attachment_generation": 2,
-            "resume_token": "second-token",
-        }
-    )[0]
-    heartbeat = protocol.encode_outbound_event(
-        {
-            "type": "session.heartbeat_ack",
-            "session_id": "sid-resume",
-        }
-    )[0]
-    replaced = protocol.encode_outbound_event(
-        {
-            "type": "session.replaced",
-            "session_id": "sid-resume",
-            "attachment_generation": 1,
-        }
-    )[0]
-    resync = protocol.encode_outbound_event(
-        {
-            "type": "session.resync_required",
-            "session_id": "sid-resume",
-            "reason": "journal_gap",
-        }
-    )[0]
-
-    assert created["type"] == "session.created"
-    assert created["incarnation"] == 3
-    assert created["attachment_generation"] == 1
-    assert created["resume_token"] == "first-token"
-    assert resumed["type"] == "session.resumed"
-    assert resumed["resume_token"] == "second-token"
-    assert heartbeat["type"] == "session.heartbeat_ack"
-    assert replaced["type"] == "session.replaced"
-    assert resync == {
-        "type": "session.resync_required",
-        "session_id": "sid-resume",
-        "reason": "journal_gap",
-        "event_id": resync["event_id"],
-    }
-
-
-def test_realtime_projects_listen_response_identity():
-    protocol = NativeRealtimeSessionProtocol({})
-    protocol.encode_outbound_event({"type": "session.created", "session": {"id": "sid-listen"}})
-
-    bound = protocol.encode_outbound_event(
-        {
-            "type": "response.listen",
-            "session_id": "sid-listen",
-            "epoch": 0,
-            "reason": "model_listen",
-            "model_listen": True,
-            "response_id": "resp_1",
-        }
-    )[0]
-    # A listen that terminates a precreated response keeps the response
-    # identity on the Realtime dialect; clients demultiplex on response_id.
-    assert bound["type"] == "response.listen"
-    assert bound["response_id"] == "resp_1"
-    assert bound["response"]["id"] == "resp_1"
-    assert bound["response"]["status"] == "listening"
-
-    anonymous = protocol.encode_outbound_event(
-        {
-            "type": "response.listen",
-            "session_id": "sid-listen",
-            "epoch": 0,
-            "reason": "silence_or_noise",
-        }
-    )[0]
-    assert "response_id" not in anonymous
-    assert "id" not in anonymous["response"]
-
-
-def test_duplex_session_registry_advances_incarnation_when_id_is_reused():
-    registry = DuplexSessionRegistry()
-
-    first = registry.create(session_id="reused-session")
-    registry.close(first.session_id)
-    second = registry.create(session_id="reused-session")
-
-    assert first.incarnation == 0
-    assert second.incarnation == 1
-
-
-def test_native_input_commit_does_not_advance_model_turn_identity():
-    session = DuplexSession(
-        session_id="sid-model-owned-turn",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-
-    first = session.commit_native_audio_input(transcript="first chunk")
-    second = session.commit_native_audio_input(transcript="second chunk")
-
-    assert session.input_commit_seq == 2
-    assert first.input_commit_seq == 1
-    assert second.input_commit_seq == 2
-    assert first.turn_id == second.turn_id == session.turn_id == 0
-
-
-def test_duplex_session_owns_response_and_overlap_identity():
-    session = DuplexSession(session_id="sid-state-owner", config=DuplexSessionConfig())
-
-    response_id = session.begin_response()
-    session.accumulate_overlap_speech(320)
-    session.accumulate_overlap_speech(180)
-    session.end_response()
-
-    assert session.active_response_id is None
-    assert session.last_response_id == response_id
-    assert session.overlap_speech_ms == 500
-    assert session.reset_overlap_speech() == 500
-    assert session.overlap_speech_ms == 0
-
-
-def test_duplex_session_composes_single_owner_ledgers():
-    session = DuplexSession(session_id="sid-ledgers", config=DuplexSessionConfig())
-
-    session.append_text("hello")
-    session.bind_request("req-1")
-    response_id = session.begin_response(turn_id=3)
-    session.mark_audio_sent(duration_ms=240)
-
-    assert not hasattr(session, "input")
-    assert not hasattr(session, "response")
-    assert not hasattr(session, "playback_ledger")
-    assert not hasattr(session, "conversation")
-    assert session.pending_text == ("hello",)
-    assert session.active_request_id == "req-1"
-    assert session.active_response_id == response_id
-    assert session.active_response_turn_id == 3
-    assert session.playback.sent_ms == 240
-
-    try:
-        session.playback.sent_ms = 480
-    except (AttributeError, TypeError):
-        pass
-    else:
-        raise AssertionError("playback view must be immutable")
-
-
-def test_duplex_barge_in_advances_epoch_and_drops_uncommitted_assistant_text():
-    registry = DuplexSessionRegistry()
-    session = registry.create()
-    response_id = session.begin_response()
-    session.bind_request("chatcmpl-duplex-test")
-    session.append_assistant_text("unplayed answer")
-
-    new_epoch = session.barge_in()
-
-    assert response_id is not None
-    assert new_epoch == 1
-    assert session.epoch == 1
-    assert session.active_request_id is None
-    assert session.active_response_id is None
-    assert session.assistant_text_buffer == ()
-    assert session.history == ()
-    assert session.turn_state == DuplexTurnState.BARGE_IN
-
-
-def test_duplex_playback_ack_tracks_committed_cursor_separately():
-    registry = DuplexSessionRegistry()
-    session = registry.create()
-    session.mark_audio_sent(duration_ms=10_000)
-
-    session.acknowledge_playback(played_ms=2_000)
-
-    assert session.playback.generated_ms == 10_000
-    assert session.playback.sent_ms == 10_000
-    assert session.playback.played_ms == 2_000
-    assert session.playback.committed_ms == 2_000
-
-
-def test_duplex_history_commit_uses_audio_text_alignment_marks():
-    registry = DuplexSessionRegistry()
-    session = registry.create()
-    session.begin_response()
-
-    session.append_assistant_text("hello ")
-    session.mark_audio_sent(duration_ms=1_000, text_chars=6)
-    session.append_assistant_text("world")
-    session.mark_audio_sent(duration_ms=2_000, text_chars=11)
-    session.acknowledge_playback(played_ms=1_200, committed_ms=1_200)
-
-    committed = session.end_response(commit_text=True)
-
-    assert committed == {"role": "assistant", "content": "hello w"}
-
-
-def test_turn_controller_accepts_external_signal_source():
-    registry = DuplexSessionRegistry()
-    session = registry.create()
-    controller = DuplexTurnController()
-
-    event = controller.signal(session, DuplexTurnEventType.USER_STARTED.value)
-
-    assert event["type"] == "turn.event"
-    assert event["event"] == "user_started"
-    assert event["turn_state"] == "user_speaking"
-    assert session.turn_state == DuplexTurnState.USER_SPEAKING
-
-
-def test_duplex_capabilities_do_not_claim_core_kv_or_input_append():
-    registry = DuplexSessionRegistry()
-    session = registry.create()
-    caps = session.capabilities.as_dict()
-
-    assert caps["implementation_level"] == "serving_session_adapter"
-    assert caps["supports_kv_lease"] is False
-    assert caps["supports_input_append"] is False
-    assert caps["supports_reencode_context"] is True
-    assert caps["adapter_patterns"] == ["chunk_group_append"]
-    assert "turn_commit_only" in caps["input_modes"]
-    assert "client_event" in caps["signal_sources"]
-
-
-def test_minicpmo_native_capabilities_separate_model_state_from_core_kv_lease():
-    caps = minicpmo45_native_capabilities(max_sessions=2).as_dict()
-
-    assert caps["implementation_level"] == "model_native_duplex"
-    assert caps["supports_input_append"] is True
-    assert caps["input_modes"] == ["append_audio_chunk"]
-    assert caps["adapter_patterns"] == ["scheduler_data_plane"]
-    assert caps["supports_model_internal_state"] is True
-    assert caps["requires_model_runner_kv"] is True
-    assert caps["requires_native_stage_role"] is True
-    assert caps["supports_kv_lease"] is False
-    assert caps["supports_core_kv_lease"] is False
-    assert caps["supports_stage_resumption"] is True
-    assert caps["supports_scheduler_native_append"] is False
-    assert caps["supports_core_resumable_request"] is True
-    assert caps["supports_stage_connector_handoff"] is True
-    assert caps["supports_audio_truncate"] is True
-    assert caps["supports_barge_in"] is True
-    assert caps["target_barge_in_latency_ms"] is None
-    assert caps["supports_multi_session"] is True
-    assert caps["supports_multi_session_same_replica"] is True
-    assert caps["supports_session_lease"] is True
-    assert caps["supports_session_resume"] is True
-    assert caps["session_admission_mode"] == "engine_managed"
-    assert caps["stage_handoff_transport"] == "scheduler_data_plane"
-
-
-def test_duplex_overlap_policy_auto_falls_back_to_listen_only():
-    from vllm_omni.entrypoints.duplex.protocol import (
-        DuplexOverlapPolicy,
-        DuplexSessionConfig,
-    )
-
-    assert DuplexSessionConfig._normalize_overlap_policy("auto") == DuplexOverlapPolicy.LISTEN_ONLY.value
-
-
-def test_minicpmo_native_capabilities_do_not_overclaim_single_session_deployment():
-    caps = minicpmo45_native_capabilities(max_sessions=1).as_dict()
-
-    assert caps["supports_multi_session"] is False
-    assert caps["supports_multi_session_same_replica"] is False
-
-
-def test_duplex_overlap_policy_defaults_and_invalid_values_to_listen_only():
-    assert DuplexSessionConfig().overlap_policy == DuplexOverlapPolicy.LISTEN_ONLY.value
-    assert DuplexSessionConfig._normalize_overlap_policy("not-a-policy") == DuplexOverlapPolicy.LISTEN_ONLY.value
diff --git a/tests/entrypoints/openai/test_duplex_session_attachment.py b/tests/entrypoints/openai/test_duplex_session_attachment.py
index b4ea9c328..9d7a208b5 100644
--- a/tests/entrypoints/openai/test_duplex_session_attachment.py
+++ b/tests/entrypoints/openai/test_duplex_session_attachment.py
@@ -78,7 +78,7 @@ def test_event_journal_sequences_acknowledges_and_replays_exact_payloads() -> No
     clock = _Clock()
     journal = DuplexEventJournal(max_bytes=4096, ttl_s=60.0, clock=clock)
 
-    first = journal.record({"type": "response.audio.delta", "delta": "AAAA"})
+    first = journal.record({"type": "response.output_audio.delta", "delta": "AAAA"})
     second = journal.record({"type": "response.done", "response_id": "resp-1"})
 
     assert first.sequence == 1
@@ -122,6 +122,90 @@ def test_event_journal_overflow_is_explicit_and_does_not_evict_silently() -> Non
         journal.replay_after(0)
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize("journal", [False, True])
+async def test_registry_failed_send_is_accepted_only_when_journaled(mocker, journal: bool) -> None:
+    registry = DuplexSessionAttachmentRegistry(replay_ttl_s=60.0, replay_max_bytes_per_session=4096)
+    accepted = mocker.Mock()
+    expected_calls = [mocker.call()] if journal else []
+
+    async def failing_send(payload):
+        assert accepted.call_args_list == expected_calls
+        raise RuntimeError("transport lost")
+
+    await registry.create("sid-send-failure", send=failing_send, close=mocker.AsyncMock())
+
+    with pytest.raises(RuntimeError, match="transport lost"):
+        await registry.send_event(
+            "sid-send-failure",
+            {"type": "response.audio.delta", "delta": "AAAA"},
+            journal=journal,
+            on_accepted=accepted,
+        )
+
+    assert accepted.call_args_list == expected_calls
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("journal", [False, True])
+async def test_registry_detached_event_is_accepted_only_when_journaled(mocker, journal: bool) -> None:
+    registry = DuplexSessionAttachmentRegistry(replay_ttl_s=60.0, replay_max_bytes_per_session=4096)
+    send = mocker.AsyncMock()
+    accepted = mocker.Mock()
+    created = await registry.create("sid-detached-acceptance", send=send, close=mocker.AsyncMock())
+    await registry.detach("sid-detached-acceptance", attachment_generation=created.attachment_generation)
+
+    entry = await registry.send_event(
+        "sid-detached-acceptance",
+        {"type": "response.audio.delta", "delta": "AAAA"},
+        journal=journal,
+        on_accepted=accepted,
+    )
+
+    send.assert_not_awaited()
+    assert (entry is not None) is journal
+    assert accepted.call_count == int(journal)
+
+
+@pytest.mark.asyncio
+async def test_registry_unjournaled_event_is_accepted_after_successful_send(mocker) -> None:
+    registry = DuplexSessionAttachmentRegistry(replay_ttl_s=60.0, replay_max_bytes_per_session=4096)
+    accepted = mocker.Mock()
+
+    async def send(payload):
+        accepted.assert_not_called()
+
+    await registry.create("sid-live-acceptance", send=send, close=mocker.AsyncMock())
+
+    entry = await registry.send_event(
+        "sid-live-acceptance",
+        {"type": "response.audio.delta", "delta": "AAAA"},
+        journal=False,
+        on_accepted=accepted,
+    )
+
+    assert entry is None
+    accepted.assert_called_once_with()
+
+
+@pytest.mark.asyncio
+async def test_registry_overflow_does_not_accept_or_send_event(mocker) -> None:
+    registry = DuplexSessionAttachmentRegistry(replay_ttl_s=60.0, replay_max_bytes_per_session=100)
+    accepted = mocker.Mock()
+    send = mocker.AsyncMock()
+    await registry.create("sid-overflow-acceptance", send=send, close=mocker.AsyncMock())
+
+    with pytest.raises(DuplexJournalOverflowError, match="byte limit"):
+        await registry.send_event(
+            "sid-overflow-acceptance",
+            {"type": "response.audio.delta", "delta": "A" * 200},
+            on_accepted=accepted,
+        )
+
+    accepted.assert_not_called()
+    send.assert_not_awaited()
+
+
 @pytest.mark.asyncio
 async def test_registry_resume_rotates_token_replays_and_atomically_replaces_attachment() -> None:
     clock = _Clock()
@@ -147,13 +231,12 @@ async def test_registry_resume_rotates_token_replays_and_atomically_replaces_att
     async def close_b(reason):
         closes_b.append(reason)
 
-    created = await registry.create("sid", incarnation=2, send=send_a, close=close_a)
+    created = await registry.create("sid", send=send_a, close=close_a)
     await registry.send_event("sid", {"type": "event-1"})
     await registry.send_event("sid", {"type": "event-2"})
 
     resumed = await registry.resume(
         "sid",
-        incarnation=2,
         resume_token=created.resume_token.plaintext,
         last_received_server_event_seq=1,
         send=send_b,
@@ -176,6 +259,34 @@ async def test_registry_resume_rotates_token_replays_and_atomically_replaces_att
     assert closes_a == [] and sends_b == [] and closes_b == []
 
 
+@pytest.mark.asyncio
+async def test_registry_detach_without_a_generation_targets_the_current_attachment_once() -> None:
+    registry = DuplexSessionAttachmentRegistry(replay_ttl_s=60.0, replay_max_bytes_per_session=4096)
+    sends: list[dict] = []
+
+    async def send(payload):
+        sends.append(payload)
+
+    async def close(reason):
+        return None
+
+    await registry.create("sid-current", send=send, close=close)
+
+    # The outbound pump outlives any one connection and only knows the session:
+    # ``None`` means "whichever socket is attached right now".
+    assert await registry.detach("sid-current", attachment_generation=None) is True
+    # A second report of the same dead socket is not a new detach, so it cannot
+    # restart the engine's disconnect grace window.
+    assert await registry.detach("sid-current", attachment_generation=None) is False
+    assert await registry.detach("sid-current", attachment_generation=1) is False
+    assert await registry.is_current_attachment("sid-current", 1) is False
+
+    # A detached session still journals for a later resume.
+    await registry.send_event("sid-current", {"type": "event-1"})
+    assert sends == []
+    assert await registry.detach("missing-session", attachment_generation=None) is False
+
+
 @pytest.mark.asyncio
 async def test_registry_resume_sends_activation_then_replay_before_new_live_events() -> None:
     registry = DuplexSessionAttachmentRegistry(
@@ -198,13 +309,12 @@ async def test_registry_resume_sends_activation_then_replay_before_new_live_even
             activation_started.set()
             await release_activation.wait()
 
-    created = await registry.create("sid-order", incarnation=0, send=old_send, close=close)
+    created = await registry.create("sid-order", send=old_send, close=close)
     await registry.detach("sid-order", attachment_generation=1)
     await registry.send_event("sid-order", {"type": "replayed"})
     resume_task = asyncio.create_task(
         registry.resume(
             "sid-order",
-            incarnation=0,
             resume_token=created.resume_token.plaintext,
             last_received_server_event_seq=0,
             send=new_send,
@@ -238,13 +348,12 @@ async def test_registry_resume_delivery_failure_keeps_one_shot_old_token_recover
     async def close(reason):
         del reason
 
-    created = await registry.create("sid-recovery", incarnation=0, send=send, close=close)
+    created = await registry.create("sid-recovery", send=send, close=close)
     await registry.detach("sid-recovery", attachment_generation=1)
 
     with pytest.raises(RuntimeError, match="transport lost"):
         await registry.resume(
             "sid-recovery",
-            incarnation=0,
             resume_token=created.resume_token.plaintext,
             last_received_server_event_seq=0,
             send=failing_send,
@@ -258,7 +367,6 @@ async def test_registry_resume_delivery_failure_keeps_one_shot_old_token_recover
 
     recovered = await registry.resume(
         "sid-recovery",
-        incarnation=0,
         resume_token=created.resume_token.plaintext,
         last_received_server_event_seq=0,
         send=send,
@@ -269,7 +377,6 @@ async def test_registry_resume_delivery_failure_keeps_one_shot_old_token_recover
     with pytest.raises(InvalidResumeTokenError):
         await registry.resume(
             "sid-recovery",
-            incarnation=0,
             resume_token=created.resume_token.plaintext,
             last_received_server_event_seq=0,
             send=send,
@@ -290,13 +397,12 @@ async def test_registry_concurrent_resume_allows_exactly_one_rotated_token_winne
     async def close(reason):
         del reason
 
-    created = await registry.create("sid-race", incarnation=0, send=send, close=close)
+    created = await registry.create("sid-race", send=send, close=close)
 
     async def attempt():
         try:
             return await registry.resume(
                 "sid-race",
-                incarnation=0,
                 resume_token=created.resume_token.plaintext,
                 last_received_server_event_seq=0,
                 send=send,
@@ -312,7 +418,7 @@ async def test_registry_concurrent_resume_allows_exactly_one_rotated_token_winne
 
 
 @pytest.mark.asyncio
-async def test_registry_keeps_sessions_journals_and_incarnations_isolated() -> None:
+async def test_registry_keeps_sessions_journals_and_tokens_isolated() -> None:
     registry = DuplexSessionAttachmentRegistry(
         replay_ttl_s=60.0,
         replay_max_bytes_per_session=4096,
@@ -324,8 +430,8 @@ async def test_registry_keeps_sessions_journals_and_incarnations_isolated() -> N
     async def close(reason):
         del reason
 
-    created_a = await registry.create("sid-a", incarnation=1, send=send, close=close)
-    created_b = await registry.create("sid-b", incarnation=4, send=send, close=close)
+    created_a = await registry.create("sid-a", send=send, close=close)
+    created_b = await registry.create("sid-b", send=send, close=close)
     await registry.detach("sid-a", attachment_generation=1)
     await registry.detach("sid-b", attachment_generation=1)
     await registry.send_event("sid-a", {"type": "a-only"})
@@ -333,7 +439,6 @@ async def test_registry_keeps_sessions_journals_and_incarnations_isolated() -> N
 
     resumed_a = await registry.resume(
         "sid-a",
-        incarnation=1,
         resume_token=created_a.resume_token.plaintext,
         last_received_server_event_seq=0,
         send=send,
@@ -341,7 +446,6 @@ async def test_registry_keeps_sessions_journals_and_incarnations_isolated() -> N
     )
     resumed_b = await registry.resume(
         "sid-b",
-        incarnation=4,
         resume_token=created_b.resume_token.plaintext,
         last_received_server_event_seq=0,
         send=send,
@@ -350,11 +454,10 @@ async def test_registry_keeps_sessions_journals_and_incarnations_isolated() -> N
 
     assert [entry.payload["type"] for entry in resumed_a.replay_entries] == ["a-only"]
     assert [entry.payload["type"] for entry in resumed_b.replay_entries] == ["b-only"]
-    with pytest.raises(ValueError, match="incarnation mismatch"):
+    with pytest.raises(InvalidResumeTokenError):
         await registry.resume(
             "sid-a",
-            incarnation=2,
-            resume_token=resumed_a.resume_token.plaintext,
+            resume_token=resumed_b.resume_token.plaintext,
             last_received_server_event_seq=1,
             send=send,
             close=close,
@@ -374,7 +477,7 @@ async def test_registry_repr_never_contains_plaintext_tokens() -> None:
     async def close(reason):
         del reason
 
-    created = await registry.create("sid-repr", incarnation=0, send=send, close=close)
+    created = await registry.create("sid-repr", send=send, close=close)
     await registry.detach("sid-repr", attachment_generation=1)
     entry = await registry.send_event(
         "sid-repr",
@@ -385,3 +488,67 @@ async def test_registry_repr_never_contains_plaintext_tokens() -> None:
     assert created.resume_token.plaintext not in repr(created)
     assert created.resume_token.plaintext not in repr(entry)
     assert created.resume_token.plaintext not in repr(registry)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("cancel_on", ["activation", "replay"])
+async def test_registry_resume_cancelled_mid_delivery_rolls_back_like_a_failure(cancel_on: str) -> None:
+    """Cancellation must take the same rollback as an ordinary delivery failure.
+
+    ``CancelledError`` derives from ``BaseException``, so an ``except
+    Exception`` around the activation and replay sends let a cancelled resume
+    keep its attachment as the current generation while the token it rotated
+    past was already gone — the session left attached to an unusable transport
+    with no way back. Both send points are covered because either can be the
+    one that gets cancelled.
+    """
+    registry = DuplexSessionAttachmentRegistry(replay_ttl_s=60.0, replay_max_bytes_per_session=4096)
+
+    async def send(payload):
+        del payload
+
+    async def close(reason):
+        del reason
+
+    created = await registry.create("sid-cancel", send=send, close=close)
+    # One journaled event, so the replay loop has something to send.
+    await registry.send_event("sid-cancel", {"type": "response.output_text.delta", "delta": "a"})
+    await registry.detach("sid-cancel", attachment_generation=1)
+
+    sends = 0
+    cancel_at = 1 if cancel_on == "activation" else 2
+
+    async def cancelling_send(payload):
+        del payload
+        nonlocal sends
+        sends += 1
+        if sends == cancel_at:
+            raise asyncio.CancelledError
+
+    with pytest.raises(asyncio.CancelledError):
+        await registry.resume(
+            "sid-cancel",
+            resume_token=created.resume_token.plaintext,
+            last_received_server_event_seq=0,
+            send=cancelling_send,
+            close=close,
+            activation_payload_factory=lambda token, generation: {
+                "type": "session.resumed",
+                "resume_token": token.plaintext,
+                "attachment_generation": generation,
+            },
+        )
+
+    assert sends == cancel_at, "the send that was cancelled is the one under test"
+    # The cancelled attachment must not remain current...
+    assert not await registry.has_attachment("sid-cancel")
+    # ...and the token the caller presented has to work again, or the session
+    # is unreachable: resume() had already rotated past it.
+    recovered = await registry.resume(
+        "sid-cancel",
+        resume_token=created.resume_token.plaintext,
+        last_received_server_event_seq=0,
+        send=send,
+        close=close,
+    )
+    assert recovered.attachment_generation == 3
diff --git a/tests/entrypoints/openai_api/test_api_server_guards.py b/tests/entrypoints/openai_api/test_api_server_guards.py
index ee141182c..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"),
@@ -80,6 +151,11 @@ _EXPECTED_ROUTER_ROUTES = {
     ("WEBSOCKET", "/v1/realtime"),
     ("WEBSOCKET", "/v1/realtime/robot/openpi"),
     ("WEBSOCKET", "/v1/duplex"),
+    ("POST", "/v1/realtime/sessions"),
+    ("POST", "/v1/realtime/sessions/{session_id}/step"),
+    ("POST", "/v1/realtime/sessions/{session_id}/reset"),
+    ("POST", "/v1/realtime/sessions/{session_id}/close"),
+    ("GET", "/v1/realtime/sessions/{session_id}/status"),
     ("GET", "/health"),
     ("GET", "/v1/models"),
     ("POST", "/v1/images/generations"),
@@ -120,6 +196,7 @@ _DIFFUSION_APP_STATE_KEYS = {
     "openai_streaming_speech",
     "openai_streaming_video",
     "openai_serving_realtime_robot",
+    "rl_rollout_serving",
     "enable_server_load_tracking",
     "server_load_metrics",
 }
@@ -151,12 +228,14 @@ _MULTISTAGE_APP_STATE_KEYS = {
     "openai_serving_realtime",
     "openai_serving_video",
     "openai_serving_realtime_robot",
+    "rl_rollout_serving",
     "enable_server_load_tracking",
     "server_load_metrics",
 }
 _MULTISTAGE_MUST_BE_NONE = {
     "openai_serving_duplex",
     "openai_serving_realtime_robot",
+    "rl_rollout_serving",
 }
 _MULTISTAGE_MUST_BE_WIRED = _MULTISTAGE_APP_STATE_KEYS - _MULTISTAGE_MUST_BE_NONE
 
@@ -486,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()
@@ -514,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"}
@@ -611,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.
 
@@ -700,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.
 
@@ -768,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"))
@@ -813,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")
@@ -833,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",
@@ -912,7 +1062,6 @@ async def test_multistage_app_state_key_snapshot(monkeypatch) -> None:
     monkeypatch.setattr(api_server, "create_streaming_video_handler", lambda **_k: _marker("streaming_video"))
     monkeypatch.setattr(api_server, "OpenAIServingRealtime", _FakeCtor)
     monkeypatch.setattr(api_server, "OmniOpenAIServingVideo", _FakeCtor)
-    monkeypatch.setattr(api_server, "should_enable_duplex_endpoint", lambda *_a, **_k: False)
 
     state = State()
     await api_server.omni_init_app_state(engine, state, _minimal_args())
@@ -923,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_audio_format.py b/tests/entrypoints/openai_api/test_audio_format.py
index 9c7eb9d89..2fb76e3f6 100644
--- a/tests/entrypoints/openai_api/test_audio_format.py
+++ b/tests/entrypoints/openai_api/test_audio_format.py
@@ -12,6 +12,8 @@ Covers:
 
 from __future__ import annotations
 
+import base64
+import json
 from io import BytesIO
 
 import numpy as np
@@ -27,6 +29,8 @@ from vllm_omni.entrypoints.openai.protocol.audio import (
     SUPPORTED_CHAT_AUDIO_FORMATS,
     CreateAudio,
 )
+from vllm_omni.outputs import OmniRequestOutput
+from vllm_omni.outputs.mm_outputs import MultimodalCompletionOutput, MultimodalPayload
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
@@ -65,6 +69,13 @@ class TestCreateAudio:
         )
         response = mixin.create_audio(audio_obj)
         assert len(response.audio_data) > 0
+        assert response.audio_metadata is not None
+        assert response.audio_metadata.model_dump() == {
+            "format": fmt,
+            "sample_rate_hz": 24000,
+            "frame_count": 24000,
+            "channels": 1,
+        }
 
     def test_wav_magic_bytes(self, mixin, audio_tensor):
         audio_obj = CreateAudio(
@@ -113,10 +124,9 @@ class TestCreateAudio:
         response = mixin.create_audio(audio_obj)
         assert response.audio_data[:4] == b"RIFF"
         assert response.media_type == "audio/wav"
+        assert response.audio_metadata.format == "wav"
 
     def test_base64_encoding(self, mixin, audio_tensor):
-        import base64
-
         audio_obj = CreateAudio(
             audio_tensor=audio_tensor,
             sample_rate=24000,
@@ -128,21 +138,33 @@ class TestCreateAudio:
         decoded = base64.b64decode(response.audio_data)
         assert decoded[:4] == b"RIFF"
 
-    def test_resamples_wav_to_requested_output_rate(self, mixin, audio_tensor):
+    @pytest.mark.parametrize(
+        "channels,speed,frame_count",
+        [(1, 1.0, 8000), (2, 2.0, 4000)],
+        ids=["mono-resampled", "stereo-resampled-faster"],
+    )
+    def test_metadata_matches_transformed_waveform(self, mixin, audio_tensor, channels, speed, frame_count):
         response = mixin.create_audio(
             CreateAudio(
-                audio_tensor=audio_tensor,
+                audio_tensor=audio_tensor if channels == 1 else np.stack((audio_tensor, audio_tensor)),
                 sample_rate=24000,
                 output_sample_rate=8000,
                 response_format="wav",
-                speed=1.0,
+                speed=speed,
                 base64_encode=False,
             )
         )
 
         with soundfile.SoundFile(BytesIO(response.audio_data)) as audio_file:
             assert audio_file.samplerate == 8000
-            assert audio_file.frames == 8000
+            assert audio_file.frames == frame_count
+            assert audio_file.channels == channels
+            assert response.audio_metadata.model_dump() == {
+                "format": "wav",
+                "sample_rate_hz": audio_file.samplerate,
+                "frame_count": audio_file.frames,
+                "channels": audio_file.channels,
+            }
 
 
 class TestStreamingAudioResampler:
@@ -262,3 +284,65 @@ class TestResolveAudioFormat:
             request = self._make_request({"format": fmt, "voice": "alloy"})
             result = serving_chat._resolve_audio_format(request)
             assert not isinstance(result, ErrorResponse), f"Format {fmt} should be accepted"
+
+
+@pytest.mark.parametrize("stream", [False, True])
+@pytest.mark.parametrize("fmt", ["pcm", "wav"])
+def test_chat_audio_metadata_survives_response_serialization(stream, fmt):
+    from vllm.entrypoints.openai.chat_completion.protocol import ChatCompletionRequest
+    from vllm.entrypoints.serve.engine.protocol import ErrorResponse, UsageInfo
+
+    from vllm_omni.entrypoints.openai.protocol.chat_completion import (
+        OmniChatCompletionResponse,
+        OmniChatCompletionStreamResponse,
+    )
+    from vllm_omni.entrypoints.openai.serving_chat import OmniOpenAIServingChat
+
+    serving_chat = object.__new__(OmniOpenAIServingChat)
+    output = MultimodalCompletionOutput(
+        index=0,
+        text="",
+        token_ids=[],
+        cumulative_logprob=None,
+        logprobs=None,
+        multimodal_output=MultimodalPayload.from_dict(
+            {"audio": [torch.zeros(17), torch.zeros(23)], "sr": torch.tensor(22050)}
+        ),
+        finish_reason="stop",
+        stop_reason=None,
+    )
+    request = ChatCompletionRequest(
+        model="test-model",
+        messages=[{"role": "user", "content": "hello"}],
+        audio={"format": fmt, "voice": "alloy"},
+    )
+    choices = serving_chat._create_audio_choice(
+        OmniRequestOutput(outputs=[output], final_output_type="audio"), "assistant", request, stream=stream
+    )
+    assert not isinstance(choices, ErrorResponse)
+    response_type = OmniChatCompletionStreamResponse if stream else OmniChatCompletionResponse
+    response = response_type(
+        id="chatcmpl-audio-metadata",
+        created=0,
+        model="test-model",
+        choices=choices,
+        usage=UsageInfo(prompt_tokens=0, completion_tokens=0, total_tokens=0),
+    )
+
+    serialized = json.loads(response.model_dump_json(exclude_unset=True))
+    choice = serialized["choices"][0]
+    frame_count = 23 if stream else 40
+    assert choice["audio_metadata"] == {
+        "format": fmt,
+        "sample_rate_hz": 22050,
+        "frame_count": frame_count,
+        "channels": 1,
+    }
+    audio = choice["delta"]["content"] if stream else choice["message"]["audio"]["data"]
+    raw = base64.b64decode(audio)
+    if fmt == "wav":
+        with soundfile.SoundFile(BytesIO(raw)) as audio_file:
+            assert audio_file.frames == frame_count
+            assert audio_file.samplerate == 22050
+    else:
+        assert len(raw) == frame_count * 2
diff --git a/tests/entrypoints/openai_api/test_duplex_api_server.py b/tests/entrypoints/openai_api/test_duplex_api_server.py
new file mode 100644
index 000000000..0d9eebe5b
--- /dev/null
+++ b/tests/entrypoints/openai_api/test_duplex_api_server.py
@@ -0,0 +1,520 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""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
+from fastapi import FastAPI
+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, 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]
+
+# ``app.state`` of a duplex-only server. Presence is not enough: a route whose
+# handler is missing answers "not available", so "not wired" is written as None.
+_DUPLEX_APP_STATE_KEYS = {
+    "engine_client",
+    "log_stats",
+    "args",
+    "sleeping_stages",
+    "stage_configs",
+    "vllm_config",
+    "diffusion_engine",
+    "openai_serving_models",
+    "serving_tokenization",
+    "serving_tokens",
+    "online_renderer",
+    "openai_serving_chat",
+    "openai_serving_chat_batch",
+    "openai_serving_completion",
+    "openai_serving_responses",
+    "openai_serving_embedding",
+    "openai_serving_pooling",
+    "openai_serving_classification",
+    "openai_serving_scores",
+    "openai_serving_transcription",
+    "openai_serving_translation",
+    "openai_serving_speech",
+    "openai_serving_audio_generate",
+    "openai_serving_video",
+    "openai_streaming_speech",
+    "openai_streaming_video",
+    "openai_streaming_video_output",
+    "openai_serving_realtime",
+    "openai_serving_realtime_robot",
+    "anthropic_serving_messages",
+    "openai_serving_duplex",
+    "enable_server_load_tracking",
+    "server_load_metrics",
+}
+#: Every turn-based service, plus the Realtime route that is not the duplex one.
+#: ``openai_serving_chat`` is absent: a duplex engine also serves chat, through
+#: the ordinary turn-based service, because DuplexOmni extends AsyncOmni.
+#: ``online_renderer`` is absent for the same reason -- the chat service needs it.
+_DUPLEX_MUST_BE_NONE = _DUPLEX_APP_STATE_KEYS - {
+    "engine_client",
+    "log_stats",
+    "args",
+    "sleeping_stages",
+    "stage_configs",
+    "vllm_config",
+    "openai_serving_models",
+    "openai_serving_duplex",
+    "openai_serving_chat",
+    "online_renderer",
+    "enable_server_load_tracking",
+    "server_load_metrics",
+}
+_DUPLEX_MUST_BE_WIRED = {
+    "engine_client",
+    "args",
+    "stage_configs",
+    "vllm_config",
+    "openai_serving_models",
+    "openai_serving_duplex",
+    "openai_serving_chat",
+}
+
+
+class _FakeDuplexOmni(DuplexOmni):
+    """A ``DuplexOmni`` without an engine: only what the app-state wiring reads."""
+
+    def __init__(self) -> None:
+        self.model = "demo-duplex-model"
+        self._stage_configs = [object(), object(), object()]
+        self._vllm_config = SimpleNamespace(
+            lora_config=None,
+            model_config=SimpleNamespace(),
+            parallel_config=SimpleNamespace(_api_process_rank=0),
+        )
+        self._duplex_session_config = DuplexSessionRuntimeConfig()
+        self._capabilities = DuplexCapabilities(supports_chat_completions=True)
+
+    async def get_vllm_config(self):
+        return self._vllm_config
+
+    async def get_supported_tasks(self) -> tuple[str, ...]:
+        return ("generate",)
+
+    async def get_tokenizer(self):
+        return SimpleNamespace(chat_template="{{ messages }}")
+
+    @property
+    def stage_configs(self) -> list[object]:
+        return self._stage_configs
+
+    @property
+    def duplex_session_config(self) -> DuplexSessionRuntimeConfig:
+        return self._duplex_session_config
+
+    @property
+    def duplex_capabilities(self) -> DuplexCapabilities:
+        return self._capabilities
+
+    # Properties on AsyncOmni, so the fake overrides rather than assigns them.
+    @property
+    def model_config(self) -> SimpleNamespace:
+        return SimpleNamespace()
+
+    @property
+    def renderer(self) -> SimpleNamespace:
+        return SimpleNamespace()
+
+
+class _FakeModels:
+    def __init__(self, *args, **kwargs) -> None:
+        self.base_model_paths = kwargs.get("base_model_paths") or []
+
+
+def _minimal_args(**overrides) -> SimpleNamespace:
+    args = SimpleNamespace(
+        model="demo-duplex-model",
+        served_model_name=None,
+        disable_log_stats=True,
+        enable_log_requests=False,
+        max_log_len=None,
+        enable_server_load_tracking=False,
+        trust_remote_code=True,
+        deploy_config=None,
+        # What the chat service reads when a duplex model also serves chat.
+        chat_template=None,
+        chat_template_content_format="auto",
+        trust_request_chat_template=False,
+        default_chat_template_kwargs=None,
+        response_role="assistant",
+        return_tokens_as_token_ids=False,
+        enable_auto_tool_choice=False,
+        exclude_tools_when_tool_choice_none=False,
+        tool_call_parser=None,
+        structured_outputs_config=SimpleNamespace(reasoning_parser=None),
+        enable_prompt_tokens_details=False,
+        enable_force_include_usage=False,
+        enable_log_outputs=False,
+        enable_log_deltas=False,
+    )
+    for key, value in overrides.items():
+        setattr(args, key, value)
+    return args
+
+
+# --------------------------------------------------------------------------- #
+# Startup: which entrypoint class serves the model                            #
+# --------------------------------------------------------------------------- #
+
+
+@pytest.mark.parametrize(
+    ("pipeline_config", "expected"),
+    [
+        (SimpleNamespace(duplex_plugin="pkg.mod.Plugin"), True),
+        (SimpleNamespace(duplex_plugin=None), False),
+        (SimpleNamespace(duplex_plugin=""), False),
+        (SimpleNamespace(), False),
+        (None, False),
+    ],
+)
+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)
+        return pipeline_config
+
+    monkeypatch.setattr(StageConfigFactory, "get_pipeline_config", fake_get_pipeline_config)
+
+    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": str(deploy_path),
+    }
+
+
+def test_duplex_model_probe_propagates_resolution_errors(monkeypatch) -> None:
+    """A pipeline that cannot be resolved must fail startup, not fall back to turn-based."""
+
+    def fake_get_pipeline_config(**_kwargs):
+        raise ValueError("needs trust_remote_code=True")
+
+    monkeypatch.setattr(StageConfigFactory, "get_pipeline_config", fake_get_pipeline_config)
+
+    with pytest.raises(ValueError, match="trust_remote_code"):
+        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
+
+
+# --------------------------------------------------------------------------- #
+# app.state of a duplex-only server                                           #
+# --------------------------------------------------------------------------- #
+
+
+@pytest.mark.asyncio
+async def test_duplex_app_state_wires_only_the_session_surfaces(monkeypatch) -> None:
+    """Lock the duplex ``app.state``: the two session-backed surfaces are live, every turn-based service is None.
+
+    Fails if a turn-based service is wired into a duplex server (its route
+    would answer instead of reporting "not available"), or if a key the routes
+    read disappears. ``openai_serving_chat`` is the one shared name: the route
+    is served, but by the adapter that runs it on a duplex session, never by
+    the turn-based chat service.
+    """
+    monkeypatch.setattr(api_server, "OpenAIServingModels", _FakeModels)
+    monkeypatch.setattr(api_server, "OnlineRenderer", lambda **kwargs: SimpleNamespace(**kwargs))
+    monkeypatch.setattr(api_server, "OmniOpenAIServingChat", lambda **kwargs: SimpleNamespace(**kwargs))
+    engine = _FakeDuplexOmni()
+    state = State()
+
+    await api_server.omni_init_app_state(engine, state, _minimal_args())
+
+    present = {key for key in _DUPLEX_APP_STATE_KEYS if hasattr(state, key)}
+    assert present == _DUPLEX_APP_STATE_KEYS
+    not_wired = sorted(key for key in _DUPLEX_MUST_BE_WIRED if getattr(state, key) is None)
+    assert not not_wired, f"duplex app.state keys registered but not wired: {not_wired}"
+    unexpectedly_set = sorted(key for key in _DUPLEX_MUST_BE_NONE if getattr(state, key) is not None)
+    assert not unexpectedly_set, f"turn-based services wired into a duplex server: {unexpectedly_set}"
+    assert isinstance(state.openai_serving_duplex, OmniDuplexSessionHandler)
+    assert state.openai_serving_chat is not None
+    assert state.engine_client is engine
+    assert state.vllm_config is engine._vllm_config
+
+
+# --------------------------------------------------------------------------- #
+# Routes                                                                      #
+# --------------------------------------------------------------------------- #
+
+
+class _RecordingHandler:
+    """Stands in for ``OmniDuplexSessionHandler`` on the app state."""
+
+    def __init__(self) -> None:
+        self.queries: list[dict[str, str]] = []
+
+    async def handle_realtime_session(self, websocket) -> None:
+        await websocket.accept()
+        self.queries.append(dict(websocket.query_params))
+        await websocket.send_json({"type": "session.created", "session": {"id": "duplex-test"}})
+        await websocket.close()
+
+
+def _duplex_app(handler: object) -> FastAPI:
+    app = FastAPI()
+    app.include_router(api_server.router)
+    app.state.openai_serving_duplex = handler
+    # A duplex server serves no turn-based Realtime route.
+    app.state.openai_serving_realtime = None
+    return app
+
+
+@pytest.mark.parametrize("path", ["/v1/duplex", "/v1/realtime?duplex=1"])
+def test_both_duplex_routes_reach_the_session_handler(path: str) -> None:
+    """``/v1/duplex`` is an alias of ``/v1/realtime?duplex=1``: same handler, same protocol."""
+    handler = _RecordingHandler()
+
+    with TestClient(_duplex_app(handler)) as client:
+        with client.websocket_connect(path) as websocket:
+            assert websocket.receive_json()["type"] == "session.created"
+            with pytest.raises(WebSocketDisconnect):
+                websocket.receive_text()
+
+    assert len(handler.queries) == 1
+
+
+@pytest.mark.parametrize("flag", ["1", "true", "on"])
+def test_realtime_route_switches_to_duplex_only_for_the_documented_flag_values(flag: str) -> None:
+    handler = _RecordingHandler()
+
+    with TestClient(_duplex_app(handler)) as client:
+        with client.websocket_connect(f"/v1/realtime?duplex={flag}") as websocket:
+            assert websocket.receive_json()["type"] == "session.created"
+            with pytest.raises(WebSocketDisconnect):
+                websocket.receive_text()
+
+    assert handler.queries == [{"duplex": flag}]
+
+
+@pytest.mark.parametrize("query", ["", "?model=openbmb%2FMiniCPM-o-4_5"])
+def test_realtime_without_a_duplex_flag_reaches_the_session_handler(query: str) -> None:
+    """A bare connection to a duplex deployment is a duplex session.
+
+    ``?duplex=1`` is the spelling the server advertises, but it is not a
+    requirement: a deployment that declares a duplex plugin answers plain
+    ``/v1/realtime`` too, so a stock Realtime client needs no vendor query
+    parameter.
+    """
+    handler = _RecordingHandler()
+
+    with TestClient(_duplex_app(handler)) as client:
+        with client.websocket_connect(f"/v1/realtime{query}") as websocket:
+            assert websocket.receive_json()["type"] == "session.created"
+            with pytest.raises(WebSocketDisconnect):
+                websocket.receive_text()
+
+    assert len(handler.queries) == 1
+
+
+@pytest.mark.parametrize("query", ["?duplex=0", "?duplex=false", "?duplex=off"])
+def test_realtime_opted_out_of_duplex_falls_through_to_the_turn_based_route(query: str) -> None:
+    """An explicit opt-out selects the legacy handler, which a duplex server does not mount."""
+    handler = _RecordingHandler()
+
+    with TestClient(_duplex_app(handler)) as client:
+        with client.websocket_connect(f"/v1/realtime{query}") as websocket:
+            assert websocket.receive_json() == {
+                "type": "error",
+                "error": "Realtime API is not available",
+                "code": "unsupported",
+            }
+            with pytest.raises(WebSocketDisconnect):
+                websocket.receive_text()
+
+    assert handler.queries == []
+
+
+# --------------------------------------------------------------------------- #
+# Startup warmup gate                                                         #
+# --------------------------------------------------------------------------- #
+
+
+def _warmup_websocket(warmup_done: asyncio.Event | None, query: dict[str, str]) -> SimpleNamespace:
+    return SimpleNamespace(
+        app=SimpleNamespace(state=SimpleNamespace(duplex_warmup_done=warmup_done)),
+        query_params=query,
+    )
+
+
+@pytest.mark.asyncio
+async def test_warmup_gate_holds_clients_until_the_warmup_session_finishes() -> None:
+    warmup_done = asyncio.Event()
+    websocket = _warmup_websocket(warmup_done, {})
+
+    waiting = asyncio.create_task(api_server._wait_for_duplex_warmup(websocket))
+    with pytest.raises(asyncio.TimeoutError):
+        await asyncio.wait_for(asyncio.shield(waiting), timeout=0.05)
+
+    warmup_done.set()
+    await asyncio.wait_for(waiting, timeout=1.0)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ("warmup_done", "query"),
+    [
+        (None, {}),
+        (asyncio.Event(), {"vllm_omni_warmup": "1"}),
+    ],
+    ids=["no-warmup-configured", "the-warmup-connection-itself"],
+)
+async def test_warmup_gate_lets_the_warmup_connection_and_plain_servers_through(warmup_done, query) -> None:
+    websocket = _warmup_websocket(warmup_done, query)
+
+    await asyncio.wait_for(api_server._wait_for_duplex_warmup(websocket), timeout=1.0)
+
+
+@pytest.mark.asyncio
+async def test_a_model_that_does_not_declare_chat_completions_does_not_get_the_route(monkeypatch) -> None:
+    """The decision stays the model's: no capability, no chat service, and the route says so."""
+    monkeypatch.setattr(api_server, "OpenAIServingModels", _FakeModels)
+    engine = _FakeDuplexOmni()
+    engine._capabilities = DuplexCapabilities(supports_chat_completions=False)
+    state = State()
+
+    await api_server.omni_init_app_state(engine, state, _minimal_args())
+
+    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_duplex_handler.py b/tests/entrypoints/openai_api/test_duplex_handler.py
deleted file mode 100644
index d3bbc5d01..000000000
--- a/tests/entrypoints/openai_api/test_duplex_handler.py
+++ /dev/null
@@ -1,9168 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-from __future__ import annotations
-
-import asyncio
-import base64
-import io
-import json
-import struct
-import wave
-from types import SimpleNamespace
-from typing import Any
-
-import numpy as np
-import pytest
-from starlette.websockets import WebSocketDisconnect
-
-# Import the OpenAI entrypoints package at collection time, before pytest
-# attaches its caplog handlers to the root logger. vllm's api_server
-# transitively imports model_hosting_container_standards, whose import-time
-# configure_root_logger() raises the level of every handler then attached to
-# the root logger to ERROR. The serving runtime under test reaches this chain
-# lazily (runtime_bridge -> entrypoints.openai.protocol.audio), so without
-# this eager import the side effect fires mid-test and silences caplog for
-# the remainder of the session. Before the capability predicate moved to
-# vllm_omni.entrypoints.duplex.capability, this file imported the package at
-# module scope implicitly.
-import vllm_omni.entrypoints.openai  # noqa: F401
-from vllm_omni.config.stage_config import DuplexSessionRuntimeConfig
-from vllm_omni.engine.duplex.control_client import DuplexControlRequestError
-from vllm_omni.engine.duplex.lease import DuplexLeaseActivity
-from vllm_omni.engine.duplex.messages import DuplexFence, DuplexSessionLifecycleMessage
-from vllm_omni.engine.duplex.runtime import duplex_resource_request_id
-from vllm_omni.entrypoints.duplex.protocol import (
-    DuplexCapabilities,
-    DuplexOverlapPolicy,
-    DuplexPlaybackCommitPolicy,
-    DuplexSession,
-    DuplexSessionConfig,
-    ResponseCreateOptions,
-)
-from vllm_omni.entrypoints.duplex.realtime_session import NativeRealtimeSessionProtocol
-from vllm_omni.entrypoints.duplex.runtime_adapter import ServingRuntimeConfigError
-from vllm_omni.entrypoints.duplex.serving import (
-    OmniDuplexSessionHandler,
-    should_enable_duplex_endpoint,
-)
-from vllm_omni.entrypoints.duplex.websocket import DuplexWebSocketActor
-from vllm_omni.model_executor.models.minicpmo_4_5.duplex import (
-    MiniCPMO45NativeDuplexServingAdapter,
-    MiniCPMO45PcmAppendBuffer,
-)
-from vllm_omni.model_executor.models.minicpmo_4_5.duplex.capabilities import (
-    minicpmo45_native_capabilities,
-)
-from vllm_omni.model_executor.models.minicpmo_4_5.duplex.data_plane import (
-    MiniCPMO45DataPlaneContext,
-    MiniCPMO45DataPlaneSession,
-)
-from vllm_omni.model_executor.models.minicpmo_4_5.duplex.runtime import (
-    MiniCPMO45DuplexRuntimeExtension,
-)
-from vllm_omni.model_executor.models.minicpmo_4_5.duplex.session import (
-    MiniCPMO45ServingSessionState,
-)
-from vllm_omni.model_executor.models.personaplex.duplex.serving_adapter import (
-    PersonaPlexServingRuntimeAdapter,
-)
-from vllm_omni.outputs import OmniRequestOutput
-from vllm_omni.outputs.duplex import attach_duplex_output_decision
-
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
-INVALID_VALIDATED_SAMPLE_RATES = (
-    pytest.param(16_000.5, id="fractional"),
-    pytest.param(float("inf"), id="infinite"),
-    pytest.param(float("nan"), id="nan"),
-)
-
-
-def test_native_input_append_supports_explicit_session_opt_out():
-    session = DuplexSession(
-        "sid-explicit-tts",
-        DuplexSessionConfig(model="test-model"),
-        capabilities=minicpmo45_native_capabilities(),
-    )
-
-    assert OmniDuplexSessionHandler._uses_native_input_append(session) is True
-
-    session.config.extra_body["native_duplex"] = False
-    assert OmniDuplexSessionHandler._uses_native_input_append(session) is False
-
-
-class _ModelConfig:
-    model = "test-model"
-
-
-class FakeEngineClient:
-    output_modalities = ["text", "audio"]
-
-    def __init__(
-        self,
-        *,
-        fail_open: bool = False,
-        fail_signal: bool = False,
-        fail_touch: bool = False,
-        fail_signal_events: set[str] | None = None,
-        fail_close: bool = False,
-        fail_abort: bool = False,
-        control_result: dict[str, object] | None = None,
-        open_result: dict[str, object] | None = None,
-        append_result: dict[str, object] | None = None,
-        append_results: list[dict[str, object]] | None = None,
-        collect_outputs: list[list[object]] | None = None,
-        collect_delay_s: float = 0.0,
-        signal_result: dict[str, object] | None = None,
-        close_result: dict[str, object] | None = None,
-    ) -> None:
-        self.fail_open = fail_open
-        self.fail_signal = fail_signal
-        self.fail_touch = fail_touch
-        self.fail_signal_events = set(fail_signal_events or ())
-        self.fail_close = fail_close
-        self.fail_abort = fail_abort
-        self.control_result = control_result
-        self.open_result = open_result
-        self.append_result = append_result
-        self.append_results = list(append_results or [])
-        self.collect_outputs = list(collect_outputs or [])
-        self.collect_delay_s = collect_delay_s
-        self.signal_result = signal_result
-        self.close_result = close_result
-        self.opened: list[str] = []
-        self.opened_fences: list[DuplexFence | None] = []
-        self.appended: list[tuple[str, str, Any, bool]] = []
-        self.append_operation_ids: list[str | None] = []
-        self.appended_fences: list[DuplexFence | None] = []
-        self.opened_configs: list[dict[str, Any]] = []
-        self.opened_runtime_configs: list[dict[str, Any]] = []
-        self.signals: list[tuple[str, str]] = []
-        self.signal_fences: list[DuplexFence | None] = []
-        self.signal_next_fences: list[DuplexFence | None] = []
-        self.signal_session_configs: list[dict[str, Any] | None] = []
-        self.signal_runtime_configs: list[dict[str, Any] | None] = []
-        self.closed: list[tuple[str, str]] = []
-        self.touched: list[tuple[str, DuplexLeaseActivity]] = []
-        self.touch_fences: list[DuplexFence] = []
-        self.resumed: list[tuple[str, int]] = []
-        self.resume_fences: list[DuplexFence] = []
-        self.aborted: list[str] = []
-        self.abort_batches: list[list[str]] = []
-        self.internal_abort_batches: list[list[str]] = []
-        self.collected: list[tuple[str, int | None]] = []
-        self.duplex_lifecycle_events: asyncio.Queue[DuplexSessionLifecycleMessage] = asyncio.Queue()
-
-    async def open_duplex_session_async(
-        self,
-        session_id: str,
-        *,
-        session_mode: str = "duplex",
-        capabilities: dict[str, object] | None = None,
-        session_config: dict[str, object] | None = None,
-        runtime_config: dict[str, object] | None = None,
-        timeout: float | None = None,
-        fence: DuplexFence | None = None,
-    ) -> Any:
-        del timeout
-        if self.fail_open:
-            raise RuntimeError("open failed")
-        self.opened.append(session_id)
-        self.opened_fences.append(fence)
-        self.opened_configs.append(dict(session_config or {}))
-        self.opened_runtime_configs.append(dict(runtime_config or {}))
-        return self.open_result if self.open_result is not None else self.control_result
-
-    async def append_duplex_input_async(
-        self,
-        session_id: str,
-        *,
-        mode: str,
-        payload: object,
-        operation_id: str | None = None,
-        final: bool = False,
-        timeout: float | None = None,
-        collect_outputs: bool = True,
-        fence: DuplexFence | None = None,
-    ) -> Any:
-        del timeout, collect_outputs
-        self.appended.append((session_id, mode, payload, final))
-        self.append_operation_ids.append(operation_id)
-        self.appended_fences.append(fence)
-        if self.append_results:
-            return self.append_results.pop(0)
-        return self.append_result if self.append_result is not None else self.control_result
-
-    async def collect_duplex_data_plane_outputs_async(
-        self,
-        request_id: str,
-        *,
-        response_stage_id: int | None = None,
-        timeout: float | None = None,
-    ) -> list[object]:
-        del timeout
-        self.collected.append((request_id, response_stage_id))
-        if self.collect_delay_s > 0:
-            await asyncio.sleep(self.collect_delay_s)
-        if not self.collect_outputs:
-            return []
-        return self.collect_outputs.pop(0)
-
-    async def signal_duplex_turn_async(
-        self,
-        session_id: str,
-        *,
-        event: str,
-        timeout: float | None = None,
-        fence: DuplexFence | None = None,
-        next_fence: DuplexFence | None = None,
-        session_config: dict[str, object] | None = None,
-        runtime_config: dict[str, object] | None = None,
-    ) -> Any:
-        del timeout
-        if self.fail_signal or event in self.fail_signal_events:
-            raise RuntimeError("signal failed")
-        self.signals.append((session_id, event))
-        self.signal_fences.append(fence)
-        self.signal_next_fences.append(next_fence)
-        self.signal_session_configs.append(session_config)
-        self.signal_runtime_configs.append(runtime_config)
-        return self.signal_result if self.signal_result is not None else self.control_result
-
-    async def close_duplex_session_async(
-        self,
-        session_id: str,
-        *,
-        reason: str = "client_close",
-        timeout: float | None = None,
-        fence: DuplexFence | None = None,
-    ) -> Any:
-        del timeout
-        if self.fail_close:
-            raise RuntimeError("close failed")
-        self.closed.append((session_id, reason))
-        return self.close_result if self.close_result is not None else self.control_result
-
-    async def touch_duplex_session_async(
-        self,
-        session_id: str,
-        *,
-        fence: DuplexFence,
-        activity: DuplexLeaseActivity,
-        timeout: float | None = None,
-    ) -> dict[str, object]:
-        del timeout
-        if self.fail_touch:
-            raise RuntimeError("touch failed")
-        self.touched.append((session_id, activity))
-        self.touch_fences.append(fence)
-        return {
-            "operation": "touch",
-            "session_id": session_id,
-            "ok": True,
-            "stage_results": [
-                {
-                    "stage_id": -1,
-                    "replica_id": -1,
-                    "result": {"supported": True, "lease_generation": 0},
-                }
-            ],
-        }
-
-    async def resume_duplex_session_async(
-        self,
-        session_id: str,
-        *,
-        fence: DuplexFence,
-        expected_lease_generation: int,
-        timeout: float | None = None,
-    ) -> dict[str, object]:
-        del timeout
-        self.resumed.append((session_id, expected_lease_generation))
-        self.resume_fences.append(fence)
-        return {
-            "operation": "resume",
-            "session_id": session_id,
-            "ok": True,
-            "stage_results": [
-                {
-                    "stage_id": -1,
-                    "replica_id": -1,
-                    "result": {
-                        "supported": True,
-                        "lease_generation": expected_lease_generation + 1,
-                    },
-                }
-            ],
-        }
-
-    async def abort(self, request_ids: list[str]) -> None:
-        if self.fail_abort:
-            raise RuntimeError("abort failed")
-        assert isinstance(request_ids, list)
-        self.abort_batches.append(list(request_ids))
-        self.aborted.extend(request_ids)
-
-    async def _abort_internal_requests(self, request_ids: list[str]) -> None:
-        if self.fail_abort:
-            raise RuntimeError("abort failed")
-        assert isinstance(request_ids, list)
-        self.internal_abort_batches.append(list(request_ids))
-        self.aborted.extend(request_ids)
-
-
-class FakeChatService:
-    duplex_serving_adapter_path = (
-        "vllm_omni.model_executor.models.minicpmo_4_5.duplex.serving_adapter.MiniCPMO45ServingRuntimeAdapter"
-    )
-
-    def __init__(self, engine_client: FakeEngineClient) -> None:
-        self.engine_client = engine_client
-        self.model_config = _ModelConfig()
-        self.seen_request_ids: list[str] = []
-
-    async def create_chat_completion(self, request, raw_request=None):
-        self.seen_request_ids.append(request.request_id)
-
-        async def _gen():
-            await asyncio.sleep(999)
-            yield "data: [DONE]\n\n"
-
-        return _gen()
-
-    def create_audio(self, audio_obj):
-        return SimpleNamespace(audio_data=f"wav-{int(audio_obj.audio_tensor.shape[0])}")
-
-
-class TurnBasedFakeChatService(FakeChatService):
-    """Chat-fallback service without a model-native duplex adapter."""
-
-    duplex_serving_adapter_path = None
-
-    def __init__(self, engine_client: FakeEngineClient) -> None:
-        super().__init__(engine_client)
-        self.requests: list[Any] = []
-
-    async def create_chat_completion(self, request, raw_request=None):
-        del raw_request
-        self.requests.append(request)
-        self.seen_request_ids.append(request.request_id)
-
-        async def _gen():
-            yield "data: [DONE]\n\n"
-
-        return _gen()
-
-
-class GateChatService(FakeChatService):
-    def __init__(self, engine_client: FakeEngineClient) -> None:
-        super().__init__(engine_client)
-        self.first_response_gate = asyncio.Event()
-        self.response_count = 0
-
-    async def create_chat_completion(self, request, raw_request=None):
-        del raw_request
-        self.seen_request_ids.append(request.request_id)
-        self.response_count += 1
-        response_number = self.response_count
-
-        async def _gen():
-            if response_number == 1:
-                await self.first_response_gate.wait()
-            yield "data: [DONE]\n\n"
-
-        return _gen()
-
-
-def _test_data_plane() -> MiniCPMO45DataPlaneSession:
-    def encode_audio(
-        audio: object,
-        sample_rate_hz: int,
-        response_format: str,
-        speed: float | None,
-    ) -> str | None:
-        del sample_rate_hz, response_format, speed
-        if audio is None:
-            return None
-        if hasattr(audio, "numel"):
-            return f"wav-{int(audio.numel())}"
-        return f"wav-{int(np.asarray(audio).size)}"
-
-    return MiniCPMO45DataPlaneSession(encode_audio)
-
-
-def _data_plane_context(session: DuplexSession | None = None) -> MiniCPMO45DataPlaneContext:
-    if session is None:
-        return MiniCPMO45DataPlaneContext()
-    return MiniCPMO45DataPlaneContext(
-        epoch=session.epoch,
-        turn_id=session.turn_id,
-        active_response_turn_id=session.active_response_turn_id,
-        active_response_id=session.active_response_id,
-        auto_responds=bool(session.config.extra_body.get("auto_response", False)),
-        response_format=session.config.response_format,
-        speed=session.config.speed,
-        modalities=tuple(session.config.modalities),
-    )
-
-
-def _project_data_plane(
-    data_plane: MiniCPMO45DataPlaneSession,
-    result: object,
-    *,
-    session: DuplexSession | None = None,
-) -> list[dict[str, Any]]:
-    return list(data_plane.project(result, context=_data_plane_context(session)))
-
-
-class TimedWebSocket:
-    def __init__(self, *, on_send=None, receive_timeout_s: float = 1.0):
-        self._q: asyncio.Queue[str | BaseException] = asyncio.Queue()
-        self.sent: list[dict[str, Any]] = []
-        self.accepted = False
-        self._on_send = on_send
-        self._receive_timeout_s = receive_timeout_s
-        self.query_params: dict[str, str] = {}
-
-    async def accept(self):
-        self.accepted = True
-
-    async def receive_text(self) -> str:
-        try:
-            item = await asyncio.wait_for(self._q.get(), timeout=self._receive_timeout_s)
-        except asyncio.TimeoutError as exc:
-            raise WebSocketDisconnect(code=1000) from exc
-        if isinstance(item, BaseException):
-            raise item
-        return item
-
-    async def send_json(self, data: dict[str, Any]):
-        self.sent.append(data)
-        if self._on_send is not None:
-            self._on_send(self, data)
-
-    def put(self, payload: dict[str, Any]) -> None:
-        self._q.put_nowait(json.dumps(payload))
-
-    async def close(self, code: int = 1000, reason: str | None = None) -> None:
-        del reason
-        self._q.put_nowait(WebSocketDisconnect(code=code))
-
-    def sent_types(self) -> list[str]:
-        return [m.get("type", "") for m in self.sent]
-
-
-class FakeServerVADBackend:
-    frame_samples = 160
-
-    def __init__(self, probabilities: list[float]) -> None:
-        self.probabilities = probabilities
-        self.calls = 0
-
-    def new_state(self) -> int:
-        return 0
-
-    def infer(self, frame: np.ndarray, state: object) -> tuple[float, object]:
-        del frame
-        self.calls += 1
-        index = int(state)
-        probability = self.probabilities[index] if index < len(self.probabilities) else 0.0
-        return probability, index + 1
-
-
-class FakeServerVADProvider:
-    def __init__(self, backend: FakeServerVADBackend) -> None:
-        self.backend = backend
-
-    def get(self) -> FakeServerVADBackend:
-        return self.backend
-
-
-class FailingServerVADProvider:
-    def __init__(self) -> None:
-        self.calls = 0
-
-    def get(self) -> FakeServerVADBackend:
-        self.calls += 1
-        raise RuntimeError("server VAD backend unavailable")
-
-
-class FailOnceServerVADBackend(FakeServerVADBackend):
-    def __init__(self, probabilities: list[float]) -> None:
-        super().__init__(probabilities)
-        self._failed = False
-
-    def infer(self, frame: np.ndarray, state: object) -> tuple[float, object]:
-        if not self._failed and int(state) == 2:
-            self._failed = True
-            raise RuntimeError("server VAD inference failed")
-        return super().infer(frame, state)
-
-
-def _server_vad_turn_detection(*, create_response: bool = True) -> dict[str, Any]:
-    return {
-        "type": "server_vad",
-        "prefix_padding_ms": 10,
-        "silence_duration_ms": 20,
-        "create_response": create_response,
-        "interrupt_response": False,
-    }
-
-
-def _server_vad_session_update(
-    turn_detection: dict[str, Any] | None,
-    *,
-    event_id: str | None = None,
-    sample_rate_hz: int = 16_000,
-) -> dict[str, Any]:
-    event: dict[str, Any] = {
-        "type": "session.update",
-        "session": {
-            "model": "test-model",
-            "audio": {
-                "input": {
-                    "format": {"type": "audio/pcm", "rate": sample_rate_hz},
-                    "turn_detection": turn_detection,
-                }
-            },
-        },
-    }
-    if event_id is not None:
-        event["event_id"] = event_id
-    return event
-
-
-def _server_vad_audio_append(
-    frame_count: int = 5,
-    *,
-    event_id: str | None = None,
-    is_speech: bool | None = None,
-    sample_rate_hz: int = 16_000,
-) -> dict[str, Any]:
-    sample_count = frame_count * 160 * sample_rate_hz // 16_000
-    event: dict[str, Any] = {
-        "type": "input_audio_buffer.append",
-        "audio": base64.b64encode(np.zeros(sample_count, dtype="<i2").tobytes()).decode(),
-    }
-    if event_id is not None:
-        event["event_id"] = event_id
-    if is_speech is not None:
-        event["is_speech"] = is_speech
-    return event
-
-
-def test_native_realtime_protocol_emits_speak_once_per_response():
-    protocol = NativeRealtimeSessionProtocol({})
-    response_id = "resp-speak-once"
-
-    projected = protocol.encode_outbound_event(
-        {
-            "type": "response.created",
-            "response_id": response_id,
-            "modalities": ["audio", "text"],
-        }
-    )
-    projected.extend(
-        protocol.encode_outbound_event(
-            {
-                "type": "response.speak",
-                "response_id": response_id,
-                "text": "hello",
-                "model_speak": True,
-            }
-        )
-    )
-    projected.extend(
-        protocol.encode_outbound_event(
-            {
-                "type": "response.output_audio.delta",
-                "response_id": response_id,
-                "audio": base64.b64encode(b"\x00\x00").decode("ascii"),
-                "format": "pcm16",
-                "sample_rate_hz": 24000,
-                "model_speak": True,
-            }
-        )
-    )
-
-    assert [event["type"] for event in projected].count("response.speak") == 1
-    speak = next(event for event in projected if event["type"] == "response.speak")
-    assert "text" not in speak
-    assert speak["metadata"] == {"model_speak": True}
-
-
-def test_native_realtime_protocol_speak_does_not_expose_internal_event():
-    protocol = NativeRealtimeSessionProtocol({})
-
-    projected = protocol.encode_outbound_event(
-        {
-            "type": "response.speak",
-            "response_id": "resp-curated-speak",
-            "session_id": "sid-curated-speak",
-            "epoch": 3,
-            "text": "transcript belongs on the delta channel",
-            "model_speak": True,
-            "data_plane_request_id": "internal-request-id",
-            "uses_model_runner_scheduler": True,
-        }
-    )
-
-    assert len(projected) == 1
-    projected[0].pop("event_id")
-    assert projected == [
-        {
-            "type": "response.speak",
-            "response_id": "resp-curated-speak",
-            "item_id": "item_resp-curated-speak",
-            "output_index": 0,
-            "content_index": 0,
-            "metadata": {
-                "session_id": "sid-curated-speak",
-                "epoch": 3,
-                "model_speak": True,
-            },
-        }
-    ]
-
-
-@pytest.mark.asyncio
-async def test_native_realtime_protocol_drains_internal_conversation_item_control_event():
-    ws = TimedWebSocket()
-    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
-    protocol.bind_sender(ws.send_json)
-
-    ws.put({"type": "session.update", "model": "test-model", "session_id": "rt-delete"})
-    session_create = json.loads(await protocol.receive_internal_event_text(ws))
-    assert session_create["type"] == "session.create"
-
-    ws.put(
-        {
-            "type": "conversation.item.create",
-            "item": {
-                "id": "item-a",
-                "type": "message",
-                "role": "user",
-                "content": [{"type": "input_text", "text": "hello"}],
-            },
-        }
-    )
-    assert json.loads(await protocol.receive_internal_event_text(ws)) == {
-        "type": "turn.signal",
-        "event": "conversation.item.create",
-        "payload": {
-            "item": {
-                "id": "item-a",
-                "object": "realtime.item",
-                "type": "message",
-                "status": "completed",
-                "role": "user",
-                "content": [{"type": "input_text", "text": "hello"}],
-            }
-        },
-    }
-
-    ws.put({"type": "conversation.item.delete", "item_id": "item-a"})
-    translated = json.loads(await protocol.receive_internal_event_text(ws))
-
-    assert translated == {
-        "type": "turn.signal",
-        "event": "conversation.item.delete",
-        "payload": {"item_id": "item-a"},
-    }
-
-
-@pytest.mark.asyncio
-async def test_native_realtime_protocol_conversation_item_create_commits_user_text():
-    ws = TimedWebSocket()
-    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
-    protocol.bind_sender(ws.send_json)
-
-    ws.put({"type": "session.update", "model": "test-model", "session_id": "rt-item-create"})
-    session_create = json.loads(await protocol.receive_internal_event_text(ws))
-    assert session_create["type"] == "session.create"
-
-    ws.put(
-        {
-            "type": "conversation.item.create",
-            "item": {
-                "id": "item-user-text",
-                "type": "message",
-                "role": "user",
-                "content": [{"type": "input_text", "text": "hello"}],
-            },
-        }
-    )
-
-    translated = json.loads(await protocol.receive_internal_event_text(ws))
-
-    assert translated == {
-        "type": "turn.signal",
-        "event": "conversation.item.create",
-        "payload": {
-            "item": {
-                "id": "item-user-text",
-                "object": "realtime.item",
-                "type": "message",
-                "status": "completed",
-                "role": "user",
-                "content": [{"type": "input_text", "text": "hello"}],
-            }
-        },
-    }
-
-
-@pytest.mark.asyncio
-async def test_function_output_is_recorded_only_after_runtime_delivery():
-    ws = TimedWebSocket()
-    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
-    protocol.bind_sender(ws.send_json)
-    protocol.encode_outbound_event(
-        {
-            "type": "conversation.item.created",
-            "item": {
-                "id": "item-call",
-                "type": "function_call",
-                "call_id": "call-1",
-                "name": "weather",
-                "arguments": "{}",
-                "status": "completed",
-            },
-        }
-    )
-    event = {
-        "type": "conversation.item.create",
-        "item": {
-            "id": "item-output",
-            "type": "function_call_output",
-            "call_id": "call-1",
-            "output": '{"temperature":20}',
-        },
-    }
-
-    first = await protocol._to_duplex_event(event)
-    retry = await protocol._to_duplex_event(event)
-
-    assert first is not None
-    assert retry is not None
-    assert "item-output" not in protocol._conversation_items
-
-    delivered_item = first["payload"]["item"]
-    protocol.encode_outbound_event(
-        {
-            "type": "conversation.item.created",
-            "item": delivered_item,
-        }
-    )
-
-    assert protocol._conversation_items["item-output"] == delivered_item
-    assert await protocol._to_duplex_event(event) is None
-    assert ws.sent[-1]["error"]["code"] == "invalid_function_call_output"
-
-
-@pytest.mark.asyncio
-async def test_native_realtime_protocol_audio_commit_requires_non_empty_buffer():
-    ws = TimedWebSocket()
-    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
-    protocol.bind_sender(ws.send_json)
-
-    ws.put({"type": "session.update", "model": "test-model", "session_id": "rt-audio-commit"})
-    session_create = json.loads(await protocol.receive_internal_event_text(ws))
-    assert session_create["type"] == "session.create"
-
-    ws.put({"type": "input_audio_buffer.commit", "final": True})
-    with pytest.raises(WebSocketDisconnect):
-        await protocol.receive_internal_event_text(ws)
-
-    assert ws.sent[-1]["type"] == "error"
-    assert ws.sent[-1]["error"]["code"] == "input_audio_buffer_empty"
-
-
-@pytest.mark.asyncio
-async def test_native_realtime_protocol_audio_commit_does_not_auto_create_response():
-    ws = TimedWebSocket()
-    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
-    protocol.bind_sender(ws.send_json)
-
-    ws.put({"type": "session.update", "model": "test-model", "session_id": "rt-audio-commit-full"})
-    session_create = json.loads(await protocol.receive_internal_event_text(ws))
-    assert session_create["type"] == "session.create"
-
-    pcm = struct.pack("<2h", 1024, -1024)
-    ws.put({"type": "input_audio_buffer.append", "audio": base64.b64encode(pcm).decode("ascii"), "format": "pcm16"})
-    append_event = json.loads(await protocol.receive_internal_event_text(ws))
-    assert append_event["type"] == "input_audio_buffer.append"
-
-    ws.put({"type": "input_audio_buffer.commit", "final": True})
-    commit_event = json.loads(await protocol.receive_internal_event_text(ws))
-
-    assert commit_event["type"] == "input_audio_buffer.commit"
-    assert commit_event["response_create"] is False
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("complete_item", [False, True], ids=["manual-commit", "complete-audio-item"])
-async def test_realtime_commit_ack_preserves_next_turn(complete_item: bool):
-    ws = TimedWebSocket()
-    protocol = NativeRealtimeSessionProtocol({})
-    protocol.bind_sender(ws.send_json)
-    protocol.encode_outbound_event({"type": "session.created", "session": {}})
-    audio = base64.b64encode(struct.pack("<2h", 1024, -1024)).decode()
-    append = {"type": "input_audio_buffer.append", "audio": audio, "format": "pcm16"}
-    if complete_item:
-        await protocol._to_duplex_event(
-            {
-                "type": "conversation.item.create",
-                "item": {
-                    "type": "message",
-                    "role": "user",
-                    "content": [{"type": "input_audio", "audio": audio}],
-                },
-            }
-        )
-        first_commit = json.loads(await protocol.receive_internal_event_text(ws))
-    else:
-        await protocol._to_duplex_event(append)
-        first_commit = await protocol._to_duplex_event({"type": "input_audio_buffer.commit"})
-    assert first_commit is not None
-
-    await protocol._to_duplex_event({**append, "transcript": "second turn"})
-    second_item_id = next(
-        (event["item_id"] for event in reversed(ws.sent) if event["type"] == "input_audio_buffer.speech_started"),
-        None,
-    )
-    assert second_item_id is not None
-    protocol.encode_outbound_event({"type": "input.committed", "item_id": first_commit["item_id"]})
-    second_commit = await protocol._to_duplex_event({"type": "input_audio_buffer.commit"})
-
-    assert second_commit is not None
-    assert second_commit["item_id"] == second_item_id != first_commit["item_id"]
-    assert second_commit["transcript"] == "second turn"
-    assert "error" not in ws.sent_types()
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("pending_next_turn", [False, True])
-async def test_realtime_silence_commit_does_not_reuse_speech_item(pending_next_turn: bool):
-    ws = TimedWebSocket()
-    protocol = NativeRealtimeSessionProtocol({})
-    protocol.bind_sender(ws.send_json)
-    protocol.encode_outbound_event({"type": "session.created", "session": {}})
-    append = {
-        "type": "input_audio_buffer.append",
-        "audio": base64.b64encode(struct.pack("<2h", 1024, -1024)).decode(),
-        "format": "pcm16",
-    }
-    await protocol._to_duplex_event(append)
-    first_commit = await protocol._to_duplex_event({"type": "input_audio_buffer.commit"})
-    assert first_commit is not None
-    events = protocol.encode_outbound_event(
-        {"type": "input.committed", "item_id": first_commit["item_id"], "message": {"transcript": "first turn"}}
-    )
-
-    await protocol._to_duplex_event({**append, "audio": base64.b64encode(bytes(4)).decode()})
-    silence_commit = await protocol._to_duplex_event({"type": "input_audio_buffer.commit"})
-    assert silence_commit is not None and silence_commit["is_speech"] is False
-    if pending_next_turn:
-        await protocol._to_duplex_event(append)
-        next_commit = await protocol._to_duplex_event({"type": "input_audio_buffer.commit"})
-        assert next_commit is not None
-    events.extend(
-        protocol.encode_outbound_event(
-            {"type": "input.committed", "empty": True, "is_speech": False, "no_response": True}
-        )
-    )
-    if pending_next_turn:
-        events.extend(protocol.encode_outbound_event({"type": "input.committed", "item_id": next_commit["item_id"]}))
-
-    committed = [event for event in events if event["type"] == "input_audio_buffer.committed"]
-    assert len(committed) == len({event["item_id"] for event in committed}) == 2 + int(pending_next_turn)
-    assert committed[0]["item_id"] == first_commit["item_id"]
-    if pending_next_turn:
-        assert committed[2]["item_id"] == next_commit["item_id"]
-    transcripts = [
-        event for event in events if event["type"] == "conversation.item.input_audio_transcription.completed"
-    ]
-    assert [(event["item_id"], event["transcript"]) for event in transcripts] == [
-        (first_commit["item_id"], "first turn")
-    ]
-    assert "error" not in ws.sent_types()
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize(
-    "turn_detection,sample_rate_hz",
-    [(None, 192_001), (_server_vad_turn_detection(), [16_000])],
-    ids=["manual-out-of-range", "server-vad-invalid-type"],
-)
-async def test_native_realtime_protocol_rejects_invalid_sample_rate_without_closing(turn_detection, sample_rate_hz):
-    ws = TimedWebSocket()
-    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
-    protocol.bind_sender(ws.send_json)
-
-    ws.put(_server_vad_session_update(turn_detection))
-    session_create = json.loads(await protocol.receive_internal_event_text(ws))
-    assert session_create["type"] == "session.create"
-    protocol.commit_realtime_turn_detection_update()
-
-    ws.put(
-        {
-            "type": "input_audio_buffer.append",
-            "audio": _pcm16_b64(1),
-            "format": "pcm16",
-            "sample_rate_hz": sample_rate_hz,
-            "event_id": "invalid-rate",
-        }
-    )
-    ws.put({"type": "input_audio_buffer.clear"})
-    translated = json.loads(await protocol.receive_internal_event_text(ws))
-
-    assert translated == {"type": "input_audio_buffer.clear", "reason": "input_audio_buffer.clear"}
-    error = next(event for event in ws.sent if event.get("type") == "error")
-    assert error["error"]["code"] == "bad_event"
-    assert error["error"]["param"] == "sample_rate_hz"
-    assert error["error"]["event_id"] == "invalid-rate"
-
-
-@pytest.mark.asyncio
-async def test_native_realtime_protocol_audio_clear_is_not_barge_in_cancel():
-    ws = TimedWebSocket()
-    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
-    protocol.bind_sender(ws.send_json)
-
-    ws.put({"type": "session.update", "model": "test-model", "session_id": "rt-audio-clear"})
-    session_create = json.loads(await protocol.receive_internal_event_text(ws))
-    assert session_create["type"] == "session.create"
-
-    ws.put({"type": "input_audio_buffer.clear"})
-    clear_event = json.loads(await protocol.receive_internal_event_text(ws))
-
-    assert clear_event == {"type": "input_audio_buffer.clear", "reason": "input_audio_buffer.clear"}
-
-
-@pytest.mark.asyncio
-async def test_native_realtime_protocol_preserves_input_turn_policy_hints():
-    ws = TimedWebSocket()
-    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
-    protocol.bind_sender(ws.send_json)
-
-    translated = await protocol._to_duplex_event(
-        {
-            "type": "input_audio_buffer.append",
-            "audio": "AAAA",
-            "format": "pcm_f32le",
-            "duration_ms": 240,
-            "vad": {"is_speech": True, "speech_probability": 0.9},
-            "overlap_action": "listen",
-        }
-    )
-
-    assert translated is not None
-    assert translated["duration_ms"] == 240
-    assert translated["vad"] == {"is_speech": True, "speech_probability": 0.9}
-    assert translated["overlap_action"] == "listen"
-
-
-@pytest.mark.asyncio
-async def test_realtime_protocol_accepts_legacy_server_vad_alias():
-    ws = TimedWebSocket()
-    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
-    protocol.bind_sender(ws.send_json)
-
-    translated = await protocol._to_duplex_event(
-        {
-            "type": "session.update",
-            "model": "test-model",
-            "session_id": "rt-turn-detection",
-            "turn_detection": {
-                "type": "server_vad",
-                "interrupt_response": False,
-                "threshold": 0.4,
-            },
-        }
-    )
-
-    assert translated is not None
-    config = DuplexSessionConfig.from_event(translated)
-    assert config.server_vad is not None
-    assert config.server_vad.threshold == 0.4
-
-
-@pytest.mark.asyncio
-async def test_native_realtime_protocol_accepts_disabled_turn_detection():
-    ws = TimedWebSocket()
-    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
-    protocol.bind_sender(ws.send_json)
-
-    ws.put(
-        {
-            "type": "session.update",
-            "model": "test-model",
-            "session_id": "rt-no-turn-detection",
-            "turn_detection": None,
-        }
-    )
-    translated = json.loads(await protocol.receive_internal_event_text(ws))
-
-    assert translated["type"] == "session.create"
-    assert translated["session"]["extra_body"]["realtime_session_payload"]["turn_detection"] is None
-
-
-def test_native_realtime_protocol_preserves_omitted_turn_detection():
-    protocol = NativeRealtimeSessionProtocol({})
-
-    updated = protocol._from_duplex_event(
-        {
-            "type": "session.updated",
-            "session": {},
-        }
-    )[0]
-
-    assert "turn_detection" not in updated["session"]
-    assert "turn_detection" not in updated["session"]["audio"]["input"]
-
-
-@pytest.mark.asyncio
-async def test_duplex_session_create_reports_invalid_server_vad_as_client_error():
-    session_id = "sid-invalid-server-vad-config"
-    event = _session_create(session_id)
-    event["session"]["extra_body"] = {
-        "realtime_session_payload": {"turn_detection": {"type": "server_vad", "threshold": 1.5}},
-    }
-
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket()
-    ws.put(event)
-
-    await handler.handle_session(ws)
-
-    assert ws.sent_types() == ["error"]
-    assert ws.sent[0]["code"] == "invalid_request_error"
-    assert ws.sent[0]["error"] == "server_vad.threshold must be a number between 0 and 1"
-    assert handler._registry.get(session_id) is None
-    assert engine.opened == []
-
-
-def test_native_duplex_handler_has_no_fixed_session_admission_cap():
-    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
-    client_config = DuplexSessionConfig(
-        extra_body={"max_duplex_sessions": 99, "duplex_max_sessions": 99},
-    )
-
-    assert not hasattr(handler, "_max_native_duplex_sessions")
-    assert not hasattr(handler, "_max_duplex_sessions")
-    assert client_config.extra_body["max_duplex_sessions"] == 99
-
-
-def test_native_response_options_ignore_private_runtime_config():
-    session = DuplexSession(
-        session_id="sid-response-private-config",
-        config=DuplexSessionConfig(),
-        capabilities=minicpmo45_native_capabilities(),
-    )
-
-    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
-    handler._apply_response_create_options(
-        session,
-        {
-            "extra_body": {
-                "duplex_stage_max_tokens": {"0": 999},
-                "client_trace_id": "trace-1",
-            }
-        },
-    )
-    session.begin_response()
-
-    assert "duplex_stage_max_tokens" not in session.config.extra_body
-    assert "client_trace_id" not in session.config.extra_body
-    assert session.response_config.extra_body["client_trace_id"] == "trace-1"
-
-
-@pytest.mark.parametrize(
-    "payload",
-    [
-        {"instructions": "not wired"},
-        {"voice": "not-wired"},
-        {"temperature": 0.2},
-        {"max_output_tokens": 8},
-        {"tools": [{"type": "function", "name": "lookup"}]},
-    ],
-)
-def test_native_response_create_rejects_unwired_generation_options(payload):
-    session = DuplexSession(
-        session_id="sid-response-unwired-options",
-        config=DuplexSessionConfig(),
-        capabilities=minicpmo45_native_capabilities(),
-    )
-
-    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
-    error = handler._apply_response_create_options(session, payload)
-
-    assert error == "unsupported_native_response_options"
-    session.begin_response()
-    assert session.response_config == session.config
-
-
-def test_chat_fallback_excludes_realtime_response_metadata_from_model_request():
-    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
-    session = DuplexSession(
-        session_id="sid-response-protocol-metadata",
-        config=DuplexSessionConfig(),
-    )
-    session.reserve_response_options(
-        ResponseCreateOptions(
-            extra_body={
-                "user": "trace-1",
-                "realtime_response_conversation": "none",
-                "realtime_response_metadata": {"source": "test"},
-                "realtime_response_prompt": {"id": "prompt-1"},
-                "realtime_response_tools": [
-                    {
-                        "type": "function",
-                        "function": {"name": "lookup", "parameters": {}},
-                    }
-                ],
-                "realtime_response_tool_choice": "auto",
-            }
-        )
-    )
-    session.begin_response()
-
-    request = handler._build_chat_request(session, "request-1")
-    created = handler._response_created_payload(session, session.active_response_id or "response-1", epoch=0)
-    dumped = request.model_dump()
-
-    assert dumped["user"] == "trace-1"
-    assert dumped["tools"][0]["function"]["name"] == "lookup"
-    assert dumped["tool_choice"] == "auto"
-    assert not any(key.startswith("realtime_response_") for key in dumped)
-    assert created["conversation"] == "none"
-    assert created["metadata"] == {"source": "test"}
-    assert created["prompt"] == {"id": "prompt-1"}
-    assert session.response_config.extra_body["realtime_response_conversation"] == "none"
-
-
-@pytest.mark.asyncio
-async def test_native_response_create_surfaces_unwired_generation_options_error():
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(FakeEngineClient()),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-response-unwired-options-event"))
-    ws.put(
-        {
-            "type": "response.create",
-            "response": {"instructions": "not wired"},
-        }
-    )
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    error = next(message for message in ws.sent if message.get("type") == "error")
-    assert error["code"] == "unsupported_native_response_options"
-    assert "response_create_without_input" not in {message.get("code") for message in ws.sent}
-
-
-@pytest.mark.asyncio
-async def test_realtime_session_update_preserves_tools_and_metadata():
-    engine = FakeEngineClient()
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-rt-update-fields"))
-    ws.put(
-        {
-            "type": "turn.signal",
-            "event": "session.update",
-            "payload": {
-                "tools": [{"type": "function", "name": "lookup"}],
-                "tool_choice": "auto",
-                "metadata": {"demo": "yes"},
-            },
-        }
-    )
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    updated = next(m for m in ws.sent if m.get("type") == "session.updated")
-    session = updated["session"]
-    assert session["tools"] == [{"type": "function", "name": "lookup"}]
-    assert session["tool_choice"] == "auto"
-    assert session["metadata"] == {"demo": "yes"}
-    assert "turn_detection" not in session
-    runtime_config = engine.signal_session_configs[-1]
-    assert runtime_config is not None
-    assert runtime_config["extra_body"]["realtime_tools"] == [{"type": "function", "name": "lookup"}]
-    assert runtime_config["extra_body"]["realtime_metadata"] == {"demo": "yes"}
-
-
-@pytest.mark.asyncio
-async def test_native_realtime_protocol_non_speech_append_does_not_emit_speech_started():
-    ws = TimedWebSocket()
-    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
-    protocol.bind_sender(ws.send_json)
-
-    translated = await protocol._to_duplex_event(
-        {
-            "type": "input_audio_buffer.append",
-            "audio": "AAAA",
-            "format": "pcm_f32le",
-            "vad": {"is_speech": False},
-        }
-    )
-
-    assert translated is not None
-    assert translated["vad"] == {"is_speech": False}
-    assert not any(event.get("type") == "input_audio_buffer.speech_started" for event in ws.sent)
-
-
-@pytest.mark.asyncio
-async def test_native_session_update_rebuilds_server_runtime_policy():
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-runtime-update"))
-    ws.put(
-        {
-            "type": "turn.signal",
-            "event": "session.update",
-            "payload": {"temperature": 0.2, "max_output_tokens": 7},
-        }
-    )
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    assert "session.updated" in ws.sent_types()
-    public_config = engine.signal_session_configs[-1]
-    runtime_config = engine.signal_runtime_configs[-1]
-    assert public_config is not None
-    assert runtime_config is not None
-    assert "duplex_stage_sampling_params" not in public_config["extra_body"]
-    assert runtime_config["duplex_stage_max_tokens"]["0"] == 7
-    assert runtime_config["duplex_stage_sampling_params"]["0"]["temperature"] == 0.2
-    assert runtime_config["duplex_stage_sampling_params"]["0"]["top_k"] == 20
-    assert runtime_config["duplex_stage_sampling_params"]["0"]["top_p"] == 0.8
-
-
-@pytest.mark.asyncio
-async def test_realtime_server_vad_locks_turn_detection_after_audio_append():
-    ws = TimedWebSocket()
-    ws.put(_server_vad_session_update({"type": "server_vad"}))
-    ws.put(_server_vad_audio_append(frame_count=1))
-    # Repeating the same omitted defaults must not look like a config change.
-    ws.put(_server_vad_session_update({"type": "server_vad"}))
-    ws.put(
-        {
-            "type": "session.update",
-            "event_id": "event-change-turn-detection",
-            "session": {"audio": {"input": {"turn_detection": None}}},
-        }
-    )
-    ws.put({"type": "session.close"})
-    handler = OmniDuplexSessionHandler(
-        chat_service=TurnBasedFakeChatService(FakeEngineClient()),
-        server_vad_backend_provider=FakeServerVADProvider(FakeServerVADBackend([0.0])),
-    )
-
-    await handler.handle_realtime_session(ws)  # type: ignore[arg-type]
-
-    (error,) = [event["error"] for event in ws.sent if event.get("type") == "error"]
-    assert error["code"] == "unsupported_turn_detection"
-    assert error["event_id"] == "event-change-turn-detection"
-    assert "turn_detection cannot be changed after the first audio append" in error["message"]
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize(
-    "audio",
-    ["not-base64", base64.b64encode(b"\x00").decode()],
-    ids=["invalid-base64", "incomplete-pcm16-sample"],
-)
-@pytest.mark.parametrize(
-    "event_type,error_param",
-    [("input_audio_buffer.append", "audio"), ("conversation.item.create", "item.content.audio")],
-)
-async def test_realtime_invalid_server_vad_audio_is_correlated_and_unbuffered(
-    audio: str, event_type: str, error_param: str
-):
-    ws = TimedWebSocket()
-    ws.put(_server_vad_session_update(_server_vad_turn_detection(create_response=False)))
-    event = {"type": event_type, "event_id": "event-invalid-server-vad-audio"}
-    if event_type == "input_audio_buffer.append":
-        event["audio"] = audio
-    else:
-        event["item"] = {
-            "type": "message",
-            "role": "user",
-            "content": [{"type": "input_audio", "audio": audio}],
-        }
-    ws.put(event)
-    ws.put(_server_vad_session_update(None))
-    ws.put({"type": "input_audio_buffer.commit", "event_id": "event-commit-after-invalid-audio"})
-    ws.put({"type": "session.close"})
-    handler = OmniDuplexSessionHandler(
-        chat_service=TurnBasedFakeChatService(FakeEngineClient()),
-        server_vad_backend_provider=FakeServerVADProvider(FakeServerVADBackend([])),
-    )
-
-    await handler.handle_realtime_session(ws)  # type: ignore[arg-type]
-
-    errors = [event["error"] for event in ws.sent if event.get("type") == "error"]
-    bad_audio = next(error for error in errors if error["code"] == "bad_audio")
-    assert bad_audio["event_id"] == "event-invalid-server-vad-audio"
-    assert bad_audio["param"] == error_param
-    empty_buffer = next(error for error in errors if error["code"] == "input_audio_buffer_empty")
-    assert empty_buffer["event_id"] == "event-commit-after-invalid-audio"
-
-
-def test_native_realtime_protocol_projects_input_commit_in_openai_order():
-    protocol = NativeRealtimeSessionProtocol(TimedWebSocket())  # type: ignore[arg-type]
-    client_event_id = "client-input-commit"
-
-    events = protocol.encode_outbound_event(
-        {
-            "type": "input.committed",
-            "item_id": "item-user-audio",
-            "message": {"role": "user"},
-            "event_id": client_event_id,
-        }
-    )
-
-    assert [event["type"] for event in events] == [
-        "input_audio_buffer.committed",
-        "conversation.item.added",
-        "conversation.item.done",
-    ]
-    committed, added, done = events
-    assert set(committed) == {
-        "event_id",
-        "item_id",
-        "previous_item_id",
-        "type",
-    }
-    assert set(added) == {"event_id", "item", "previous_item_id", "type"}
-    assert set(done) == {"event_id", "item", "previous_item_id", "type"}
-    assert committed["item_id"] == added["item"]["id"] == done["item"]["id"]
-    assert committed["previous_item_id"] == added["previous_item_id"] == done["previous_item_id"]
-    server_event_ids = [event["event_id"] for event in events]
-    assert len(set(server_event_ids)) == len(events)
-    assert client_event_id not in server_event_ids
-    assert all(isinstance(event_id, str) and event_id.startswith("event_") for event_id in server_event_ids)
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("native", [False, True])
-@pytest.mark.parametrize("interrupt_response", [False, True])
-async def test_realtime_server_vad_input_path_uses_runtime_capability(native: bool, interrupt_response: bool):
-    ws = TimedWebSocket()
-    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
-    protocol.bind_sender(ws.send_json)
-
-    translated = await protocol._to_duplex_event(
-        {
-            "type": "session.update",
-            "session": {
-                "model": "test-model",
-                "audio": {
-                    "input": {
-                        "turn_detection": {
-                            "type": "server_vad",
-                            "interrupt_response": interrupt_response,
-                        }
-                    }
-                },
-            },
-        }
-    )
-    assert translated is not None
-    # Serving validates supported combinations separately. Input translation
-    # must follow the selected runtime, not infer it from interruption policy.
-    protocol.bind_native_input_append(native)
-    protocol.commit_realtime_turn_detection_update()
-
-    source = np.arange(240, dtype="<i2")
-    append = await protocol._to_duplex_event(
-        {
-            "type": "input_audio_buffer.append",
-            "audio": base64.b64encode(source.tobytes()).decode(),
-        }
-    )
-
-    assert append is not None
-    if native:
-        assert append["format"] == "pcm_f32le"
-        assert append["sample_rate_hz"] == 16_000
-        assert len(base64.b64decode(append["audio"])) == 160 * 4
-    else:
-        assert append["format"] == "pcm16"
-        assert append["sample_rate_hz"] == 24_000
-        np.testing.assert_array_equal(np.frombuffer(base64.b64decode(append["audio"]), dtype="<i2"), source)
-
-
-@pytest.mark.parametrize(("initial_rate_hz", "updated_rate_hz"), [(16_000, 24_000), (24_000, 16_000)])
-@pytest.mark.asyncio
-async def test_turn_based_server_vad_rejects_input_rate_change_after_append(
-    initial_rate_hz: int,
-    updated_rate_hz: int,
-):
-    initial = _server_vad_session_update(_server_vad_turn_detection(create_response=False))
-    initial["session"]["audio"]["input"]["format"]["rate"] = initial_rate_hz
-    append = _server_vad_audio_append(frame_count=1)
-    append["sample_rate_hz"] = initial_rate_hz
-    append["audio"] = base64.b64encode(np.zeros(initial_rate_hz // 100, dtype="<i2").tobytes()).decode()
-    ws = TimedWebSocket()
-    ws.put(initial)
-    ws.put(append)
-    ws.put(
-        {
-            "type": "session.update",
-            "event_id": "event-rate-change",
-            "session": {
-                "audio": {
-                    "input": {
-                        "format": {"type": "audio/pcm", "rate": updated_rate_hz},
-                    }
-                }
-            },
-        }
-    )
-    ws.put({"type": "session.close"})
-    handler = OmniDuplexSessionHandler(
-        chat_service=TurnBasedFakeChatService(FakeEngineClient()),
-        server_vad_backend_provider=FakeServerVADProvider(FakeServerVADBackend([0.0])),
-    )
-
-    await handler.handle_realtime_session(ws)  # type: ignore[arg-type]
-
-    error = next(
-        event["error"]
-        for event in ws.sent
-        if event.get("type") == "error" and event.get("error", {}).get("code") == "unsupported_audio_format"
-    )
-    assert error["event_id"] == "event-rate-change"
-
-
-@pytest.mark.parametrize("sample_rate_hz", INVALID_VALIDATED_SAMPLE_RATES)
-@pytest.mark.asyncio
-async def test_native_realtime_protocol_rejects_invalid_nested_audio_sample_rate(sample_rate_hz: object):
-    ws = TimedWebSocket()
-    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
-    protocol.bind_sender(ws.send_json)
-
-    translated = await protocol._to_duplex_event(
-        {
-            "type": "session.update",
-            "event_id": "event-invalid-rate",
-            "session": {
-                "audio": {
-                    "input": {
-                        "format": {"type": "audio/pcm", "rate": sample_rate_hz},
-                    }
-                }
-            },
-        }
-    )
-
-    assert translated is None
-    error = ws.sent[-1]["error"]
-    assert error["code"] == "unsupported_audio_format"
-    assert error["event_id"] == "event-invalid-rate"
-    assert "sample_rate_hz" in error["message"]
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("at_creation", [True, False], ids=["create", "update"])
-@pytest.mark.parametrize(
-    "input_update",
-    [
-        {"format": "g711_ulaw"},
-        {"channels": 2},
-        {"format": {"type": "audio/pcm", "rate": 44_100}},
-    ],
-    ids=["g711", "stereo", "unsupported-rate"],
-)
-async def test_realtime_rejects_unsupported_turn_based_server_vad_audio(
-    input_update: dict[str, Any],
-    at_creation: bool,
-):
-    def on_send(ws: TimedWebSocket, data: dict[str, Any]) -> None:
-        if data.get("type") == "response.done":
-            ws.put({"type": "session.close"})
-
-    ws = TimedWebSocket(on_send=on_send)
-    if not at_creation:
-        ws.put(_server_vad_session_update(_server_vad_turn_detection()))
-    update = _server_vad_session_update(_server_vad_turn_detection(), event_id="bad-vad-audio-format")
-    update["session"]["audio"]["input"].update(input_update)
-    ws.put(update)
-    if not at_creation:
-        ws.put(_server_vad_audio_append())
-    handler = OmniDuplexSessionHandler(
-        chat_service=TurnBasedFakeChatService(FakeEngineClient()),
-        server_vad_backend_provider=FakeServerVADProvider(FakeServerVADBackend([0.0, 0.9, 0.8, 0.0, 0.0])),
-    )
-
-    await handler.handle_realtime_session(ws)  # type: ignore[arg-type]
-
-    (error,) = [event["error"] for event in ws.sent if event.get("type") == "error"]
-    assert error["code"] == "unsupported_turn_detection"
-    assert error["event_id"] == "bad-vad-audio-format"
-    assert "mono PCM16" in error["message"]
-    assert ("session.created" in ws.sent_types()) is not at_creation
-    assert ("response.done" in ws.sent_types()) is not at_creation
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("sample_rate_hz", [16_000, 24_000])
-@pytest.mark.parametrize("create_response", [False, True], ids=["commit-only", "minimal-config"])
-@pytest.mark.parametrize("at_creation", [True, False], ids=["create", "update"])
-async def test_realtime_server_vad_commits_without_client_commit(
-    sample_rate_hz: int, create_response: bool, at_creation: bool
-):
-    def on_send(ws: TimedWebSocket, data: dict[str, Any]) -> None:
-        terminal_event = "response.done" if create_response else "input_audio_buffer.committed"
-        if data.get("type") == terminal_event:
-            ws.put({"type": "session.close"})
-
-    ws = TimedWebSocket(on_send=on_send)
-    if not at_creation:
-        ws.put(_server_vad_session_update(None, sample_rate_hz=sample_rate_hz))
-    ws.put(
-        _server_vad_session_update(
-            {"type": "server_vad"} if create_response else _server_vad_turn_detection(create_response=False),
-            sample_rate_hz=sample_rate_hz,
-        )
-    )
-    # Cover the default 500 ms silence timeout, plus streaming FIR right context.
-    ws.put(_server_vad_audio_append(54, sample_rate_hz=sample_rate_hz))
-    engine = FakeEngineClient()
-    chat_service = TurnBasedFakeChatService(engine)
-    handler = OmniDuplexSessionHandler(
-        chat_service=chat_service,
-        server_vad_backend_provider=FakeServerVADProvider(FakeServerVADBackend([0.0, 0.9, 0.8, 0.0, 0.0])),
-    )
-
-    await handler.handle_realtime_session(ws)  # type: ignore[arg-type]
-
-    event_types = ws.sent_types()
-    assert "error" not in event_types
-    effective_session = [
-        event["session"] for event in ws.sent if event["type"] in {"session.created", "session.updated"}
-    ][-1]
-    assert effective_session["turn_detection"]["interrupt_response"] is False
-    assert effective_session["audio"]["input"]["turn_detection"] == effective_session["turn_detection"]
-    assert effective_session["overlap_policy"] == "listen_only"
-    assert event_types.index("input_audio_buffer.speech_started") < event_types.index(
-        "input_audio_buffer.speech_stopped"
-    )
-    assert event_types.index("input_audio_buffer.speech_stopped") < event_types.index("input_audio_buffer.committed")
-    assert event_types.index("input_audio_buffer.committed") < event_types.index("conversation.item.added")
-    assert event_types.index("conversation.item.added") < event_types.index("conversation.item.done")
-    assert "conversation.item.created" not in event_types
-    committed = next(event for event in ws.sent if event.get("type") == "input_audio_buffer.committed")
-    added = next(event for event in ws.sent if event.get("type") == "conversation.item.added")
-    done = next(event for event in ws.sent if event.get("type") == "conversation.item.done")
-    assert committed["item_id"] == added["item"]["id"] == done["item"]["id"]
-    assert event_types.count("response.created") == int(create_response)
-    assert len(chat_service.seen_request_ids) == int(create_response)
-    if create_response:
-        assert event_types.index("input_audio_buffer.committed") < event_types.index("response.created")
-        assert event_types.index("response.created") < event_types.index("response.done")
-    assert engine.opened == []
-    assert engine.signals == []
-    assert engine.closed == []
-
-
-@pytest.mark.asyncio
-async def test_realtime_server_vad_create_response_false_accepts_response_create():
-    def on_send(ws: TimedWebSocket, data: dict[str, Any]) -> None:
-        if data.get("type") == "input_audio_buffer.committed":
-            ws.put({"type": "response.create"})
-        if data.get("type") == "response.done":
-            ws.put({"type": "session.close"})
-
-    ws = TimedWebSocket(on_send=on_send)
-    ws.put(_server_vad_session_update(_server_vad_turn_detection(create_response=False)))
-    ws.put(_server_vad_audio_append())
-    engine = FakeEngineClient()
-    chat_service = TurnBasedFakeChatService(engine)
-    handler = OmniDuplexSessionHandler(
-        chat_service=chat_service,
-        server_vad_backend_provider=FakeServerVADProvider(FakeServerVADBackend([0.0, 0.9, 0.8, 0.0, 0.0])),
-    )
-
-    await handler.handle_realtime_session(ws)  # type: ignore[arg-type]
-
-    event_types = ws.sent_types()
-    assert event_types.index("input_audio_buffer.committed") < event_types.index("response.created")
-    assert event_types.index("response.created") < event_types.index("response.done")
-    assert event_types.count("response.created") == 1
-    assert len(chat_service.seen_request_ids) == 1
-    assert engine.opened == engine.signals == engine.closed == []
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("sample_rate_hz", [16_000, 24_000])
-async def test_realtime_server_vad_complete_audio_item_bypasses_vad(sample_rate_hz: int):
-    def on_send(ws: TimedWebSocket, data: dict[str, Any]) -> None:
-        item = data.get("item")
-        if (
-            data.get("type") == "conversation.item.done"
-            and isinstance(item, dict)
-            and item.get("id") == "item-complete-audio"
-        ):
-            ws.put({"type": "response.create"})
-        if data.get("type") == "response.done":
-            ws.put({"type": "session.close"})
-
-    ws = TimedWebSocket(on_send=on_send)
-    ws.put(_server_vad_session_update(_server_vad_turn_detection(), sample_rate_hz=sample_rate_hz))
-    samples = np.arange(sample_rate_hz // 10, dtype=np.float32)
-    pcm16 = np.rint(0.5 * np.sin(2 * np.pi * 1_000 * samples / sample_rate_hz) * 32_767).astype("<i2")
-    public_audio = base64.b64encode(pcm16.tobytes()).decode()
-    ws.put(
-        {
-            "type": "conversation.item.create",
-            "event_id": "event-complete-audio",
-            "item": {
-                "id": "item-complete-audio",
-                "type": "message",
-                "role": "user",
-                "content": [{"type": "input_audio", "audio": public_audio}],
-            },
-        }
-    )
-    engine = FakeEngineClient()
-    chat_service = TurnBasedFakeChatService(engine)
-    vad_backend = FakeServerVADBackend([0.0])
-    handler = OmniDuplexSessionHandler(
-        chat_service=chat_service,
-        server_vad_backend_provider=FakeServerVADProvider(vad_backend),
-    )
-
-    await handler.handle_realtime_session(ws)  # type: ignore[arg-type]
-
-    added = next(event for event in ws.sent if event.get("type") == "conversation.item.added")
-    done = next(event for event in ws.sent if event.get("type") == "conversation.item.done")
-    assert added["item"] == done["item"]
-    assert done["item"]["content"] == [{"type": "input_audio", "audio": public_audio}]
-    event_types = ws.sent_types()
-    assert event_types.index("conversation.item.added") < event_types.index("conversation.item.done")
-    assert event_types.index("conversation.item.done") < event_types.index("response.created")
-    assert not {
-        "input_audio_buffer.speech_started",
-        "input_audio_buffer.speech_stopped",
-        "input_audio_buffer.committed",
-    }.intersection(event_types)
-    assert vad_backend.calls == 0
-    assert len(chat_service.requests) == 1
-
-    request = chat_service.requests[0]
-    history_content = request.messages[-1]["content"]
-    audio_url = history_content[-1]["audio_url"]["url"]
-    assert audio_url.startswith("data:audio/wav;base64,")
-    wav_payload = base64.b64decode(audio_url.partition(",")[2])
-    with wave.open(io.BytesIO(wav_payload), "rb") as wav_file:
-        assert wav_file.getnchannels() == 1
-        assert wav_file.getsampwidth() == 2
-        assert wav_file.getframerate() == 16_000
-        assert wav_file.getnframes() == 1_600
-
-
-@pytest.mark.asyncio
-async def test_realtime_server_vad_update_initialization_failure_keeps_session_open():
-    ws = TimedWebSocket()
-    ws.put(_server_vad_session_update(None))
-    ws.put(_server_vad_session_update(_server_vad_turn_detection(), event_id="event-enable-server-vad"))
-    ws.put(
-        {
-            "type": "session.update",
-            "session": {"instructions": "session remains usable"},
-        }
-    )
-    ws.put({"type": "session.close"})
-    handler = OmniDuplexSessionHandler(
-        chat_service=TurnBasedFakeChatService(FakeEngineClient()),
-        server_vad_backend_provider=FailingServerVADProvider(),
-    )
-
-    await handler.handle_realtime_session(ws)  # type: ignore[arg-type]
-
-    initialization_error_index, initialization_error = next(
-        (index, event)
-        for index, event in enumerate(ws.sent)
-        if event.get("type") == "error" and event.get("error", {}).get("code") == "server_vad_initialization_failed"
-    )
-    recovered_update_index, recovered_update = next(
-        (index, event)
-        for index, event in enumerate(ws.sent)
-        if event.get("type") == "session.updated"
-        and event.get("session", {}).get("instructions") == "session remains usable"
-    )
-    closed_index = ws.sent_types().index("session.closed")
-    assert initialization_error_index < recovered_update_index < closed_index
-    assert initialization_error["error"]["event_id"] == "event-enable-server-vad"
-    assert recovered_update["session"]["audio"]["input"]["turn_detection"] is None
-
-
-@pytest.mark.asyncio
-async def test_realtime_session_update_barrier_enables_server_vad_before_following_commit():
-    ws = TimedWebSocket()
-    ws.put(_server_vad_session_update(None))
-    ws.put(_server_vad_session_update({"type": "server_vad"}))
-    ws.put(
-        _server_vad_session_update(
-            {"type": "server_vad", "interrupt_response": True}, event_id="unsupported-interruption"
-        )
-    )
-    ws.put({"type": "session.update", "session": {"overlap_policy": "listen_only"}})
-    ws.put(_server_vad_audio_append(frame_count=1))
-    ws.put({"type": "input_audio_buffer.commit", "event_id": "commit-after-enable"})
-    ws.put({"type": "session.close"})
-    handler = OmniDuplexSessionHandler(
-        chat_service=TurnBasedFakeChatService(FakeEngineClient()),
-        server_vad_backend_provider=FakeServerVADProvider(FakeServerVADBackend([0.0])),
-    )
-
-    await handler.handle_realtime_session(ws)  # type: ignore[arg-type]
-
-    update_index = next(
-        index
-        for index, event in enumerate(ws.sent)
-        if event.get("type") == "session.updated"
-        and isinstance(
-            event.get("session", {}).get("audio", {}).get("input", {}).get("turn_detection"),
-            dict,
-        )
-        and event["session"]["audio"]["input"]["turn_detection"].get("type") == "server_vad"
-    )
-    commit_error_index, commit_error = next(
-        (index, event["error"])
-        for index, event in enumerate(ws.sent)
-        if event.get("type") == "error" and event.get("error", {}).get("code") == "server_vad_manual_commit_unsupported"
-    )
-    assert update_index < commit_error_index
-    errors = [event["error"] for event in ws.sent if event["type"] == "error"]
-    assert [error["code"] for error in errors] == [
-        "server_vad_requires_native_duplex",
-        "server_vad_manual_commit_unsupported",
-    ]
-    assert errors[0]["event_id"] == "unsupported-interruption"
-    assert "set interrupt_response=false" in errors[0]["message"]
-    assert commit_error["event_id"] == "commit-after-enable"
-    assert "input_audio_buffer.committed" not in ws.sent_types()
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("reset_reason", ["clear", "input_backpressure", "server_vad_inference_failed"])
-async def test_realtime_server_vad_reset_preserves_timeline_and_accepts_next_turn(reset_reason: str):
-    backend_class = FailOnceServerVADBackend if reset_reason == "server_vad_inference_failed" else FakeServerVADBackend
-    backend = backend_class([0.9, 0.9, 0.8, 0.0, 0.0])
-
-    def on_send(ws: TimedWebSocket, data: dict[str, Any]) -> None:
-        if data.get("type") == "response.done":
-            ws.put({"type": "session.close"})
-
-    ws = TimedWebSocket(on_send=on_send)
-    ws.put(_server_vad_session_update(_server_vad_turn_detection()))
-    first_append = _server_vad_audio_append(frame_count=2)
-    first_append["audio"] = base64.b64encode(np.full(320, 12_000, dtype="<i2").tobytes()).decode()
-    ws.put(first_append)
-    ws.put(
-        {"type": "input_audio_buffer.clear"}
-        if reset_reason == "clear"
-        else _server_vad_audio_append(
-            frame_count=6 if reset_reason == "input_backpressure" else 1,
-            event_id="event-server-vad-reset",
-        )
-    )
-    ws.put(_server_vad_audio_append())
-    chat_service = TurnBasedFakeChatService(FakeEngineClient())
-    handler = OmniDuplexSessionHandler(
-        chat_service=chat_service,
-        server_vad_backend_provider=FakeServerVADProvider(backend),
-        duplex_session_config=DuplexSessionRuntimeConfig(max_pending_input_bytes_per_session=5 * 160 * 4),
-    )
-
-    await handler.handle_realtime_session(ws)  # type: ignore[arg-type]
-
-    event_types = ws.sent_types()
-    cleared_index = event_types.index("input_audio_buffer.cleared")
-    speech_started_indices = [
-        index for index, event_type in enumerate(event_types) if event_type == "input_audio_buffer.speech_started"
-    ]
-    speech_stopped_index = event_types.index("input_audio_buffer.speech_stopped")
-    committed_index = event_types.index("input_audio_buffer.committed")
-    first_started_index, second_started_index = speech_started_indices
-    assert first_started_index < cleared_index < second_started_index < speech_stopped_index < committed_index
-    errors = [(index, event["error"]) for index, event in enumerate(ws.sent) if event.get("type") == "error"]
-    if reset_reason == "clear":
-        assert not errors
-    else:
-        ((error_index, error),) = errors
-        assert first_started_index < error_index < cleared_index
-        assert error["code"] == reset_reason
-        assert error["event_id"] == "event-server-vad-reset"
-    assert not {
-        "input_audio_buffer.speech_stopped",
-        "input_audio_buffer.committed",
-    }.intersection(event_types[first_started_index + 1 : cleared_index])
-    assert ws.sent[second_started_index]["audio_start_ms"] == 20
-    assert ws.sent[speech_stopped_index]["audio_end_ms"] == 70
-    assert ws.sent[first_started_index]["item_id"] != ws.sent[second_started_index]["item_id"]
-    assert ws.sent[second_started_index]["item_id"] == ws.sent[committed_index]["item_id"]
-    assert len(chat_service.requests) == 1
-    audio_url = chat_service.requests[0].messages[-1]["content"][-1]["audio_url"]["url"]
-    with wave.open(io.BytesIO(base64.b64decode(audio_url.partition(",")[2])), "rb") as wav_file:
-        # Only the new 50 ms turn is committed; the cleared nonzero audio is gone.
-        assert wav_file.getnframes() == 800
-        assert not np.frombuffer(wav_file.readframes(800), dtype="<i2").any()
-
-
-@pytest.mark.asyncio
-async def test_realtime_failed_server_vad_append_does_not_lock_turn_detection():
-    ws = TimedWebSocket()
-    ws.put(_server_vad_session_update(_server_vad_turn_detection(create_response=False)))
-    ws.put(_server_vad_audio_append(frame_count=3, event_id="event-failed-append"))
-    ws.put(
-        {
-            "type": "session.update",
-            "session": {"audio": {"input": {"turn_detection": None}}},
-        }
-    )
-    ws.put({"type": "session.close"})
-    handler = OmniDuplexSessionHandler(
-        chat_service=TurnBasedFakeChatService(FakeEngineClient()),
-        server_vad_backend_provider=FakeServerVADProvider(FailOnceServerVADBackend([0.9, 0.9])),
-    )
-
-    await handler.handle_realtime_session(ws)  # type: ignore[arg-type]
-
-    error_index, error = next(
-        (index, event["error"])
-        for index, event in enumerate(ws.sent)
-        if event.get("type") == "error" and event.get("error", {}).get("code") == "server_vad_inference_failed"
-    )
-    event_types = ws.sent_types()
-    disabled_index = next(
-        index
-        for index, event in enumerate(ws.sent)
-        if event.get("type") == "session.updated"
-        and event.get("session", {}).get("audio", {}).get("input", {}).get("turn_detection", "missing") is None
-    )
-    assert error_index < event_types.index("input_audio_buffer.cleared") < disabled_index
-    assert error["event_id"] == "event-failed-append"
-
-
-@pytest.mark.asyncio
-async def test_realtime_server_vad_queues_one_turn_and_rejects_further_input():
-    chat_service = GateChatService(FakeEngineClient())
-    committed_count = 0
-    response_count = 0
-
-    def on_send(ws: TimedWebSocket, data: dict[str, Any]) -> None:
-        nonlocal committed_count, response_count
-        if data.get("type") == "input_audio_buffer.committed":
-            committed_count += 1
-        if data.get("type") == "error" and data.get("error", {}).get("code") == "input_backpressure":
-            chat_service.first_response_gate.set()
-        if data.get("type") == "response.created":
-            response_count += 1
-            if response_count == 2:
-                ws.put({"type": "session.close"})
-
-    ws = TimedWebSocket(on_send=on_send)
-    ws.put(_server_vad_session_update(_server_vad_turn_detection()))
-    for _ in range(3):
-        ws.put(_server_vad_audio_append())
-    handler = OmniDuplexSessionHandler(
-        chat_service=chat_service,
-        server_vad_backend_provider=FakeServerVADProvider(FakeServerVADBackend([0.0, 0.9, 0.8, 0.0, 0.0] * 3)),
-    )
-
-    await handler.handle_realtime_session(ws)  # type: ignore[arg-type]
-
-    assert committed_count == 2
-    assert response_count == 2
-    event_types = ws.sent_types()
-    committed_indices = [index for index, event in enumerate(event_types) if event == "input_audio_buffer.committed"]
-    response_created_indices = [index for index, event in enumerate(event_types) if event == "response.created"]
-    assert committed_indices[1] < event_types.index("response.done") < response_created_indices[1]
-    backpressure = [
-        event
-        for event in ws.sent
-        if event.get("type") == "error" and event.get("error", {}).get("code") == "input_backpressure"
-    ]
-    assert len(backpressure) == 1
-
-
-@pytest.mark.asyncio
-async def test_native_session_update_rejects_client_runtime_config():
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-runtime-update-reject"))
-    ws.put(
-        {
-            "type": "turn.signal",
-            "event": "session.update",
-            "payload": {
-                "extra_body": {"duplex_stage_max_tokens": {"0": 999}},
-            },
-        }
-    )
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    error = next(message for message in ws.sent if message.get("type") == "error")
-    assert error["code"] == "invalid_duplex_runtime_config"
-    assert ("sid-runtime-update-reject", "session.update") not in engine.signals
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_session_update_requires_ref_audio_before_enabling_audio():
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-runtime-update-ref-required", modalities=["text"]))
-    ws.put(
-        {
-            "type": "turn.signal",
-            "event": "session.update",
-            "payload": {"modalities": ["text", "audio"]},
-        }
-    )
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    error = next(message for message in ws.sent if message.get("type") == "error")
-    assert error["code"] == "ref_audio_required"
-    assert "session.updated" not in ws.sent_types()
-    assert ("sid-runtime-update-ref-required", "session.update") not in engine.signals
-
-
-def test_personaplex_candidate_update_does_not_leak_minicpmo_ref_audio_check():
-    handler = OmniDuplexSessionHandler(
-        chat_service=SimpleNamespace(engine_client=SimpleNamespace()),
-        served_model_name="test-model",
-        serving_runtime_adapter=PersonaPlexServingRuntimeAdapter(lambda *_: None),
-    )
-    session = DuplexSession(
-        session_id="sid-personaplex-voice-change",
-        config=DuplexSessionConfig(modalities=["audio"], voice="NATF2.pt"),
-        capabilities=PersonaPlexServingRuntimeAdapter.capabilities(max_sessions=1),
-    )
-    candidate_config = DuplexSessionConfig(modalities=["audio"], voice="OtherVoice.pt")
-
-    error = handler._runtime_session_candidate_update_error(session, candidate_config)
-
-    assert error is None
-
-
-@pytest.mark.parametrize(
-    ("native", "turn_detection", "expected_code"),
-    [
-        (False, {"type": "server_vad", "interrupt_response": False}, None),
-        (False, {"type": "server_vad"}, None),
-        (False, {"type": "server_vad", "interrupt_response": True}, "server_vad_requires_native_duplex"),
-        (True, {"type": "server_vad", "interrupt_response": False}, "unsupported_turn_detection"),
-        (True, {"type": "server_vad"}, None),
-    ],
-    ids=[
-        "turn-based-endpointing",
-        "turn-based-default-endpointing",
-        "turn-based-explicit-interruption",
-        "native-non-interrupting",
-        "native-default-interruption",
-    ],
-)
-def test_server_vad_runtime_capability_matrix(
-    native: bool,
-    turn_detection: dict[str, object],
-    expected_code: str | None,
-):
-    handler = OmniDuplexSessionHandler(
-        chat_service=TurnBasedFakeChatService(FakeEngineClient()),
-    )
-    capabilities = minicpmo45_native_capabilities() if native else DuplexCapabilities()
-    session = DuplexSession(
-        "sid-server-vad-capability",
-        DuplexSessionConfig(),
-        capabilities=capabilities,
-    )
-    candidate = DuplexSessionConfig.from_event({"session": {"turn_detection": turn_detection}})
-    handler._resolve_server_vad_defaults(session, candidate, {"turn_detection": turn_detection})
-
-    error = handler._runtime_session_candidate_update_error(session, candidate)
-
-    assert (error or {}).get("code") == expected_code
-    if expected_code is None:
-        assert candidate.server_vad is not None
-        assert candidate.server_vad.interrupt_response is native
-        assert candidate.overlap_policy == ("barge_in_on_speech" if native else "listen_only")
-    elif expected_code == "server_vad_requires_native_duplex":
-        assert "set interrupt_response=false" in error["error"]
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_session_update_rejects_instructions_after_native_context_locked():
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-instructions-locked", modalities=["text"]))
-    ws.put(
-        {
-            "type": "input_audio_buffer.append",
-            "audio": _pcm_f32_b64(16000, value=0.05),
-            "format": "pcm_f32le",
-            "sample_rate_hz": 16000,
-            "duration_ms": 1000,
-            "is_speech": True,
-        }
-    )
-    ws.put(
-        {
-            "type": "turn.signal",
-            "event": "session.update",
-            "payload": {"instructions": "You are now a pirate."},
-        }
-    )
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    error = next(message for message in ws.sent if message.get("type") == "error")
-    assert error["code"] == "instructions_update_unsupported"
-    assert "session.updated" not in ws.sent_types()
-    assert ("sid-instructions-locked", "session.update") not in engine.signals
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_session_update_allows_unchanged_instructions_after_lock():
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-instructions-unchanged", modalities=["text"]))
-    ws.put(
-        {
-            "type": "input_audio_buffer.append",
-            "audio": _pcm_f32_b64(16000, value=0.05),
-            "format": "pcm_f32le",
-            "sample_rate_hz": 16000,
-            "duration_ms": 1000,
-            "is_speech": True,
-        }
-    )
-    ws.put(
-        {
-            "type": "turn.signal",
-            "event": "session.update",
-            "payload": {"instructions": "You are a concise assistant.", "temperature": 0.3},
-        }
-    )
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    assert "session.updated" in ws.sent_types()
-    assert not any(
-        message.get("type") == "error" and message.get("code") == "instructions_update_unsupported"
-        for message in ws.sent
-    )
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_session_update_rejects_instructions_before_first_real_append():
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-buffered-before-lock", modalities=["text"]))
-    ws.put(
-        {
-            "type": "input_audio_buffer.append",
-            "audio": _pcm_f32_b64(3200, value=0.05),
-            "format": "pcm_f32le",
-            "sample_rate_hz": 16000,
-            "duration_ms": 200,
-            "is_speech": True,
-        }
-    )
-    ws.put(
-        {
-            "type": "turn.signal",
-            "event": "session.update",
-            "payload": {
-                "instructions": (
-                    "You are now a swashbuckling pirate captain who speaks entirely in "
-                    "nautical slang, references buried treasure constantly, and never "
-                    "breaks character no matter what the user asks."
-                )
-            },
-        }
-    )
-    ws.put({"type": "input_audio_buffer.commit", "final": True, "response_create": True})
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    error = next(message for message in ws.sent if message.get("type") == "error")
-    assert error["code"] == "instructions_update_unsupported"
-    assert "session.updated" not in ws.sent_types()
-    assert engine.appended, "the commit must still flush the buffered chunk despite the rejected update"
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_session_update_rejects_native_duplex_mode_flip():
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-native-duplex-flag-flip", modalities=["text"]))
-    ws.put(
-        {
-            "type": "turn.signal",
-            "event": "session.update",
-            "payload": {"extra_body": {"native_duplex": False}},
-        }
-    )
-    ws.put(
-        {
-            "type": "turn.signal",
-            "event": "session.update",
-            "payload": {"instructions": "You are now a pirate."},
-        }
-    )
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    errors = [message for message in ws.sent if message.get("type") == "error"]
-    assert [error["code"] for error in errors] == [
-        "native_duplex_mode_update_unsupported",
-        "instructions_update_unsupported",
-    ]
-    assert "session.updated" not in ws.sent_types()
-
-
-def test_native_realtime_protocol_audio_delta_preserves_sample_rate_hz():
-    ws = TimedWebSocket()
-    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
-
-    payloads = protocol._from_duplex_event(
-        {
-            "type": "response.output_audio.delta",
-            "response_id": "resp-a",
-            "audio": "AAAA",
-            "format": "pcm",
-            "sample_rate_hz": 24000,
-        }
-    )
-
-    audio_events = [
-        payload for payload in payloads if payload["type"] in {"response.output_audio.delta", "response.audio.delta"}
-    ]
-    assert {payload["type"] for payload in audio_events} == {"response.audio.delta"}
-    assert {payload["format"] for payload in audio_events} == {"pcm16"}
-    assert {payload["sample_rate_hz"] for payload in audio_events} == {24000}
-
-
-def test_native_realtime_protocol_ignores_removed_legacy_event_switches():
-    ws = TimedWebSocket()
-    ws.query_params = {
-        "legacy_audio_events": "true",
-        "vllm_omni_legacy_events": "true",
-        "output_audio_events": "true",
-        "vllm_omni_output_audio_events": "true",
-    }
-    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
-
-    payloads = protocol._from_duplex_event(
-        {
-            "type": "response.output_audio.delta",
-            "response_id": "resp-canonical",
-            "audio": "AAAA",
-            "text": "hello",
-            "format": "pcm",
-            "sample_rate_hz": 24000,
-            "end_of_turn": True,
-        }
-    )
-
-    event_types = {payload["type"] for payload in payloads}
-    assert "response.audio.delta" in event_types
-    assert "response.audio.done" in event_types
-    assert "response.audio_transcript.delta" in event_types
-    assert "response.audio_transcript.done" in event_types
-    assert "response.output_audio.delta" not in event_types
-    assert "response.output_audio.done" not in event_types
-    assert "response.output_audio_transcript.delta" not in event_types
-    assert "response.output_audio_transcript.done" not in event_types
-    assert "response.output_item.created" not in event_types
-    assert "response.text.delta" not in event_types
-
-
-def test_native_realtime_protocol_emits_terminal_audio_transcript_events():
-    ws = TimedWebSocket()
-    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
-
-    payloads = protocol._from_duplex_event(
-        {
-            "type": "response.output_audio.delta",
-            "response_id": "resp-a",
-            "audio": "AAAA",
-            "text": "hello",
-            "format": "pcm",
-            "sample_rate_hz": 24000,
-            "end_of_turn": True,
-        }
-    )
-
-    by_type = {payload["type"]: payload for payload in payloads}
-    assert "response.audio.done" in by_type
-    assert "response.audio_transcript.delta" in by_type
-    assert "response.audio_transcript.done" in by_type
-    assert by_type["response.content_part.done"]["part"]["transcript"] == "hello"
-    assert by_type["response.output_item.done"]["item"]["object"] == "realtime.item"
-    assert by_type["response.done"]["response"]["output"][0]["object"] == "realtime.item"
-
-
-def test_native_realtime_protocol_terminal_transcript_equals_joined_deltas():
-    protocol = NativeRealtimeSessionProtocol(TimedWebSocket())  # type: ignore[arg-type]
-    response_id = "resp-transcript-contract"
-    events: list[dict[str, object]] = []
-
-    for text, end_of_turn in (("It's Canberra.", False), (" Next question.", True)):
-        events.extend(
-            protocol._from_duplex_event(
-                {
-                    "type": "response.output_audio.delta",
-                    "response_id": response_id,
-                    "audio": "AAAA",
-                    "text": text,
-                    "format": "pcm",
-                    "sample_rate_hz": 24000,
-                    "end_of_turn": end_of_turn,
-                }
-            )
-        )
-
-    transcript = "".join(str(event["delta"]) for event in events if event["type"] == "response.audio_transcript.delta")
-    done = [str(event["transcript"]) for event in events if event["type"] == "response.audio_transcript.done"]
-
-    assert transcript == "It's Canberra. Next question."
-    assert done == [transcript]
-
-
-def test_native_realtime_protocol_updates_in_progress_item_for_audio_truncate():
-    ws = TimedWebSocket()
-    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
-
-    protocol._from_duplex_event({"type": "response.created", "response_id": "resp-truncate"})
-    protocol._from_duplex_event(
-        {
-            "type": "response.output_audio.delta",
-            "response_id": "resp-truncate",
-            "audio": "AAAA",
-            "text": "hello",
-            "format": "pcm",
-            "sample_rate_hz": 24000,
-            "audio_duration_ms": 100,
-            "audio_text_marks": [{"text_chars": 5, "audio_end_ms": 100}],
-        }
-    )
-
-    item = protocol._conversation_items["item_resp-truncate"]
-    assert item["content"][0]["type"] == "output_audio"
-    assert item["content"][0]["transcript"] == "hello"
-    assert item["content"][0]["audio_duration_ms"] == 100
-
-    translated = asyncio.run(
-        protocol._to_duplex_event(
-            {
-                "type": "conversation.item.truncate",
-                "item_id": "item_resp-truncate",
-                "content_index": 0,
-                "audio_end_ms": 50,
-            }
-        )
-    )
-
-    assert translated is None
-    assert protocol._conversation_items["item_resp-truncate"]["content"][0]["transcript"] == "he"
-
-
-@pytest.mark.asyncio
-async def test_native_realtime_protocol_rejects_truncate_for_user_item():
-    ws = TimedWebSocket()
-    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
-    protocol.bind_sender(ws.send_json)
-    protocol._conversation_items["item-user"] = {
-        "id": "item-user",
-        "object": "realtime.item",
-        "type": "message",
-        "role": "user",
-        "status": "completed",
-        "content": [{"type": "input_audio", "transcript": "hello"}],
-    }
-
-    translated = await protocol._to_duplex_event(
-        {
-            "type": "conversation.item.truncate",
-            "item_id": "item-user",
-            "content_index": 0,
-            "audio_end_ms": 10,
-        }
-    )
-
-    assert translated is None
-    error = next(event for event in ws.sent if event.get("type") == "error")
-    assert error["error"]["code"] == "bad_event"
-
-
-def test_native_realtime_protocol_response_done_emits_audio_done_before_terminal_events():
-    ws = TimedWebSocket()
-    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
-    protocol._from_duplex_event({"type": "response.created", "response_id": "resp-done"})
-    protocol._from_duplex_event(
-        {
-            "type": "response.output_audio.delta",
-            "response_id": "resp-done",
-            "audio": "AAAA",
-            "format": "pcm",
-            "sample_rate_hz": 24000,
-        }
-    )
-
-    payloads = protocol._from_duplex_event({"type": "response.done", "response_id": "resp-done"})
-    event_types = [payload["type"] for payload in payloads]
-
-    assert event_types.index("response.audio.done") < event_types.index("response.content_part.done")
-    assert event_types.index("response.content_part.done") < event_types.index("response.output_item.done")
-    assert event_types.index("conversation.item.done") < event_types.index("response.done")
-    assert event_types.index("response.output_item.done") < event_types.index("response.done")
-
-
-def test_native_realtime_protocol_audio_cancelled_uses_active_response_id():
-    ws = TimedWebSocket()
-    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
-    protocol._from_duplex_event({"type": "response.created", "response_id": "resp-cancel"})
-
-    payloads = protocol._from_duplex_event(
-        {
-            "type": "audio.cancelled",
-            "reason": "barge_in",
-            "committed_ms": 0,
-        }
-    )
-
-    done = [payload for payload in payloads if payload.get("type") == "response.done"]
-    assert len(done) == 1
-    assert done[0]["response_id"] == "resp-cancel"
-    assert done[0]["response"]["id"] == "resp-cancel"
-
-
-def test_native_realtime_protocol_audio_cancelled_does_not_reopen_completed_response():
-    ws = TimedWebSocket()
-    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
-    protocol._from_duplex_event({"type": "response.created", "response_id": "resp-complete"})
-    protocol._from_duplex_event(
-        {
-            "type": "response.output_audio.delta",
-            "response_id": "resp-complete",
-            "audio": "AAAA",
-            "format": "pcm",
-            "sample_rate_hz": 24000,
-        }
-    )
-    protocol._from_duplex_event({"type": "response.done", "response_id": "resp-complete"})
-
-    payloads = protocol._from_duplex_event(
-        {
-            "type": "audio.cancelled",
-            "reason": "session_close",
-            "committed_ms": 999999,
-        }
-    )
-
-    assert [payload.get("type") for payload in payloads] == []
-
-
-def test_native_audio_text_marks_are_normalized_to_session_cumulative_offsets():
-    marks = OmniDuplexSessionHandler._normalize_native_audio_text_marks(
-        [{"text_chars": 3, "audio_end_ms": 200}],
-        audio_offset_ms=800,
-        text_offset_chars=5,
-    )
-
-    assert marks == [{"text_chars": 8, "audio_end_ms": 1000}]
-
-
-def test_duplex_session_playback_commit_uses_multi_delta_audio_text_marks():
-    session = DuplexSession(
-        session_id="sid-marks",
-        config=DuplexSessionConfig(playback_commit_policy=DuplexPlaybackCommitPolicy.ACK_ONLY.value),
-    )
-    session.begin_response()
-    session.append_assistant_text("hello ")
-    session.mark_audio_sent(1000, text_chars=6)
-    session.append_assistant_text("world")
-    session.mark_audio_sent(2000, text_chars=11)
-    session.acknowledge_playback(played_ms=1500, committed_ms=1500)
-
-    committed = session.end_response(commit_text=True)
-
-    assert committed == {"role": "assistant", "content": "hello wo"}
-    assert session.history == (committed,)
-
-
-def test_duplex_session_preserves_response_history_order_when_user_item_arrives_during_generation():
-    session = DuplexSession(session_id="sid-history-order", config=DuplexSessionConfig())
-    first_user = {"role": "user", "content": "first turn"}
-    next_user = {
-        "role": "user",
-        "content": [{"type": "audio_url", "audio_url": {"url": "data:audio/wav;base64,AAAA"}}],
-    }
-    session.append_history_message(first_user)
-    session.begin_response()
-    session.append_assistant_text("first answer")
-    session.append_history_message(next_user)
-
-    assistant = session.end_response(commit_text=True)
-
-    assert session.history == (first_user, assistant, next_user)
-
-
-@pytest.mark.asyncio
-async def test_duplex_session_actor_preserves_wire_order_before_control():
-    ws = TimedWebSocket()
-    actor = DuplexWebSocketActor(ws)
-
-    await actor.enqueue_event({"type": "input_audio_buffer.append", "audio": "AAAA"})
-    await actor.enqueue_event({"type": "response.cancel"})
-
-    first = await actor.next_event()
-    second = await actor.next_event()
-
-    assert first["type"] == "input_audio_buffer.append"
-    assert second["type"] == "response.cancel"
-
-
-def _pcm_f32_b64(samples: int, *, value: float = 0.05) -> str:
-    return base64.b64encode(struct.pack(f"<{samples}f", *([value] * samples))).decode("ascii")
-
-
-def _pcm16_b64(samples: int = 1, *, value: int = 1000) -> str:
-    return base64.b64encode(struct.pack(f"<{samples}h", *([value] * samples))).decode("ascii")
-
-
-def _session_create(session_id: str = "duplex-test") -> dict[str, Any]:
-    return {
-        "type": "session.create",
-        "session_id": session_id,
-        "session": {
-            "model": "test-model",
-            "modalities": ["text", "audio"],
-            "idle_timeout_s": 1,
-        },
-    }
-
-
-def _native_session_create(
-    session_id: str = "duplex-native",
-    *,
-    modalities: list[str] | None = None,
-) -> dict[str, Any]:
-    event = _session_create(session_id)
-    event["session"]["model"] = "openbmb/MiniCPM-o-4_5"
-    event["session"]["modalities"] = list(modalities or ["text"])
-    event["session"]["instructions"] = "You are a concise assistant."
-    event["session"]["extra_body"] = {"native_duplex": True}
-    return event
-
-
-def _native_realtime_session_update(
-    session_id: str,
-    *,
-    modalities: list[str] | None = None,
-) -> dict[str, Any]:
-    return {
-        "type": "session.update",
-        "session": {
-            "session_id": session_id,
-            "model": "openbmb/MiniCPM-o-4_5",
-            "modalities": list(modalities or ["text"]),
-            "instructions": "You are a concise assistant.",
-            "idle_timeout_s": 1,
-            "extra_body": {"native_duplex": True},
-        },
-    }
-
-
-def _native_server_vad_update(event_id: str, **session: object) -> dict[str, object]:
-    return {
-        "type": "session.update",
-        "event_id": event_id,
-        "session": {"turn_detection": {"type": "server_vad"}, **session},
-    }
-
-
-def test_native_stage0_request_id_matches_engine_after_same_session_id_reopen():
-    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
-    first = handler._registry.create(session_id="sid-reused")
-    handler._registry.close(first.session_id)
-    reopened = handler._registry.create(session_id="sid-reused")
-    expected = duplex_resource_request_id(
-        DuplexFence(
-            reopened.session_id,
-            epoch=reopened.epoch,
-            incarnation=reopened.incarnation,
-        ),
-        "stage0",
-    )
-
-    assert reopened.incarnation == 1
-    assert handler._native_stage0_request_id(reopened, reopened.epoch) == expected
-
-
-def _native_audio_payload(
-    *,
-    samples: int = 16000,
-    value: float = 0.05,
-    is_speech: bool | None = True,
-    force_listen: bool | None = None,
-) -> dict[str, Any]:
-    payload: dict[str, Any] = {
-        "type": "audio",
-        "audio": _pcm_f32_b64(samples, value=value),
-        "format": "pcm_f32le",
-        "sample_rate_hz": 16000,
-    }
-    if is_speech is not None:
-        payload["is_speech"] = is_speech
-    if force_listen is not None:
-        payload["force_listen"] = force_listen
-    return payload
-
-
-def _auto_response_context(
-    session_id: str,
-    *,
-    playback_active: bool = False,
-) -> tuple[OmniDuplexSessionHandler, DuplexSession]:
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(FakeEngineClient()),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    session = DuplexSession(
-        session_id=session_id,
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    if playback_active:
-        session.config.playback_commit_policy = DuplexPlaybackCommitPolicy.ACK_ONLY.value
-        session.begin_response()
-        session.mark_audio_sent(duration_ms=1000)
-    return handler, session
-
-
-def _install_direct_silence_scheduler(
-    handler: OmniDuplexSessionHandler,
-    session: DuplexSession,
-) -> None:
-    native = handler._runtime_session_state(session)
-
-    async def _schedule(payload: object, **kwargs: Any) -> bool:
-        if handler._native_silence_continuation_is_stale(
-            session,
-            request_id=kwargs["request_id"],
-            response_id=kwargs["response_id"],
-            response_owned=kwargs["response_owned"],
-            expected_epoch=kwargs["expected_epoch"],
-            expected_incarnation=kwargs["expected_incarnation"],
-            expected_model_turn_id=kwargs["expected_model_turn_id"],
-        ):
-            return False
-        append_ok, _ = await handler._append_runtime_input(
-            session,
-            payload,
-            final=False,
-            send_json=kwargs["send_json"],
-            mode="append_audio_chunk",
-            expected_epoch=kwargs["expected_epoch"],
-        )
-        return append_ok
-
-    native.silence_continuation_scheduler = _schedule
-
-
-def test_minicpmo_pcm_append_buffer_flush_preserves_accumulated_speech_marker():
-    buffer = MiniCPMO45PcmAppendBuffer()
-    payload = _native_audio_payload(samples=8000)
-
-    assert buffer.append(payload, chunk_period_ms=1000) is None
-    flushed = buffer.flush(chunk_period_ms=1000)
-
-    assert flushed is not None
-    assert flushed["is_speech"] is True
-
-
-def test_minicpmo_pcm_append_buffer_drops_serving_new_user_turn_marker():
-    buffer = MiniCPMO45PcmAppendBuffer()
-    first = _native_audio_payload(samples=8000)
-    first.update(
-        new_user_turn=True,
-        new_user_turn_prefix_variant="clean_response_done",
-        force_speak=True,
-    )
-    second = _native_audio_payload(samples=8000)
-
-    assert buffer.append(first, chunk_period_ms=1000) is None
-    emitted = buffer.append(second, chunk_period_ms=1000)
-
-    assert emitted is not None
-    assert emitted["is_speech"] is True
-    assert "new_user_turn" not in emitted
-    assert "new_user_turn_prefix_variant" not in emitted
-    assert "force_speak" not in emitted
-
-
-def test_minicpmo_merge_native_audio_payloads_preserves_speech_marker():
-    first = _native_audio_payload(samples=8000)
-    second = _native_audio_payload(samples=8000, value=0.0, is_speech=False)
-
-    merged = OmniDuplexSessionHandler._merge_native_audio_payloads(first, second)
-
-    assert merged["is_speech"] is True
-
-
-def test_minicpmo_merge_drops_serving_new_user_turn_marker():
-    first = _native_audio_payload(samples=8000)
-    first.update(
-        new_user_turn=True,
-        new_user_turn_prefix_variant="clean_response_done",
-        force_speak=True,
-    )
-    second = _native_audio_payload(samples=8000, is_speech=False)
-
-    merged = OmniDuplexSessionHandler._merge_native_audio_payloads(first, second)
-
-    assert merged["is_speech"] is True
-    assert "new_user_turn" not in merged
-    assert "new_user_turn_prefix_variant" not in merged
-    assert "force_speak" not in merged
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_clear_continuation_does_not_cancel_pending_silence_task():
-    async def _pending() -> bool:
-        await asyncio.sleep(3600)
-        return True
-
-    native = MiniCPMO45ServingSessionState()
-    task = asyncio.create_task(_pending())
-    native.continuation_owner_id = "owner"
-    native.continuation_units = 1
-    native.pending_silence_task = task
-    native.pending_silence_owner_id = "owner"
-
-    native.clear_continuation()
-
-    assert native.continuation_owner_id is None
-    assert native.continuation_units == 0
-    assert native.pending_silence_task is None
-    assert native.pending_silence_owner_id is None
-    assert not task.cancelled()
-    task.cancel()
-    with pytest.raises(asyncio.CancelledError):
-        await task
-
-
-def test_auto_response_playback_overlap_keeps_model_owned_listen_speak_decision():
-    handler, session = _auto_response_context("sid-auto-silent-overlap", playback_active=True)
-    session.mark_audio_sent(duration_ms=1000)
-    silent_payload = _native_audio_payload(value=0.0, is_speech=None, force_listen=False)
-    speech_payload = _native_audio_payload(is_speech=None, force_listen=False)
-
-    assert handler._should_force_listen_for_auto_response_overlap(session, {}, silent_payload) is False
-    assert handler._should_force_listen_for_auto_response_overlap(session, {}, speech_payload) is False
-    assert (
-        handler._should_force_listen_for_auto_response_overlap(
-            session,
-            {"force_listen": True},
-            speech_payload,
-        )
-        is True
-    )
-    assert (
-        handler._should_force_listen_for_auto_response_overlap(
-            session,
-            {"force_barge_in": True},
-            speech_payload,
-        )
-        is False
-    )
-
-    session.acknowledge_playback(played_ms=1000, committed_ms=1000)
-    assert handler._should_force_listen_for_auto_response_overlap(session, {}, speech_payload) is False
-
-
-def test_legacy_auto_overlap_policy_falls_back_to_listen_only():
-    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
-    session = DuplexSession(
-        session_id="sid-auto-policy-fallback",
-        config=DuplexSessionConfig(
-            overlap_policy=DuplexSessionConfig._normalize_overlap_policy("auto"),
-        ),
-    )
-    session.capabilities = minicpmo45_native_capabilities()
-
-    decision = handler._overlap_decision(
-        session,
-        {"duration_ms": session.config.overlap_barge_in_ms, "is_speech": True},
-        _native_audio_payload(is_speech=True),
-    )
-
-    assert session.config.overlap_policy == DuplexOverlapPolicy.LISTEN_ONLY.value
-    assert decision["action"] == "listen"
-    assert decision["reason"] == "policy_listen_only"
-
-
-def test_auto_response_overlap_silence_advances_model_unit_and_preserves_realtime_input():
-    handler, session = _auto_response_context(
-        "sid-auto-silent-wire-buffer",
-        playback_active=True,
-    )
-    decision = handler._overlap_decision(
-        session,
-        {"is_speech": False},
-        _native_audio_payload(samples=3200, is_speech=False),
-    )
-
-    assert decision["action"] == "listen"
-    assert decision["buffer_audio"] is True
-    assert decision["defer_runtime_append"] is False
-    assert decision["force_listen"] is False
-    assert decision["preserve_realtime_input"] is True
-
-
-def test_auto_response_playback_overlap_admits_model_units_and_tracks_speech():
-    handler, session = _auto_response_context("sid-auto-deferred-overlap", playback_active=True)
-    payload = _native_audio_payload(samples=8640)
-
-    decision = handler._overlap_decision(
-        session,
-        {"duration_ms": 540, "is_speech": True},
-        payload,
-    )
-
-    assert decision["action"] == "listen"
-    assert decision["defer_runtime_append"] is False
-    assert decision["force_listen"] is False
-    assert decision["buffer_audio"] is True
-    assert session.overlap_speech_ms == 540
-
-
-@pytest.mark.asyncio
-async def test_auto_response_overlap_exact_unit_commit_does_not_block_or_replay_next_unit():
-    class ModelUnitEngine(FakeEngineClient):
-        def __init__(self) -> None:
-            super().__init__()
-            self.append_started = asyncio.Event()
-            self.active_response_ids_at_append: list[str | None] = []
-            self.response_done_seen_at_append = False
-            self.session: DuplexSession | None = None
-            self.websocket: TimedWebSocket | None = None
-
-        async def append_duplex_input_async(self, session_id: str, **kwargs):
-            assert self.session is not None
-            assert self.websocket is not None
-            self.active_response_ids_at_append.append(self.session.active_response_id)
-            self.response_done_seen_at_append = "response.done" in self.websocket.sent_types()
-            kwargs.pop("expected_epoch", None)
-            result = await super().append_duplex_input_async(session_id, **kwargs)
-            self.append_started.set()
-            return result
-
-    engine = ModelUnitEngine()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket()
-    engine.websocket = ws
-    create = _native_session_create("sid-auto-overlap-model-unit")
-    create["session"]["extra_body"]["auto_response"] = True
-    ws.put(create)
-    handler_task = asyncio.create_task(handler.handle_session(ws))
-
-    try:
-        for _ in range(100):
-            session = handler._registry.get("sid-auto-overlap-model-unit")
-            if session is not None and "session.created" in ws.sent_types():
-                break
-            await asyncio.sleep(0.01)
-        else:
-            pytest.fail("native duplex session did not open")
-
-        engine.session = session
-        session.config.playback_commit_policy = DuplexPlaybackCommitPolicy.ACK_ONLY.value
-        response_id = session.begin_response()
-        session.mark_audio_sent(duration_ms=2000)
-        request_id = handler._native_stage0_request_id(session, session.epoch)
-        session.bind_request(request_id)
-        expected_fence = DuplexFence(
-            session.session_id,
-            epoch=session.epoch,
-            turn_id=session.turn_id,
-            incarnation=session.incarnation,
-        )
-
-        chunk = {
-            "type": "input_audio_buffer.append",
-            "audio": _pcm_f32_b64(3200, value=0.05),
-            "format": "pcm_f32le",
-            "sample_rate_hz": 16000,
-            "duration_ms": 200,
-            "is_speech": True,
-        }
-        for _ in range(4):
-            ws.put(chunk)
-        await asyncio.sleep(0.05)
-        assert engine.appended == []
-
-        ws.put(chunk)
-        await asyncio.wait_for(engine.append_started.wait(), timeout=0.5)
-
-        ws.put({"type": "input_audio_buffer.commit", "final": True})
-        for _ in range(100):
-            if "input.committed" in ws.sent_types():
-                break
-            await asyncio.sleep(0.01)
-        else:
-            pytest.fail("exact model unit input did not commit")
-
-        engine.append_started.clear()
-        for _ in range(5):
-            ws.put(chunk)
-        await asyncio.wait_for(engine.append_started.wait(), timeout=0.5)
-        await asyncio.sleep(0.05)
-        assert "error" not in ws.sent_types()
-    finally:
-        ws.put({"type": "session.close"})
-        await asyncio.wait_for(handler_task, timeout=2)
-
-    assert len(engine.appended) == 2
-    for appended_session_id, mode, payload, final in engine.appended:
-        assert appended_session_id == session.session_id
-        assert mode == "append_audio_chunk"
-        assert final is False
-        assert isinstance(payload, dict)
-        assert np.frombuffer(base64.b64decode(payload["audio"]), dtype="<f4").shape == (16000,)
-        assert payload.get("force_listen") is not True
-    assert engine.appended_fences == [expected_fence, expected_fence]
-    assert engine.active_response_ids_at_append == [response_id, response_id]
-    assert engine.response_done_seen_at_append is False
-    assert not any(event in {"barge_in", "input.cancel"} for _, event in engine.signals)
-    assert ws.sent_types().count("response.speak") <= 1
-
-
-@pytest.mark.asyncio
-async def test_stale_terminal_event_does_not_reset_current_session_overlap():
-    handler, session = _auto_response_context("sid-stale-terminal")
-    session.epoch = 2
-    session.accumulate_overlap_speech(540)
-    actor = DuplexWebSocketActor(TimedWebSocket(), current_epoch=lambda: session.epoch)
-    native = MiniCPMO45ServingSessionState()
-
-    accepted, deferred = await handler._apply_outbound_session_event(
-        {"type": "response.done", "epoch": 1},
-        session=session,
-        actor=actor,
-        native=native,
-        realtime_protocol=None,
-    )
-
-    assert accepted is False
-    assert deferred is None
-    assert session.overlap_speech_ms == 540
-
-
-@pytest.mark.asyncio
-async def test_current_terminal_event_resets_session_owned_overlap():
-    handler, session = _auto_response_context("sid-current-terminal")
-    session.accumulate_overlap_speech(320)
-    actor = DuplexWebSocketActor(TimedWebSocket(), current_epoch=lambda: session.epoch)
-    native = MiniCPMO45ServingSessionState()
-
-    accepted, deferred = await handler._apply_outbound_session_event(
-        {"type": "response.done", "epoch": session.epoch},
-        session=session,
-        actor=actor,
-        native=native,
-        realtime_protocol=None,
-    )
-
-    assert accepted is True
-    assert deferred is None
-    assert session.overlap_speech_ms == 0
-
-
-@pytest.mark.asyncio
-async def test_response_listen_terminal_does_not_drive_serving_generation_state():
-    handler, session = _auto_response_context("sid-listen-terminal")
-    actor = DuplexWebSocketActor(TimedWebSocket(), current_epoch=lambda: session.epoch)
-    native = MiniCPMO45ServingSessionState()
-
-    accepted, deferred = await handler._apply_outbound_session_event(
-        {"type": "response.listen", "epoch": session.epoch},
-        session=session,
-        actor=actor,
-        native=native,
-        realtime_protocol=None,
-    )
-
-    assert accepted is True
-    assert deferred is None
-    assert session.turn_id == 0
-
-
-@pytest.mark.asyncio
-async def test_stale_audio_cancelled_does_not_reset_current_session_overlap():
-    handler, session = _auto_response_context("sid-stale-audio-cancelled")
-    session.epoch = 3
-    session.accumulate_overlap_speech(640)
-    actor = DuplexWebSocketActor(TimedWebSocket(), current_epoch=lambda: session.epoch)
-    native = MiniCPMO45ServingSessionState()
-
-    accepted, deferred = await handler._apply_outbound_session_event(
-        {"type": "audio.cancelled", "epoch": 2},
-        session=session,
-        actor=actor,
-        native=native,
-        realtime_protocol=None,
-    )
-
-    assert accepted is False
-    assert deferred is None
-    assert session.overlap_speech_ms == 640
-
-
-def test_auto_response_post_response_silence_remains_model_owned_input():
-    handler, session = _auto_response_context("sid-auto-waiting-silence", playback_active=True)
-    silent_payload = _native_audio_payload(value=0.0, is_speech=False, force_listen=False)
-    speech_payload = _native_audio_payload(force_listen=False)
-
-    assert handler._assistant_playback_active(session) is True
-    assert handler._should_force_listen_for_auto_response_overlap(session, {}, silent_payload) is False
-    assert handler._should_force_listen_for_auto_response_overlap(session, {}, speech_payload) is False
-
-
-@pytest.mark.asyncio
-async def test_auto_response_terminal_advances_open_realtime_input_without_commit():
-    handler, session = _auto_response_context("sid-auto-realtime-open-input", playback_active=True)
-    session.capabilities = minicpmo45_native_capabilities()
-    response_id = session.active_response_id
-    assert response_id is not None
-
-    native = handler._runtime_session_state(session)
-    native.input_since_commit = True
-    native.speech_since_commit = True
-    session.accumulate_overlap_speech(800)
-    assert (
-        native.audio_buffer.append(
-            _native_audio_payload(samples=8000),
-            chunk_period_ms=session.capabilities.chunk_period_ms or 1000,
-        )
-        is None
-    )
-    session.end_response(commit_text=False, preserve_request=True)
-
-    allowed, promoted = await handler._apply_outbound_session_event(
-        {
-            "type": "response.done",
-            "response_id": response_id,
-            "epoch": session.epoch,
-            "status": "completed",
-        },
-        session=session,
-        actor=DuplexWebSocketActor(TimedWebSocket()),
-        native=native,
-        realtime_protocol=NativeRealtimeSessionProtocol({}),
-    )
-
-    assert allowed is True
-    assert promoted is None
-    assert native.audio_buffer.has_pending()
-    assert native.committed_audio_payload is None
-    assert native.deferred_response_create is False
-    assert native.input_since_commit is True
-    assert native.speech_since_commit is True
-    next_speech = _native_audio_payload(samples=8000)
-    assert "new_user_turn" not in next_speech
-
-
-@pytest.mark.asyncio
-async def test_auto_response_terminal_allows_next_model_unit_while_playback_drains():
-    handler, session = _auto_response_context(
-        "sid-auto-realtime-open-before-overlap",
-        playback_active=True,
-    )
-    session.capabilities = minicpmo45_native_capabilities()
-    response_id = session.active_response_id
-    assert response_id is not None
-
-    native = handler._runtime_session_state(session)
-    native.input_since_commit = True
-    native.speech_since_commit = True
-    session.end_response(commit_text=False, preserve_request=True)
-
-    allowed, promoted = await handler._apply_outbound_session_event(
-        {
-            "type": "response.done",
-            "response_id": response_id,
-            "epoch": session.epoch,
-            "status": "completed",
-        },
-        session=session,
-        actor=DuplexWebSocketActor(TimedWebSocket()),
-        native=native,
-        realtime_protocol=NativeRealtimeSessionProtocol({}),
-    )
-
-    assert allowed is True
-    assert promoted is None
-    assert native.input_since_commit is True
-    assert handler._assistant_playback_active(session) is True
-
-    next_speech = _native_audio_payload(samples=16_000)
-    assert "new_user_turn" not in next_speech
-
-
-@pytest.mark.asyncio
-async def test_realtime_committed_overlap_promotes_after_response_done():
-    handler, session = _auto_response_context("sid-auto-realtime-committed-input", playback_active=True)
-    session.capabilities = minicpmo45_native_capabilities()
-    response_id = session.active_response_id
-    assert response_id is not None
-
-    native = handler._runtime_session_state(session)
-    native.committed_audio_payload = _native_audio_payload()
-    native.deferred_response_create = True
-    session.accumulate_overlap_speech(1000)
-    session.end_response(commit_text=False, preserve_request=True)
-
-    allowed, promoted = await handler._apply_outbound_session_event(
-        {
-            "type": "response.done",
-            "response_id": response_id,
-            "epoch": session.epoch,
-            "status": "completed",
-        },
-        session=session,
-        actor=DuplexWebSocketActor(TimedWebSocket()),
-        native=native,
-        realtime_protocol=NativeRealtimeSessionProtocol({}),
-    )
-
-    assert allowed is True
-    assert promoted is not None
-    assert promoted["force_listen"] is False
-    assert native.committed_audio_payload is promoted
-    assert native.deferred_response_create is False
-    assert "new_user_turn" not in promoted
-
-
-@pytest.mark.asyncio
-async def test_auto_response_committed_overlap_does_not_precreate_empty_response():
-    session_id = "sid-auto-overlap-no-empty-response"
-    request_id = f"duplex-{session_id}-e0-stage0"
-
-    def _stage_output(samples: int, *, turn_end: bool = False):
-        return SimpleNamespace(
-            request_id=request_id,
-            finished=False,
-            outputs=[
-                SimpleNamespace(
-                    text="hello",
-                    multimodal_output={
-                        "audio": np.zeros(samples, dtype=np.float32),
-                        "sr": 24000,
-                        "meta": {
-                            "turn_end": turn_end,
-                            "duplex_turn_id": 0,
-                            "duplex_epoch": 0,
-                        },
-                    },
-                )
-            ],
-        )
-
-    first_append = {
-        "operation": "append",
-        "session_id": session_id,
-        "ok": True,
-        "unsupported_count": 0,
-        "error_count": 0,
-        "stage_results": [
-            {
-                "stage_id": 0,
-                "replica_id": 0,
-                "result": {
-                    "supported": True,
-                    "implementation_level": "model_native_duplex",
-                    "data_plane_append": True,
-                    "request_id": request_id,
-                    "response_stage_id": 1,
-                },
-            }
-        ],
-        "data_plane_outputs": [_stage_output(2400)],
-    }
-    promoted_append = {
-        "operation": "append",
-        "session_id": session_id,
-        "ok": True,
-        "unsupported_count": 0,
-        "error_count": 0,
-        "stage_results": [],
-        "data_plane_outputs": [],
-    }
-    engine = FakeEngineClient(
-        append_results=[first_append, promoted_append],
-        collect_outputs=[[_stage_output(4800, turn_end=True)]],
-        collect_delay_s=0.1,
-    )
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=2,
-    )
-
-    overlap_sent = False
-
-    def commit_overlap_after_first_response(ws: TimedWebSocket, data: dict[str, Any]) -> None:
-        nonlocal overlap_sent
-        if data.get("type") != "response.audio.delta" or overlap_sent:
-            return
-        overlap_sent = True
-        chunk = {
-            "type": "input_audio_buffer.append",
-            "audio": _pcm_f32_b64(3200, value=0.05),
-            "format": "pcm_f32le",
-            "sample_rate_hz": 16000,
-            "duration_ms": 200,
-            "is_speech": True,
-        }
-        for _ in range(4):
-            ws.put(chunk)
-        ws.put({"type": "input_audio_buffer.commit", "final": True})
-
-    ws = TimedWebSocket(on_send=commit_overlap_after_first_response, receive_timeout_s=3)
-    create = _native_realtime_session_update(session_id)
-    create["session"]["extra_body"]["auto_response"] = True
-    ws.put(create)
-    ws.put(
-        {
-            "type": "input_audio_buffer.append",
-            "audio": _pcm_f32_b64(16000, value=0.05),
-            "format": "pcm_f32le",
-            "sample_rate_hz": 16000,
-            "duration_ms": 1000,
-            "is_speech": True,
-        }
-    )
-    ws.put({"type": "input_audio_buffer.commit", "final": True})
-
-    handler_task = asyncio.create_task(handler.handle_realtime_session(ws))
-    try:
-        for _ in range(300):
-            if len(engine.appended) >= 2:
-                break
-            await asyncio.sleep(0.01)
-        else:
-            pytest.fail(
-                f"committed overlap was not promoted after response.done: "
-                f"appends={len(engine.appended)}, events={ws.sent_types()}"
-            )
-
-        assert overlap_sent is True
-        assert len(engine.appended) == 2
-        assert engine.appended[1][3] is True
-        assert ws.sent_types().count("response.created") == 1
-    finally:
-        ws.put({"type": "session.close"})
-        await asyncio.wait_for(handler_task, timeout=3)
-
-    assert ws.sent_types().count("response.done") >= 1
-
-
-def test_auto_response_barge_in_does_not_mark_serving_new_user_turn_payload():
-    handler, session = _auto_response_context("sid-auto-barge-new-turn", playback_active=True)
-    payload = _native_audio_payload()
-
-    assert handler._should_force_listen_for_auto_response_overlap(session, {"force_barge_in": True}, payload) is False
-    assert "new_user_turn" not in payload
-    assert "new_user_turn_prefix_variant" not in payload
-    assert session.turn_id == 0
-    assert payload.get("force_speak") is not True
-
-
-def test_native_realtime_barge_in_payload_does_not_create_serving_turn_boundary():
-    payload: dict[str, object] = {
-        "type": "audio",
-        "audio": _pcm_f32_b64(16000, value=0.05),
-        "format": "pcm_f32le",
-        "sample_rate_hz": 16000,
-        "is_speech": True,
-    }
-    session = DuplexSession(session_id="sid-realtime-barge", config=DuplexSessionConfig())
-    session.turn_id = 2
-
-    assert "new_user_turn" not in payload
-    assert "new_user_turn_prefix_variant" not in payload
-    assert session.turn_id == 2
-
-
-def test_auto_response_force_barge_in_has_no_waiting_turn_variant():
-    handler, session = _auto_response_context("sid-auto-barge-keeps-variant")
-    payload = _native_audio_payload()
-
-    assert (
-        handler._should_force_listen_for_auto_response_overlap(
-            session,
-            {"force_barge_in": True},
-            payload,
-        )
-        is False
-    )
-
-
-def test_duplex_endpoint_requires_explicit_realtime_configuration():
-    assert should_enable_duplex_endpoint(None) is False
-    assert should_enable_duplex_endpoint([]) is False
-    assert should_enable_duplex_endpoint([SimpleNamespace(session_mode="turn")]) is False
-    assert should_enable_duplex_endpoint([{"session_mode": "turn"}]) is False
-    assert (
-        should_enable_duplex_endpoint(
-            [
-                SimpleNamespace(session_mode="turn"),
-                SimpleNamespace(session_mode="duplex"),
-            ]
-        )
-        is True
-    )
-    assert should_enable_duplex_endpoint([{"session_mode": "duplex"}]) is True
-
-
-def test_duplex_endpoint_supports_top_level_session_mode(tmp_path):
-    config_path = tmp_path / "stage_config.yaml"
-    config_path.write_text(
-        """
-session_mode: duplex
-stage_args:
-  - stage_id: 0
-    engine_args: {}
-""",
-        encoding="utf-8",
-    )
-
-    assert should_enable_duplex_endpoint([], config_path=str(config_path)) is True
-
-
-def test_duplex_endpoint_supports_inherited_duplex_session(tmp_path):
-    base_path = tmp_path / "base.yaml"
-    base_path.write_text(
-        """
-session_mode: turn
-duplex_session: {}
-stages: []
-""",
-        encoding="utf-8",
-    )
-    config_path = tmp_path / "deploy.yaml"
-    config_path.write_text("base_config: base.yaml\n", encoding="utf-8")
-
-    assert should_enable_duplex_endpoint([], config_path=str(config_path)) is True
-
-
-def test_duplex_handler_splits_data_plane_audio_list_into_deltas():
-    import torch
-
-    data_plane = _test_data_plane()
-    output = SimpleNamespace(
-        finished=True,
-        outputs=[
-            SimpleNamespace(
-                text="hello",
-                multimodal_output={
-                    "audio": [
-                        torch.zeros(10, dtype=torch.float32),
-                        torch.zeros(20, dtype=torch.float32),
-                    ],
-                    "sr": 24000,
-                },
-            )
-        ],
-    )
-
-    native_results = list(data_plane.project_output(output))
-
-    assert [result["audio_data"] for result in native_results] == ["wav-10", "wav-20"]
-    assert [result["text"] for result in native_results] == ["hello", ""]
-    assert [result["end_of_turn"] for result in native_results] == [False, True]
-
-
-def test_duplex_listen_latent_does_not_poison_cumulative_audio_offset():
-    import torch
-
-    data_plane = _test_data_plane()
-    request_id = "duplex-duplex-sess-stage0"
-
-    # A model-listen decision wraps the segment with a latent tensor that is
-    # NOT reply audio; it must not advance the cumulative audio offset.
-    listen_output = SimpleNamespace(
-        request_id=request_id,
-        finished=True,
-        outputs=[],
-        multimodal_output={
-            "duplex_native_decision": "listen",
-            "model_listen": True,
-            "latent": torch.zeros(331776, dtype=torch.float32),
-            "meta": {"sr": 24000},
-        },
-    )
-    listen_results = list(data_plane.project_output(listen_output))
-    assert [result.get("is_listen") for result in listen_results] == [True]
-
-    # The first speak unit carries cumulative stage-1 audio far smaller than
-    # the listen latent; it must still be delivered from sample 0.
-    speak_output = SimpleNamespace(
-        request_id=request_id,
-        finished=False,
-        outputs=[
-            SimpleNamespace(
-                text=" It was a very",
-                multimodal_output={},
-            )
-        ],
-        multimodal_output={
-            "audio": torch.zeros(32768, dtype=torch.float32),
-            "sr": 24000,
-        },
-    )
-    speak_results = list(data_plane.project_output(speak_output))
-    assert [result.get("audio_data") for result in speak_results] == ["wav-32768"]
-    assert speak_results[0]["text"] == " It was a very"
-
-
-def test_direct_listen_decision_survives_inner_completion_metadata():
-    inner_output = SimpleNamespace(
-        outputs=[
-            SimpleNamespace(
-                multimodal_output={"special_token_ids": {"listen_token_id": 151705}},
-            )
-        ]
-    )
-    decision = MiniCPMO45DuplexRuntimeExtension().decide_output(
-        stage_id=0,
-        final_stage_id=1,
-        segment_finished=True,
-        segment_token_ids=(151705,),
-        segment_output_metadata={"special_token_ids": {"listen_token_id": 151705}},
-        output=inner_output,
-    )
-    assert decision is not None
-    output = attach_duplex_output_decision(
-        OmniRequestOutput.from_stage_output(
-            inner_output,
-            request_id="duplex-direct-listen",
-            finished=True,
-            stage_id=0,
-            final_output_type=decision.final_output_type,
-            metrics={
-                "stage_metrics": {
-                    "0": {
-                        "vllm_ttft_ms": 125.0,
-                        "vllm_tpot_ms": 18.0,
-                        "vllm_itl_ms": 17.5,
-                        "vllm_itls_ms": [17.0, 18.0],
-                    }
-                }
-            },
-        ),
-        decision,
-    )
-
-    results = list(_test_data_plane().project_output(output))
-
-    assert len(results) == 1
-    assert results[0]["is_listen"] is True
-    assert results[0]["model_listen"] is True
-    assert results[0]["listen_source"] == "model_listen"
-    assert results[0]["stage_metrics"] == output.metrics["stage_metrics"]
-
-
-def test_duplex_segment_text_is_attached_once_across_streaming_batches():
-    import torch
-
-    class _ChatService:
-        model_config = _ModelConfig()
-
-        def create_audio(self, audio_obj):
-            return SimpleNamespace(audio_data=f"wav-{int(audio_obj.audio_tensor.shape[0])}")
-
-    data_plane = _test_data_plane()
-    request_id = "duplex-duplex-sess-stage0"
-    session = DuplexSession(
-        session_id="sid-auto-respond",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-
-    def _speak(total_samples: int, text: str, *, finished: bool):
-        output = SimpleNamespace(
-            request_id=request_id,
-            finished=finished,
-            outputs=[SimpleNamespace(text=text, multimodal_output={})],
-            multimodal_output={
-                "audio": torch.zeros(total_samples, dtype=torch.float32),
-                "sr": 24000,
-            },
-        )
-        return _project_data_plane(data_plane, {"data_plane_outputs": [output]}, session=session)
-
-    def _audio(results):
-        return [r for r in results if r.get("is_listen") is False]
-
-    def _listen(results):
-        return [r for r in results if r.get("is_listen") is True]
-
-    # One talker segment streams several cumulative-audio batches, each
-    # carrying the SAME segment text; only the first may attach it.
-    assert [r["text"] for r in _audio(_speak(100, " movie called", finished=False))] == [" movie called"]
-    assert [r["text"] for r in _audio(_speak(220, " movie called", finished=False))] == [""]
-    finished_results = _speak(300, " movie called", finished=True)
-    assert [r["text"] for r in _audio(finished_results)] == [""]
-    assert _listen(finished_results) == []
-
-    # Continuation units re-run the talker with the SAME handed text past a
-    # finished boundary (every engine segment ends finished=True); the text
-    # must stay suppressed or each continuation duplicates the transcript.
-    assert [r["text"] for r in _audio(_speak(400, " movie called", finished=False))] == [""]
-    assert [r["text"] for r in _audio(_speak(450, " movie called", finished=True))] == [""]
-
-    # A genuinely new segment text is attached in full.
-    assert [r["text"] for r in _audio(_speak(500, " Titanic", finished=True))] == [" Titanic"]
-
-    # Text growing within a segment is delivered as suffix deltas.
-    assert [r["text"] for r in _audio(_speak(600, " by", finished=False))] == [" by"]
-    assert [r["text"] for r in _audio(_speak(700, " by James", finished=True))] == [" James"]
-
-    # A segment whose finished batch slices to an EMPTY audio delta (all
-    # samples already delivered) must not block the next segment's text.
-    assert [r["text"] for r in _audio(_speak(800, " James Cameron. The", finished=False))] == [" James Cameron. The"]
-    assert _speak(800, " James Cameron. The", finished=True) == []
-    assert [r["text"] for r in _audio(_speak(900, " 997.", finished=False))] == [" 997."]
-
-
-def test_duplex_data_plane_output_prefers_audio_segment_text_metadata():
-    data_plane = _test_data_plane()
-    request_id = "duplex-sid-native-segment-text-e0-stage0"
-    segment_text = "你好，有什么想聊的吗？"
-    cumulative_text = segment_text * 2
-    output = SimpleNamespace(
-        request_id=request_id,
-        finished=False,
-        outputs=[SimpleNamespace(text=cumulative_text, multimodal_output={})],
-        multimodal_output={
-            "audio": np.zeros(24000, dtype=np.float32),
-            "sr": 24000,
-            "meta.llm_output_text_utf8": np.frombuffer(segment_text.encode("utf-8"), dtype=np.uint8),
-        },
-    )
-
-    results = list(data_plane.project_output(output))
-
-    assert len(results) == 1
-    assert results[0]["audio_data"] == "wav-24000"
-    assert results[0]["text"] == segment_text
-
-    next_output_without_segment_metadata = SimpleNamespace(
-        request_id=request_id,
-        finished=False,
-        outputs=[SimpleNamespace(text=segment_text * 3, multimodal_output={})],
-        multimodal_output={
-            "audio": np.zeros(30720, dtype=np.float32),
-            "sr": 24000,
-        },
-    )
-    next_results = list(data_plane.project_output(next_output_without_segment_metadata))
-
-    assert len(next_results) == 1
-    assert next_results[0]["audio_data"] == "wav-6720"
-    assert next_results[0]["text"] == ""
-
-
-@pytest.mark.parametrize(
-    ("request_id", "second_samples", "expected_second_audio"),
-    [
-        ("duplex-sid-model-turn-audio-e0-stage0", 36000, "wav-12000"),
-        ("duplex-sid-model-turn-audio-restart-e0-stage0", 12000, "wav-12000"),
-    ],
-    ids=["cumulative-across-model-turns", "upstream-cumulative-audio-restarts"],
-)
-def test_duplex_audio_cursor_across_model_turns(
-    request_id: str,
-    second_samples: int,
-    expected_second_audio: str,
-):
-    data_plane = _test_data_plane()
-
-    def output(turn_id: int, samples: int):
-        return SimpleNamespace(
-            request_id=request_id,
-            finished=False,
-            outputs=[SimpleNamespace(text="", multimodal_output={})],
-            multimodal_output={
-                "audio": np.zeros(samples, dtype=np.float32),
-                "sr": 24000,
-                "meta.duplex_turn_id": np.array([turn_id], dtype=np.int32),
-            },
-        )
-
-    first = list(data_plane.project_output(output(0, 24000)))
-    second = list(data_plane.project_output(output(1, second_samples)))
-
-    assert first[0]["audio_data"] == "wav-24000"
-    assert second[0]["audio_data"] == expected_second_audio
-
-
-def test_duplex_data_plane_accepts_model_turn_output_across_client_commits():
-    data_plane = _test_data_plane()
-    session = DuplexSession(
-        session_id="sid-auto-stale-turn",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    session.commit_native_audio_input()
-    session.commit_native_audio_input()
-    session.turn_id = 1
-    session.epoch = 0
-    request_id = "duplex-sid-auto-stale-turn-stage0"
-    output = SimpleNamespace(
-        request_id=request_id,
-        finished=False,
-        outputs=[SimpleNamespace(text="old tail", multimodal_output={})],
-        multimodal_output={
-            "audio": np.zeros(24000, dtype=np.float32),
-            "sr": 24000,
-            "meta.duplex_turn_id": np.array([1], dtype=np.int32),
-            "meta.llm_output_text_utf8": np.frombuffer("旧尾巴".encode(), dtype=np.uint8),
-        },
-    )
-
-    results = list(data_plane.project_output(output, context=_data_plane_context(session)))
-
-    assert len(results) == 1
-    assert results[0]["audio_data"] == "wav-24000"
-    assert results[0]["model_turn_id"] == 1
-
-
-def test_duplex_data_plane_accepts_active_response_turn_identity():
-    data_plane = _test_data_plane()
-    session = DuplexSession(
-        session_id="sid-active-response-turn",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    session.turn_id = 1
-    session.epoch = 0
-    session.begin_response(turn_id=0)
-    output = SimpleNamespace(
-        request_id="duplex-sid-active-response-turn-stage0",
-        finished=True,
-        outputs=[SimpleNamespace(text="", multimodal_output={})],
-        multimodal_output={
-            "audio": np.zeros(10, dtype=np.float32),
-            "sr": 24000,
-            "meta.duplex_turn_id": np.array([0], dtype=np.int32),
-            "meta.duplex_epoch": np.array([0], dtype=np.int32),
-        },
-    )
-
-    results = _project_data_plane(data_plane, {"data_plane_outputs": [output]}, session=session)
-
-    assert len(results) == 1
-
-
-def test_duplex_data_plane_listen_preserves_model_turn_identity():
-    data_plane = _test_data_plane()
-    session = DuplexSession(
-        session_id="sid-listen-turn",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    output = SimpleNamespace(
-        request_id="duplex-sid-listen-turn-stage0",
-        finished=True,
-        outputs=[SimpleNamespace(text="", token_ids=[], multimodal_output={})],
-        multimodal_output={
-            "duplex_native_decision": "listen",
-            "meta.duplex_turn_id": np.array([2], dtype=np.int32),
-            "meta.duplex_epoch": np.array([0], dtype=np.int32),
-        },
-    )
-
-    results = _project_data_plane(data_plane, {"data_plane_outputs": [output]}, session=session)
-
-    assert len(results) == 1
-    assert results[0]["is_listen"] is True
-    assert results[0]["model_turn_id"] == 2
-
-
-def test_duplex_data_plane_does_not_drop_future_model_turn_while_response_active():
-    data_plane = _test_data_plane()
-    session = DuplexSession(
-        session_id="sid-future-response-turn",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    session.turn_id = 0
-    session.epoch = 0
-    session.begin_response(turn_id=0)
-    output = SimpleNamespace(
-        request_id="duplex-sid-future-response-turn-stage0",
-        finished=False,
-        outputs=[SimpleNamespace(text="", multimodal_output={})],
-        multimodal_output={
-            "audio": np.zeros(10, dtype=np.float32),
-            "sr": 24000,
-            "meta.duplex_turn_id": np.array([1], dtype=np.int32),
-            "meta.duplex_epoch": np.array([0], dtype=np.int32),
-        },
-    )
-
-    results = _project_data_plane(data_plane, {"data_plane_outputs": [output]}, session=session)
-
-    assert len(results) == 1
-    assert results[0]["model_turn_id"] == 1
-    assert results[0]["audio_data"] == "wav-10"
-
-
-def _duplex_tts_output(
-    *,
-    request_id: str,
-    samples: int,
-    finished: bool,
-    text: str = "hello",
-    tts_is_last_chunk: bool = False,
-    turn_end: bool = False,
-    turn_id: int = 0,
-    token_ids: list[int] | None = None,
-):
-    return SimpleNamespace(
-        request_id=request_id,
-        finished=finished,
-        outputs=[SimpleNamespace(text=text, token_ids=list(token_ids or []), multimodal_output={})],
-        multimodal_output={
-            "audio": np.zeros(samples, dtype=np.float32),
-            "sr": 24000,
-            "meta.tts_is_last_chunk": np.array([int(tts_is_last_chunk)], dtype=np.int32),
-            "meta.turn_end": np.array([int(turn_end)], dtype=np.int32),
-            "meta.duplex_turn_id": np.array([turn_id], dtype=np.int32),
-            "meta.duplex_epoch": np.array([0], dtype=np.int32),
-        },
-    )
-
-
-@pytest.mark.parametrize(
-    (
-        "finished",
-        "tts_is_last_chunk",
-        "turn_end",
-        "consume_audio_first",
-        "expected_end_of_turn",
-        "expected_audio",
-    ),
-    [
-        (False, True, False, False, False, "wav-24000"),
-        (True, True, False, True, False, ""),
-        (True, True, True, True, True, ""),
-    ],
-    ids=[
-        "last-audio-batch-does-not-end-response",
-        "scheduler-eos-only-ends-tts-segment",
-        "explicit-turn-end-metadata-ends-response",
-    ],
-)
-def test_duplex_auto_response_tts_boundary(
-    finished: bool,
-    tts_is_last_chunk: bool,
-    turn_end: bool,
-    consume_audio_first: bool,
-    expected_end_of_turn: bool,
-    expected_audio: str,
-):
-    data_plane = _test_data_plane()
-    request_id = "duplex-sid-tts-boundary-e0-stage0"
-    session = DuplexSession(
-        session_id="sid-tts-boundary",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    session.bind_response_turn(0)
-    if consume_audio_first:
-        data_plane.slice_cumulative_audio(request_id, np.zeros(24000, dtype=np.float32))
-    output = _duplex_tts_output(
-        request_id=request_id,
-        samples=24000,
-        finished=finished,
-        tts_is_last_chunk=tts_is_last_chunk,
-        turn_end=turn_end,
-        token_ids=[151645] if finished else None,
-    )
-
-    results = _project_data_plane(data_plane, {"data_plane_outputs": [output]}, session=session)
-
-    assert len(results) == 1
-    boundary = results[0]
-    assert boundary["stage_role"] == "tts"
-    assert boundary["end_of_turn"] is expected_end_of_turn
-    assert boundary["abort_data_plane_request"] is True
-    assert boundary["audio_data"] == expected_audio
-
-
-def test_duplex_auto_response_tts_scheduler_eos_fallback():
-    data_plane = _test_data_plane()
-    request_id = "duplex-sid-tts-eos-no-profile-e0-stage0"
-    session = DuplexSession(
-        session_id="sid-tts-eos-no-profile",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    session.bind_response_turn(0)
-    data_plane.slice_cumulative_audio(request_id, np.zeros(24000, dtype=np.float32))
-    output = _duplex_tts_output(
-        request_id=request_id,
-        samples=24000,
-        finished=True,
-        tts_is_last_chunk=False,
-        token_ids=[151645],
-    )
-
-    results = _project_data_plane(data_plane, {"data_plane_outputs": [output]}, session=session)
-
-    assert len(results) == 1
-    assert results[0]["stage_role"] == "tts"
-    assert results[0]["abort_data_plane_request"] is True
-
-
-def test_duplex_auto_response_rearms_tts_boundary_for_next_segment_in_same_turn():
-    data_plane = _test_data_plane()
-    request_id = "duplex-sid-next-segment-same-turn-e0-stage0"
-    session = DuplexSession(
-        session_id="sid-next-segment-same-turn",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    session.bind_response_turn(0)
-    data_plane.begin_request(request_id)
-
-    first_segment = _duplex_tts_output(
-        request_id=request_id,
-        samples=24000,
-        finished=False,
-        tts_is_last_chunk=True,
-        turn_id=0,
-    )
-    first_results = _project_data_plane(
-        data_plane,
-        {"data_plane_outputs": [first_segment]},
-        session=session,
-    )
-
-    assert len(first_results) == 1
-    assert first_results[0]["abort_data_plane_request"] is True
-
-    data_plane.begin_request(request_id)
-    second_segment = _duplex_tts_output(
-        request_id=request_id,
-        samples=48000,
-        finished=False,
-        text="hello again",
-        tts_is_last_chunk=True,
-        turn_id=0,
-    )
-    second_results = _project_data_plane(
-        data_plane,
-        {"data_plane_outputs": [second_segment]},
-        session=session,
-    )
-
-    assert len(second_results) == 1
-    assert second_results[0]["audio_data"] == "wav-24000"
-    assert second_results[0]["abort_data_plane_request"] is True
-
-
-def test_duplex_turn_end_is_not_swallowed_by_finished_segment_fallback():
-    data_plane = _test_data_plane()
-    request_id = "duplex-sid-turn-end-after-segment-e0-stage0"
-    session = DuplexSession(
-        session_id="sid-turn-end-after-segment",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    session.begin_response(turn_id=0)
-    session.bind_request(request_id)
-    _project_data_plane(
-        data_plane,
-        {
-            "data_plane_outputs": [
-                _duplex_tts_output(
-                    request_id=request_id,
-                    samples=24000,
-                    finished=False,
-                    tts_is_last_chunk=True,
-                )
-            ]
-        },
-        session=session,
-    )
-    output = _duplex_tts_output(
-        request_id=request_id,
-        samples=24000,
-        finished=True,
-        text="",
-        tts_is_last_chunk=False,
-        turn_end=True,
-        token_ids=[151645],
-    )
-
-    results = _project_data_plane(data_plane, {"data_plane_outputs": [output]}, session=session)
-
-    assert len(results) == 1
-    assert results[0]["stage_role"] == "tts"
-    assert results[0]["end_of_turn"] is True
-
-    duplicate = _project_data_plane(data_plane, {"data_plane_outputs": [output]}, session=session)
-
-    assert not any(result.get("end_of_turn") is True for result in duplicate)
-
-
-def test_duplex_auto_response_discards_terminal_only_audio_before_response_creation():
-    data_plane = _test_data_plane()
-    request_id = "duplex-sid-terminal-only-audio-e0-stage0"
-    session = DuplexSession(
-        session_id="sid-terminal-only-audio",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    session.bind_request(request_id)
-    first_audio = _duplex_tts_output(
-        request_id=request_id,
-        samples=3840,
-        finished=False,
-        text="",
-    )
-
-    assert _project_data_plane(data_plane, {"data_plane_outputs": [first_audio]}, session=session) == []
-
-    terminal = _duplex_tts_output(
-        request_id=request_id,
-        samples=3840,
-        finished=True,
-        text="",
-        tts_is_last_chunk=True,
-        turn_end=True,
-        token_ids=[151645],
-    )
-    results = _project_data_plane(data_plane, {"data_plane_outputs": [terminal]}, session=session)
-
-    assert len(results) == 1
-    assert results[0]["audio_data"] == ""
-    assert results[0]["end_of_turn"] is True
-    assert session.active_request_id == request_id
-    assert not data_plane.is_terminal(request_id)
-
-
-def test_duplex_auto_response_releases_buffered_audio_when_transcript_arrives():
-    data_plane = _test_data_plane()
-    request_id = "duplex-sid-delayed-transcript-e0-stage0"
-    session = DuplexSession(
-        session_id="sid-delayed-transcript",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    audio_before_text = _duplex_tts_output(
-        request_id=request_id,
-        samples=100,
-        finished=False,
-        text="",
-    )
-
-    assert _project_data_plane(data_plane, {"data_plane_outputs": [audio_before_text]}, session=session) == []
-
-    audio_with_text = _duplex_tts_output(
-        request_id=request_id,
-        samples=200,
-        finished=False,
-        text="hello",
-    )
-    results = _project_data_plane(data_plane, {"data_plane_outputs": [audio_with_text]}, session=session)
-
-    assert [result["audio_data"] for result in results] == ["wav-100", "wav-100"]
-    assert [result["text"] for result in results] == ["", "hello"]
-
-
-def test_duplex_auto_response_releases_buffered_audio_on_text_only_terminal():
-    data_plane = _test_data_plane()
-    request_id = "duplex-sid-delayed-terminal-text-e0-stage0"
-    session = DuplexSession(
-        session_id="sid-delayed-terminal-text",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    audio_before_text = _duplex_tts_output(
-        request_id=request_id,
-        samples=100,
-        finished=False,
-        text="",
-        turn_id=1,
-    )
-
-    assert _project_data_plane(data_plane, {"data_plane_outputs": [audio_before_text]}, session=session) == []
-
-    textless_turn_terminal = _duplex_tts_output(
-        request_id=request_id,
-        samples=100,
-        finished=True,
-        text="",
-        tts_is_last_chunk=True,
-        turn_end=True,
-        turn_id=1,
-        token_ids=[151645],
-    )
-    terminal_results = list(
-        data_plane.project(
-            {"data_plane_outputs": [textless_turn_terminal]},
-            context=_data_plane_context(session),
-        )
-    )
-
-    assert len(terminal_results) == 1
-    assert terminal_results[0]["audio_data"] == ""
-    assert terminal_results[0]["end_of_turn"] is True
-
-    text_only_terminal = SimpleNamespace(
-        request_id=request_id,
-        finished=True,
-        outputs=[SimpleNamespace(text="hello", token_ids=[151645], multimodal_output={})],
-        multimodal_output={
-            "sr": 24000,
-            "meta.tts_is_last_chunk": np.array([1], dtype=np.int32),
-            "meta.turn_end": np.array([1], dtype=np.int32),
-            "meta.duplex_turn_id": np.array([2], dtype=np.int32),
-            "meta.duplex_epoch": np.array([0], dtype=np.int32),
-        },
-    )
-    results = _project_data_plane(data_plane, {"data_plane_outputs": [text_only_terminal]}, session=session)
-
-    assert len(results) == 1
-    assert results[0]["audio_data"] == "wav-100"
-    assert results[0]["text"] == "hello"
-    assert results[0]["end_of_turn"] is True
-    assert results[0]["abort_data_plane_request"] is True
-    assert not data_plane.has_pending_audio(request_id)
-
-
-@pytest.mark.asyncio
-async def test_native_append_propagates_current_turn_fence_to_engine():
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(engine))
-    session = DuplexSession(
-        session_id="sid-fenced-append",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    session.capabilities = minicpmo45_native_capabilities()
-    session.turn_id = 2
-    session.begin_response(turn_id=2)
-    ws = TimedWebSocket()
-
-    await handler._append_runtime_input(
-        session,
-        {"duplex_turn_id": 2, "audio": "", "format": "pcm_f32le"},
-        final=True,
-        send_json=ws.send_json,
-        mode="append_audio_chunk",
-        expected_epoch=0,
-    )
-
-    assert engine.appended_fences == [DuplexFence("sid-fenced-append", epoch=0, turn_id=2)]
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_auto_response_tts_segment_boundary_appends_silence_unit():
-    request_id = "duplex-sid-segment-boundary-e0-stage0"
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    session = DuplexSession(
-        session_id="sid-segment-boundary",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    session.capabilities = minicpmo45_native_capabilities()
-    session.begin_response(turn_id=0)
-    session.turn_id = 1
-    session.bind_request(request_id)
-    session.mark_audio_sent(100)
-    _install_direct_silence_scheduler(handler, session)
-    ws = TimedWebSocket()
-
-    await handler._send_one_native_duplex_event(
-        ws.send_json,
-        {
-            "supported": True,
-            "stage_role": "tts",
-            "is_listen": False,
-            "data_plane_request_id": request_id,
-            "text": "",
-            "audio_data": "",
-            "audio_format": "pcm16",
-            "end_of_turn": False,
-            "abort_data_plane_request": True,
-            "uses_model_runner_scheduler": True,
-            "runner_kv_backed": True,
-            "runtime_impl": "scheduler_data_plane",
-        },
-        session=session,
-        expected_epoch=session.epoch,
-    )
-    await asyncio.sleep(0.01)
-
-    assert len(engine.appended) == 1
-    _, mode, payload, final = engine.appended[0]
-    assert mode == "append_audio_chunk"
-    assert payload["format"] == "pcm_f32le"
-    assert payload["duplex_turn_id"] == 0
-    assert "force_speak" not in payload
-    assert final is False
-    assert session.active_response_id is not None
-    assert "response.done" not in ws.sent_types()
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_auto_response_pre_response_tts_boundary_continues_model_turn():
-    request_id = "duplex-sid-pre-response-boundary-e0-stage0"
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(engine))
-    session = DuplexSession(
-        session_id="sid-pre-response-boundary",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    session.capabilities = minicpmo45_native_capabilities()
-    session.bind_request(request_id)
-    _install_direct_silence_scheduler(handler, session)
-    ws = TimedWebSocket()
-
-    close_reason, emitted = await handler._send_one_native_duplex_event(
-        ws.send_json,
-        {
-            "supported": True,
-            "stage_role": "tts",
-            "is_listen": False,
-            "data_plane_request_id": request_id,
-            "model_turn_id": session.turn_id,
-            "text": "",
-            "audio_data": "",
-            "audio_format": "pcm16",
-            "end_of_turn": False,
-            "abort_data_plane_request": True,
-            "uses_model_runner_scheduler": True,
-            "runner_kv_backed": True,
-            "runtime_impl": "scheduler_data_plane",
-        },
-        session=session,
-        expected_epoch=session.epoch,
-    )
-    await asyncio.sleep(0.01)
-
-    assert close_reason is None
-    assert emitted is False
-    assert session.active_response_id is None
-    assert ws.sent == []
-    assert len(engine.appended) == 1
-    _, mode, payload, final = engine.appended[0]
-    assert mode == "append_audio_chunk"
-    assert payload["duplex_turn_id"] == session.turn_id
-    assert final is False
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_pre_response_continuation_drops_after_model_turn_ends():
-    request_id = "duplex-sid-stale-pre-response-boundary-e0-stage0"
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(engine))
-    session = DuplexSession(
-        session_id="sid-stale-pre-response-boundary",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    session.capabilities = minicpmo45_native_capabilities()
-    session.bind_request(request_id)
-    model_turn_id = session.turn_id
-
-    native = handler._runtime_session_state(session)
-
-    async def _stale_before_append(payload: object, **kwargs: Any) -> bool:
-        session.complete_model_turn(model_turn_id)
-        if handler._native_silence_continuation_is_stale(
-            session,
-            request_id=kwargs["request_id"],
-            response_id=kwargs["response_id"],
-            response_owned=kwargs["response_owned"],
-            expected_epoch=kwargs["expected_epoch"],
-            expected_incarnation=kwargs["expected_incarnation"],
-            expected_model_turn_id=kwargs["expected_model_turn_id"],
-        ):
-            return False
-        append_ok, _ = await handler._append_runtime_input(
-            session,
-            payload,
-            final=False,
-            send_json=kwargs["send_json"],
-            mode="append_audio_chunk",
-            expected_epoch=kwargs["expected_epoch"],
-        )
-        return append_ok
-
-    native.silence_continuation_scheduler = _stale_before_append
-
-    await handler._maybe_continue_native_response(
-        TimedWebSocket().send_json,
-        session=session,
-        expected_epoch=session.epoch,
-        expected_model_turn_id=model_turn_id,
-    )
-    await asyncio.sleep(0.01)
-
-    assert engine.appended == []
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_auto_response_continuation_stops_at_large_safety_boundary():
-    request_id = "duplex-sid-long-response-e0-stage0"
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(engine))
-    session = DuplexSession(
-        session_id="sid-long-response",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    session.capabilities = minicpmo45_native_capabilities()
-    session.begin_response(turn_id=0)
-    session.turn_id = 1
-    session.bind_request(request_id)
-    session.mark_audio_sent(100)
-    _install_direct_silence_scheduler(handler, session)
-    ws = TimedWebSocket()
-
-    for _ in range(handler._NATIVE_AUTO_RESPONSE_MAX_CONTINUATION_UNITS):
-        await handler._maybe_continue_native_response(
-            ws.send_json,
-            session=session,
-            expected_epoch=session.epoch,
-        )
-    await asyncio.sleep(0.02)
-
-    response_id = session.active_response_id
-    assert response_id is not None
-    assert len(engine.appended) == handler._NATIVE_AUTO_RESPONSE_MAX_CONTINUATION_UNITS
-    assert all(payload["duplex_turn_id"] == 0 for _, _, payload, _ in engine.appended)
-    assert all(not {"force_speak", "force_listen"} & payload.keys() for _, _, payload, _ in engine.appended[:-1])
-    assert engine.appended[-1][2]["force_listen"] is True
-    assert handler._native_response_continuations_remaining(session, response_id) is False
-
-    await handler._maybe_continue_native_response(
-        ws.send_json,
-        session=session,
-        expected_epoch=session.epoch,
-    )
-
-    assert len(engine.appended) == handler._NATIVE_AUTO_RESPONSE_MAX_CONTINUATION_UNITS
-    assert ws.sent_types()[-2:] == ["response.listen", "response.done"]
-    assert session.active_response_id is None
-    assert session.active_request_id == request_id
-    assert session.turn_id == 1
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_auto_response_boundary_listen_closes_response():
-    request_id = "duplex-sid-boundary-listen-e0-stage0"
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(engine))
-    session = DuplexSession(
-        session_id="sid-boundary-listen",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    session.capabilities = minicpmo45_native_capabilities()
-    response_id = session.begin_response(turn_id=0)
-    session.bind_request(request_id)
-    native = handler._runtime_session_state(session)
-    native.continuation_owner_id = f"response:{response_id}"
-    native.continuation_units = handler._NATIVE_AUTO_RESPONSE_MAX_CONTINUATION_UNITS
-    _install_direct_silence_scheduler(handler, session)
-    ws = TimedWebSocket()
-
-    close_reason, emitted = await handler._send_one_native_duplex_event(
-        ws.send_json,
-        {
-            "supported": True,
-            "stage_role": "llm",
-            "is_listen": True,
-            "model_listen": True,
-            "data_plane_request_id": request_id,
-            "end_of_turn": False,
-            "uses_model_runner_scheduler": True,
-            "runner_kv_backed": True,
-            "runtime_impl": "scheduler_data_plane",
-        },
-        session=session,
-        expected_epoch=session.epoch,
-    )
-
-    assert close_reason is None
-    assert emitted is True
-    assert engine.appended == []
-    assert ws.sent_types() == ["response.listen", "response.done"]
-    # The listen terminates the precreated response: clients demultiplex the
-    # decision by its id, so the payload must carry the response identity.
-    listen_payload, done_payload = ws.sent[-2], ws.sent[-1]
-    assert listen_payload["response_id"] == response_id
-    assert done_payload["response_id"] == response_id
-    assert session.active_response_id is None
-    assert session.active_request_id == request_id
-    assert session.turn_id == 1
-    assert native.continuation_owner_id is None
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_auto_response_boundary_allows_next_model_turn_response():
-    request_id = "duplex-sid-boundary-next-turn-e0-stage0"
-    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
-    session = DuplexSession(
-        session_id="sid-boundary-next-turn",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    session.capabilities = minicpmo45_native_capabilities()
-    session.begin_response(turn_id=0)
-    session.bind_request(request_id)
-    native = handler._runtime_session_state(session)
-    native.continuation_owner_id = f"response:{session.active_response_id}"
-    native.continuation_units = handler._NATIVE_AUTO_RESPONSE_MAX_CONTINUATION_UNITS
-    ws = TimedWebSocket()
-
-    await handler._maybe_continue_native_response(
-        ws.send_json,
-        session=session,
-        expected_epoch=session.epoch,
-    )
-
-    assert session.active_response_id is None
-    assert session.turn_id == 1
-
-    close_reason, emitted = await handler._send_one_native_duplex_event(
-        ws.send_json,
-        {
-            "supported": True,
-            "stage_role": "tts",
-            "is_listen": False,
-            "data_plane_request_id": request_id,
-            "text": "next response",
-            "audio_data": "next-audio",
-            "audio_format": "pcm16",
-            "audio_duration_ms": 100,
-            "end_of_turn": False,
-            "model_turn_id": 1,
-        },
-        session=session,
-        expected_epoch=session.epoch,
-    )
-
-    assert close_reason is None
-    assert emitted is True
-    assert ws.sent_types() == [
-        "response.listen",
-        "response.done",
-        "response.created",
-        "response.speak",
-        "response.output_audio.delta",
-    ]
-    assert session.active_response_turn_id == 1
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_auto_response_boundary_does_not_close_new_epoch_response():
-    request_id = "duplex-sid-boundary-race-e0-stage0"
-    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
-    session = DuplexSession(
-        session_id="sid-boundary-race",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    session.capabilities = minicpmo45_native_capabilities()
-    old_response_id = session.begin_response(turn_id=0)
-    session.bind_request(request_id)
-    native = handler._runtime_session_state(session)
-    native.continuation_owner_id = f"response:{old_response_id}"
-    native.continuation_units = handler._NATIVE_AUTO_RESPONSE_MAX_CONTINUATION_UNITS
-    sent: list[dict[str, Any]] = []
-    new_response_ids: list[str] = []
-
-    async def _barge_in_on_listen(payload: dict[str, Any]) -> None:
-        sent.append(payload)
-        if payload["type"] == "response.listen":
-            session.barge_in()
-            session.bind_request("duplex-sid-boundary-race-e1-stage0")
-            new_response_ids.append(session.begin_response(turn_id=1))
-
-    await handler._maybe_continue_native_response(
-        _barge_in_on_listen,
-        session=session,
-        expected_epoch=session.epoch,
-    )
-
-    assert [payload["type"] for payload in sent] == ["response.listen"]
-    assert len(new_response_ids) == 1
-    assert session.active_response_id == new_response_ids[0]
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_auto_response_pre_speak_listen_continues_same_response():
-    request_id = "duplex-sid-pre-speak-listen-e0-stage0"
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(engine))
-    session = DuplexSession(
-        session_id="sid-pre-speak-listen",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    session.capabilities = minicpmo45_native_capabilities()
-    response_id = session.begin_response(turn_id=0)
-    session.turn_id = 1
-    session.bind_request(request_id)
-    _install_direct_silence_scheduler(handler, session)
-    ws = TimedWebSocket()
-
-    await handler._send_one_native_duplex_event(
-        ws.send_json,
-        {
-            "supported": True,
-            "stage_role": "llm",
-            "is_listen": True,
-            "model_listen": True,
-            "data_plane_request_id": request_id,
-            "end_of_turn": False,
-            "uses_model_runner_scheduler": True,
-            "runner_kv_backed": True,
-            "runtime_impl": "scheduler_data_plane",
-        },
-        session=session,
-        expected_epoch=session.epoch,
-    )
-    await asyncio.sleep(0.01)
-
-    assert len(engine.appended) == 1
-    assert session.active_response_id == response_id
-    assert session.active_request_id == request_id
-    assert "response.listen" not in ws.sent_types()
-    assert "response.done" not in ws.sent_types()
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_auto_response_listen_before_response_keeps_resumable_request():
-    request_id = "duplex-sid-listen-before-response-e0-stage0"
-    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
-    session = DuplexSession(
-        session_id="sid-listen-before-response",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    session.capabilities = minicpmo45_native_capabilities()
-    session.bind_request(request_id)
-    ws = TimedWebSocket()
-
-    close_reason, emitted = await handler._send_one_native_duplex_event(
-        ws.send_json,
-        {
-            "supported": True,
-            "stage_role": "llm",
-            "is_listen": True,
-            "model_listen": True,
-            "data_plane_request_id": request_id,
-            "end_of_turn": False,
-            "uses_model_runner_scheduler": True,
-            "runner_kv_backed": True,
-            "runtime_impl": "scheduler_data_plane",
-        },
-        session=session,
-        expected_epoch=session.epoch,
-    )
-
-    assert close_reason is None
-    assert emitted is True
-    assert session.active_request_id == request_id
-    assert not handler._serving_runtime_adapter.data_plane.is_terminal(request_id)
-    assert ws.sent_types().count("response.listen") == 1
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_auto_response_listen_without_response_does_not_defer_commit():
-    session_id = "sid-listen-before-response-commit"
-    request_id = duplex_resource_request_id(DuplexFence(session_id), "stage0")
-    inner_output = SimpleNamespace(
-        outputs=[
-            SimpleNamespace(
-                multimodal_output={"special_token_ids": {"listen_token_id": 151705}},
-            )
-        ]
-    )
-    decision = MiniCPMO45DuplexRuntimeExtension().decide_output(
-        stage_id=0,
-        final_stage_id=1,
-        segment_finished=True,
-        segment_token_ids=(151705,),
-        segment_output_metadata={"special_token_ids": {"listen_token_id": 151705}},
-        output=inner_output,
-    )
-    assert decision is not None
-    listen_output = attach_duplex_output_decision(
-        OmniRequestOutput.from_stage_output(
-            inner_output,
-            request_id=request_id,
-            finished=True,
-            stage_id=0,
-            final_output_type=decision.final_output_type,
-        ),
-        decision,
-    )
-    append_result = {
-        "operation": "append",
-        "session_id": session_id,
-        "ok": True,
-        "unsupported_count": 0,
-        "error_count": 0,
-        "stage_results": [
-            {
-                "stage_id": 0,
-                "replica_id": 0,
-                "result": {
-                    "supported": True,
-                    "implementation_level": "model_native_duplex",
-                    "data_plane_append": True,
-                    "request_id": request_id,
-                    "response_stage_id": 1,
-                },
-            }
-        ],
-        "data_plane_outputs": [listen_output],
-    }
-    engine = FakeEngineClient(append_result=append_result)
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    listen_count = 0
-
-    def append_residual_after_listen(ws: TimedWebSocket, data: dict[str, Any]) -> None:
-        nonlocal listen_count
-        if data.get("type") == "response.listen":
-            listen_count += 1
-            if listen_count == 1:
-                ws.put(
-                    {
-                        "type": "input_audio_buffer.append",
-                        "audio": _pcm_f32_b64(3_200),
-                        "format": "pcm_f32le",
-                        "sample_rate_hz": 16_000,
-                        "duration_ms": 200,
-                        "is_speech": True,
-                    }
-                )
-                ws.put({"type": "input_audio_buffer.commit", "final": True})
-        elif data.get("type") == "input_audio_buffer.committed":
-            asyncio.get_running_loop().call_later(0.05, ws.put, {"type": "session.close"})
-
-    ws = TimedWebSocket(on_send=append_residual_after_listen, receive_timeout_s=2)
-    create = _native_realtime_session_update(session_id)
-    create["session"]["extra_body"]["auto_response"] = True
-    ws.put(create)
-    ws.put(
-        {
-            "type": "input_audio_buffer.append",
-            "audio": _pcm_f32_b64(16_000),
-            "format": "pcm_f32le",
-            "sample_rate_hz": 16_000,
-            "duration_ms": 1_000,
-            "is_speech": True,
-        }
-    )
-
-    await handler.handle_realtime_session(ws)
-
-    committed = [event for event in ws.sent if event.get("type") == "input_audio_buffer.committed"]
-    assert len(engine.appended) == 2
-    assert engine.appended[1][3] is True
-    assert len(committed) == 1
-    assert committed[0].get("event", {}).get("overlap_deferred") is not True
-    assert committed[0].get("event", {}).get("response_create_deferred") is not True
-    assert "response.created" not in ws.sent_types()
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_pcm_f32_residual_commit_releases_pending_input_bytes():
-    session_id = "sid-pcm-residual-byte-accounting"
-    control_result = {
-        "operation": "append",
-        "session_id": session_id,
-        "ok": True,
-        "unsupported_count": 0,
-        "error_count": 0,
-        "stage_results": [],
-    }
-    engine = FakeEngineClient(control_result=control_result)
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket(receive_timeout_s=2)
-    create = _native_realtime_session_update(session_id)
-    create["session"]["extra_body"]["auto_response"] = True
-    ws.put(create)
-    handler_task = asyncio.create_task(handler.handle_realtime_session(ws))
-
-    try:
-        for _ in range(100):
-            session = handler._registry.get(session_id)
-            if session is not None and "session.created" in ws.sent_types():
-                break
-            await asyncio.sleep(0.01)
-        else:
-            pytest.fail("native duplex session did not open")
-
-        pending_bytes_after_turn: list[int] = []
-        for turn_index in range(3):
-            ws.put(
-                {
-                    "type": "input_audio_buffer.append",
-                    "audio": _pcm_f32_b64(19_200),
-                    "format": "pcm_f32le",
-                    "sample_rate_hz": 16_000,
-                    "duration_ms": 1_200,
-                    "is_speech": True,
-                }
-            )
-            ws.put({"type": "input_audio_buffer.commit", "final": True})
-            expected_appends = (turn_index + 1) * 2
-            for _ in range(100):
-                if len(engine.appended) >= expected_appends:
-                    await asyncio.sleep(0)
-                    break
-                await asyncio.sleep(0.01)
-            else:
-                pytest.fail(f"turn {turn_index} residual append did not complete")
-            pending_bytes_after_turn.append(session.pending_input_bytes)
-    finally:
-        ws.put({"type": "session.close"})
-        await asyncio.wait_for(handler_task, timeout=2)
-
-    assert pending_bytes_after_turn == [0, 0, 0]
-    assert not any(
-        event.get("type") == "error"
-        and isinstance(event.get("error"), dict)
-        and event["error"].get("code") == "input_backpressure"
-        for event in ws.sent
-    )
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_auto_response_post_speak_listen_continues_same_response():
-    request_id = "duplex-sid-post-speak-listen-e0-stage0"
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(engine))
-    session = DuplexSession(
-        session_id="sid-post-speak-listen",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    session.capabilities = minicpmo45_native_capabilities()
-    response_id = session.begin_response(turn_id=0)
-    session.turn_id = 1
-    session.bind_request(request_id)
-    session.mark_audio_sent(100)
-    _install_direct_silence_scheduler(handler, session)
-    ws = TimedWebSocket()
-
-    await handler._send_one_native_duplex_event(
-        ws.send_json,
-        {
-            "supported": True,
-            "stage_role": "llm",
-            "is_listen": True,
-            "model_listen": True,
-            "data_plane_request_id": request_id,
-            "end_of_turn": False,
-            "uses_model_runner_scheduler": True,
-            "runner_kv_backed": True,
-            "runtime_impl": "scheduler_data_plane",
-        },
-        session=session,
-        expected_epoch=session.epoch,
-    )
-    await asyncio.sleep(0.01)
-
-    assert len(engine.appended) == 1
-    assert session.active_response_id == response_id
-    assert session.active_request_id == request_id
-    assert "response.listen" not in ws.sent_types()
-    assert "response.done" not in ws.sent_types()
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_auto_response_turn_end_preserves_resumable_request():
-    request_id = "duplex-sid-turn-end-preserve-request-e0-stage0"
-    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
-    session = DuplexSession(
-        session_id="sid-turn-end-preserve-request",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    session.capabilities = minicpmo45_native_capabilities()
-    session.begin_response(turn_id=0)
-    session.bind_request(request_id)
-    ws = TimedWebSocket()
-
-    await handler._send_one_native_duplex_event(
-        ws.send_json,
-        {
-            "supported": True,
-            "stage_role": "tts",
-            "is_listen": False,
-            "data_plane_request_id": request_id,
-            "text": "done",
-            "audio_data": "audio",
-            "audio_format": "pcm16",
-            "audio_duration_ms": 100,
-            "end_of_turn": True,
-            "model_turn_id": 0,
-            "uses_model_runner_scheduler": True,
-            "runner_kv_backed": True,
-            "runtime_impl": "scheduler_data_plane",
-        },
-        session=session,
-        expected_epoch=session.epoch,
-    )
-
-    assert session.active_response_id is None
-    assert session.active_request_id == request_id
-    assert "response.done" in ws.sent_types()
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_auto_response_empty_turn_end_emits_model_listen():
-    request_id = "duplex-sid-empty-turn-end-e0-stage0"
-    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
-    session = DuplexSession(
-        session_id="sid-empty-turn-end",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    session.capabilities = minicpmo45_native_capabilities()
-    session.bind_request(request_id)
-    ws = TimedWebSocket()
-
-    close_reason, emitted = await handler._send_one_native_duplex_event(
-        ws.send_json,
-        {
-            "supported": True,
-            "stage_role": "tts",
-            "is_listen": False,
-            "data_plane_request_id": request_id,
-            "text": "",
-            "audio_data": "",
-            "audio_format": "pcm16",
-            "end_of_turn": True,
-            "abort_data_plane_request": True,
-            "model_turn_id": 0,
-            "uses_model_runner_scheduler": True,
-            "runner_kv_backed": True,
-            "runtime_impl": "scheduler_data_plane",
-        },
-        session=session,
-        expected_epoch=session.epoch,
-    )
-
-    assert close_reason is None
-    assert emitted is True
-    assert session.turn_id == 1
-    assert session.active_request_id == request_id
-    assert session.active_response_id is None
-    assert ws.sent_types() == ["response.listen"]
-    assert ws.sent[0]["model_listen"] is True
-    assert ws.sent[0]["reason"] == "model_turn_completed_without_output"
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_auto_response_drops_late_audio_from_completed_model_turn():
-    request_id = "duplex-sid-late-completed-turn-e0-stage0"
-    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
-    session = DuplexSession(
-        session_id="sid-late-completed-turn",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    session.capabilities = minicpmo45_native_capabilities()
-    session.bind_request(request_id)
-    session.complete_model_turn(0)
-    ws = TimedWebSocket()
-
-    close_reason, emitted = await handler._send_one_native_duplex_event(
-        ws.send_json,
-        {
-            "supported": True,
-            "stage_role": "tts",
-            "is_listen": False,
-            "data_plane_request_id": request_id,
-            "text": "late duplicate",
-            "audio_data": "late-audio",
-            "audio_format": "pcm16",
-            "audio_duration_ms": 100,
-            "end_of_turn": True,
-            "model_turn_id": 0,
-            "uses_model_runner_scheduler": True,
-            "runner_kv_backed": True,
-            "runtime_impl": "scheduler_data_plane",
-        },
-        session=session,
-        expected_epoch=session.epoch,
-    )
-
-    assert close_reason is None
-    assert emitted is False
-    assert session.turn_id == 1
-    assert session.active_response_id is None
-    assert "response.created" not in ws.sent_types()
-    assert "response.done" not in ws.sent_types()
-
-
-def test_duplex_data_plane_drops_stale_epoch_audio_after_barge_in():
-    class _ChatService:
-        model_config = _ModelConfig()
-
-        def create_audio(self, audio_obj):
-            return SimpleNamespace(audio_data=f"wav-{int(audio_obj.audio_tensor.shape[0])}")
-
-    data_plane = _test_data_plane()
-    session = DuplexSession(
-        session_id="sid-auto-stale-epoch",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    session.turn_id = 1
-    session.epoch = 2
-    output = SimpleNamespace(
-        request_id="duplex-sid-auto-stale-epoch-stage0",
-        finished=False,
-        outputs=[SimpleNamespace(text="old epoch", multimodal_output={})],
-        multimodal_output={
-            "audio": np.zeros(24000, dtype=np.float32),
-            "sr": 24000,
-            "meta.duplex_epoch": np.array([1], dtype=np.int32),
-            "meta.duplex_turn_id": np.array([1], dtype=np.int32),
-            "meta.llm_output_text_utf8": np.frombuffer("旧轮".encode(), dtype=np.uint8),
-        },
-    )
-
-    assert list(data_plane.project_output(output, context=_data_plane_context(session))) == []
-
-
-def test_duplex_data_plane_text_delta_preserves_repeated_suffix_growth():
-    data_plane = _test_data_plane()
-    request_id = "duplex-sid-native-repeated-word-e0-stage0"
-
-    assert data_plane.segment_text_delta(request_id, "好的") == "好的"
-    assert data_plane.segment_text_delta(request_id, "好的好的") == "好的"
-
-
-def test_duplex_data_plane_text_delta_appends_distinct_non_prefix_segments():
-    data_plane = _test_data_plane()
-    request_id = "duplex-sid-native-rewrite-e0-stage0"
-
-    deltas = [
-        data_plane.segment_text_delta(request_id, "It's Canberra."),
-        data_plane.segment_text_delta(request_id, " Next question."),
-    ]
-
-    assert deltas == ["It's Canberra.", " Next question."]
-    assert "".join(deltas) == "It's Canberra. Next question."
-
-
-def test_duplex_data_plane_close_session_removes_encoded_request_state():
-    data_plane = _test_data_plane()
-    target_request_id = duplex_resource_request_id(
-        DuplexFence("sid-to-close", incarnation=1, epoch=2),
-        "stage0",
-    )
-    other_request_id = duplex_resource_request_id(
-        DuplexFence("sid-to-keep", incarnation=1, epoch=2),
-        "stage0",
-    )
-    data_plane.begin_request(target_request_id)
-    data_plane.begin_request(other_request_id)
-
-    data_plane.close_session("sid-to-close")
-
-    assert data_plane.has_request(target_request_id) is False
-    assert data_plane.has_request(other_request_id) is True
-
-
-def test_duplex_auto_response_segment_complete_keeps_data_plane_request_open():
-    import numpy as np
-
-    class _ChatService:
-        model_config = _ModelConfig()
-
-        def create_audio(self, audio_obj):
-            return SimpleNamespace(audio_data=f"wav-{int(audio_obj.audio_tensor.shape[0])}")
-
-    data_plane = _test_data_plane()
-    request_id = "duplex-duplex-sess-stage0"
-    session = DuplexSession(
-        session_id="sid-auto-respond",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    session.begin_response()
-    session.mark_audio_sent(1280)
-    data_plane.slice_cumulative_audio(request_id, np.zeros(30720, dtype=np.float32))
-
-    output = SimpleNamespace(
-        request_id=request_id,
-        finished=True,
-        outputs=[SimpleNamespace(text="hello", multimodal_output={})],
-        multimodal_output={
-            "audio": np.zeros(30720, dtype=np.float32),
-            "sr": 24000,
-        },
-    )
-
-    native_results = _project_data_plane(data_plane, {"data_plane_outputs": [output]}, session=session)
-
-    assert len(native_results) == 1
-    assert native_results[0]["is_listen"] is True
-    assert native_results[0]["reason"] == "auto_response_segment_complete"
-    assert native_results[0]["data_plane_request_id"] == request_id
-    assert "abort_data_plane_request" not in native_results[0]
-
-
-def test_duplex_auto_response_prior_playback_does_not_abort_before_current_response():
-    data_plane = _test_data_plane()
-    request_id = "duplex-duplex-sess-stage0"
-    session = DuplexSession(
-        session_id="sid-auto-respond-next-turn",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    session.mark_audio_sent(1280)
-    session.acknowledge_playback(played_ms=1280, committed_ms=1280)
-
-    output = SimpleNamespace(
-        request_id=request_id,
-        finished=True,
-        outputs=[SimpleNamespace(text="", multimodal_output={})],
-        multimodal_output={},
-    )
-
-    native_results = _project_data_plane(data_plane, {"data_plane_outputs": [output]}, session=session)
-
-    assert native_results == []
-
-
-def test_duplex_auto_response_text_only_flush_does_not_consume_audio_transcript():
-    import numpy as np
-
-    data_plane = _test_data_plane()
-    request_id = "duplex-duplex-sess-stage0"
-    session = DuplexSession(
-        session_id="sid-auto-respond-delayed-audio",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    text = "你好呀，有什莫问的吗？"
-
-    text_only_output = SimpleNamespace(
-        request_id=request_id,
-        finished=False,
-        outputs=[SimpleNamespace(text=text, multimodal_output={})],
-        multimodal_output={"sr": 24000},
-    )
-
-    assert _project_data_plane(data_plane, {"data_plane_outputs": [text_only_output]}, session=session) == []
-
-    audio_output = SimpleNamespace(
-        request_id=request_id,
-        finished=False,
-        outputs=[SimpleNamespace(text=text, multimodal_output={})],
-        multimodal_output={
-            "audio": np.zeros(24000, dtype=np.float32),
-            "sr": 24000,
-        },
-    )
-
-    native_results = _project_data_plane(data_plane, {"data_plane_outputs": [audio_output]}, session=session)
-
-    assert len(native_results) == 1
-    assert native_results[0]["audio_data"].startswith("wav-")
-    assert native_results[0]["text"] == text
-
-
-@pytest.mark.asyncio
-async def test_duplex_auto_response_empty_terminal_does_not_create_empty_response():
-    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
-    request_id = "duplex-sid-native-empty-terminal-e0-stage0"
-    session = DuplexSession(
-        session_id="sid-native-empty-terminal",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    session.mark_audio_sent(1280)
-    sent: list[dict[str, Any]] = []
-
-    async def send_json(payload: dict[str, Any]) -> None:
-        sent.append(payload)
-
-    output = SimpleNamespace(
-        request_id=request_id,
-        finished=False,
-        outputs=[SimpleNamespace(text="hello", multimodal_output={})],
-        multimodal_output={
-            "sr": 24000,
-            "meta": {"turn_end": True, "duplex_turn_id": 0},
-        },
-    )
-
-    native_results = list(
-        handler._serving_runtime_adapter.data_plane.project(
-            {"data_plane_outputs": [output]},
-            context=_data_plane_context(session),
-        )
-    )
-    assert len(native_results) == 1
-    assert native_results[0]["end_of_turn"] is True
-    assert native_results[0]["model_turn_id"] == 0
-
-    for native_result in native_results:
-        await handler._send_one_native_duplex_event(send_json, native_result, session=session)
-
-    assert "response.created" not in [m.get("type") for m in sent]
-    assert "response.done" not in [m.get("type") for m in sent]
-    assert session.turn_id == 1
-    assert not handler._serving_runtime_adapter.data_plane.is_terminal(request_id)
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_duplex_session_close_cleans_auto_response_data_plane_state():
-    session_id = "sid-native-cleanup"
-    request_id = f"duplex-{session_id}-e0-stage0"
-    engine = FakeEngineClient()
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-    handler._serving_runtime_adapter.data_plane.slice_cumulative_audio(request_id, np.zeros(24000, dtype=np.float32))
-    handler._serving_runtime_adapter.data_plane.segment_text_delta(request_id, "hello")
-    handler._serving_runtime_adapter.data_plane.mark_terminal(request_id)
-    native = MiniCPMO45ServingSessionState()
-    handler._serving_runtime_adapter.session_states[session_id] = native
-
-    event = _native_session_create(session_id)
-    event["session"]["extra_body"]["auto_response"] = True
-    ws = TimedWebSocket()
-    ws.put(event)
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    assert not handler._serving_runtime_adapter.data_plane.has_request(request_id)
-    assert session_id not in handler._serving_runtime_adapter.session_states
-
-
-@pytest.mark.asyncio
-async def test_duplex_chat_audio_stream_uses_output_audio_delta_event():
-    engine = FakeEngineClient()
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-    session = DuplexSession(session_id="sid-chat-audio", config=DuplexSessionConfig())
-    response_id = session.begin_response()
-    sent: list[dict[str, Any]] = []
-
-    async def send_json(data: dict[str, Any]) -> None:
-        sent.append(data)
-
-    await handler._emit_chat_payload(
-        session,
-        {
-            "modality": "audio",
-            "choices": [
-                {
-                    "delta": {
-                        "content": "AAAA",
-                    }
-                }
-            ],
-        },
-        session.epoch,
-        response_id,
-        send_json,
-    )
-
-    assert sent == [
-        {
-            "type": "response.output_audio.delta",
-            "session_id": "sid-chat-audio",
-            "response_id": response_id,
-            "epoch": 0,
-            "audio": "AAAA",
-            "format": "wav",
-        }
-    ]
-
-
-@pytest.mark.asyncio
-async def test_duplex_chat_stage_metrics_use_latest_streaming_snapshot():
-    class SnapshotChatService(FakeChatService):
-        async def create_chat_completion(self, request, raw_request=None):
-            del raw_request
-            self.seen_request_ids.append(request.request_id)
-            snapshots = [
-                {"num_tokens_out": 1, "vllm_tpot_ms": 0.0, "vllm_itls_ms": []},
-                {"num_tokens_out": 2, "vllm_tpot_ms": 10.0, "vllm_itls_ms": [10.0]},
-                {"num_tokens_out": 3, "vllm_tpot_ms": 11.0, "vllm_itls_ms": [10.0, 12.0]},
-            ]
-
-            async def generate():
-                for index, snapshot in enumerate(snapshots):
-                    payload = {
-                        "modality": "audio",
-                        "choices": [{"delta": {"content": f"audio-{index}"}}],
-                        "metrics": {"stage_metrics": {"0": snapshot}},
-                    }
-                    yield f"data: {json.dumps(payload)}\n\n"
-
-            return generate()
-
-    handler = OmniDuplexSessionHandler(
-        chat_service=SnapshotChatService(FakeEngineClient()),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    session = DuplexSession(
-        session_id="sid-chat-snapshots",
-        config=DuplexSessionConfig(instructions="speak"),
-    )
-    sent: list[dict[str, Any]] = []
-
-    async def send_json(data: dict[str, Any]) -> None:
-        sent.append(data)
-
-    await handler._run_response(session, send_json)
-
-    audio_deltas = [event for event in sent if event.get("type") == "response.output_audio.delta"]
-    done = next(event for event in sent if event.get("type") == "response.done")
-    assert all("vllm_omni" not in event for event in audio_deltas)
-    assert done["vllm_omni"]["stage_metrics"]["0"] == {
-        "num_tokens_out": 3,
-        "vllm_tpot_ms": 11.0,
-        "vllm_itls_ms": [10.0, 12.0],
-    }
-
-
-@pytest.mark.asyncio
-async def test_duplex_chat_rejects_unknown_output_modality():
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(FakeEngineClient()),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    session = DuplexSession(session_id="sid-chat-unknown", config=DuplexSessionConfig())
-    response_id = session.begin_response()
-    sent: list[dict[str, Any]] = []
-
-    async def send_json(data: dict[str, Any]) -> None:
-        sent.append(data)
-
-    await handler._emit_chat_payload(
-        session,
-        {
-            "modality": "video",
-            "choices": [{"delta": {"content": "not-text"}}],
-        },
-        session.epoch,
-        response_id,
-        send_json,
-    )
-
-    assert sent == [
-        {
-            "type": "error",
-            "session_id": session.session_id,
-            "response_id": response_id,
-            "epoch": session.epoch,
-            "code": "unsupported_response_modality",
-            "error": "Unsupported chat response modality: video",
-        }
-    ]
-    assert session.assistant_text_buffer == ()
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_model_name_does_not_auto_enable_experimental_native_duplex():
-    event = _session_create("sid-minicpmo-default-protocol")
-    event["session"]["model"] = "openbmb/MiniCPM-o-4_5"
-    engine = FakeEngineClient()
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-    ws = TimedWebSocket()
-    ws.put(event)
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    created = next(m for m in ws.sent if m.get("type") == "session.created")
-    capabilities = created["session"]["capabilities"]
-    assert capabilities["implementation_level"] == "serving_session_adapter"
-    assert capabilities["supports_input_append"] is False
-
-
-@pytest.mark.asyncio
-async def test_duplex_handler_aborts_current_chat_request_id_on_barge_in():
-    engine = FakeEngineClient()
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-
-    def on_send(ws: TimedWebSocket, data: dict[str, Any]) -> None:
-        if data.get("type") == "response.created":
-            ws.put({"type": "input.cancel", "reason": "test_barge_in"})
-
-    ws = TimedWebSocket(on_send=on_send)
-    ws.put(_session_create("sid-a"))
-    ws.put({"type": "input.text.append", "text": "hello"})
-    ws.put({"type": "input.commit"})
-
-    await handler.handle_session(ws)
-
-    assert ws.accepted
-    assert "response.created" in ws.sent_types()
-    assert "audio.cancelled" in ws.sent_types()
-    assert chat_service.seen_request_ids == ["duplex-sid-a-0-1"]
-    assert engine.aborted == ["chatcmpl-duplex-sid-a-0-1"]
-    assert engine.internal_abort_batches == [["chatcmpl-duplex-sid-a-0-1"]]
-
-
-@pytest.mark.asyncio
-async def test_duplex_handler_runtime_open_failure_is_reported_to_client():
-    engine = FakeEngineClient(fail_open=True)
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-open-fail"))
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    assert ws.sent_types() == ["error"]
-    assert ws.sent[0]["code"] == "runtime_open_failed"
-    assert engine.opened == []
-
-
-@pytest.mark.asyncio
-async def test_duplex_handler_preserves_typed_admission_error():
-    class AdmissionRejectingEngine(FakeEngineClient):
-        async def open_duplex_session_async(self, session_id: str, **kwargs):
-            del kwargs
-            raise DuplexControlRequestError(
-                {
-                    "operation": "open",
-                    "session_id": session_id,
-                    "error": {
-                        "code": "resource_exhausted",
-                        "message": "duplex session capacity exhausted",
-                        "retryable": True,
-                    },
-                    "accepted_fence": None,
-                    "lease_generation": None,
-                }
-            )
-
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(AdmissionRejectingEngine()),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-admission-rejected"))
-
-    await handler.handle_session(ws)
-
-    assert ws.sent_types() == ["error"]
-    assert ws.sent[0]["code"] == "resource_exhausted"
-    assert ws.sent[0]["retryable"] is True
-
-
-@pytest.mark.asyncio
-async def test_duplex_cancel_reports_playback_committed_cursor():
-    engine = FakeEngineClient()
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-
-    def on_send(ws: TimedWebSocket, data: dict[str, Any]) -> None:
-        if data.get("type") == "response.created":
-            ws.put({"type": "playback.ack", "played_ms": 1200, "committed_ms": 1000})
-            ws.put({"type": "input.cancel", "reason": "test_barge_in"})
-
-    ws = TimedWebSocket(on_send=on_send)
-    ws.put(_session_create("sid-playback"))
-    ws.put({"type": "input.text.append", "text": "hello"})
-    ws.put({"type": "input.commit"})
-
-    await handler.handle_session(ws)
-
-    ack = next(m for m in ws.sent if m.get("type") == "playback.acknowledged")
-    cancelled = next(m for m in ws.sent if m.get("type") == "audio.cancelled")
-    assert ack["playback"]["played_ms"] == 1200
-    assert ack["playback"]["committed_ms"] == 1000
-    assert cancelled["committed_ms"] == 1000
-    assert cancelled["epoch"] == 1
-
-
-@pytest.mark.asyncio
-async def test_playback_ack_response_id_selects_matching_pending_history_item():
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(FakeEngineClient()),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    session = DuplexSession(
-        session_id="sid-playback-response-id",
-        config=DuplexSessionConfig(),
-    )
-    first_item_id = "item_resp-first"
-    second_item_id = "item_resp-second"
-    session.stage_pending_history_item(
-        first_item_id,
-        {"role": "assistant", "content": "first response"},
-    )
-    session.stage_pending_history_item(
-        second_item_id,
-        {"role": "assistant", "content": "second response"},
-    )
-    ws = TimedWebSocket()
-
-    await handler._handle_playback_ack(
-        session,
-        {
-            "type": "playback.ack",
-            "response_id": "resp-second",
-            "played_ms": 1000,
-            "committed_ms": 1000,
-        },
-        ws.send_json,
-    )
-
-    ack = next(message for message in ws.sent if message.get("type") == "playback.acknowledged")
-    assert ack["item_id"] == second_item_id
-    assert ack["history_committed"] is True
-    assert first_item_id in session.pending_history_item_ids
-    assert second_item_id not in session.pending_history_item_ids
-
-
-@pytest.mark.asyncio
-async def test_playback_ack_recovers_missing_response_history_registration():
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(FakeEngineClient()),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    session = DuplexSession(
-        session_id="sid-playback-missing-registration",
-        config=DuplexSessionConfig(playback_commit_policy="ack_only"),
-    )
-    response_id = session.begin_response()
-    session.append_assistant_text("response text")
-    session.mark_audio_sent(1000, text_chars=len("response text"))
-    session.end_response(commit_text=True, preserve_request=True)
-    assert not session.history_item_ids
-    assert f"item_{response_id}" in session.pending_history_item_ids
-
-    ws = TimedWebSocket()
-    await handler._handle_playback_ack(
-        session,
-        {
-            "type": "playback.ack",
-            "response_id": response_id,
-            "item_id": f"item_{response_id}",
-            "played_ms": 1000,
-            "committed_ms": 1000,
-        },
-        ws.send_json,
-    )
-
-    ack = next(message for message in ws.sent if message.get("type") == "playback.acknowledged")
-    assert ack["history_committed"] is True
-    assert f"item_{response_id}" in session.history_item_ids
-    assert session.history[-1] == {"role": "assistant", "content": "response text"}
-
-
-@pytest.mark.asyncio
-async def test_playback_ack_rejects_response_after_followup_user_commit():
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(FakeEngineClient()),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    session = DuplexSession(
-        session_id="sid-playback-after-followup-user",
-        config=DuplexSessionConfig(playback_commit_policy="ack_only"),
-    )
-    session.append_text("user A")
-    session.commit_user_input()
-    response_id = session.begin_response()
-    session.append_assistant_text("assistant A")
-    session.mark_audio_sent(1000, text_chars=len("assistant A"))
-    session.end_response(commit_text=False, preserve_request=True)
-    session.append_text("user B")
-    session.commit_user_input()
-    ws = TimedWebSocket()
-
-    await handler._handle_playback_ack(
-        session,
-        {
-            "type": "playback.ack",
-            "response_id": response_id,
-            "item_id": f"item_{response_id}",
-            "played_ms": 1000,
-            "committed_ms": 1000,
-        },
-        ws.send_json,
-    )
-
-    assert ws.sent_types() == ["error"]
-    assert ws.sent[0]["code"] == "playback_ack_too_late"
-    assert session.history == (
-        {"role": "user", "content": "user A"},
-        {"role": "user", "content": "user B"},
-    )
-
-
-@pytest.mark.asyncio
-async def test_precommit_zero_audio_ack_reserves_history_for_response_that_finishes_after_commit():
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(FakeEngineClient()),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    session = DuplexSession(
-        session_id="sid-zero-audio-checkpoint",
-        config=DuplexSessionConfig(playback_commit_policy="ack_only"),
-    )
-    session.mark_user_input_activity()
-    response_id = session.begin_response()
-    item_id = f"item_{response_id}"
-    ws = TimedWebSocket()
-
-    await handler._handle_playback_ack(
-        session,
-        {
-            "type": "playback.ack",
-            "response_id": response_id,
-            "item_id": item_id,
-            "played_ms": 0,
-            "committed_ms": 0,
-        },
-        ws.send_json,
-    )
-    session.commit_native_audio_input(transcript="later user input")
-    session.append_assistant_text("hello world")
-    session.mark_audio_sent(1000, text_chars=len("hello world"))
-    committed_message = session.end_response(commit_text=True, preserve_request=True)
-    session.register_history_item(item_id, committed_message)
-
-    await handler._handle_playback_ack(
-        session,
-        {
-            "type": "playback.ack",
-            "response_id": response_id,
-            "item_id": item_id,
-            "played_ms": 1000,
-            "committed_ms": 1000,
-        },
-        ws.send_json,
-    )
-
-    assert not any(message.get("type") == "error" for message in ws.sent)
-    assert session.history == (
-        {"role": "assistant", "content": "hello world"},
-        {
-            "role": "user",
-            "content": [
-                {
-                    "type": "audio_url",
-                    "audio_url": {"url": "native-duplex:input-audio"},
-                    "transcript": "later user input",
-                }
-            ],
-            "transcript": "later user input",
-        },
-    )
-
-
-@pytest.mark.asyncio
-async def test_precommit_partial_ack_extends_history_after_response_finishes():
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(FakeEngineClient()),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    session = DuplexSession(
-        session_id="sid-partial-checkpoint",
-        config=DuplexSessionConfig(playback_commit_policy="ack_only"),
-    )
-    session.mark_user_input_activity()
-    response_id = session.begin_response()
-    item_id = f"item_{response_id}"
-    session.append_assistant_text("hello world")
-    session.mark_audio_sent(1000, text_chars=len("hello world"))
-    ws = TimedWebSocket()
-
-    await handler._handle_playback_ack(
-        session,
-        {
-            "type": "playback.ack",
-            "response_id": response_id,
-            "item_id": item_id,
-            "played_ms": 500,
-            "committed_ms": 500,
-        },
-        ws.send_json,
-    )
-    session.commit_native_audio_input(transcript="later user input")
-    committed_message = session.end_response(commit_text=True, preserve_request=True)
-    session.register_history_item(item_id, committed_message)
-
-    assert session.history[0] == {"role": "assistant", "content": "hello"}
-    await handler._handle_playback_ack(
-        session,
-        {
-            "type": "playback.ack",
-            "response_id": response_id,
-            "item_id": item_id,
-            "played_ms": 1000,
-            "committed_ms": 1000,
-        },
-        ws.send_json,
-    )
-
-    assert not any(message.get("type") == "error" for message in ws.sent)
-    assert session.history[0] == {"role": "assistant", "content": "hello world"}
-    assert session.history[1]["role"] == "user"
-
-
-@pytest.mark.asyncio
-async def test_explicit_truncate_seals_snapshot_against_later_playback_ack():
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(FakeEngineClient()),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    session = DuplexSession(
-        session_id="sid-hard-playback-truncate",
-        config=DuplexSessionConfig(playback_commit_policy="ack_only"),
-    )
-    response_id = session.begin_response()
-    item_id = f"item_{response_id}"
-    session.append_assistant_text("hello world")
-    session.mark_audio_sent(1000, text_chars=len("hello world"))
-    session.end_response(commit_text=False, preserve_request=True)
-    ws = TimedWebSocket()
-
-    await handler._handle_playback_ack(
-        session,
-        {
-            "type": "playback.ack",
-            "response_id": response_id,
-            "item_id": item_id,
-            "played_ms": 500,
-            "committed_ms": 500,
-            "truncate": True,
-        },
-        ws.send_json,
-    )
-    assert session.history == ({"role": "assistant", "content": "hello"},)
-
-    await handler._handle_playback_ack(
-        session,
-        {
-            "type": "playback.ack",
-            "response_id": response_id,
-            "item_id": item_id,
-            "played_ms": 1000,
-            "committed_ms": 1000,
-        },
-        ws.send_json,
-    )
-
-    assert not any(message.get("type") == "error" for message in ws.sent)
-    assert session.history == ({"role": "assistant", "content": "hello"},)
-
-
-@pytest.mark.asyncio
-async def test_cancel_does_not_append_old_assistant_after_followup_user():
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(FakeEngineClient()),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    session = DuplexSession(
-        session_id="sid-cancel-after-followup-user",
-        config=DuplexSessionConfig(playback_commit_policy="ack_only"),
-    )
-    session.append_text("user A")
-    session.commit_user_input()
-    session.begin_response()
-    session.append_assistant_text("assistant A")
-    session.mark_audio_sent(1000, text_chars=len("assistant A"))
-    session.acknowledge_playback(500, 500)
-    session.append_text("user B")
-    session.commit_user_input()
-    ws = TimedWebSocket()
-
-    cancelled = await handler._cancel_active_response(session, None, ws.send_json, reason="new_response")
-
-    assert cancelled is True
-    assert session.history == (
-        {"role": "user", "content": "user A"},
-        {"role": "user", "content": "user B"},
-    )
-
-
-@pytest.mark.asyncio
-async def test_playback_ack_rejects_item_from_another_response():
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(FakeEngineClient()),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    session = DuplexSession(session_id="sid-playback-mismatch", config=DuplexSessionConfig())
-    first_response_id = session.begin_response()
-    session.append_assistant_text("first response")
-    session.mark_audio_sent(1000)
-    session.end_response(commit_text=False, preserve_request=True)
-    session.register_history_item(f"item_{first_response_id}", None)
-    second_response_id = session.begin_response()
-    session.mark_audio_sent(1000)
-    ws = TimedWebSocket()
-
-    await handler._handle_playback_ack(
-        session,
-        {
-            "type": "playback.ack",
-            "response_id": second_response_id,
-            "item_id": f"item_{first_response_id}",
-            "played_ms": 500,
-            "committed_ms": 500,
-        },
-        ws.send_json,
-    )
-
-    assert ws.sent_types() == ["error"]
-    assert ws.sent[0]["code"] == "playback_item_mismatch"
-    assert session.active_response_id == second_response_id
-    assert session.playback.as_dict() == {
-        "generated_ms": 1000,
-        "sent_ms": 1000,
-        "played_ms": 0,
-        "committed_ms": 0,
-    }
-
-
-@pytest.mark.asyncio
-async def test_playback_ack_rejects_user_history_item():
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(FakeEngineClient()),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    session = DuplexSession(session_id="sid-playback-user-item", config=DuplexSessionConfig())
-    user_message = {"role": "user", "content": "user input"}
-    session.append_history_message(user_message)
-    session.register_history_item("item_user", user_message)
-    ws = TimedWebSocket()
-
-    await handler._handle_playback_ack(
-        session,
-        {
-            "type": "playback.ack",
-            "response_id": "user",
-            "item_id": "item_user",
-            "played_ms": 500,
-            "committed_ms": 500,
-        },
-        ws.send_json,
-    )
-
-    assert ws.sent_types() == ["error"]
-    assert ws.sent[0]["code"] == "playback_item_not_found"
-    assert session.history == ({"role": "user", "content": "user input"},)
-
-
-@pytest.mark.asyncio
-async def test_late_playback_ack_recovers_response_local_history_after_next_response_begins():
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(FakeEngineClient()),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    session = DuplexSession(session_id="sid-playback-response-local", config=DuplexSessionConfig())
-    first_response_id = session.begin_response()
-    session.append_assistant_text("first response")
-    session.mark_audio_sent(1000, text_chars=len("first response"))
-    session.end_response(commit_text=False, preserve_request=True)
-    second_response_id = session.begin_response()
-    session.mark_audio_sent(2000, text_chars=len("second response"))
-    ws = TimedWebSocket()
-
-    await handler._handle_playback_ack(
-        session,
-        {
-            "type": "playback.ack",
-            "response_id": first_response_id,
-            "item_id": f"item_{first_response_id}",
-            "played_ms": 1000,
-            "committed_ms": 1000,
-        },
-        ws.send_json,
-    )
-
-    ack = next(message for message in ws.sent if message.get("type") == "playback.acknowledged")
-    assert ack["history_committed"] is True
-    assert session.history[-1] == {"role": "assistant", "content": "first response"}
-    assert session.active_response_id == second_response_id
-    assert session.playback.as_dict() == {
-        "generated_ms": 2000,
-        "sent_ms": 2000,
-        "played_ms": 0,
-        "committed_ms": 0,
-    }
-
-
-@pytest.mark.asyncio
-async def test_late_playback_ack_does_not_advance_new_response_cursor():
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(FakeEngineClient()),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    session = DuplexSession(
-        session_id="sid-late-playback-ack",
-        config=DuplexSessionConfig(),
-    )
-    first_response_id = session.begin_response()
-    session.append_assistant_text("first response")
-    session.mark_audio_sent(11480, text_chars=len("first response"))
-    session.end_response(commit_text=False, preserve_request=True)
-    session.register_history_item(f"item_{first_response_id}", None)
-
-    second_response_id = session.begin_response()
-    session.mark_audio_sent(2200, text_chars=len("second response"))
-    ws = TimedWebSocket()
-
-    await handler._handle_playback_ack(
-        session,
-        {
-            "type": "playback.ack",
-            "response_id": first_response_id,
-            "item_id": f"item_{first_response_id}",
-            "played_ms": 11480,
-            "committed_ms": 11480,
-        },
-        ws.send_json,
-    )
-
-    assert session.active_response_id == second_response_id
-    assert session.playback.as_dict() == {
-        "generated_ms": 2200,
-        "sent_ms": 2200,
-        "played_ms": 0,
-        "committed_ms": 0,
-    }
-    ack = next(message for message in ws.sent if message.get("type") == "playback.acknowledged")
-    assert ack["playback"] == {
-        "generated_ms": 11480,
-        "sent_ms": 11480,
-        "played_ms": 11480,
-        "committed_ms": 11480,
-    }
-    assert first_response_id not in session.response_playbacks
-    assert session.response_playbacks[second_response_id] == session.playback
-
-
-@pytest.mark.asyncio
-async def test_late_playback_ack_truncates_history_with_matching_response_cursor():
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(FakeEngineClient()),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    session = DuplexSession(
-        session_id="sid-late-playback-history",
-        config=DuplexSessionConfig(),
-    )
-    first_response_id = session.begin_response()
-    session.append_assistant_text("abcdefghij")
-    session.mark_audio_sent(1000)
-    session.end_response(commit_text=False, preserve_request=True)
-    session.register_history_item(f"item_{first_response_id}", None)
-
-    session.begin_response()
-    session.mark_audio_sent(10000)
-    ws = TimedWebSocket()
-
-    await handler._handle_playback_ack(
-        session,
-        {
-            "type": "playback.ack",
-            "response_id": first_response_id,
-            "item_id": f"item_{first_response_id}",
-            "played_ms": 500,
-            "committed_ms": 500,
-        },
-        ws.send_json,
-    )
-
-    assert session.history[-1] == {"role": "assistant", "content": "abcde"}
-    assert first_response_id in session.response_playbacks
-
-
-@pytest.mark.asyncio
-async def test_cancel_active_response_commits_only_played_assistant_history():
-    engine = FakeEngineClient()
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-    ws = TimedWebSocket()
-    session = DuplexSession(
-        session_id="sid-playback-partial",
-        config=DuplexSessionConfig(playback_commit_policy=DuplexPlaybackCommitPolicy.COMMIT_ALL_ON_DONE.value),
-    )
-    response_id = session.begin_response()
-    session.append_assistant_text("hello world")
-    session.mark_audio_sent(1000, text_chars=len("hello world"))
-    session.acknowledge_playback(played_ms=500, committed_ms=500)
-
-    cancelled = await handler._cancel_active_response(session, None, ws.send_json, reason="barge_in")
-
-    assert cancelled is True
-    assert session.epoch == 1
-    assert session.history == ({"role": "assistant", "content": "hello"},)
-    assert session.history_item_ids[f"item_{response_id}"] == session.history[0]
-    event = next(m for m in ws.sent if m.get("type") == "audio.cancelled")
-    assert event["committed_ms"] == 500
-
-
-@pytest.mark.asyncio
-async def test_cancel_active_response_keeps_truncated_history_in_serving():
-    engine = FakeEngineClient()
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-    ws = TimedWebSocket()
-    session = DuplexSession(
-        session_id="sid-playback-runtime-rebuild",
-        config=DuplexSessionConfig(playback_commit_policy=DuplexPlaybackCommitPolicy.COMMIT_ALL_ON_DONE.value),
-    )
-    response_id = session.begin_response()
-    session.append_assistant_text("hello world")
-    session.mark_audio_sent(1000, text_chars=len("hello world"))
-    session.acknowledge_playback(played_ms=500, committed_ms=500)
-
-    cancelled = await handler._cancel_active_response(
-        session,
-        None,
-        ws.send_json,
-        reason="barge_in",
-    )
-
-    assert cancelled is True
-    assert session.history == ({"role": "assistant", "content": "hello"},)
-    assert session.history_item_ids[f"item_{response_id}"] == session.history[0]
-    assert engine.signals == []
-    assert "error" not in ws.sent_types()
-
-
-@pytest.mark.asyncio
-async def test_cancel_active_native_data_plane_request_aborts_stage_request_id():
-    engine = FakeEngineClient()
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-    ws = TimedWebSocket()
-    session = DuplexSession(session_id="sid-native-abort", config=DuplexSessionConfig())
-    session.bind_request("duplex-sid-native-abort-e0-stage0-s1")
-
-    cancelled = await handler._cancel_active_response(session, None, ws.send_json, reason="barge_in")
-
-    assert cancelled is True
-    assert engine.aborted == ["duplex-sid-native-abort-e0-stage0-s1"]
-    assert engine.internal_abort_batches == [["duplex-sid-native-abort-e0-stage0-s1"]]
-    assert "audio.cancelled" in ws.sent_types()
-
-
-@pytest.mark.asyncio
-async def test_cancel_chat_fallback_response_aborts_request_and_task():
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(chat_service=TurnBasedFakeChatService(engine))
-    session = DuplexSession("sid-chat-cancel", DuplexSessionConfig())
-    response_id = session.begin_response()
-    session.bind_request("chatcmpl-cancel")
-    ws = TimedWebSocket()
-    task = asyncio.create_task(asyncio.sleep(60))
-    try:
-        cancelled = await handler._cancel_active_response(session, task, ws.send_json, reason="response.cancel")
-
-        assert cancelled is True
-        assert task.cancelled()
-        assert engine.internal_abort_batches == [["chatcmpl-cancel"]]
-        assert "error" not in ws.sent_types()
-        (event,) = [event for event in ws.sent if event["type"] == "audio.cancelled"]
-        assert event["response_id"] == response_id
-        assert event["reason"] == "response.cancel"
-    finally:
-        task.cancel()
-        await asyncio.gather(task, return_exceptions=True)
-
-
-@pytest.mark.asyncio
-async def test_duplex_handler_explicit_close_closes_runtime_once_with_client_reason():
-    engine = FakeEngineClient()
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-close"))
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    assert ws.sent_types() == ["session.created", "session.closed"]
-    assert engine.closed == [("sid-close", "session_close")]
-
-
-@pytest.mark.asyncio
-async def test_realtime_disconnect_detaches_resumable_session_without_runtime_close():
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket(receive_timeout_s=0.01)
-    ws.put(_native_realtime_session_update("sid-resumable-disconnect"))
-
-    await handler.handle_realtime_session(ws)
-
-    created = next(message for message in ws.sent if message.get("type") == "session.created")
-    assert created["session"]["id"] == "sid-resumable-disconnect"
-    assert isinstance(created["resume_token"], str)
-    assert created["resume_token"]
-    assert created["attachment_generation"] == 1
-    assert engine.closed == []
-    assert engine.touched == [
-        ("sid-resumable-disconnect", DuplexLeaseActivity.DETACH),
-    ]
-    assert handler._registry.get("sid-resumable-disconnect") is not None
-    assert "sid-resumable-disconnect" in handler._serving_runtime_adapter.session_states
-
-
-@pytest.mark.asyncio
-async def test_realtime_initial_resume_token_delivery_failure_closes_unrecoverable_session():
-    class FailingCreatedWebSocket(TimedWebSocket):
-        async def send_json(self, data: dict[str, Any]):
-            if data.get("type") == "session.created":
-                raise WebSocketDisconnect(code=1006)
-            await super().send_json(data)
-
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = FailingCreatedWebSocket(receive_timeout_s=0.01)
-    ws.put(_native_realtime_session_update("sid-created-delivery-failure"))
-
-    await handler.handle_realtime_session(ws)
-
-    assert engine.closed == [("sid-created-delivery-failure", "disconnect")]
-    assert handler._registry.get("sid-created-delivery-failure") is None
-    assert "sid-created-delivery-failure" not in handler._serving_runtime_adapter.session_states
-
-
-@pytest.mark.asyncio
-async def test_realtime_send_after_created_disconnect_preserves_resumable_session():
-    class ClosedAfterCreatedWebSocket(TimedWebSocket):
-        def __init__(self) -> None:
-            super().__init__(receive_timeout_s=0.01)
-            self.transport_closed = False
-
-        async def send_json(self, data: dict[str, Any]):
-            if self.transport_closed:
-                raise RuntimeError(
-                    "Unexpected ASGI message 'websocket.send', "
-                    "after sending 'websocket.close' or response already completed."
-                )
-            await super().send_json(data)
-            if data.get("type") == "session.created":
-                self.transport_closed = True
-
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = ClosedAfterCreatedWebSocket()
-    ws.put(_native_realtime_session_update("sid-created-then-disconnected"))
-
-    await handler.handle_realtime_session(ws)
-
-    assert engine.closed == []
-    assert engine.touched == [
-        ("sid-created-then-disconnected", DuplexLeaseActivity.DETACH),
-    ]
-    assert handler._registry.get("sid-created-then-disconnected") is not None
-    assert "sid-created-then-disconnected" in handler._serving_runtime_adapter.session_states
-
-
-@pytest.mark.asyncio
-async def test_realtime_resume_rotates_token_replays_and_preserves_runtime_identity():
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    first = TimedWebSocket(receive_timeout_s=0.01)
-    first.put(_native_realtime_session_update("sid-realtime-resume"))
-    first.put({"type": "session.heartbeat"})
-
-    await handler.handle_realtime_session(first)
-
-    created = next(message for message in first.sent if message.get("type") == "session.created")
-    heartbeat = next(message for message in first.sent if message.get("type") == "session.heartbeat_ack")
-    token = created["resume_token"]
-    incarnation = created["incarnation"]
-    second = TimedWebSocket(receive_timeout_s=0.1)
-    second.query_params = {
-        "model": "openbmb/MiniCPM-o-4_5",
-        "native_duplex": "1",
-        "resume": "1",
-    }
-    second.put(
-        {
-            "type": "session.resume",
-            "session_id": "sid-realtime-resume",
-            "incarnation": incarnation,
-            "resume_token": token,
-            "last_received_server_event_seq": heartbeat["server_event_seq"] - 1,
-        }
-    )
-    second.put({"type": "session.close"})
-
-    await handler.handle_realtime_session(second)
-
-    resumed = next(message for message in second.sent if message.get("type") == "session.resumed")
-    replayed = [
-        message
-        for message in second.sent
-        if message.get("type") == "session.heartbeat_ack"
-        and message.get("server_event_seq") == heartbeat["server_event_seq"]
-    ]
-    assert resumed["session_id"] == "sid-realtime-resume"
-    assert resumed["incarnation"] == incarnation
-    assert resumed["attachment_generation"] == 2
-    assert resumed["resume_token"] != token
-    assert replayed == [heartbeat]
-    assert engine.opened == ["sid-realtime-resume"]
-    assert engine.resumed == [("sid-realtime-resume", 0)]
-    assert engine.resume_fences[0] == engine.opened_fences[0]
-    assert engine.closed == [("sid-realtime-resume", "session_close")]
-
-
-@pytest.mark.asyncio
-async def test_realtime_resume_preserves_append_tail_order_across_connections():
-    class SlowFirstAppendEngine(FakeEngineClient):
-        def __init__(self) -> None:
-            super().__init__()
-            self.first_append_started = asyncio.Event()
-            self.second_append_started = asyncio.Event()
-            self.release_first_append = asyncio.Event()
-            self.append_start_order: list[int] = []
-
-        async def append_duplex_input_async(self, session_id: str, **kwargs):
-            call_index = len(self.append_start_order) + 1
-            self.append_start_order.append(call_index)
-            if call_index == 1:
-                self.first_append_started.set()
-                await self.release_first_append.wait()
-            else:
-                self.second_append_started.set()
-            kwargs.pop("expected_epoch", None)
-            return await super().append_duplex_input_async(session_id, **kwargs)
-
-    engine = SlowFirstAppendEngine()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    first = TimedWebSocket(receive_timeout_s=1.0)
-    session_update = _native_realtime_session_update("sid-resume-append-order")
-    session_update["session"]["extra_body"]["auto_response"] = True
-    first.put(session_update)
-    first_task = asyncio.create_task(handler.handle_realtime_session(first))
-    for _ in range(100):
-        created = next((message for message in first.sent if message.get("type") == "session.created"), None)
-        if created is not None:
-            break
-        await asyncio.sleep(0.01)
-    else:
-        pytest.fail("resumable session did not open")
-    assert created is not None
-    session = handler._registry.get("sid-resume-append-order")
-    assert session is not None
-    native_state = handler._runtime_session_state(session)
-    first_scheduler = native_state.silence_continuation_scheduler
-    assert first_scheduler is not None
-    first.put(
-        {
-            "type": "input_audio_buffer.append",
-            "audio": _pcm16_b64(16000),
-            "sample_rate_hz": 16000,
-            "is_speech": True,
-        }
-    )
-    await asyncio.wait_for(engine.first_append_started.wait(), timeout=1)
-    await first.close(code=1006)
-    await asyncio.wait_for(first_task, timeout=1)
-
-    second = TimedWebSocket(receive_timeout_s=0.5)
-    second.query_params = {
-        "model": "openbmb/MiniCPM-o-4_5",
-        "native_duplex": "1",
-        "resume": "1",
-    }
-    second.put(
-        {
-            "type": "session.resume",
-            "session_id": "sid-resume-append-order",
-            "incarnation": created["incarnation"],
-            "resume_token": created["resume_token"],
-            "last_received_server_event_seq": created.get("server_event_seq", 0),
-        }
-    )
-    second_task = asyncio.create_task(handler.handle_realtime_session(second))
-    for _ in range(100):
-        if "session.resumed" in second.sent_types():
-            break
-        await asyncio.sleep(0.01)
-    else:
-        pytest.fail("session did not resume")
-    assert native_state.silence_continuation_scheduler is not first_scheduler
-    second.put(
-        {
-            "type": "input_audio_buffer.append",
-            "audio": _pcm16_b64(16000),
-            "sample_rate_hz": 16000,
-            "is_speech": True,
-        }
-    )
-    try:
-        await asyncio.sleep(0.05)
-        assert not engine.second_append_started.is_set()
-    finally:
-        engine.release_first_append.set()
-
-    await asyncio.wait_for(engine.second_append_started.wait(), timeout=1)
-    second.put({"type": "session.close"})
-    await asyncio.wait_for(second_task, timeout=2)
-    assert engine.append_start_order == [1, 2]
-
-
-@pytest.mark.asyncio
-async def test_realtime_takeover_ignores_late_detach_from_replaced_attachment():
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    first = TimedWebSocket(receive_timeout_s=1.0)
-    first.put(_native_realtime_session_update("sid-takeover"))
-    first_task = asyncio.create_task(handler.handle_realtime_session(first))
-    for _ in range(100):
-        created = next((message for message in first.sent if message.get("type") == "session.created"), None)
-        if created is not None:
-            break
-        await asyncio.sleep(0.001)
-    else:
-        raise AssertionError("first attachment did not create the session")
-
-    second = TimedWebSocket(receive_timeout_s=0.03)
-    second.put(
-        {
-            "type": "session.resume",
-            "session_id": "sid-takeover",
-            "incarnation": created["incarnation"],
-            "resume_token": created["resume_token"],
-            "last_received_server_event_seq": 0,
-        }
-    )
-    await handler.handle_realtime_session(second)
-    await first_task
-
-    detach_touches = [item for item in engine.touched if item[1] is DuplexLeaseActivity.DETACH]
-    assert detach_touches == [("sid-takeover", DuplexLeaseActivity.DETACH)]
-    assert "session.replaced" in first.sent_types()
-    assert engine.resumed == [("sid-takeover", 0)]
-    assert engine.closed == []
-
-
-@pytest.mark.asyncio
-async def test_realtime_takeover_does_not_clear_new_attachment_pending_turns():
-    class DelayedReplacementCloseWebSocket(TimedWebSocket):
-        def __init__(self) -> None:
-            super().__init__(receive_timeout_s=1.0)
-            self.replacement_close_started = asyncio.Event()
-            self.release_replacement_close = asyncio.Event()
-
-        async def close(self, code: int = 1000, reason: str | None = None) -> None:
-            if not self.replacement_close_started.is_set():
-                self.replacement_close_started.set()
-                await self.release_replacement_close.wait()
-            await super().close(code=code, reason=reason)
-
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    first = DelayedReplacementCloseWebSocket()
-    first.put(_native_realtime_session_update("sid-takeover-pending-turn"))
-    first_task = asyncio.create_task(handler.handle_realtime_session(first))
-    for _ in range(100):
-        created = next((message for message in first.sent if message.get("type") == "session.created"), None)
-        if created is not None:
-            break
-        await asyncio.sleep(0.001)
-    else:
-        pytest.fail("first attachment did not create the session")
-    assert created is not None
-
-    second = TimedWebSocket(receive_timeout_s=1.0)
-    second.put(
-        {
-            "type": "session.resume",
-            "session_id": "sid-takeover-pending-turn",
-            "incarnation": created["incarnation"],
-            "resume_token": created["resume_token"],
-            "last_received_server_event_seq": 0,
-        }
-    )
-    second_task = asyncio.create_task(handler.handle_realtime_session(second))
-    await asyncio.wait_for(first.replacement_close_started.wait(), timeout=1)
-
-    session = handler._registry.get("sid-takeover-pending-turn")
-    assert session is not None
-    assert session.reserve_pending_turn(limit=2)
-    first.release_replacement_close.set()
-    await asyncio.wait_for(first_task, timeout=1)
-
-    assert session.pending_input_turns == 1
-    session.release_pending_turn()
-    second.put({"type": "session.close"})
-    await asyncio.wait_for(second_task, timeout=2)
-
-
-@pytest.mark.asyncio
-async def test_realtime_takeover_drops_input_queued_by_replaced_attachment():
-    class DelayedReplacementCloseWebSocket(TimedWebSocket):
-        def __init__(self) -> None:
-            super().__init__(receive_timeout_s=1.0)
-            self.replacement_close_started = asyncio.Event()
-            self.release_replacement_close = asyncio.Event()
-            self.stale_heartbeat_read = asyncio.Event()
-
-        async def receive_text(self) -> str:
-            payload = await super().receive_text()
-            if json.loads(payload).get("type") == "session.heartbeat":
-                self.stale_heartbeat_read.set()
-            return payload
-
-        async def close(self, code: int = 1000, reason: str | None = None) -> None:
-            if not self.replacement_close_started.is_set():
-                self.replacement_close_started.set()
-                await self.release_replacement_close.wait()
-            await super().close(code=code, reason=reason)
-
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    first = DelayedReplacementCloseWebSocket()
-    first.put(_native_realtime_session_update("sid-takeover-stale-input"))
-    first_task = asyncio.create_task(handler.handle_realtime_session(first))
-    for _ in range(100):
-        created = next((message for message in first.sent if message.get("type") == "session.created"), None)
-        if created is not None:
-            break
-        await asyncio.sleep(0.001)
-    else:
-        pytest.fail("first attachment did not create the session")
-    assert created is not None
-
-    second = TimedWebSocket(receive_timeout_s=1.0)
-    second.put(
-        {
-            "type": "session.resume",
-            "session_id": "sid-takeover-stale-input",
-            "incarnation": created["incarnation"],
-            "resume_token": created["resume_token"],
-            "last_received_server_event_seq": 0,
-        }
-    )
-    second_task = asyncio.create_task(handler.handle_realtime_session(second))
-    await asyncio.wait_for(first.replacement_close_started.wait(), timeout=1)
-
-    first.put({"type": "session.heartbeat"})
-    await asyncio.wait_for(first.stale_heartbeat_read.wait(), timeout=1)
-    first.release_replacement_close.set()
-    await asyncio.wait_for(first_task, timeout=1)
-
-    second.put({"type": "session.close"})
-    await asyncio.wait_for(second_task, timeout=2)
-    assert all(activity is not DuplexLeaseActivity.HEARTBEAT for _, activity in engine.touched)
-    assert "session.heartbeat_ack" not in second.sent_types()
-
-
-@pytest.mark.asyncio
-async def test_realtime_resume_rejects_invalid_token_before_engine_control():
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    first = TimedWebSocket(receive_timeout_s=0.01)
-    first.put(_native_realtime_session_update("sid-invalid-resume"))
-    await handler.handle_realtime_session(first)
-
-    created = next(message for message in first.sent if message.get("type") == "session.created")
-    second = TimedWebSocket(receive_timeout_s=0.01)
-    second.put(
-        {
-            "type": "session.resume",
-            "session_id": "sid-invalid-resume",
-            "incarnation": created["incarnation"],
-            "resume_token": "invalid-token",
-            "last_received_server_event_seq": 0,
-        }
-    )
-
-    await handler.handle_realtime_session(second)
-
-    error = next(message for message in second.sent if message.get("type") == "error")
-    assert error["error"]["code"] == "invalid_resume_token"
-    assert engine.resumed == []
-    assert engine.closed == []
-
-
-@pytest.mark.asyncio
-async def test_realtime_resume_recovers_when_rotated_token_delivery_is_lost():
-    class FailingResumeWebSocket(TimedWebSocket):
-        async def send_json(self, data: dict[str, Any]):
-            if data.get("type") == "session.resumed":
-                raise RuntimeError("resume transport disappeared")
-            await super().send_json(data)
-
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    first = TimedWebSocket(receive_timeout_s=0.01)
-    first.put(_native_realtime_session_update("sid-token-delivery"))
-    await handler.handle_realtime_session(first)
-    created = next(message for message in first.sent if message.get("type") == "session.created")
-    resume_event = {
-        "type": "session.resume",
-        "session_id": "sid-token-delivery",
-        "incarnation": created["incarnation"],
-        "resume_token": created["resume_token"],
-        "last_received_server_event_seq": 0,
-    }
-
-    failed_transport = FailingResumeWebSocket(receive_timeout_s=0.01)
-    failed_transport.put(resume_event)
-    await handler.handle_realtime_session(failed_transport)
-
-    recovered_transport = TimedWebSocket(receive_timeout_s=0.1)
-    recovered_transport.put(resume_event)
-    recovered_transport.put({"type": "session.close"})
-    await handler.handle_realtime_session(recovered_transport)
-
-    assert "session.resumed" in recovered_transport.sent_types()
-    assert engine.resumed == [
-        ("sid-token-delivery", 0),
-        ("sid-token-delivery", 1),
-    ]
-    assert engine.closed == [("sid-token-delivery", "session_close")]
-
-
-@pytest.mark.asyncio
-async def test_realtime_disconnect_grace_cancels_only_orphan_response():
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-        duplex_session_config=DuplexSessionRuntimeConfig(disconnect_grace_s=0.02),
-    )
-    ws = TimedWebSocket(receive_timeout_s=0.01)
-    ws.put(_native_realtime_session_update("sid-grace-response"))
-
-    await handler.handle_realtime_session(ws)
-    session = handler._registry.get("sid-grace-response")
-    assert session is not None
-    session.begin_response()
-    session.bind_request("orphan-request")
-    orphan_task = asyncio.create_task(asyncio.sleep(10))
-    handler._session_tasks[session.session_id].active_response_task = orphan_task
-    assert engine.closed == []
-
-    await asyncio.sleep(0.05)
-
-    assert engine.closed == []
-    assert engine.aborted == ["orphan-request"]
-    assert orphan_task.cancelled()
-    assert session.active_response_id is None
-    assert "sid-grace-response" in handler._serving_runtime_adapter.session_states
-
-
-@pytest.mark.asyncio
-async def test_realtime_heartbeat_control_failure_is_non_terminal():
-    engine = FakeEngineClient(fail_touch=True)
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket(receive_timeout_s=0.1)
-    ws.put(_native_realtime_session_update("sid-heartbeat-failure"))
-    ws.put({"type": "session.heartbeat"})
-    ws.put({"type": "session.close"})
-
-    await handler.handle_realtime_session(ws)
-
-    error = next(message for message in ws.sent if message.get("type") == "error")
-    assert error["error"]["code"] == "runtime_touch_failed"
-    assert engine.closed == [("sid-heartbeat-failure", "session_close")]
-
-
-@pytest.mark.asyncio
-async def test_realtime_idle_ttl_lifecycle_removes_detached_serving_projection():
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket(receive_timeout_s=0.01)
-    ws.put(_native_realtime_session_update("sid-idle-expired"))
-
-    await handler.handle_realtime_session(ws)
-    fence = engine.opened_fences[0]
-    assert fence is not None
-    await engine.duplex_lifecycle_events.put(
-        DuplexSessionLifecycleMessage(
-            fence=fence,
-            session_id="sid-idle-expired",
-            event="expired",
-            reason="idle_ttl_expired",
-            lease_generation=1,
-            submitted_request_ids=[],
-            reserved_request_ids=[],
-        )
-    )
-    await asyncio.sleep(0.05)
-
-    assert handler._registry.get("sid-idle-expired") is None
-    assert "sid-idle-expired" not in handler._serving_runtime_adapter.session_states
-    assert "sid-idle-expired" not in handler._session_tasks
-    assert engine.closed == []
-
-
-@pytest.mark.asyncio
-async def test_realtime_resume_reports_resync_required_after_journal_ttl_gap():
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-        duplex_session_config=DuplexSessionRuntimeConfig(resume_replay_ttl_s=0.01),
-    )
-    first = TimedWebSocket(receive_timeout_s=0.01)
-    first.put(_native_realtime_session_update("sid-journal-gap"))
-    first.put({"type": "session.heartbeat"})
-    await handler.handle_realtime_session(first)
-    created = next(message for message in first.sent if message.get("type") == "session.created")
-    await asyncio.sleep(0.02)
-
-    second = TimedWebSocket(receive_timeout_s=0.01)
-    second.put(
-        {
-            "type": "session.resume",
-            "session_id": "sid-journal-gap",
-            "incarnation": created["incarnation"],
-            "resume_token": created["resume_token"],
-            "last_received_server_event_seq": 0,
-        }
-    )
-    await handler.handle_realtime_session(second)
-
-    assert "session.resync_required" in second.sent_types()
-    assert engine.resumed == []
-    assert engine.closed == []
-
-
-@pytest.mark.asyncio
-async def test_realtime_journal_overflow_degrades_to_live_resync_without_closing_runtime():
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-        duplex_session_config=DuplexSessionRuntimeConfig(resume_replay_max_bytes_per_session=128),
-    )
-    ws = TimedWebSocket(receive_timeout_s=0.01)
-    ws.put(_native_realtime_session_update("sid-journal-overflow"))
-
-    await handler.handle_realtime_session(ws)
-
-    assert "session.created" in ws.sent_types()
-    assert "session.resync_required" in ws.sent_types()
-    assert engine.closed == []
-    assert handler._registry.get("sid-journal-overflow") is not None
-
-
-@pytest.mark.asyncio
-async def test_realtime_input_backpressure_is_per_session_and_rejects_before_mutation():
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-        duplex_session_config=DuplexSessionRuntimeConfig(
-            max_pending_input_bytes_per_session=100,
-        ),
-    )
-    first = TimedWebSocket(receive_timeout_s=0.1)
-    first.put(_native_realtime_session_update("sid-backpressure-a"))
-    for _ in range(2):
-        first.put(
-            {
-                "type": "input_audio_buffer.append",
-                "audio": _pcm16_b64(20),
-                "format": "pcm16",
-                "sample_rate_hz": 16000,
-            }
-        )
-    first.put({"type": "session.close"})
-
-    await handler.handle_realtime_session(first)
-
-    backpressure = [
-        event
-        for event in first.sent
-        if event.get("type") == "error"
-        and isinstance(event.get("error"), dict)
-        and event["error"].get("code") == "input_backpressure"
-    ]
-    assert len(backpressure) == 1
-
-    second = TimedWebSocket(receive_timeout_s=0.1)
-    second.put(_native_realtime_session_update("sid-backpressure-b"))
-    second.put(
-        {
-            "type": "input_audio_buffer.append",
-            "audio": _pcm16_b64(20),
-            "format": "pcm16",
-            "sample_rate_hz": 16000,
-        }
-    )
-    second.put({"type": "session.close"})
-
-    await handler.handle_realtime_session(second)
-
-    assert not any(
-        event.get("type") == "error"
-        and isinstance(event.get("error"), dict)
-        and event["error"].get("code") == "input_backpressure"
-        for event in second.sent
-    )
-
-
-@pytest.mark.asyncio
-async def test_duplex_handler_idle_timeout_close_does_not_emit_runtime_control():
-    control_result = {
-        "operation": "close",
-        "session_id": "sid-disconnect",
-        "ok": True,
-        "unsupported_count": 1,
-        "error_count": 0,
-        "stage_results": [{"stage_id": 0, "replica_id": 0, "result": {"supported": False}}],
-    }
-    engine = FakeEngineClient(append_result=control_result)
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=0.1)
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-disconnect"))
-
-    await handler.handle_session(ws)
-
-    assert engine.closed == [("sid-disconnect", "timeout")]
-
-
-@pytest.mark.asyncio
-async def test_idle_output_audio_clear_does_not_advance_runtime_fence():
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket()
-    ws.put(_session_create("sid-idle-output-clear"))
-    ws.put({"type": "output_audio_buffer.clear"})
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    cancelled = next(event for event in ws.sent if event.get("type") == "audio.cancelled")
-    assert cancelled["cancelled_epoch"] == cancelled["epoch"] == 0
-    assert engine.signals == []
-
-
-@pytest.mark.asyncio
-async def test_duplex_handler_runtime_close_failure_is_reported_without_closed_ack():
-    engine = FakeEngineClient(fail_close=True)
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-close-fail"))
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    assert ws.sent_types() == ["session.created", "error"]
-    assert ws.sent[-1]["code"] == "runtime_close_failed"
-
-
-@pytest.mark.asyncio
-async def test_duplex_handler_control_close_failure_is_reported_without_closed_ack():
-    control_result = {
-        "operation": "close",
-        "session_id": "sid-control-close-fail",
-        "ok": False,
-        "unsupported_count": 0,
-        "error_count": 1,
-        "stage_results": [
-            {
-                "stage_id": 0,
-                "replica_id": 0,
-                "result": {"supported": False, "error": "stage close failed"},
-            }
-        ],
-    }
-    engine = FakeEngineClient(close_result=control_result)
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-control-close-fail"))
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    assert ws.sent_types() == ["session.created", "error"]
-    assert ws.sent[-1]["code"] == "runtime_close_failed"
-    assert ws.sent[-1]["runtime_control"]["error_count"] == 1
-
-
-@pytest.mark.asyncio
-async def test_duplex_cancel_without_active_response_clears_pending_input_and_acks():
-    engine = FakeEngineClient()
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-    ws = TimedWebSocket()
-    ws.put(_session_create("sid-pending-cancel"))
-    ws.put({"type": "input.text.append", "text": "hello"})
-    ws.put({"type": "input.cancel", "reason": "user_cancel"})
-    ws.put({"type": "input.commit"})
-
-    await handler.handle_session(ws)
-
-    cancelled = next(m for m in ws.sent if m.get("type") == "input.cancelled")
-    assert cancelled["cancelled"] == {"text_chunks": 1, "audio_chunks": 0}
-    assert cancelled["epoch"] == 1
-    assert chat_service.seen_request_ids == []
-    assert "response.created" not in ws.sent_types()
-
-
-@pytest.mark.asyncio
-async def test_turn_signal_input_cancel_uses_epoch_fence_transition():
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-turn-signal-cancel"))
-    ws.put({"type": "input.text.append", "text": "discard me"})
-    ws.put({"type": "turn.signal", "event": "input.cancel"})
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    assert engine.signal_fences[-1] == DuplexFence("sid-turn-signal-cancel")
-    assert engine.signal_next_fences[-1] == DuplexFence("sid-turn-signal-cancel", epoch=1)
-    assert any(message.get("type") == "input.cancelled" for message in ws.sent)
-
-
-@pytest.mark.asyncio
-async def test_duplex_handler_local_turn_signal_does_not_round_trip_runtime():
-    engine = FakeEngineClient(fail_signal=True)
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-    ws = TimedWebSocket()
-    ws.put(_session_create("sid-signal-fail"))
-    ws.put({"type": "turn.signal", "event": "user_started"})
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    turn_event = next(m for m in ws.sent if m.get("type") == "turn.event")
-    assert turn_event["event"] == "user_started"
-    assert not engine.signals
-    assert "runtime_signal_failed" not in {m.get("code") for m in ws.sent}
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_duplex_append_without_format_defaults_to_pcm16():
-    engine = FakeEngineClient()
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-native-default-pcm16"))
-    ws.put(
-        {
-            "type": "input_audio_buffer.append",
-            "audio": _pcm16_b64(16000),
-            "sample_rate_hz": 16000,
-            "is_speech": True,
-        }
-    )
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    assert len(engine.appended) == 1
-    _, mode, payload, final = engine.appended[0]
-    assert mode == "append_audio_chunk"
-    assert final is False
-    assert isinstance(payload, dict)
-    assert payload["format"] == "pcm_f32le"
-    assert payload["sample_rate_hz"] == 16000
-    samples = np.frombuffer(base64.b64decode(payload["audio"]), dtype="<f4")
-    assert samples.shape == (16000,)
-    assert samples[:4].tolist() == pytest.approx([1000 / 32768.0] * 4)
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_duplex_rejects_invalid_sample_rate_without_append():
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-native-invalid-rate"))
-    ws.put(
-        {
-            "type": "input_audio_buffer.append",
-            "audio": _pcm16_b64(1),
-            "sample_rate_hz": 16_000.5,
-            "is_speech": True,
-        }
-    )
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    assert engine.appended == []
-    error = next(event for event in ws.sent if event.get("type") == "error")
-    assert error["code"] == "bad_event"
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("sample_rate_hz", INVALID_VALIDATED_SAMPLE_RATES)
-async def test_turn_based_server_vad_rejects_invalid_direct_sample_rate_without_closing_session(
-    sample_rate_hz: object,
-):
-    backend = FakeServerVADBackend([0.9])
-    handler = OmniDuplexSessionHandler(
-        chat_service=TurnBasedFakeChatService(FakeEngineClient()),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-        server_vad_backend_provider=FakeServerVADProvider(backend),
-    )
-    ws = TimedWebSocket()
-    session_create = _session_create("sid-server-vad-invalid-rate")
-    session_create["session"]["turn_detection"] = _server_vad_turn_detection(create_response=False)
-    ws.put(session_create)
-    invalid_append = _server_vad_audio_append(frame_count=1)
-    invalid_append["sample_rate_hz"] = sample_rate_hz
-    ws.put(invalid_append)
-    ws.put(_server_vad_audio_append(frame_count=1))
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    errors = [event for event in ws.sent if event.get("type") == "error"]
-    assert [error["code"] for error in errors] == ["bad_audio"]
-    assert "internal_error" not in {error["code"] for error in errors}
-    assert "session.created" in ws.sent_types()
-    assert "session.closed" in ws.sent_types()
-    assert backend.calls == 1
-
-
-@pytest.mark.asyncio
-async def test_native_input_commit_does_not_send_noop_runtime_signal():
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-commit-without-signal"))
-    ws.put(
-        {
-            "type": "input_audio_buffer.append",
-            "audio": _pcm16_b64(16000),
-            "sample_rate_hz": 16000,
-            "is_speech": True,
-        }
-    )
-    ws.put({"type": "input_audio_buffer.commit"})
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    assert ("sid-commit-without-signal", "input.commit") not in engine.signals
-
-
-@pytest.mark.asyncio
-async def test_audio_clear_preserves_later_wire_order_append():
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-clear-then-append"))
-    ws.put({"type": "input_audio_buffer.clear"})
-    ws.put(
-        {
-            "type": "input_audio_buffer.append",
-            "audio": _pcm16_b64(16000),
-            "sample_rate_hz": 16000,
-            "is_speech": True,
-        }
-    )
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    assert len(engine.appended) == 1
-
-
-@pytest.mark.asyncio
-async def test_native_append_is_cancelled_by_later_wire_order_input_cancel(mocker):
-    class SlowAppendEngine(FakeEngineClient):
-        def __init__(self) -> None:
-            super().__init__()
-            self.append_started = asyncio.Event()
-            self.append_cancelled = asyncio.Event()
-            self.release_append = asyncio.Event()
-
-        async def append_duplex_input_async(
-            self,
-            session_id: str,
-            *,
-            mode: str,
-            payload: object,
-            operation_id: str | None = None,
-            final: bool = False,
-            timeout: float | None = None,
-            collect_outputs: bool = True,
-            fence: DuplexFence | None = None,
-        ) -> Any:
-            self.append_started.set()
-            try:
-                await self.release_append.wait()
-            except asyncio.CancelledError:
-                self.append_cancelled.set()
-                raise
-            return await super().append_duplex_input_async(
-                session_id,
-                mode=mode,
-                payload=payload,
-                operation_id=operation_id,
-                final=final,
-                timeout=timeout,
-                collect_outputs=collect_outputs,
-                fence=fence,
-            )
-
-    rollback = mocker.spy(MiniCPMO45PcmAppendBuffer, "_rollback_reservation")
-    engine = SlowAppendEngine()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-cancel-slow-append"))
-    ws.put(
-        {
-            "type": "input_audio_buffer.append",
-            "audio": _pcm16_b64(16000),
-            "sample_rate_hz": 16000,
-            "is_speech": True,
-        }
-    )
-    ws.put({"type": "input.cancel"})
-    ws.put({"type": "session.close"})
-
-    handler_task = asyncio.create_task(handler.handle_session(ws))
-    await asyncio.wait_for(engine.append_started.wait(), timeout=1)
-    try:
-        await asyncio.wait_for(engine.append_cancelled.wait(), timeout=0.2)
-    except TimeoutError:
-        pass
-    finally:
-        engine.release_append.set()
-    await asyncio.wait_for(handler_task, timeout=1)
-
-    assert engine.append_cancelled.is_set()
-    rollback.assert_called_once()
-    assert engine.signal_fences[-1] == DuplexFence("sid-cancel-slow-append")
-    assert engine.signal_next_fences[-1] == DuplexFence("sid-cancel-slow-append", epoch=1)
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_duplex_append_control_error_does_not_emit_model_delta():
-    control_result = {
-        "operation": "append",
-        "session_id": "sid-native-append-error",
-        "ok": False,
-        "unsupported_count": 0,
-        "error_count": 1,
-        "stage_results": [
-            {
-                "stage_id": -1,
-                "replica_id": -1,
-                "result": {
-                    "supported": False,
-                    "error": "duplex_stage_handoff_target_missing:tts",
-                },
-            },
-        ],
-    }
-    engine = FakeEngineClient(append_result=control_result)
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-native-append-error"))
-    ws.put({"type": "input_audio_buffer.append", "audio": "AAAA", "format": "pcm_f32le"})
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    assert "response.output_audio.delta" not in ws.sent_types()
-    error = next(m for m in ws.sent if m.get("type") == "error")
-    assert error["code"] == "runtime_append_failed"
-    assert error["runtime_control"]["error_count"] == 1
-
-
-@pytest.mark.asyncio
-async def test_duplex_handler_session_update_control_failure_rolls_back_config():
-    control_result = {
-        "operation": "signal",
-        "session_id": "sid-control-signal-fail",
-        "ok": False,
-        "unsupported_count": 0,
-        "error_count": 1,
-        "stage_results": [
-            {
-                "stage_id": 0,
-                "replica_id": 0,
-                "result": {"supported": False, "error": "stage signal failed"},
-            }
-        ],
-    }
-    engine = FakeEngineClient(signal_result=control_result)
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-control-signal-fail"))
-    ws.put(
-        {
-            "type": "turn.signal",
-            "event": "session.update",
-            "payload": {"temperature": 0.2},
-        }
-    )
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    assert "session.updated" not in ws.sent_types()
-    error = next(m for m in ws.sent if m.get("type") == "error")
-    assert error["code"] == "runtime_signal_failed"
-    assert error["runtime_control"]["error_count"] == 1
-    signaled_config = engine.signal_session_configs[-1]
-    assert signaled_config is not None
-    assert signaled_config["temperature"] == 0.2
-
-
-@pytest.mark.asyncio
-async def test_native_session_update_commits_config_only_after_runtime_ack():
-    class BlockingUpdateEngine(FakeEngineClient):
-        def __init__(self):
-            super().__init__()
-            self.update_started = asyncio.Event()
-            self.release_update = asyncio.Event()
-
-        async def signal_duplex_turn_async(self, session_id: str, **kwargs):
-            if kwargs.get("event") == "session.update":
-                self.update_started.set()
-                await self.release_update.wait()
-            return await super().signal_duplex_turn_async(session_id, **kwargs)
-
-    engine = BlockingUpdateEngine()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-        server_vad_backend_provider=FakeServerVADProvider(FakeServerVADBackend([])),
-    )
-    ws = TimedWebSocket()
-    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
-    ws.put(_native_realtime_session_update("sid-update-two-phase"))
-    ws.put(_native_server_vad_update("update-two-phase"))
-
-    handler_task = asyncio.create_task(handler.handle_session(ws, realtime_protocol=protocol))
-    await asyncio.wait_for(engine.update_started.wait(), timeout=10)
-    live_session = handler._registry.get("sid-update-two-phase")
-    assert live_session is not None
-    assert live_session.config.overlap_policy == DuplexOverlapPolicy.LISTEN_ONLY.value
-    assert protocol._pending_turn_detection_update is not None
-    assert protocol._turn_detection is None
-
-    protocol.encode_outbound_event({"type": "error", "code": "unrelated", "error": "unrelated"})
-    assert protocol._pending_turn_detection_update is not None
-
-    engine.release_update.set()
-    ws.put({"type": "session.close"})
-    await asyncio.wait_for(handler_task, timeout=2)
-
-    updated = next(message for message in reversed(ws.sent) if message.get("type") == "session.updated")
-    assert updated["session"]["overlap_policy"] == DuplexOverlapPolicy.BARGE_IN_ON_SPEECH.value
-    assert protocol._turn_detection is not None
-
-
-@pytest.mark.parametrize(
-    ("append_fails", "expected_code"),
-    [(True, "session_update_aborted"), (False, "instructions_update_unsupported")],
-)
-@pytest.mark.asyncio
-async def test_native_server_vad_update_rejection_does_not_stall(append_fails, expected_code):
-    append_result = {"operation": "append", "ok": False, "error_count": 1} if append_fails else None
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(FakeEngineClient(append_result=append_result)),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-        server_vad_backend_provider=FakeServerVADProvider(FakeServerVADBackend([])),
-    )
-    ws = TimedWebSocket()
-    protocol = NativeRealtimeSessionProtocol(ws)  # type: ignore[arg-type]
-    create = _native_realtime_session_update("sid-rejected-vad-update")
-    create["session"]["extra_body"]["auto_response"] = append_fails
-    ws.put(create)
-    if append_fails:
-        ws.put({"type": "input_audio_buffer.append", "audio": _pcm_f32_b64(16_000), "format": "pcm_f32le"})
-    update = _native_server_vad_update("rejected-vad-update")
-    if not append_fails:
-        update["session"]["instructions"] = "You are now a pirate."
-    ws.put(update)
-    ws.put({"type": "session.close"})
-
-    await asyncio.wait_for(handler.handle_session(ws, realtime_protocol=protocol), timeout=10)
-
-    errors = [message["error"] for message in ws.sent if isinstance(message.get("error"), dict)]
-    error = next(error for error in errors if error.get("code") == expected_code)
-    assert error["event_id"] == "rejected-vad-update"
-    assert protocol._pending_turn_detection_update is None
-
-
-@pytest.mark.asyncio
-async def test_native_session_update_waits_for_prior_append_effect():
-    class OrderedUpdateEngine(FakeEngineClient):
-        def __init__(self):
-            super().__init__()
-            self.append_started = asyncio.Event()
-            self.release_append = asyncio.Event()
-            self.update_started = asyncio.Event()
-            self.effects: list[str] = []
-
-        async def append_duplex_input_async(self, session_id: str, **kwargs):
-            self.effects.append("append.started")
-            self.append_started.set()
-            await self.release_append.wait()
-            kwargs.pop("expected_epoch", None)
-            result = await super().append_duplex_input_async(session_id, **kwargs)
-            self.effects.append("append.done")
-            return result
-
-        async def signal_duplex_turn_async(self, session_id: str, **kwargs):
-            if kwargs.get("event") == "session.update":
-                self.effects.append("session.update")
-                self.update_started.set()
-            return await super().signal_duplex_turn_async(session_id, **kwargs)
-
-    engine = OrderedUpdateEngine()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-ordered-update"))
-    ws.put(
-        {
-            "type": "input_audio_buffer.append",
-            "audio": _pcm_f32_b64(16000, value=0.05),
-            "format": "pcm_f32le",
-        }
-    )
-    ws.put(
-        {
-            "type": "turn.signal",
-            "event": "session.update",
-            "payload": {"temperature": 0.2},
-        }
-    )
-
-    handler_task = asyncio.create_task(handler.handle_session(ws))
-    await asyncio.wait_for(engine.append_started.wait(), timeout=1)
-    try:
-        await asyncio.sleep(0.05)
-        assert not engine.update_started.is_set()
-    finally:
-        engine.release_append.set()
-        ws.put({"type": "session.close"})
-        await asyncio.wait_for(handler_task, timeout=2)
-
-    assert engine.effects.index("append.done") < engine.effects.index("session.update")
-
-
-@pytest.mark.asyncio
-async def test_failed_native_append_prevents_queued_append_from_running():
-    failed_result = {
-        "operation": "append",
-        "session_id": "sid-append-chain-failure",
-        "ok": False,
-        "unsupported_count": 0,
-        "error_count": 1,
-        "stage_results": [
-            {
-                "stage_id": 0,
-                "replica_id": 0,
-                "result": {"supported": False, "error": "append failed"},
-            }
-        ],
-    }
-
-    class BlockingFailureEngine(FakeEngineClient):
-        def __init__(self):
-            super().__init__(append_result=failed_result)
-            self.first_started = asyncio.Event()
-            self.release_first = asyncio.Event()
-
-        async def append_duplex_input_async(self, session_id: str, **kwargs):
-            if not self.appended:
-                self.first_started.set()
-                await self.release_first.wait()
-            kwargs.pop("expected_epoch", None)
-            return await super().append_duplex_input_async(session_id, **kwargs)
-
-    engine = BlockingFailureEngine()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket()
-    create = _native_session_create("sid-append-chain-failure")
-    create["session"]["extra_body"]["auto_response"] = True
-    ws.put(create)
-    for _ in range(2):
-        ws.put(
-            {
-                "type": "input_audio_buffer.append",
-                "audio": _pcm_f32_b64(16_000, value=0.05),
-                "format": "pcm_f32le",
-            }
-        )
-
-    handler_task = asyncio.create_task(handler.handle_session(ws))
-    await asyncio.wait_for(engine.first_started.wait(), timeout=1)
-    engine.release_first.set()
-    await asyncio.sleep(0.1)
-    ws.put({"type": "session.close"})
-    await asyncio.wait_for(handler_task, timeout=2)
-
-    assert len(engine.appended) == 1
-
-
-@pytest.mark.asyncio
-async def test_failed_final_append_discards_retained_audio_without_retry():
-    failed_result = {
-        "operation": "append",
-        "session_id": "sid-final-append-retry",
-        "ok": False,
-        "unsupported_count": 0,
-        "error_count": 1,
-        "stage_results": [],
-    }
-    engine = FakeEngineClient(append_result=failed_result)
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-
-    def retry_after_runtime_error(ws: TimedWebSocket, data: dict[str, Any]) -> None:
-        if data.get("type") == "error" and data.get("code") == "runtime_append_failed":
-            ws.put({"type": "response.create"})
-
-    ws = TimedWebSocket(on_send=retry_after_runtime_error)
-    ws.put(_native_session_create("sid-final-append-retry"))
-    ws.put(
-        {
-            "type": "input_audio_buffer.append",
-            "audio": _pcm_f32_b64(8_000, value=0.05),
-            "format": "pcm_f32le",
-        }
-    )
-    ws.put({"type": "input_audio_buffer.commit", "final": True})
-    ws.put({"type": "response.create"})
-
-    handler_task = asyncio.create_task(handler.handle_session(ws))
-    for _ in range(100):
-        state = handler._serving_runtime_adapter.session_states.get("sid-final-append-retry")
-        if len(engine.appended) >= 1 and state is not None and state.committed_audio_payload is None:
-            break
-        await asyncio.sleep(0.01)
-    state = handler._serving_runtime_adapter.session_states["sid-final-append-retry"]
-    assert state.committed_audio_payload is None
-    assert state.committed_audio_reserved_bytes == 0
-    assert handler._registry.get("sid-final-append-retry").pending_input_bytes == 0
-    ws.put({"type": "session.close"})
-    await asyncio.wait_for(handler_task, timeout=2)
-
-    assert len(engine.appended) == 1
-
-
-@pytest.mark.asyncio
-async def test_duplex_handler_signal_unsupported_workers_with_data_plane_ack_is_not_fatal():
-    control_result = {
-        "operation": "signal",
-        "session_id": "sid-control-signal-data-plane",
-        "ok": False,
-        "unsupported_count": 2,
-        "error_count": 0,
-        "stage_results": [
-            {
-                "stage_id": 0,
-                "replica_id": 0,
-                "result": {"supported": False, "reason": "worker_duplex_signal_not_implemented"},
-            },
-            {
-                "stage_id": 1,
-                "replica_id": 0,
-                "result": {"supported": False, "reason": "worker_duplex_signal_not_implemented"},
-            },
-            {
-                "stage_id": -1,
-                "replica_id": -1,
-                "result": {
-                    "supported": True,
-                    "data_plane_signal": True,
-                    "event": "barge_in",
-                    "epoch": 1,
-                },
-            },
-        ],
-    }
-    engine = FakeEngineClient(signal_result=control_result)
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-control-signal-data-plane"))
-    ws.put({"type": "turn.signal", "event": "barge_in"})
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    assert "runtime_signal_failed" not in {m.get("code") for m in ws.sent}
-    assert "input.cancelled" in ws.sent_types()
-    runtime_control = next(m for m in ws.sent if m.get("type") == "runtime.control")
-    assert runtime_control["result"]["unsupported_count"] == 2
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_duplex_open_unsupported_fails_session_create():
-    control_result = {
-        "operation": "open",
-        "session_id": "sid-native-busy",
-        "ok": True,
-        "unsupported_count": 1,
-        "error_count": 0,
-        "stage_results": [
-            {
-                "stage_id": 0,
-                "replica_id": 0,
-                "result": {"supported": False, "reason": "native_duplex_session_busy"},
-            }
-        ],
-    }
-    engine = FakeEngineClient(control_result=control_result)
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-native-busy"))
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    assert ws.sent_types() == ["error"]
-    assert ws.sent[0]["code"] == "runtime_open_unsupported"
-    assert ws.sent[0]["runtime_control"]["unsupported_count"] == 1
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_duplex_rejects_engine_without_fence_contract():
-    class LegacyEngineClient(FakeEngineClient):
-        async def open_duplex_session_async(  # type: ignore[override]
-            self,
-            session_id: str,
-            *,
-            session_mode: str = "duplex",
-            capabilities: dict[str, object] | None = None,
-            session_config: dict[str, object] | None = None,
-            timeout: float | None = None,
-        ) -> Any:
-            return await super().open_duplex_session_async(
-                session_id,
-                session_mode=session_mode,
-                capabilities=capabilities,
-                session_config=session_config,
-                timeout=timeout,
-            )
-
-    engine = LegacyEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-native-no-fence-contract"))
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    assert ws.sent_types() == ["error"]
-    assert ws.sent[0]["code"] == "runtime_contract_invalid"
-    assert "open_duplex_session_async" in ws.sent[0]["error"]
-    assert "fence" in ws.sent[0]["error"]
-    assert engine.opened == []
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_duplex_audio_append_does_not_retain_pending_audio():
-    engine = FakeEngineClient()
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-native-no-pending"))
-    short_chunk = base64.b64encode(b"\x00" * (800 * 4)).decode("ascii")
-    ws.put({"type": "input_audio_buffer.append", "audio": short_chunk, "format": "pcm_f32le"})
-    ws.put({"type": "input.cancel", "reason": "barge_in"})
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    cancelled = next(m for m in ws.sent if m.get("type") == "input.cancelled")
-    assert cancelled["cancelled"] == {"text_chunks": 0, "audio_chunks": 0}
-    assert cancelled["epoch"] == 1
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_duplex_rejects_text_append_before_runtime_call():
-    engine = FakeEngineClient()
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-native-text"))
-    ws.put({"type": "input.text.append", "text": "hello"})
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    error = next(m for m in ws.sent if m.get("type") == "error")
-    assert error["code"] == "native_text_append_unsupported"
-    assert engine.appended == []
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_duplex_separates_public_and_runtime_config(monkeypatch):
-    engine = FakeEngineClient()
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-
-    async def fake_resolve_ref_audio(_, *, model_config):
-        del model_config
-        return [0.25] * 1600, 16000
-
-    monkeypatch.setattr(
-        "vllm_omni.model_executor.models.minicpmo_4_5.duplex.MiniCPMO45NativeDuplexServingAdapter.resolve_ref_audio",
-        fake_resolve_ref_audio,
-    )
-    event = _native_session_create("sid-native-ref-audio", modalities=["text", "audio"])
-    event["session"]["ref_audio"] = "data:audio/wav;base64,AAAA"
-    ws = TimedWebSocket()
-    ws.put(event)
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    assert ws.sent_types()[0] == "session.created"
-    opened_config = engine.opened_configs[0]
-    opened_runtime_config = engine.opened_runtime_configs[0]
-    extra_body = opened_config["extra_body"]
-    assert "ref_audio_data" not in extra_body
-    assert "duplex_stage_max_tokens" not in extra_body
-    assert opened_runtime_config["ref_audio_format"] == "pcm_f32le"
-    assert opened_runtime_config["ref_audio_sample_rate_hz"] == 16000
-    assert opened_runtime_config["duplex_stage_max_tokens"] == {"0": 20, "1": 8192}
-    assert opened_runtime_config["duplex_stage_sampling_params"]["0"]["top_k"] == 20
-    assert opened_runtime_config["duplex_stage_sampling_params"]["0"]["top_p"] == 0.8
-    # The Talker YAML carries upstream's min_new_token=50 for chat TTS; a duplex
-    # chunk is 26 codec samples, so check_stop would never release the request.
-    assert opened_runtime_config["duplex_stage_sampling_params"]["1"] == {"min_tokens": 0}
-    assert base64.b64decode(opened_runtime_config["ref_audio_data"]) == struct.pack("<1600f", *([0.25] * 1600))
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_duplex_rejects_client_runtime_config():
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    event = _native_session_create("sid-native-private-config")
-    event["session"]["extra_body"]["duplex_stage_sampling_params"] = {"0": {"temperature": 0.0}}
-    ws = TimedWebSocket()
-    ws.put(event)
-
-    await handler.handle_session(ws)
-
-    assert ws.sent_types() == ["error"]
-    assert ws.sent[0]["code"] == "invalid_duplex_runtime_config"
-    assert engine.opened == []
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_duplex_audio_output_requires_ref_audio(monkeypatch):
-    monkeypatch.setattr(
-        MiniCPMO45NativeDuplexServingAdapter,
-        "_load_native_tokenizer",
-        staticmethod(lambda model_config: None),
-    )
-
-    event = _native_session_create(
-        "sid-native-ref-required",
-        modalities=["text", "audio"],
-    )
-    config = DuplexSessionConfig.from_event(event)
-
-    with pytest.raises(ServingRuntimeConfigError) as exc_info:
-        await MiniCPMO45NativeDuplexServingAdapter.prepare_runtime_config(
-            config,
-            model_config=SimpleNamespace(model="openbmb/MiniCPM-o-4_5"),
-        )
-
-    assert exc_info.value.code == "ref_audio_required"
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_duplex_open_session_maps_missing_ref_audio_to_typed_error():
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket()
-    ws.put(
-        _native_session_create(
-            "sid-native-ref-required-open",
-            modalities=["text", "audio"],
-        )
-    )
-
-    await handler.handle_session(ws)
-
-    assert ws.sent_types() == ["error"]
-    assert ws.sent[0]["code"] == "ref_audio_required"
-    assert engine.opened == []
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_duplex_text_only_omits_ref_audio_when_client_does_not_provide_it(monkeypatch):
-    monkeypatch.setattr(
-        MiniCPMO45NativeDuplexServingAdapter,
-        "_load_native_tokenizer",
-        staticmethod(lambda model_config: None),
-    )
-
-    event = _native_session_create("sid-native-default-ref", modalities=["text"])
-    config = DuplexSessionConfig.from_event(event)
-
-    runtime_config = await MiniCPMO45NativeDuplexServingAdapter.prepare_runtime_config(
-        config,
-        model_config=SimpleNamespace(model="openbmb/MiniCPM-o-4_5"),
-    )
-
-    assert "ref_audio_data" not in runtime_config
-    assert "ref_audio_format" not in runtime_config
-    assert "ref_audio_sample_rate_hz" not in runtime_config
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_duplex_preserves_ref_audio_channels_until_normalize(monkeypatch):
-    class FakeMediaConnector:
-        def __init__(self, **kwargs):
-            self.kwargs = kwargs
-
-        async def fetch_audio_async(self, ref_audio):
-            assert ref_audio == "data:audio/wav;base64,AAAA"
-            return np.tile(np.array([[0.25, -0.25], [0.5, -0.5]], dtype=np.float32), (800, 1)), 16000
-
-    monkeypatch.setattr(
-        "vllm_omni.model_executor.models.minicpmo_4_5.duplex.adapter.MediaConnector",
-        FakeMediaConnector,
-    )
-
-    engine = FakeEngineClient()
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-    event = _native_session_create("sid-native-ref-audio-stereo", modalities=["text", "audio"])
-    event["session"]["ref_audio"] = "data:audio/wav;base64,AAAA"
-    ws = TimedWebSocket()
-    ws.put(event)
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    runtime_config = engine.opened_runtime_configs[0]
-    assert base64.b64decode(runtime_config["ref_audio_data"]) == struct.pack("<1600f", *([0.0] * 1600))
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_duplex_rejects_ref_audio_path():
-    engine = FakeEngineClient()
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-    event = _native_session_create("sid-native-ref-path")
-    event["session"]["extra_body"] = {
-        "native_duplex": True,
-        "ref_audio_path": "/tmp/ref.wav",
-    }
-    ws = TimedWebSocket()
-    ws.put(event)
-
-    await handler.handle_session(ws)
-
-    assert ws.sent_types() == ["error"]
-    assert ws.sent[0]["code"] == "unsupported_ref_audio_path"
-    assert engine.opened == []
-
-
-def test_minicpmo_native_duplex_explicit_barge_in_request_interrupts():
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    session = DuplexSession(
-        session_id="sid-native-explicit-barge-disabled",
-        config=DuplexSessionConfig(overlap_policy=DuplexOverlapPolicy.BARGE_IN_ON_SPEECH.value),
-        capabilities=minicpmo45_native_capabilities(),
-    )
-    payload = {
-        "type": "audio",
-        "audio": _pcm_f32_b64(16000, value=0.05),
-        "format": "pcm_f32le",
-        "sample_rate_hz": 16000,
-        "is_speech": True,
-    }
-
-    decision = handler._overlap_decision(
-        session,
-        {"force_barge_in": True},
-        payload,
-    )
-
-    assert decision == {
-        "action": "barge_in",
-        "reason": "client_force_barge_in",
-        "duration_ms": 1000,
-        "buffer_audio": True,
-    }
-
-
-@pytest.mark.asyncio
-async def test_native_server_vad_complete_audio_item_reaches_runtime():
-    engine = FakeEngineClient()
-    backend = FakeServerVADBackend([0.9] * 10)
-    ws = TimedWebSocket()
-    create = _native_realtime_session_update("sid-native-complete-audio")
-    create["session"]["turn_detection"] = {"type": "server_vad"}
-    create["session"]["input_audio_format"] = "pcm16"
-    ws.put(create)
-    ws.put(
-        {
-            "type": "conversation.item.create",
-            "item": {
-                "id": "item-native-audio",
-                "type": "message",
-                "role": "user",
-                "content": [{"type": "input_audio", "audio": _pcm16_b64(2400)}],
-            },
-        }
-    )
-    ws.put({"type": "response.create"})
-    ws.put({"type": "session.close"})
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        server_vad_backend_provider=FakeServerVADProvider(backend),
-    )
-
-    await handler.handle_realtime_session(ws)  # type: ignore[arg-type]
-
-    assert any(final for _, _, _, final in engine.appended)
-    assert "error" not in ws.sent_types()
-
-
-@pytest.mark.asyncio
-async def test_native_server_vad_uses_shared_pipeline_and_emits_boundaries():
-    backend = FakeServerVADBackend([0.9] * 10 + [0.0] * 50)
-    engine = FakeEngineClient()
-
-    def commit_after_speech_stops(ws: TimedWebSocket, event: dict[str, Any]) -> None:
-        if event.get("type") == "input_audio_buffer.speech_stopped":
-            ws.put({"type": "input_audio_buffer.commit", "final": True})
-            ws.put({"type": "response.create"})
-            ws.put({"type": "session.close"})
-
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-        server_vad_backend_provider=FakeServerVADProvider(backend),
-    )
-    ws = TimedWebSocket(on_send=commit_after_speech_stops)
-    create = _native_realtime_session_update("sid-native-shared-server-vad")
-    create["session"]["turn_detection"] = {"type": "server_vad"}
-    ws.put(create)
-    ws.put(
-        {
-            "type": "input_audio_buffer.append",
-            "audio": _pcm_f32_b64(60 * backend.frame_samples, value=0.0),
-            "format": "pcm_f32le",
-            "sample_rate_hz": 16_000,
-        }
-    )
-    await asyncio.wait_for(
-        handler.handle_session(ws, realtime_protocol=NativeRealtimeSessionProtocol({})),
-        timeout=10,
-    )
-
-    boundary_events = [
-        event
-        for event in ws.sent
-        if event.get("type") in {"input_audio_buffer.speech_started", "input_audio_buffer.speech_stopped"}
-    ]
-    assert [event["type"] for event in boundary_events] == [
-        "input_audio_buffer.speech_started",
-        "input_audio_buffer.speech_stopped",
-    ]
-    assert boundary_events[0]["item_id"] == boundary_events[1]["item_id"]
-    created_session = next(event["session"] for event in ws.sent if event["type"] == "session.created")
-    assert created_session["audio"]["input"]["turn_detection"]["interrupt_response"] is True
-    assert created_session["overlap_policy"] == "barge_in_on_speech"
-    assert backend.calls == 60
-    assert any(final for _, _, _, final in engine.appended)
-    assert not any(event.get("error", {}).get("code") == "server_vad_manual_commit_unsupported" for event in ws.sent)
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize(
-    "barge_in_event",
-    [
-        {"type": "barge_in"},
-        {"type": "turn.signal", "event": "barge_in"},
-    ],
-)
-async def test_minicpmo_native_duplex_accepts_explicit_barge_in_control(
-    barge_in_event: dict[str, object],
-):
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-native-barge-control-disabled"))
-    ws.put(barge_in_event)
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    assert not any(message.get("code") == "barge_in_unsupported" for message in ws.sent)
-    assert ("sid-native-barge-control-disabled", "barge_in") in engine.signals
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_duplex_explicit_non_speech_stays_listening_without_append():
-    engine = FakeEngineClient()
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-native-silence"))
-    ws.put(
-        {
-            "type": "input_audio_buffer.append",
-            "audio": "AAAA",
-            "format": "pcm_f32le",
-            "is_speech": False,
-        }
-    )
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    assert engine.appended == []
-    assert "response.listen" in ws.sent_types()
-    assert "response.created" not in ws.sent_types()
-    assert "response.output_audio.delta" not in ws.sent_types()
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_duplex_drains_data_plane_stream_until_done():
-    def _stage_output(samples: int, *, finished: bool):
-        return SimpleNamespace(
-            request_id="duplex-sid-native-stream-e0-stage0-s1",
-            finished=finished,
-            outputs=[
-                SimpleNamespace(
-                    text="",
-                    multimodal_output={
-                        "audio": np.zeros(samples, dtype=np.float32),
-                        "sr": 24000,
-                    },
-                )
-            ],
-        )
-
-    control_result = {
-        "operation": "append",
-        "session_id": "sid-native-stream",
-        "ok": True,
-        "unsupported_count": 0,
-        "error_count": 0,
-        "stage_results": [
-            {
-                "stage_id": 0,
-                "replica_id": 0,
-                "result": {
-                    "supported": True,
-                    "implementation_level": "model_native_duplex",
-                    "data_plane_append": True,
-                    "request_id": "duplex-sid-native-stream-e0-stage0-s1",
-                    "response_stage_id": 1,
-                },
-            }
-        ],
-        "data_plane_outputs": [_stage_output(10, finished=False)],
-    }
-    engine = FakeEngineClient(
-        append_result=control_result,
-        collect_outputs=[
-            [_stage_output(20, finished=False)],
-            [_stage_output(30, finished=True)],
-        ],
-    )
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-
-    def close_on_second_created(ws: TimedWebSocket, data: dict[str, Any]) -> None:
-        if ws.sent_types().count("response.created") >= 2:
-            ws.put({"type": "session.close"})
-
-    ws = TimedWebSocket(on_send=close_on_second_created)
-    ws.put(_native_session_create("sid-native-stream"))
-    ws.put({"type": "input_audio_buffer.append", "audio": "AAAA", "format": "pcm_f32le"})
-
-    await handler.handle_session(ws)
-
-    deltas = [m for m in ws.sent if m.get("type") == "response.output_audio.delta"]
-    assert [m["audio"] for m in deltas] == ["wav-10", "wav-10", "wav-10"]
-    assert [m["end_of_turn"] for m in deltas] == [False, False, True]
-    assert len([m for m in ws.sent if m.get("type") == "response.done"]) == 1
-    assert engine.collected == [
-        ("duplex-sid-native-stream-e0-stage0-s1", 1),
-        ("duplex-sid-native-stream-e0-stage0-s1", 1),
-    ]
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_auto_response_restarts_drain_when_append_races_idle_exit(
-    monkeypatch: pytest.MonkeyPatch,
-):
-    request_id = "duplex-sid-native-late-output-e0-stage0"
-    late_output = object()
-    engine = FakeEngineClient(
-        collect_outputs=[[], [], [], [late_output]],
-        collect_delay_s=0.05,
-    )
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    session = DuplexSession(
-        session_id="sid-native-late-output",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    session.capabilities = minicpmo45_native_capabilities()
-    session.bind_request(request_id)
-    native = handler._runtime_session_state(session)
-    projected_batches: list[object] = []
-    projected = asyncio.Event()
-
-    async def project_late_output(_send_json, result, **_kwargs):
-        projected_batches.append(result)
-        projected.set()
-        session.close()
-        return None, True
-
-    monkeypatch.setattr(handler, "_send_native_duplex_events", project_late_output)
-    result = {
-        "stage_results": [
-            {
-                "result": {
-                    "data_plane_append": True,
-                    "request_id": request_id,
-                    "response_stage_id": 1,
-                }
-            }
-        ]
-    }
-
-    assert (
-        await handler._start_native_data_plane_stream_task(
-            None,
-            result,
-            session=session,
-            expected_epoch=session.epoch,
-        )
-        is True
-    )
-    first_drain = native.data_plane_task
-    assert first_drain is not None
-    await asyncio.sleep(0.01)
-
-    assert (
-        await handler._start_native_data_plane_stream_task(
-            None,
-            result,
-            session=session,
-            expected_epoch=session.epoch,
-        )
-        is False
-    )
-    await asyncio.wait_for(projected.wait(), timeout=1)
-    await asyncio.wait_for(first_drain, timeout=1)
-
-    assert len(engine.collected) == 4
-    assert projected_batches == [{"data_plane_outputs": [late_output]}]
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_duplex_ignores_outputs_after_data_plane_turn_done():
-    request_id = "duplex-sid-native-post-done-e0-stage0-s1"
-
-    def _stage_output(samples: int, *, turn_end: bool = False):
-        return SimpleNamespace(
-            request_id=request_id,
-            finished=False,
-            outputs=[
-                SimpleNamespace(
-                    text="hello",
-                    multimodal_output={
-                        "audio": np.zeros(samples, dtype=np.float32),
-                        "sr": 24000,
-                        "meta": {
-                            "turn_end": turn_end,
-                            "duplex_turn_id": 0,
-                            "duplex_epoch": 0,
-                        },
-                    },
-                )
-            ],
-        )
-
-    control_result = {
-        "operation": "append",
-        "session_id": "sid-native-post-done",
-        "ok": True,
-        "unsupported_count": 0,
-        "error_count": 0,
-        "stage_results": [
-            {
-                "stage_id": 0,
-                "replica_id": 0,
-                "result": {
-                    "supported": True,
-                    "implementation_level": "model_native_duplex",
-                    "data_plane_append": True,
-                    "request_id": request_id,
-                    "response_stage_id": 1,
-                },
-            }
-        ],
-        "data_plane_outputs": [_stage_output(10)],
-    }
-    engine = FakeEngineClient(
-        append_result=control_result,
-        collect_outputs=[
-            [_stage_output(20, turn_end=True)],
-            [_stage_output(30)],
-        ],
-    )
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-
-    def close_on_done(ws: TimedWebSocket, data: dict[str, Any]) -> None:
-        if data.get("type") == "response.done":
-            ws.put({"type": "session.close"})
-
-    event = _native_session_create("sid-native-post-done")
-    event["session"]["extra_body"]["auto_response"] = True
-    ws = TimedWebSocket(on_send=close_on_done)
-    ws.put(event)
-    ws.put({"type": "input_audio_buffer.append", "audio": "AAAA", "format": "pcm_f32le"})
-
-    await handler.handle_session(ws)
-
-    assert ws.sent_types().count("response.created") == 1
-    assert ws.sent_types().count("response.done") == 1
-    deltas = [m for m in ws.sent if m.get("type") == "response.output_audio.delta"]
-    assert [m["audio"] for m in deltas] == ["wav-10", "wav-10"]
-    assert engine.collected
-    assert all(collected == (request_id, 1) for collected in engine.collected)
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_duplex_accepts_next_append_after_response_done():
-    def _stage_output(*, finished: bool):
-        return SimpleNamespace(
-            request_id="duplex-sid-native-next-turn-e0-stage0-s1",
-            finished=finished,
-            outputs=[
-                SimpleNamespace(
-                    text="",
-                    multimodal_output={
-                        "audio": np.zeros(10, dtype=np.float32),
-                        "sr": 24000,
-                    },
-                )
-            ],
-        )
-
-    control_result = {
-        "operation": "append",
-        "session_id": "sid-native-next-turn",
-        "ok": True,
-        "unsupported_count": 0,
-        "error_count": 0,
-        "stage_results": [
-            {
-                "stage_id": 0,
-                "replica_id": 0,
-                "result": {
-                    "supported": True,
-                    "implementation_level": "model_native_duplex",
-                    "data_plane_append": True,
-                    "request_id": "duplex-sid-native-next-turn-e0-stage0-s1",
-                    "response_stage_id": 1,
-                },
-            }
-        ],
-        "data_plane_outputs": [_stage_output(finished=True)],
-    }
-    engine = FakeEngineClient(append_result=control_result)
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-    done_count = 0
-
-    def send_next_turn_or_close(ws: TimedWebSocket, data: dict[str, Any]) -> None:
-        nonlocal done_count
-        if data.get("type") != "response.done":
-            return
-        done_count += 1
-        if done_count == 1:
-            ws.put({"type": "input_audio_buffer.append", "audio": "BBBB", "format": "pcm_f32le"})
-            ws.put({"type": "input_audio_buffer.commit", "final": True})
-            ws.put({"type": "response.create"})
-        else:
-            ws.put({"type": "session.close"})
-
-    ws = TimedWebSocket(on_send=send_next_turn_or_close, receive_timeout_s=5)
-    create = _native_session_create("sid-native-next-turn")
-    create["session"]["idle_timeout_s"] = 5
-    ws.put(create)
-    ws.put({"type": "input_audio_buffer.append", "audio": "AAAA", "format": "pcm_f32le"})
-
-    await handler.handle_session(ws)
-
-    assert len(engine.appended) >= 2, [
-        (message.get("type"), message.get("code"), message.get("reason")) for message in ws.sent
-    ]
-    assert len([m for m in ws.sent if m.get("type") == "response.done"]) == 2
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_auto_response_commit_finalizes_after_streamed_full_chunk():
-    control_result = {
-        "operation": "append",
-        "session_id": "sid-native-auto-finalize",
-        "ok": True,
-        "unsupported_count": 0,
-        "error_count": 0,
-        "stage_results": [],
-    }
-    engine = FakeEngineClient(control_result=control_result)
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket()
-    event = _native_session_create("sid-native-auto-finalize")
-    event["session"]["extra_body"]["auto_response"] = True
-    ws.put(event)
-    ws.put(
-        {
-            "type": "input_audio_buffer.append",
-            "audio": _pcm_f32_b64(16000),
-            "format": "pcm_f32le",
-            "sample_rate_hz": 16000,
-        }
-    )
-    ws.put({"type": "input_audio_buffer.commit", "final": True})
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    assert len(engine.appended) == 1
-    assert engine.appended[0][3] is False
-    assert "response.created" not in ws.sent_types()
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_auto_response_commit_finalizes_with_active_data_plane_stream():
-    request_id = "duplex-sid-native-auto-active-stream-stage0"
-    control_result = {
-        "operation": "append",
-        "session_id": "sid-native-auto-active-stream",
-        "ok": True,
-        "unsupported_count": 0,
-        "error_count": 0,
-        "stage_results": [
-            {
-                "result": {
-                    "data_plane_append": True,
-                    "request_id": request_id,
-                    "response_stage_id": 1,
-                }
-            }
-        ],
-    }
-    engine = FakeEngineClient(
-        control_result=control_result,
-        collect_outputs=[[], [], []],
-        collect_delay_s=0.05,
-    )
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket()
-    event = _native_session_create("sid-native-auto-active-stream")
-    event["session"]["extra_body"]["auto_response"] = True
-    ws.put(event)
-    ws.put(
-        {
-            "type": "input_audio_buffer.append",
-            "audio": _pcm_f32_b64(16000),
-            "format": "pcm_f32le",
-            "sample_rate_hz": 16000,
-        }
-    )
-    ws.put({"type": "input_audio_buffer.commit", "final": True})
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    assert len(engine.appended) == 1
-    assert engine.appended[0][3] is False
-    assert "response.created" not in ws.sent_types()
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_auto_response_accepts_realtime_commit_after_stream_consumed():
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket()
-    event = _native_session_create("sid-native-auto-consumed-stream")
-    event["session"]["extra_body"]["auto_response"] = True
-    ws.put(event)
-    ws.put(
-        {
-            "type": "input_audio_buffer.append",
-            "audio": _pcm_f32_b64(16000),
-            "format": "pcm_f32le",
-            "sample_rate_hz": 16000,
-        }
-    )
-    ws.put(
-        {
-            "type": "input_audio_buffer.commit",
-            "final": True,
-            "item_id": "item-consumed-stream",
-        }
-    )
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    assert not any(message.get("code") == "input_audio_buffer_empty" for message in ws.sent)
-    committed = next(message for message in ws.sent if message.get("type") == "input.committed")
-    assert committed["item_id"] == "item-consumed-stream"
-    assert committed["native_audio"] is True
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_auto_response_post_response_commit_ignores_stale_progress_state():
-    session_id = "sid-native-auto-post-response"
-    engine = FakeEngineClient()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-
-    def on_send(ws: TimedWebSocket, data: dict[str, Any]) -> None:
-        if data.get("type") != "session.created":
-            return
-        session = handler._registry.get(session_id)
-        assert session is not None
-        ws.put(
-            {
-                "type": "input_audio_buffer.append",
-                "audio": _pcm_f32_b64(8000),
-                "format": "pcm_f32le",
-                "sample_rate_hz": 16000,
-            }
-        )
-        ws.put({"type": "input_audio_buffer.commit", "final": True})
-        ws.put({"type": "session.close"})
-
-    ws = TimedWebSocket(on_send=on_send)
-    create = _native_session_create(session_id)
-    create["session"]["extra_body"]["auto_response"] = True
-    ws.put(create)
-
-    await handler.handle_session(ws)
-
-    assert len(engine.appended) == 1
-    assert engine.appended[0][3] is True
-    assert "input.committed" in ws.sent_types()
-    assert not any(message.get("code") == "response_already_active" for message in ws.sent)
-
-
-def test_realtime_overlap_commit_uses_current_generation_identity():
-    handler, session = _auto_response_context("sid-realtime-reserved-input-turn")
-    session.turn_id = 1
-    session.bind_response_turn(1)
-    session.turn_id = 3
-    committed = handler._commit_native_audio_input(session)
-
-    assert committed.turn_id == 3
-    assert session.turn_id == 3
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_auto_response_keeps_request_bound_for_segment_continuation():
-    request_id = "duplex-sid-native-auto-continuation-e0-stage0"
-    control_result = {
-        "operation": "append",
-        "session_id": "sid-native-auto-continuation",
-        "ok": True,
-        "unsupported_count": 0,
-        "error_count": 0,
-        "stage_results": [
-            {
-                "result": {
-                    "data_plane_append": True,
-                    "request_id": request_id,
-                    "response_stage_id": 1,
-                }
-            }
-        ],
-    }
-    terminal_segment = _duplex_tts_output(
-        request_id=request_id,
-        samples=0,
-        finished=True,
-        tts_is_last_chunk=True,
-        token_ids=[151645],
-    )
-    engine = FakeEngineClient(
-        control_result=control_result,
-        collect_outputs=[[terminal_segment], [], []],
-        collect_delay_s=0.05,
-    )
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-
-    def on_send(ws: TimedWebSocket, data: dict[str, Any]) -> None:
-        if data.get("type") != "session.created":
-            return
-        session = handler._registry.get("sid-native-auto-continuation")
-        assert session is not None
-        session.capabilities.chunk_period_ms = 50
-        ws.put(
-            {
-                "type": "input_audio_buffer.append",
-                "audio": _pcm_f32_b64(800),
-                "format": "pcm_f32le",
-                "sample_rate_hz": 16000,
-            }
-        )
-        ws.put({"type": "input_audio_buffer.commit", "final": True})
-
-    ws = TimedWebSocket(on_send=on_send)
-    event = _native_session_create("sid-native-auto-continuation")
-    event["session"]["extra_body"]["auto_response"] = True
-    ws.put(event)
-
-    await handler.handle_session(ws)
-
-    assert len(engine.appended) >= 3
-    _, mode, payload, final = engine.appended[2]
-    assert mode == "append_audio_chunk"
-    assert payload["duplex_turn_id"] == 0
-    assert final is False
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_auto_response_real_input_preempts_unsent_silence():
-    request_id = "duplex-sid-native-real-before-silence-e0-stage0"
-
-    class SequencedAppendEngine(FakeEngineClient):
-        def __init__(self) -> None:
-            control_result = {
-                "operation": "append",
-                "session_id": "sid-native-real-before-silence",
-                "ok": True,
-                "unsupported_count": 0,
-                "error_count": 0,
-                "stage_results": [
-                    {
-                        "result": {
-                            "data_plane_append": True,
-                            "request_id": request_id,
-                            "response_stage_id": 1,
-                        }
-                    }
-                ],
-            }
-            terminal_segment = _duplex_tts_output(
-                request_id=request_id,
-                samples=0,
-                finished=True,
-                tts_is_last_chunk=True,
-                token_ids=[151645],
-            )
-            super().__init__(
-                control_result=control_result,
-                collect_outputs=[[terminal_segment], [], []],
-                collect_delay_s=0.01,
-            )
-            self.append_sequence: list[str] = []
-            self.first_real_started = asyncio.Event()
-            self.second_real_started = asyncio.Event()
-            self.real_count = 0
-
-        async def append_duplex_input_async(self, session_id: str, **kwargs):
-            kwargs.pop("expected_epoch", None)
-            result = await super().append_duplex_input_async(session_id, **kwargs)
-            payload = kwargs.get("payload")
-            is_silence = (
-                isinstance(payload, dict)
-                and payload.get("audio") == OmniDuplexSessionHandler._NATIVE_SILENCE_UNIT_PAYLOAD_AUDIO
-            )
-            if is_silence:
-                self.append_sequence.append("silence")
-            else:
-                self.real_count += 1
-                self.append_sequence.append(f"real-{self.real_count}")
-                if self.real_count == 1:
-                    self.first_real_started.set()
-                elif self.real_count == 2:
-                    self.second_real_started.set()
-            return result
-
-    session_created = asyncio.Event()
-    engine = SequencedAppendEngine()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-
-    def on_send(ws: TimedWebSocket, data: dict[str, Any]) -> None:
-        if data.get("type") != "session.created":
-            return
-        session = handler._registry.get("sid-native-real-before-silence")
-        assert session is not None
-        session.capabilities.chunk_period_ms = 50
-        ws.put(
-            {
-                "type": "input_audio_buffer.append",
-                "audio": _pcm_f32_b64(800),
-                "format": "pcm_f32le",
-                "sample_rate_hz": 16000,
-            }
-        )
-        session_created.set()
-
-    ws = TimedWebSocket(on_send=on_send, receive_timeout_s=2.0)
-    event = _native_session_create("sid-native-real-before-silence")
-    event["session"]["extra_body"]["auto_response"] = True
-    ws.put(event)
-    handler_task = asyncio.create_task(handler.handle_session(ws))
-
-    await asyncio.wait_for(session_created.wait(), timeout=1)
-    await asyncio.wait_for(engine.first_real_started.wait(), timeout=1)
-    await asyncio.sleep(0.02)
-    ws.put(
-        {
-            "type": "input_audio_buffer.append",
-            "audio": _pcm_f32_b64(800, value=0.07),
-            "format": "pcm_f32le",
-            "sample_rate_hz": 16000,
-        }
-    )
-    await asyncio.wait_for(engine.second_real_started.wait(), timeout=1)
-    ws.put({"type": "session.close"})
-    await asyncio.wait_for(handler_task, timeout=2)
-
-    assert engine.append_sequence[:2] == ["real-1", "real-2"]
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_auto_response_real_input_waits_for_submitted_silence_tail():
-    request_id = "duplex-sid-native-silence-tail-e0-stage0"
-
-    class SubmittedSilenceEngine(FakeEngineClient):
-        def __init__(self) -> None:
-            control_result = {
-                "operation": "append",
-                "session_id": "sid-native-silence-tail",
-                "ok": True,
-                "unsupported_count": 0,
-                "error_count": 0,
-                "stage_results": [
-                    {
-                        "result": {
-                            "data_plane_append": True,
-                            "request_id": request_id,
-                            "response_stage_id": 1,
-                        }
-                    }
-                ],
-            }
-            terminal_segment = _duplex_tts_output(
-                request_id=request_id,
-                samples=0,
-                finished=True,
-                tts_is_last_chunk=True,
-                token_ids=[151645],
-            )
-            super().__init__(
-                control_result=control_result,
-                collect_outputs=[[terminal_segment], [], []],
-                collect_delay_s=0.01,
-            )
-            self.silence_append_started = asyncio.Event()
-            self.release_silence_append = asyncio.Event()
-            self.append_sequence: list[str] = []
-            self.real_append_count = 0
-
-        async def append_duplex_input_async(self, session_id: str, **kwargs):
-            kwargs.pop("expected_epoch", None)
-            payload = kwargs.get("payload")
-            is_silence_continuation = (
-                isinstance(payload, dict)
-                and payload.get("format") == "pcm_f32le"
-                and payload.get("audio") == OmniDuplexSessionHandler._NATIVE_SILENCE_UNIT_PAYLOAD_AUDIO
-            )
-            if is_silence_continuation:
-                result = await super().append_duplex_input_async(session_id, **kwargs)
-                self.append_sequence.append("silence-started")
-                self.silence_append_started.set()
-                await self.release_silence_append.wait()
-                self.append_sequence.append("silence-returned")
-                return result
-            result = await super().append_duplex_input_async(session_id, **kwargs)
-            if (
-                isinstance(payload, dict)
-                and payload.get("audio") != OmniDuplexSessionHandler._NATIVE_SILENCE_UNIT_PAYLOAD_AUDIO
-            ):
-                self.real_append_count += 1
-                self.append_sequence.append(f"real-{self.real_append_count}")
-            return result
-
-    engine = SubmittedSilenceEngine()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-
-    def on_send(ws: TimedWebSocket, data: dict[str, Any]) -> None:
-        if data.get("type") != "session.created":
-            return
-        session = handler._registry.get("sid-native-silence-tail")
-        assert session is not None
-        session.capabilities.chunk_period_ms = 50
-        ws.put(
-            {
-                "type": "input_audio_buffer.append",
-                "audio": _pcm_f32_b64(800, value=0.05),
-                "format": "pcm_f32le",
-                "sample_rate_hz": 16000,
-            }
-        )
-
-    ws = TimedWebSocket(on_send=on_send, receive_timeout_s=2.0)
-    event = _native_session_create("sid-native-silence-tail")
-    event["session"]["extra_body"]["auto_response"] = True
-    ws.put(event)
-    handler_task = asyncio.create_task(handler.handle_session(ws))
-
-    await asyncio.wait_for(engine.silence_append_started.wait(), timeout=1)
-    ws.put(
-        {
-            "type": "input_audio_buffer.append",
-            "audio": _pcm_f32_b64(16000, value=0.07),
-            "format": "pcm_f32le",
-            "sample_rate_hz": 16000,
-        }
-    )
-    await asyncio.sleep(0.05)
-
-    assert engine.real_append_count == 1
-    assert engine.append_sequence == ["real-1", "silence-started"]
-
-    engine.release_silence_append.set()
-    ws.put({"type": "session.close"})
-    await asyncio.wait_for(handler_task, timeout=2)
-
-    assert engine.real_append_count == 2
-    assert engine.append_sequence == ["real-1", "silence-started", "silence-returned", "real-2"]
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_auto_response_preserves_silence_continuations_across_append_tails():
-    request_id = "duplex-sid-native-continuation-tails-e0-stage0"
-
-    class SequencedAppendEngine(FakeEngineClient):
-        def __init__(self) -> None:
-            control_result = {
-                "operation": "append",
-                "session_id": "sid-native-continuation-tails",
-                "ok": True,
-                "unsupported_count": 0,
-                "error_count": 0,
-                "stage_results": [
-                    {
-                        "result": {
-                            "data_plane_append": True,
-                            "request_id": request_id,
-                            "response_stage_id": 1,
-                        }
-                    }
-                ],
-            }
-            super().__init__(control_result=control_result)
-            self.real_append_started = asyncio.Event()
-            self.release_real_append = asyncio.Event()
-            self.first_silence_started = asyncio.Event()
-            self.release_first_silence = asyncio.Event()
-            self.second_silence_started = asyncio.Event()
-            self.release_collect = asyncio.Event()
-            self.silence_count = 0
-
-        async def append_duplex_input_async(self, session_id: str, **kwargs):
-            kwargs.pop("expected_epoch", None)
-            payload = kwargs.get("payload")
-            assert isinstance(payload, dict)
-            result = await super().append_duplex_input_async(session_id, **kwargs)
-            if payload.get("audio") != OmniDuplexSessionHandler._NATIVE_SILENCE_UNIT_PAYLOAD_AUDIO:
-                self.real_append_started.set()
-                await self.release_real_append.wait()
-                return result
-
-            self.silence_count += 1
-            if self.silence_count == 1:
-                self.first_silence_started.set()
-                await self.release_first_silence.wait()
-            else:
-                self.second_silence_started.set()
-            return result
-
-        async def collect_duplex_data_plane_outputs_async(
-            self,
-            request_id: str,
-            *,
-            response_stage_id: int | None = None,
-            timeout: float | None = None,
-        ) -> list[object]:
-            del timeout
-            self.collected.append((request_id, response_stage_id))
-            await self.release_collect.wait()
-            return []
-
-    session_created = asyncio.Event()
-
-    def on_send(_ws: TimedWebSocket, data: dict[str, Any]) -> None:
-        if data.get("type") == "session.created":
-            session_created.set()
-
-    engine = SequencedAppendEngine()
-    handler = OmniDuplexSessionHandler(
-        chat_service=FakeChatService(engine),
-        config_timeout_s=0.1,
-        idle_timeout_s=1,
-    )
-    ws = TimedWebSocket(on_send=on_send, receive_timeout_s=2.0)
-    event = _native_session_create("sid-native-continuation-tails")
-    event["session"]["extra_body"]["auto_response"] = True
-    ws.put(event)
-    ws.put(
-        {
-            "type": "input_audio_buffer.append",
-            "audio": _pcm_f32_b64(16000, value=0.05),
-            "format": "pcm_f32le",
-            "sample_rate_hz": 16000,
-        }
-    )
-    handler_task = asyncio.create_task(handler.handle_session(ws))
-
-    await asyncio.wait_for(session_created.wait(), timeout=1)
-    await asyncio.wait_for(engine.real_append_started.wait(), timeout=1)
-    session = handler._registry.get("sid-native-continuation-tails")
-    assert session is not None
-    session.capabilities.chunk_period_ms = 50
-    session.bind_request(request_id)
-    response_id = session.begin_response(turn_id=session.turn_id)
-    native = handler._runtime_session_state(session)
-    scheduler = native.silence_continuation_scheduler
-    assert scheduler is not None
-
-    payload = handler._native_silence_unit_payload()
-    payload["duplex_turn_id"] = session.turn_id
-    kwargs = {
-        "request_id": request_id,
-        "owner_id": f"response:{response_id}",
-        "response_id": response_id,
-        "response_owned": True,
-        "expected_epoch": session.epoch,
-        "expected_incarnation": session.incarnation,
-        "expected_model_turn_id": None,
-        "send_json": ws.send_json,
-    }
-    assert await scheduler(payload, **kwargs) is True
-
-    next_schedule = asyncio.create_task(scheduler(payload, **kwargs))
-    await asyncio.sleep(0.05)
-    assert not next_schedule.done()
-
-    engine.release_real_append.set()
-    await asyncio.wait_for(engine.first_silence_started.wait(), timeout=1)
-    assert not next_schedule.done()
-
-    engine.release_first_silence.set()
-    assert await asyncio.wait_for(next_schedule, timeout=1) is True
-    await asyncio.wait_for(engine.second_silence_started.wait(), timeout=1)
-    ws.put({"type": "session.close"})
-    await asyncio.wait_for(handler_task, timeout=2)
-
-    assert engine.silence_count == 2
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_duplex_uses_segment_text_metadata_for_transcript_cursor():
-    request_id = "duplex-sid-native-repeat-text-e0-stage0"
-
-    def _stage_output(
-        text: str,
-        samples: int,
-        *,
-        segment_text: str,
-        turn_id: int = 0,
-        turn_end: bool = False,
-        token_ids: list[int] | None = None,
-    ):
-        return SimpleNamespace(
-            request_id=request_id,
-            finished=False,
-            outputs=[
-                SimpleNamespace(
-                    text=text,
-                    token_ids=list(token_ids or []),
-                    multimodal_output={
-                        "audio": np.zeros(samples, dtype=np.float32),
-                        "sr": 24000,
-                        "meta.llm_output_text_utf8": np.frombuffer(segment_text.encode("utf-8"), dtype=np.uint8),
-                        "meta": {"duplex_turn_id": turn_id, "turn_end": turn_end},
-                    },
-                )
-            ],
-        )
-
-    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
-    session = DuplexSession(
-        session_id="sid-native-repeat-text",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    sent: list[dict[str, Any]] = []
-
-    async def send_json(payload: dict[str, Any]) -> None:
-        sent.append(payload)
-
-    async def emit(output: object) -> None:
-        result = {"data_plane_outputs": [output]}
-        for native_result in handler._serving_runtime_adapter.data_plane.project(
-            result,
-            context=_data_plane_context(session),
-        ):
-            await handler._send_one_native_duplex_event(send_json, native_result, session=session)
-
-    await emit(_stage_output("same reply", 24000, segment_text="same reply"))
-    await emit(
-        _stage_output("same replysame reply", 24000, segment_text="same reply", turn_end=True, token_ids=[151645])
-    )
-
-    await emit(_stage_output("same replysame replysame reply", 48000, segment_text="same reply", turn_id=1))
-    await emit(
-        _stage_output(
-            "same replysame replysame replysame reply",
-            48000,
-            segment_text="same reply",
-            turn_id=1,
-            turn_end=True,
-            token_ids=[151645],
-        )
-    )
-
-    created = [m for m in sent if m.get("type") == "response.created"]
-    done = [m for m in sent if m.get("type") == "response.done"]
-    deltas = [m for m in sent if m.get("type") == "response.output_audio.delta" and m.get("audio")]
-    protocol = NativeRealtimeSessionProtocol(TimedWebSocket())  # type: ignore[arg-type]
-    realtime_events = [event for payload in sent for event in protocol._from_duplex_event(payload)]
-    transcript_deltas = [
-        m for m in realtime_events if m.get("type") == "response.audio_transcript.delta" and m.get("delta")
-    ]
-    assert len(created) == 2
-    assert len(done) == 2
-    assert len(deltas) == 2
-    assert [m["text"] for m in deltas] == ["same reply", "same reply"]
-    assert [m["audio"] for m in deltas] == ["wav-24000", "wav-24000"]
-    assert [m["delta"] for m in transcript_deltas] == ["same reply", "same reply"]
-    assert [m["response_id"] for m in deltas] == [m["response_id"] for m in created]
-    assert [m["response_id"] for m in done] == [m["response_id"] for m in created]
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_duplex_continuous_speak_reuses_active_response_until_turn_end():
-    request_id = "duplex-sid-native-continuous-speak-e0-stage0"
-
-    def _stage_output(
-        text: str,
-        samples: int,
-        *,
-        turn_end: bool = False,
-        token_ids: list[int] | None = None,
-    ):
-        return SimpleNamespace(
-            request_id=request_id,
-            finished=turn_end,
-            outputs=[
-                SimpleNamespace(
-                    text=text,
-                    token_ids=list(token_ids or []),
-                    multimodal_output={},
-                )
-            ],
-            multimodal_output={
-                "audio": np.zeros(samples, dtype=np.float32),
-                "sr": 24000,
-                "meta.duplex_turn_id": np.array([0], dtype=np.int32),
-                "meta.duplex_epoch": np.array([0], dtype=np.int32),
-                "meta.turn_end": np.array([int(turn_end)], dtype=np.int32),
-                "meta.tts_is_last_chunk": np.array([int(turn_end)], dtype=np.int32),
-            },
-        )
-
-    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
-    session = DuplexSession(
-        session_id="sid-native-continuous-speak",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    sent: list[dict[str, Any]] = []
-
-    async def send_json(payload: dict[str, Any]) -> None:
-        sent.append(payload)
-
-    async def emit(output: object) -> None:
-        result = {"data_plane_outputs": [output]}
-        for native_result in handler._serving_runtime_adapter.data_plane.project(
-            result,
-            context=_data_plane_context(session),
-        ):
-            await handler._send_one_native_duplex_event(send_json, native_result, session=session)
-
-    await emit(_stage_output("hello", 24000))
-    await emit(_stage_output("hello again", 48000))
-
-    created = [m for m in sent if m.get("type") == "response.created"]
-    deltas = [m for m in sent if m.get("type") == "response.output_audio.delta" and m.get("audio")]
-    assert len(created) == 1
-    assert len(deltas) == 2
-    assert {m["response_id"] for m in deltas} == {created[0]["response_id"]}
-    assert "response.done" not in [m.get("type") for m in sent]
-
-    await emit(_stage_output("hello again", 48000, turn_end=True, token_ids=[151645]))
-
-    done = [m for m in sent if m.get("type") == "response.done"]
-    assert len(done) == 1
-    assert done[0]["response_id"] == created[0]["response_id"]
-    assert session.active_response_id is None
-    assert session.turn_id == 1
-
-
-@pytest.mark.asyncio
-async def test_continuous_response_metrics_accumulate_only_owned_model_units():
-    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
-    session = DuplexSession(
-        session_id="sid-response-metrics",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    sent: list[dict[str, Any]] = []
-
-    async def send_json(payload: dict[str, Any]) -> None:
-        sent.append(payload)
-
-    async def emit(*, text: str, audio: str, tokens: int, ttft_ms: float, itls: list[float]) -> None:
-        await handler._send_one_native_duplex_event(
-            send_json,
-            {
-                "supported": True,
-                "stage_role": "tts",
-                "is_listen": False,
-                "data_plane_request_id": "duplex-sid-response-metrics-e0-stage0",
-                "text": text,
-                "audio_data": audio,
-                "audio_format": "pcm16",
-                "audio_duration_ms": 100,
-                "end_of_turn": False,
-                "model_turn_id": 0,
-                "stage_metrics": {
-                    "0": {
-                        "num_tokens_out": tokens,
-                        "stage_gen_time_ms": 80.0,
-                        "vllm_ttft_ms": ttft_ms,
-                        "vllm_tpot_ms": 9.0,
-                        "vllm_itls_ms": itls,
-                    }
-                },
-            },
-            session=session,
-        )
-
-    await emit(text="first", audio="audio-a", tokens=4, ttft_ms=50.0, itls=[10.0, 11.0])
-    await emit(text="second", audio="audio-b", tokens=6, ttft_ms=70.0, itls=[12.0, 13.0, 14.0])
-
-    deltas = [payload for payload in sent if payload.get("type") == "response.output_audio.delta"]
-    assert len(deltas) == 2
-    first_metrics = deltas[0]["vllm_omni"]["stage_metrics"]["0"]
-    second_metrics = deltas[1]["vllm_omni"]["stage_metrics"]["0"]
-    assert first_metrics["num_tokens_out"] == 4
-    assert second_metrics["num_tokens_out"] == 10
-    assert second_metrics["vllm_ttft_ms"] == 50.0
-    assert second_metrics["vllm_itls_ms"] == [10.0, 11.0, 12.0, 13.0, 14.0]
-
-    first_response_id = deltas[0]["response_id"]
-    session.end_response()
-    await emit(text="third", audio="audio-c", tokens=3, ttft_ms=90.0, itls=[15.0, 16.0])
-
-    third_delta = [payload for payload in sent if payload.get("type") == "response.output_audio.delta"][-1]
-    third_metrics = third_delta["vllm_omni"]["stage_metrics"]["0"]
-    assert third_delta["response_id"] != first_response_id
-    assert third_metrics["num_tokens_out"] == 3
-    assert third_metrics["vllm_ttft_ms"] == 90.0
-    assert third_metrics["vllm_itls_ms"] == [15.0, 16.0]
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_duplex_drops_old_turn_audio_while_new_response_is_active():
-    request_id = "duplex-sid-native-old-turn-audio-e0-stage0"
-    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
-    session = DuplexSession(
-        session_id="sid-native-old-turn-audio",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    response_id = session.begin_response(turn_id=1)
-    session.turn_id = 2
-    session.bind_request(request_id)
-    ws = TimedWebSocket()
-
-    close_reason, emitted = await handler._send_one_native_duplex_event(
-        ws.send_json,
-        {
-            "supported": True,
-            "stage_role": "tts",
-            "is_listen": False,
-            "data_plane_request_id": request_id,
-            "text": "stale",
-            "audio_data": "old-audio",
-            "audio_format": "pcm16",
-            "audio_duration_ms": 100,
-            "end_of_turn": False,
-            "model_turn_id": 0,
-            "uses_model_runner_scheduler": True,
-            "runner_kv_backed": True,
-            "runtime_impl": "scheduler_data_plane",
-        },
-        session=session,
-        expected_epoch=session.epoch,
-    )
-
-    assert close_reason is None
-    assert emitted is False
-    assert session.active_response_id == response_id
-    assert ws.sent == []
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_duplex_future_turn_audio_starts_next_response():
-    request_id = "duplex-sid-native-future-turn-audio-e0-stage0"
-    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
-    session = DuplexSession(
-        session_id="sid-native-future-turn-audio",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    first_response_id = session.begin_response(turn_id=0)
-    session.bind_request(request_id)
-    ws = TimedWebSocket()
-
-    close_reason, emitted = await handler._send_one_native_duplex_event(
-        ws.send_json,
-        {
-            "supported": True,
-            "stage_role": "tts",
-            "is_listen": False,
-            "data_plane_request_id": request_id,
-            "text": "next",
-            "audio_data": "next-audio",
-            "audio_format": "pcm16",
-            "audio_duration_ms": 100,
-            "end_of_turn": False,
-            "model_turn_id": 1,
-            "uses_model_runner_scheduler": True,
-            "runner_kv_backed": True,
-            "runtime_impl": "scheduler_data_plane",
-        },
-        session=session,
-        expected_epoch=session.epoch,
-    )
-
-    assert close_reason is None
-    assert emitted is True
-    sent_types = [event["type"] for event in ws.sent]
-    assert sent_types == [
-        "response.done",
-        "response.created",
-        "response.speak",
-        "response.output_audio.delta",
-    ]
-    assert ws.sent[0]["response_id"] == first_response_id
-    assert ws.sent[1]["response_id"] != first_response_id
-    assert ws.sent[3]["response_id"] == ws.sent[1]["response_id"]
-    assert ws.sent[3]["vllm_omni"]["model_turn_id"] == 1
-    assert session.active_response_turn_id == 1
-    assert session.turn_id == 1
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_duplex_drops_old_turn_listen_while_new_response_is_active():
-    request_id = "duplex-sid-native-old-turn-listen-e0-stage0"
-    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(FakeEngineClient()))
-    session = DuplexSession(
-        session_id="sid-native-old-turn-listen",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    response_id = session.begin_response(turn_id=1)
-    session.turn_id = 2
-    session.bind_request(request_id)
-    ws = TimedWebSocket()
-
-    close_reason, emitted = await handler._send_one_native_duplex_event(
-        ws.send_json,
-        {
-            "supported": True,
-            "stage_role": "llm",
-            "is_listen": True,
-            "model_listen": True,
-            "data_plane_request_id": request_id,
-            "end_of_turn": False,
-            "model_turn_id": 0,
-            "uses_model_runner_scheduler": True,
-            "runner_kv_backed": True,
-            "runtime_impl": "scheduler_data_plane",
-        },
-        session=session,
-        expected_epoch=session.epoch,
-    )
-
-    assert close_reason is None
-    assert emitted is False
-    assert session.active_response_id == response_id
-    assert ws.sent == []
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_duplex_silence_continuation_requires_active_request():
-    engine = FakeEngineClient()
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-    session = DuplexSession(
-        session_id="sid-native-stale-continuation",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    session.begin_response()
-    session.bind_request("duplex-sid-native-stale-continuation-stage0")
-    session.mark_audio_sent(100)
-    sent: list[dict[str, Any]] = []
-
-    async def send_json(data: dict[str, Any]) -> None:
-        sent.append(data)
-
-    _install_direct_silence_scheduler(handler, session)
-
-    await handler._maybe_continue_native_response(send_json, session=session, expected_epoch=session.epoch)
-    session.clear_request()
-    await asyncio.sleep(0.01)
-
-    assert engine.appended == []
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_auto_response_segment_complete_continues_until_model_listen():
-    engine = FakeEngineClient()
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-    session = DuplexSession(
-        session_id="sid-native-segment-complete",
-        config=DuplexSessionConfig(extra_body={"auto_response": True}),
-    )
-    session.capabilities = minicpmo45_native_capabilities()
-    response_id = session.begin_response()
-    request_id = "duplex-sid-native-segment-complete-stage0"
-    session.bind_request(request_id)
-    session.mark_audio_sent(1000)
-    _install_direct_silence_scheduler(handler, session)
-    sent: list[dict[str, Any]] = []
-
-    async def send_json(data: dict[str, Any]) -> None:
-        sent.append(data)
-
-    close_reason, emitted = await handler._send_one_native_duplex_event(
-        send_json,
-        {
-            "supported": True,
-            "stage_role": "llm",
-            "is_listen": True,
-            "model_listen": False,
-            "listen_source": "auto_response_segment_complete",
-            "reason": "auto_response_segment_complete",
-            "data_plane_request_id": request_id,
-            "end_of_turn": False,
-            "uses_model_runner_scheduler": True,
-            "runner_kv_backed": True,
-            "runtime_impl": "scheduler_data_plane",
-            "owned_runtime": False,
-        },
-        session=session,
-        expected_epoch=session.epoch,
-    )
-    await asyncio.sleep(0.01)
-
-    assert close_reason is None
-    assert emitted is False
-    assert session.active_response_id == response_id
-    assert session.active_request_id == request_id
-    assert not handler._serving_runtime_adapter.data_plane.is_terminal(request_id)
-    assert sent == []
-    assert len(engine.appended) == 1
-    _, mode, payload, final = engine.appended[0]
-    assert mode == "append_audio_chunk"
-    assert payload["type"] == "audio"
-    assert payload.get("force_listen") is not True
-    assert final is False
-
-
-@pytest.mark.parametrize(
-    ("steps", "expected_deltas"),
-    [
-        (
-            [("你好呀", 1), ("你好呀", 1), ("你好呀", 2)],
-            ["你好呀", "", "你好呀"],
-        ),
-        (
-            [("你好呀", 1), ("你好呀", 2)],
-            ["你好呀", "你好呀"],
-        ),
-    ],
-    ids=["turn-scoped", "exact-repeated-turn-text"],
-)
-def test_minicpmo_data_plane_text_cursor(
-    steps: list[tuple[str, int]],
-    expected_deltas: list[str],
-):
-    data_plane = _test_data_plane()
-    request_id = "duplex-sid-native-e0-stage0"
-
-    deltas = [data_plane.segment_text_delta(request_id, text, turn_id=turn_id) for text, turn_id in steps]
-
-    assert deltas == expected_deltas
-
-
-def test_minicpmo_data_plane_text_cursor_does_not_clip_prior_turn_overlap():
-    data_plane = _test_data_plane()
-    request_id = "duplex-sid-native-e0-stage0"
-
-    assert data_plane.segment_text_delta(request_id, "你好呀。你有什么想聊的吗？", turn_id=1)
-    assert (
-        data_plane.segment_text_delta(request_id, "你有什么想聊的吗？你好呀。", turn_id=2)
-        == "你有什么想聊的吗？你好呀。"
-    )
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_duplex_cancel_interrupts_background_data_plane_stream():
-    control_result = {
-        "operation": "append",
-        "session_id": "sid-native-cancel-stream",
-        "ok": True,
-        "unsupported_count": 0,
-        "error_count": 0,
-        "stage_results": [
-            {
-                "stage_id": 0,
-                "replica_id": 0,
-                "result": {
-                    "supported": True,
-                    "implementation_level": "model_native_duplex",
-                    "data_plane_append": True,
-                    "request_id": "duplex-sid-native-cancel-stream-e0-stage0-s1",
-                    "response_stage_id": 1,
-                },
-            }
-        ],
-    }
-    engine = FakeEngineClient(
-        append_result=control_result,
-        collect_delay_s=0.2,
-        collect_outputs=[
-            [
-                SimpleNamespace(
-                    request_id="duplex-sid-native-cancel-stream-e0-stage0-s1",
-                    finished=True,
-                    outputs=[
-                        SimpleNamespace(
-                            text="",
-                            multimodal_output={"audio": np.zeros(10, dtype=np.float32), "sr": 24000},
-                        )
-                    ],
-                )
-            ]
-        ],
-    )
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-native-cancel-stream"))
-    ws.put({"type": "input_audio_buffer.append", "audio": "AAAA", "format": "pcm_f32le"})
-    ws.put({"type": "input.cancel"})
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    assert "audio.cancelled" in ws.sent_types()
-    assert "response.output_audio.delta" not in ws.sent_types()
-    assert engine.signals == [("sid-native-cancel-stream", "barge_in")]
-    assert engine.signal_fences == [DuplexFence("sid-native-cancel-stream")]
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_duplex_session_close_discards_partial_pcm_tail():
-    engine = FakeEngineClient()
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=1)
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-native-short-chunks"))
-    chunk = _pcm_f32_b64(3200)
-    for _ in range(6):
-        ws.put(
-            {
-                "type": "input_audio_buffer.append",
-                "audio": chunk,
-                "format": "pcm_f32le",
-                "sample_rate_hz": 16000,
-            }
-        )
-    ws.put({"type": "session.close"})
-
-    await handler.handle_session(ws)
-
-    assert len(engine.appended) == 1
-    _, mode, payload, final = engine.appended[0]
-    assert mode == "append_audio_chunk"
-    assert final is False
-    assert isinstance(payload, dict)
-    assert len(base64.b64decode(payload["audio"])) == 16000 * 4
-    assert "duplex_num_input_tokens" not in payload
-
-
-@pytest.mark.asyncio
-async def test_minicpmo_native_duplex_idle_timeout_closes_runtime_with_timeout_reason():
-    engine = FakeEngineClient()
-    chat_service = FakeChatService(engine)
-    handler = OmniDuplexSessionHandler(chat_service=chat_service, config_timeout_s=0.1, idle_timeout_s=0.1)
-    ws = TimedWebSocket()
-    ws.put(_native_session_create("sid-native-timeout"))
-
-    await handler.handle_session(ws)
-
-    assert ws.sent_types() == ["session.created", "session.closed"]
-    assert ws.sent[-1]["reason"] == "timeout"
-    assert engine.closed == [("sid-native-timeout", "timeout")]
diff --git a/tests/entrypoints/openai_api/test_gepard_tts_adapter.py b/tests/entrypoints/openai_api/test_gepard_tts_adapter.py
new file mode 100644
index 000000000..f9e1e3dd2
--- /dev/null
+++ b/tests/entrypoints/openai_api/test_gepard_tts_adapter.py
@@ -0,0 +1,276 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""CPU tests for the Gepard-1.0 speech adapter.
+
+Covers detection, the reject matrix, voice default, empty input, extra_params,
+max_new_tokens frame bounds, and build() parity with the offline prompt helper.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from types import SimpleNamespace
+
+import pytest
+import torch
+from pydantic import ValidationError
+from pytest_mock import MockerFixture
+
+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 import detect_tts_model_type, resolve_adapter
+from vllm_omni.entrypoints.openai.tts_adapters.base import SpeechServingContext
+from vllm_omni.entrypoints.openai.tts_adapters.gepard import GepardAdapter
+from vllm_omni.model_executor.models.gepard.configuration_gepard import GepardConfig
+from vllm_omni.model_executor.models.gepard.prompt import build_gepard_prompt_ids
+from vllm_omni.outputs import OmniRequestOutput
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+_MODEL = "nineninesix/gepard-1.0"
+
+
+def _adapter(*, revision: str | None = None) -> GepardAdapter:
+    engine = SimpleNamespace(model_config=SimpleNamespace(model=_MODEL, revision=revision))
+    return GepardAdapter(SpeechServingContext(server=SimpleNamespace(engine_client=engine), engine_client=engine))
+
+
+def test_gepard_detection_and_registration() -> None:
+    assert resolve_adapter("gepard") is GepardAdapter
+    assert GepardAdapter.stage_keys == {"gepard"}
+    assert GepardAdapter.model_archs == {"GepardTalkerForConditionalGeneration"}
+    assert detect_tts_model_type("gepard", None) == "gepard"
+    assert detect_tts_model_type("gepard", "GepardTalkerForConditionalGeneration") == "gepard"
+    assert detect_tts_model_type(None, "GepardTalkerForConditionalGeneration") == "gepard"
+
+
+def test_gepard_accepts_omitted_and_default_voice() -> None:
+    adapter = _adapter()
+    assert adapter.validate(OpenAICreateSpeechRequest(input="Hello from Gepard.")) is None
+    assert adapter.validate(OpenAICreateSpeechRequest(input="Hello from Gepard.", voice="default")) is None
+    assert adapter.validate(OpenAICreateSpeechRequest(input="Hello from Gepard.", voice="Default")) is None
+    assert (
+        adapter.validate(
+            OpenAICreateSpeechRequest.model_validate({"input": "Hello from Gepard.", "speaker": "default"})
+        )
+        is None
+    )
+
+
+@pytest.mark.parametrize(
+    ("kwargs", "field"),
+    [
+        ({"voice": "vivian"}, "voice"),
+        ({"speed": 1.2}, "speed"),
+        ({"extra_params": {"temperature": 0.3}}, "extra_params"),
+        ({"extra_params": {"top_p": 0.9}}, "extra_params"),
+        ({"extra_params": {"top_k": 20}}, "extra_params"),
+        ({"extra_params": {"foo": 1}}, "extra_params"),
+        ({"ref_audio": "https://example.com/ref.wav"}, "ref_audio"),
+        ({"ref_text": "transcript"}, "ref_text"),
+        ({"ref_audio_2": "https://example.com/ref2.wav"}, "ref_audio_2"),
+        ({"speaker_embedding": [0.1, 0.2]}, "speaker_embedding"),
+        ({"x_vector_only_mode": True}, "x_vector_only_mode"),
+        ({"task_type": "Base"}, "task_type"),
+        ({"non_streaming_mode": True}, "non_streaming_mode"),
+        ({"instructions": "speak happily"}, "instructions"),
+        ({"language": "English"}, "language"),
+        ({"ambient_sound": "rain"}, "ambient_sound"),
+        ({"duration_seconds": 2.0}, "duration_seconds"),
+        ({"initial_codec_chunk_frames": 4}, "initial_codec_chunk_frames"),
+        ({"word_timestamps": True}, "word_timestamps"),
+        ({"response_format": "opus"}, "opus"),
+    ],
+)
+def test_gepard_rejects_unsupported_fields(kwargs: dict, field: str) -> None:
+    adapter = _adapter()
+    err = adapter.validate(OpenAICreateSpeechRequest(input="Hello from Gepard.", **kwargs))
+    assert err is not None
+    assert field in err
+
+
+@pytest.mark.parametrize("text", ["", "   ", "\n\t"])
+def test_gepard_rejects_empty_input(text: str) -> None:
+    adapter = _adapter()
+    err = adapter.validate(OpenAICreateSpeechRequest(input=text))
+    assert err is not None
+    assert "empty" in err.lower()
+
+
+@pytest.mark.parametrize("max_new_tokens", [0, -1])
+def test_gepard_schema_rejects_non_positive_max_new_tokens(max_new_tokens: int) -> None:
+    with pytest.raises(ValidationError, match="greater than or equal to 1"):
+        OpenAICreateSpeechRequest(input="Hello from Gepard.", max_new_tokens=max_new_tokens)
+
+
+def test_gepard_rejects_max_new_tokens_above_frame_budget() -> None:
+    adapter = _adapter()
+    err = adapter.validate(OpenAICreateSpeechRequest(input="Hello from Gepard.", max_new_tokens=4097))
+    assert err is not None
+    assert "max_new_tokens" in err
+    assert "frames" in err
+
+
+def test_gepard_accepts_max_new_tokens_bounds() -> None:
+    adapter = _adapter()
+    assert adapter.validate(OpenAICreateSpeechRequest(input="Hello from Gepard.", max_new_tokens=1)) is None
+    assert adapter.validate(OpenAICreateSpeechRequest(input="Hello from Gepard.", max_new_tokens=4096)) is None
+
+
+def test_gepard_apply_sampling_overrides_uses_frames() -> None:
+    adapter = _adapter()
+    stage_defaults = [SimpleNamespace(max_tokens=1000)]
+    overridden = adapter.apply_sampling_overrides(
+        stage_defaults,
+        OpenAICreateSpeechRequest(input="Hello from Gepard.", max_new_tokens=32),
+    )
+    assert overridden[0].max_tokens == 32
+    assert stage_defaults[0].max_tokens == 1000
+
+
+def test_gepard_build_matches_offline_prompt_builder(monkeypatch) -> None:
+    adapter = _adapter()
+    cfg = GepardConfig()
+    monkeypatch.setattr(
+        "vllm_omni.model_executor.models.gepard.configuration_gepard.GepardConfig.from_checkpoint",
+        staticmethod(lambda *_a, **_k: cfg),
+    )
+
+    class _Tok:
+        def __call__(self, text, add_special_tokens=False):
+            return {"input_ids": [11, 12, 13]}
+
+    adapter._tokenizer = _Tok()
+    adapter._gepard_config = cfg
+    text = "Hello from Gepard."
+    prepared = asyncio.run(adapter.build(OpenAICreateSpeechRequest(input=text, seed=7), [], False))
+
+    expected = build_gepard_prompt_ids([11, 12, 13], config=cfg)
+    assert prepared.prompt["prompt_token_ids"] == expected
+    assert prepared.prompt["additional_information"] == {"text": [text]}
+    assert prepared.model_type == "gepard"
+    assert prepared.output_policy.accumulate_nonstreaming is True
+
+
+def test_gepard_loads_tokenizer_and_config_at_served_revision(monkeypatch) -> None:
+    adapter = _adapter(revision="abc123")
+    seen: dict[str, object] = {}
+
+    def fake_from_checkpoint(model, backbone_config=None, revision=None):
+        seen["config"] = (model, revision)
+        return GepardConfig()
+
+    class _Tok:
+        def __init__(self, *args, **kwargs):
+            seen["tok"] = (args[0] if args else None, kwargs.get("revision"))
+
+        def __call__(self, text, add_special_tokens=False):
+            return {"input_ids": [11, 12, 13]}
+
+    monkeypatch.setattr(
+        "vllm_omni.model_executor.models.gepard.configuration_gepard.GepardConfig.from_checkpoint",
+        staticmethod(fake_from_checkpoint),
+    )
+    monkeypatch.setattr("transformers.AutoTokenizer.from_pretrained", _Tok)
+    prepared = asyncio.run(adapter.build(OpenAICreateSpeechRequest(input="Hello from Gepard."), [], False))
+    assert seen["config"] == (_MODEL, "abc123")
+    assert seen["tok"] == (_MODEL, "abc123")
+    assert prepared.prompt["prompt_token_ids"] == build_gepard_prompt_ids([11, 12, 13], config=GepardConfig())
+
+
+def _gepard_mock_output(sample_rate: int = 22050, num_samples: int = 2048) -> OmniRequestOutput:
+    class MockCompletionOutput:
+        def __init__(self) -> None:
+            self.index = 0
+            self.text = ""
+            self.token_ids: list[int] = []
+            self.finish_reason = "stop"
+            self.stop_reason = None
+            self.logprobs = None
+
+    class MockRequestOutput:
+        def __init__(self) -> None:
+            self.request_id = "speech-gepard-mock"
+            self.outputs = [MockCompletionOutput()]
+            self.multimodal_output = {
+                "audio": torch.zeros(num_samples),
+                "sr": torch.tensor(sample_rate),
+            }
+            self.finished = True
+            self.prompt_token_ids = None
+            self.encoder_prompt_token_ids = None
+            self.num_cached_tokens = None
+            self.prompt_logprobs = None
+            self.kv_transfer_params = None
+
+    output = OmniRequestOutput.from_stage_output(MockRequestOutput(), stage_id=0, final_output_type="audio")
+    output.metrics = {"stage_metrics": {"0": {"num_tokens_in": 0, "num_tokens_out": 2}}}
+    return output
+
+
+@pytest.fixture
+def gepard_server(mocker: MockerFixture):
+    mocker.patch(
+        "vllm_omni.entrypoints.openai.tts_adapters.base.load_supported_speakers",
+        return_value={"default"},
+    )
+    mocker.patch(
+        "vllm_omni.entrypoints.openai.tts_adapters.base.load_codec_frame_rate",
+        return_value=22050.0,
+    )
+
+    async def _gen(*_args, **_kwargs):
+        yield _gepard_mock_output()
+
+    mock_engine_client = mocker.MagicMock()
+    mock_engine_client.errored = False
+    mock_engine_client.model_config = mocker.MagicMock(model=_MODEL, async_chunk=False, revision=None)
+    mock_engine_client.default_sampling_params_list = [SimpleNamespace(max_tokens=1000, seed=42, extra_args=None)]
+    mock_engine_client.tts_batch_max_items = 32
+    mock_engine_client.generate = mocker.MagicMock(side_effect=lambda **_k: _gen())
+    mock_engine_client.stage_configs = [
+        SimpleNamespace(
+            engine_args=SimpleNamespace(model_stage="gepard", model_arch="GepardTalkerForConditionalGeneration"),
+            tts_args={},
+        )
+    ]
+
+    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(),
+    )
+    cfg = GepardConfig()
+    server._adapter._gepard_config = cfg
+    server._adapter._tokenizer = lambda text, add_special_tokens=False: {"input_ids": [11, 12, 13]}
+    yield server
+    server.shutdown()
+
+
+def test_gepard_prepare_uses_prompt_builder(gepard_server) -> None:
+    request_id, _generator, _ = asyncio.run(
+        gepard_server._prepare_speech_generation(OpenAICreateSpeechRequest(input="Hello from Gepard."))
+    )
+    assert request_id.startswith("speech-")
+    prompt = gepard_server.engine_client.generate.call_args.kwargs["prompt"]
+    assert prompt["prompt_token_ids"] == build_gepard_prompt_ids([11, 12, 13], config=GepardConfig())
+
+
+@pytest.mark.parametrize("response_format", ["wav", "pcm", "flac", "mp3"])
+def test_gepard_mocked_engine_encodes_response_formats(gepard_server, response_format: str) -> None:
+    audio, media_type = asyncio.run(
+        gepard_server._generate_audio_bytes(
+            OpenAICreateSpeechRequest(input="Hello from Gepard.", response_format=response_format)
+        )
+    )
+    assert isinstance(audio, (bytes, str))
+    assert len(audio) > 0
+    expected_media_type = {"wav": "audio/wav", "pcm": "audio/pcm", "flac": "audio/flac", "mp3": "audio/mpeg"}
+    assert media_type == expected_media_type[response_format]
+
+
+def test_gepard_streaming_rejects_non_pcm_wav() -> None:
+    with pytest.raises(ValidationError, match="requires response_format='pcm' or 'wav'"):
+        OpenAICreateSpeechRequest(input="Hello from Gepard.", stream=True, response_format="mp3")
diff --git a/tests/entrypoints/openai_api/test_image_api_utils.py b/tests/entrypoints/openai_api/test_image_api_utils.py
new file mode 100644
index 000000000..31bc36c5e
--- /dev/null
+++ b/tests/entrypoints/openai_api/test_image_api_utils.py
@@ -0,0 +1,54 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""L1 tests for the image response encoder's compression contract."""
+
+import base64
+import io
+
+import pytest
+from PIL import Image
+
+from vllm_omni.entrypoints.openai.image_api_utils import (
+    encode_image_base64_with_compression,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+@pytest.fixture(scope="module")
+def image():
+    # Photographic-content proxy: noise-plus-gradient content compresses very
+    # differently across PNG compress levels, which is what the mapping under
+    # test controls.
+    import numpy as np
+
+    rng = np.random.default_rng(0)
+    grad = np.linspace(0, 255, 256, dtype=np.float32)
+    arr = np.clip(grad[None, :, None] + rng.integers(-24, 25, (256, 256, 3)), 0, 255).astype(np.uint8)
+    return Image.fromarray(arr, mode="RGB")
+
+
+def test_png_output_compression_maps_to_compress_level(image):
+    """output_compression 100 -> compress_level 0, 1 -> compress_level 9."""
+
+    def encode(compression):
+        buffer = io.BytesIO()
+        image.save(buffer, format="PNG", compress_level=max(0, min(9, 9 - compression // 11)))
+        return len(base64.b64encode(buffer.getvalue()))
+
+    fast = encode_image_base64_with_compression(image, format="png", output_compression=100)
+    small = encode_image_base64_with_compression(image, format="png", output_compression=1)
+
+    # Level-0 PNG barely compresses; the mapped level-9 encode is smaller.
+    assert len(small) < len(fast)
+    # The mapping must produce the same sizes as the equivalent compress_level.
+    assert len(fast) == encode(100)
+    assert len(small) == encode(1)
+
+
+def test_jpeg_output_compression_maps_to_quality(image):
+    high = base64.b64decode(encode_image_base64_with_compression(image, format="jpeg", output_compression=100))
+    low = base64.b64decode(encode_image_base64_with_compression(image, format="jpeg", output_compression=10))
+
+    assert len(high) > len(low)
diff --git a/tests/entrypoints/openai_api/test_image_protocol.py b/tests/entrypoints/openai_api/test_image_protocol.py
new file mode 100644
index 000000000..b77038933
--- /dev/null
+++ b/tests/entrypoints/openai_api/test_image_protocol.py
@@ -0,0 +1,75 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import base64
+import io
+import zipfile
+
+import pytest
+from fastapi.responses import StreamingResponse
+
+from vllm_omni.entrypoints.openai.protocol.images import (
+    _FILE_RESPONSE_CHUNK_SIZE,
+    ImageData,
+    ImageGenerationResponse,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+_NEWLINE_HEAVY_PAYLOAD = (b"\x89PNG\n\x1a\n" * 64) + bytes(range(256)) * 8
+
+
+def _response(*payloads: bytes) -> ImageGenerationResponse:
+    return ImageGenerationResponse(
+        created=0,
+        data=[ImageData(b64_json=base64.b64encode(payload).decode()) for payload in payloads],
+        output_format="png",
+        size="1x1",
+    )
+
+
+async def _collect(response: StreamingResponse) -> list[bytes]:
+    return [bytes(chunk) async for chunk in response.body_iterator]
+
+
+@pytest.mark.asyncio
+async def test_single_file_response_chunks_ignore_newlines() -> None:
+    payload = _NEWLINE_HEAVY_PAYLOAD
+    assert b"\n" in payload
+
+    response = _response(payload).stream_response()
+    chunks = await _collect(response)
+
+    assert len(chunks) == 1
+    assert b"".join(chunks) == payload
+    assert response.headers["content-length"] == str(len(payload))
+    assert response.headers["content-type"] == "image/png"
+
+
+@pytest.mark.asyncio
+async def test_single_file_response_chunks_are_bounded() -> None:
+    payload = _NEWLINE_HEAVY_PAYLOAD * 200
+    expected_chunks = -(-len(payload) // _FILE_RESPONSE_CHUNK_SIZE)
+    assert expected_chunks > 1
+
+    chunks = await _collect(_response(payload).stream_response())
+
+    assert len(chunks) == expected_chunks
+    assert max(len(chunk) for chunk in chunks) <= _FILE_RESPONSE_CHUNK_SIZE
+    assert b"".join(chunks) == payload
+
+
+@pytest.mark.asyncio
+async def test_zip_file_response_streams_whole_archive() -> None:
+    payloads = (_NEWLINE_HEAVY_PAYLOAD, b"second image\nwith a newline")
+
+    response = _response(*payloads).stream_response()
+    chunks = await _collect(response)
+
+    zip_bytes = b"".join(chunks)
+    assert len(chunks) == -(-len(zip_bytes) // _FILE_RESPONSE_CHUNK_SIZE)
+    assert response.headers["content-length"] == str(len(zip_bytes))
+    assert response.headers["content-type"] == "application/zip"
+    with zipfile.ZipFile(io.BytesIO(zip_bytes)) as archive:
+        assert archive.read("image_0.png") == payloads[0]
+        assert archive.read("image_1.png") == payloads[1]
diff --git a/tests/entrypoints/openai_api/test_image_server.py b/tests/entrypoints/openai_api/test_image_server.py
index 989b65b1e..2f23d7c8d 100644
--- a/tests/entrypoints/openai_api/test_image_server.py
+++ b/tests/entrypoints/openai_api/test_image_server.py
@@ -2314,3 +2314,72 @@ def test_image_edits_size_auto_preserves_bridge_size(async_omni_stage_configs_on
         assert captured_prompt["prompt"].count("<img>") == 2, (
             f"N=2 reference images must emit 2 <img> placeholders in AR prompt; got {captured_prompt[KEY].count(IMG)} -- prompt: {captured_prompt[KEY]!r}"
         )
+
+
+@pytest.mark.xfail(
+    strict=True,
+    reason=(
+        "Pre-existing gap, not introduced by this change: the /v1/images/edits route in "
+        "api_server.py never calls resolve_stop_token_ids at all (grep: api_server.py has "
+        "no stop_token_ids reference), so the AR stage keeps SamplingParams' default empty "
+        "list. The omitted-bot_task fix landed in serving_chat.py, which is the only "
+        "production caller; that path is covered by "
+        "test_serving_chat_multistage_generation.py::"
+        "test_build_multistage_generation_inputs_omitted_bot_task_matches_prompt_default. "
+        "Wiring the images/edits route through the same seam needs a tokenizer in that "
+        "scope and a decision on whether HunyuanImage3 it2i should resolve AR stop tokens "
+        "unconditionally (today the whole AR block is gated on an explicit bot_task / "
+        "use_system_prompt / system_prompt), so it is tracked separately."
+    ),
+)
+def test_image_edits_omitted_bot_task_stop_tokens_match_prompt_default(
+    async_omni_stage_configs_only_client,
+):
+    """Regression: an omitted bot_task must resolve identically for the AR
+    prompt and its stop_token_ids.
+
+    build_prompt/build_prompt_tokens default an omitted bot_task per-task
+    (e.g. "think" for the base "it2i" task, since it isn't itself a key in
+    _TASK_PRESETS). resolve_stop_token_ids must land on that same default
+    to compute the matching stop set. Passing the raw (still-None) outer
+    bot_task variable to resolve_stop_token_ids -- instead of mirroring
+    build_kwargs's own omitted-or-not "bot_task" entry -- made it normalize
+    bot_task=None instead of "think", so it fell through to the full
+    <img_ratio_*> stop range instead of the think/recaption-only pair.
+
+    An explicit (non-"auto") size is required to reach this: with
+    need_ratio=True (size="auto"), resolve_stop_token_ids returns the full
+    ratio range regardless of bot_task, so the two code paths only visibly
+    disagree once a concrete size selects the narrower think/recaption stop
+    set.
+    """
+    from vllm_omni.diffusion.models.hunyuan_image3.prompt_utils import (
+        HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS,
+    )
+
+    img = make_test_image_bytes((64, 64))
+    response = async_omni_stage_configs_only_client.post(
+        "/v1/images/edits",
+        files=[("image", img)],
+        data={
+            "prompt": "make it neon",
+            "size": "512x512",
+        },
+    )
+    assert response.status_code == 200, response.text
+
+    engine = async_omni_stage_configs_only_client.app.state.engine_client
+    captured = engine.captured_sampling_params_list
+    assert captured is not None
+
+    ar_params = captured[0]
+    expected_stop_token_ids = [
+        HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS["</think>"],
+        HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS["</recaption>"],
+    ]
+    assert ar_params.stop_token_ids == expected_stop_token_ids, (
+        f"omitted bot_task with an explicit size must resolve stop_token_ids "
+        f"for the default 'think' bot_task ({expected_stop_token_ids}); got "
+        f"{ar_params.stop_token_ids} -- this is the full ratio range, meaning "
+        "resolve_stop_token_ids disagreed with build_prompt_tokens's default."
+    )
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_connection.py b/tests/entrypoints/openai_api/test_openpi_connection.py
index 19ec23b6d..a6f12f661 100644
--- a/tests/entrypoints/openai_api/test_openpi_connection.py
+++ b/tests/entrypoints/openai_api/test_openpi_connection.py
@@ -310,6 +310,29 @@ def test_handle_connection_closes_websocket_on_idle_timeout(monkeypatch):
     serving.infer.assert_not_called()
 
 
+def test_handle_connection_can_disable_idle_timeout(monkeypatch):
+    monkeypatch.setattr(openpi_connection, "_pack", lambda obj: obj)
+
+    async def fail_wait_for(*_args, **_kwargs):
+        pytest.fail("asyncio.wait_for should not be used when the idle timeout is disabled")
+
+    monkeypatch.setattr(openpi_connection.asyncio, "wait_for", fail_wait_for)
+    websocket = FakeWebSocket([{"type": "websocket.disconnect"}])
+    serving = _serving_mock()
+
+    asyncio.run(
+        openpi_connection.RobotRealtimeConnection(
+            websocket,
+            serving,
+            idle_timeout=None,
+        ).handle_connection()
+    )
+
+    assert websocket.accepted is True
+    assert websocket.closed is False
+    serving.infer.assert_not_called()
+
+
 def test_handle_connection_keeps_session_state_per_websocket(monkeypatch):
     monkeypatch.setattr(openpi_connection, "_pack", lambda obj: obj)
     requests = {
@@ -343,6 +366,73 @@ def test_handle_connection_keeps_session_state_per_websocket(monkeypatch):
     assert calls[2].kwargs == {"session_id": "session-b", "reset": True}
 
 
+def test_handle_connection_keeps_interleaved_parallel_session_state(monkeypatch):
+    monkeypatch.setattr(openpi_connection, "_pack", lambda obj: obj)
+    requests = {
+        b"a1": {"prompt": "first-a", "session_id": "session-a"},
+        b"b1": {"prompt": "first-b", "session_id": "session-b"},
+        b"a2": {"prompt": "second-a", "session_id": "session-a"},
+        b"b2": {"prompt": "second-b", "session_id": "session-b"},
+    }
+    monkeypatch.setattr(openpi_connection, "_unpack", lambda data: dict(requests[data]))
+    serving = _serving_mock()
+    websocket = FakeWebSocket(
+        [{"type": "websocket.receive", "bytes": key} for key in (b"a1", b"b1", b"a2", b"b2")]
+        + [{"type": "websocket.disconnect"}]
+    )
+
+    asyncio.run(openpi_connection.RobotRealtimeConnection(websocket, serving).handle_connection())
+
+    assert [call.kwargs for call in serving.infer.await_args_list] == [
+        {"session_id": "session-a", "reset": True},
+        {"session_id": "session-b", "reset": True},
+        {"session_id": "session-a", "reset": False},
+        {"session_id": "session-b", "reset": False},
+    ]
+
+
+def test_handle_connection_bounds_tracked_sessions_without_resetting_live_ones(monkeypatch):
+    """A client may hold one socket across many episodes, minting a fresh
+    session id per episode and never sending ``reset`` (RoboLab does exactly
+    this). Session tracking must stay bounded, and evicting finished episodes
+    must not disturb the sessions that are still running.
+    """
+    monkeypatch.setattr(openpi_connection, "_pack", lambda obj: obj)
+    monkeypatch.setattr(openpi_connection, "MAX_TRACKED_SESSIONS", 8)
+
+    # One long-lived session interleaved with far more short episodes than the cap.
+    episodes = 40
+    keys = []
+    requests = {}
+    for episode in range(episodes):
+        for session_id in (f"episode-{episode}", "live-env"):
+            key = f"{session_id}@{episode}".encode()
+            keys.append(key)
+            requests[key] = {"prompt": "pick", "session_id": session_id}
+
+    monkeypatch.setattr(openpi_connection, "_unpack", lambda data: dict(requests[data]))
+    serving = _serving_mock()
+    websocket = FakeWebSocket(
+        [{"type": "websocket.receive", "bytes": key} for key in keys] + [{"type": "websocket.disconnect"}]
+    )
+    connection = openpi_connection.RobotRealtimeConnection(websocket, serving)
+
+    asyncio.run(connection.handle_connection())
+
+    assert len(connection._seen_sessions) <= 8
+
+    resets_by_session: dict[str, list[bool]] = {}
+    for call in serving.infer.await_args_list:
+        resets_by_session.setdefault(call.kwargs["session_id"], []).append(call.kwargs["reset"])
+
+    # Each new episode resets exactly once, on its first observation.
+    for episode in range(episodes):
+        assert resets_by_session[f"episode-{episode}"] == [True]
+    # The continuously active session is never evicted, so it resets only once
+    # despite ``episodes`` other sessions churning past the cap.
+    assert resets_by_session["live-env"] == [True] + [False] * (episodes - 1)
+
+
 def test_handle_connection_reset_endpoint_resets_next_infer(monkeypatch):
     monkeypatch.setattr(openpi_connection, "_pack", lambda obj: obj)
     requests = {
diff --git a/tests/entrypoints/openai_api/test_openpi_serving.py b/tests/entrypoints/openai_api/test_openpi_serving.py
index 072e734e4..fa0148599 100644
--- a/tests/entrypoints/openai_api/test_openpi_serving.py
+++ b/tests/entrypoints/openai_api/test_openpi_serving.py
@@ -15,6 +15,7 @@ from starlette.testclient import TestClient
 
 from vllm_omni.entrypoints.openpi import connection as openpi_connection
 from vllm_omni.entrypoints.openpi import serving as openpi_serving
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
@@ -137,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,
@@ -177,6 +208,22 @@ def test_create_policy_server_returns_none_without_policy_config():
     assert serving is None
 
 
+def test_legacy_policy_request_defaults_key_no_longer_controls_serving():
+    od_config = SimpleNamespace(
+        model_config={
+            "policy_server_config": {},
+            "policy_request_defaults": "malformed legacy value",
+        }
+    )
+
+    serving = openpi_serving.ServingRealtimeRobotOpenPI.create_policy_server(
+        engine_client=SimpleNamespace(get_diffusion_od_config=lambda: od_config),
+        model_name="generic-policy",
+    )
+
+    assert serving is not None
+
+
 def test_policy_server_config_allows_explicit_empty_config():
     serving = openpi_serving.ServingRealtimeRobotOpenPI(
         engine_client=_engine_with_policy_config(policy_config={}),
@@ -221,6 +268,54 @@ def test_build_request_uses_unique_engine_request_id_per_inference():
     assert request_a.request_id != request_b.request_id
 
 
+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(
+        get_diffusion_od_config=lambda: od_config,
+        default_sampling_params_list=[default_params],
+    )
+    serving = openpi_serving.ServingRealtimeRobotOpenPI(
+        engine_client=engine_client,
+        model_name="custom-policy",
+    )
+
+    request_a = serving._build_request(
+        {"prompt": "pick up the object"},
+        session_id="wire-session",
+        reset=True,
+    )
+    request_b = serving._build_request(
+        {"prompt": "pick up the object"},
+        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": []}
+
+
 def test_build_request_forwards_seed_to_sampling_params():
     """``seed`` in the inference message is the engine-level seed; omitted, the request auto-seeds."""
     serving = openpi_serving.ServingRealtimeRobotOpenPI(engine_client=_engine_with_policy_config())
@@ -233,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)
@@ -257,6 +392,29 @@ def test_infer_keeps_session_state_but_uses_unique_engine_request_ids():
     assert sampling_params_b.extra_args["reset"] is False
 
 
+def test_infer_yields_event_loop_while_engine_is_running():
+    class DelayedEngine(RecordingEngine):
+        def generate(self, *, prompt, request_id, sampling_params_list):
+            async def _generate():
+                await asyncio.sleep(0.03)
+                yield SimpleNamespace(multimodal_output={"actions": [0.0]})
+
+            return _generate()
+
+    serving = openpi_serving.ServingRealtimeRobotOpenPI(engine_client=DelayedEngine())
+
+    async def run_test():
+        infer_task = asyncio.create_task(serving.infer({"prompt": "pick"}, session_id="session-a", reset=True))
+        ticks = 0
+        while not infer_task.done():
+            await asyncio.sleep(0.005)
+            ticks += 1
+        await infer_task
+        return ticks
+
+    assert asyncio.run(run_test()) >= 2
+
+
 def test_two_websocket_clients_without_session_id_do_not_conflict(monkeypatch):
     monkeypatch.setattr(openpi_connection, "_pack", _json_pack)
     monkeypatch.setattr(openpi_connection, "_unpack", _json_unpack)
@@ -362,3 +520,17 @@ def test_extract_actions_does_not_iterate_result_object():
     actions = serving._extract_actions(IterableResult())
 
     np.testing.assert_allclose(actions, np.array([[1.0, 2.0, 3.0]], dtype=np.float32))
+
+
+def test_drop_session_calls_dreamzero_close_hook():
+    closed: list[str] = []
+    pipeline = SimpleNamespace(close_ar_diffusion_session=lambda session_id: closed.append(session_id))
+    engine_client = SimpleNamespace(
+        model_config={"policy_server_config": TEST_POLICY_SERVER_CONFIG},
+        model_runner=SimpleNamespace(pipeline=pipeline),
+    )
+    serving = openpi_serving.ServingRealtimeRobotOpenPI(engine_client=engine_client)
+
+    serving.drop_session("rollout-1")
+
+    assert closed == ["rollout-1"]
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 406668a4c..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,21 +18,27 @@ 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.entrypoints.duplex.server_vad import (
+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,
     SILERO_VAD_REVISION,
@@ -175,7 +181,7 @@ async def _run_realtime_audio_roundtrip(
             if event_type == "session.created":
                 continue
 
-            if event_type == "response.audio.delta":
+            if event_type == "response.output_audio.delta":
                 delta_events += 1
                 sr = event.get("sample_rate_hz")
                 if isinstance(sr, int) and sr > 0:
@@ -195,7 +201,7 @@ async def _run_realtime_audio_roundtrip(
                 final_text = event.get("text", "") or "".join(text_chunks)
                 continue
 
-            if event_type == "response.audio.done":
+            if event_type == "response.output_audio.done":
                 break
 
             if event_type == "error":
@@ -315,7 +321,7 @@ def _server_vad_pcm16_input() -> bytes:
 def _assert_realtime_smoke(result: dict) -> None:
     out_pcm = result["output_pcm"]
     assert result["delta_events"] >= 1
-    assert out_pcm, "No output PCM from response.audio.delta"
+    assert out_pcm, "No output PCM from response.output_audio.delta"
     assert len(out_pcm) % 2 == 0
     assert len(out_pcm) >= 4096, "Output audio unexpectedly small"
     assert result["output_sample_rate"] > 0
@@ -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)
@@ -388,7 +403,7 @@ class TestQwen3OmniRealtimeWebSocket:
     @hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
     @pytest.mark.parametrize("omni_server", realtime_async_chunk_server_params, indirect=True)
     def test_long_audio_response_completes_async_chunk(self, omni_server) -> None:
-        """Regression for #6474: long async-chunk audio must emit response.audio.done."""
+        """Regression for #6474: long async-chunk audio must emit response.output_audio.done."""
         issue_6474_pcm16 = _synthetic_pcm16_input(
             phrase_text=ISSUE_6474_SYNTH_PHRASE_TEXT,
         )
@@ -450,8 +465,8 @@ class TestQwen3OmniRealtimeWebSocket:
             "input_audio_buffer.speech_stopped",
             "input_audio_buffer.committed",
             "response.created",
-            "response.audio.delta",
-            "response.audio.done",
+            "response.output_audio.delta",
+            "response.output_audio.done",
             "response.done",
         ]
         input_item_ids: list[str] = []
@@ -459,7 +474,7 @@ class TestQwen3OmniRealtimeWebSocket:
         for events in turns:
             event_types = [event["type"] for event in events]
             for event_type in required_sequence:
-                if event_type != "response.audio.delta":
+                if event_type != "response.output_audio.delta":
                     assert event_types.count(event_type) == 1, event_types
             positions = [event_types.index(event_type) for event_type in required_sequence]
             assert positions == sorted(positions)
@@ -486,7 +501,7 @@ class TestQwen3OmniRealtimeWebSocket:
             output_pcm = b"".join(
                 base64.b64decode(event["delta"])
                 for event in events
-                if event["type"] == "response.audio.delta" and event.get("delta")
+                if event["type"] == "response.output_audio.delta" and event.get("delta")
             )
             assert output_pcm
             assert created["id"] == done["id"]
@@ -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_server_vad.py b/tests/entrypoints/openai_api/test_server_vad.py
deleted file mode 100644
index 67476be73..000000000
--- a/tests/entrypoints/openai_api/test_server_vad.py
+++ /dev/null
@@ -1,429 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-from __future__ import annotations
-
-import asyncio
-import base64
-import io
-import sys
-import threading
-import wave
-import weakref
-from concurrent.futures import ThreadPoolExecutor
-from types import SimpleNamespace
-
-import numpy as np
-import pytest
-
-from vllm_omni.entrypoints.duplex.protocol import (
-    DuplexSession,
-    DuplexSessionConfig,
-)
-from vllm_omni.entrypoints.duplex.server_vad import (
-    ServerVADConfig,
-    ServerVADFrame,
-    ServerVADPipeline,
-    SileroVADBackend,
-    SileroVADBackendProvider,
-    SpeechEndpointDecision,
-    ThresholdEndpointPolicy,
-    parse_session_turn_detection,
-)
-
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
-
-
-class SequenceDetector:
-    frame_samples = 160
-
-    def __init__(self, probabilities: list[float]) -> None:
-        self.probabilities = probabilities
-
-    def new_state(self) -> int:
-        return 0
-
-    def infer(self, frame: np.ndarray, state: object) -> tuple[float, object]:
-        index = int(state)
-        probability = self.probabilities[index] if index < len(self.probabilities) else 0.0
-        return probability, index + 1
-
-
-def test_server_vad_config_defaults_and_validation():
-    config = ServerVADConfig.from_value({"type": "server_vad"})
-
-    assert config.type == "server_vad"
-    assert config.threshold == 0.5
-    assert config.prefix_padding_ms == 300
-    assert config.silence_duration_ms == 500
-    assert config.create_response is True
-    assert config.interrupt_response is None
-    assert "interrupt_response" not in config.as_dict()
-    assert config.min_speech_duration_ms is None
-    assert config.as_dict()["type"] == config.type
-
-    interrupting = ServerVADConfig.from_value(
-        {
-            "type": "server_vad",
-            "interrupt_response": True,
-            "min_speech_duration_ms": 96,
-        }
-    )
-    assert interrupting.interrupt_response is True
-    assert interrupting.min_speech_duration_ms == 96
-    for value in (None, 0, "true"):
-        with pytest.raises(ValueError, match="interrupt_response must be a boolean"):
-            ServerVADConfig.from_value({"type": "server_vad", "interrupt_response": value})
-    for enabled in (False, True):
-        _, aliased = parse_session_turn_detection(
-            {
-                "turn_detection": {"type": "server_vad"},
-                "audio": {"input": {"turn_detection": {"type": "server_vad", "interrupt_response": enabled}}},
-            }
-        )
-        assert aliased is not None and aliased.interrupt_response is enabled
-    with pytest.raises(ValueError, match="Unknown"):
-        ServerVADConfig.from_value({"type": "server_vad", "semantic_eagerness": "high"})
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("prefix_padding_ms", [0, 10, 30])
-async def test_server_vad_pipeline_handles_arbitrary_chunk_boundaries(prefix_padding_ms: int):
-    detector = SequenceDetector([0.0, 0.9, 0.8, 0.0, 0.0])
-    pipeline = ServerVADPipeline(
-        detector,
-        ServerVADConfig(prefix_padding_ms=prefix_padding_ms, silence_duration_ms=20),
-    )
-    samples = np.zeros(detector.frame_samples * 5, dtype=np.float32)
-
-    batches = [
-        await pipeline.push(samples[:73]),
-        await pipeline.push(samples[73:431]),
-        await pipeline.push(samples[431:]),
-    ]
-    frames = [frame for batch in batches for frame in batch.frames]
-
-    assert len(frames) == 5
-    assert [index for index, frame in enumerate(frames) if frame.decision.speech_started] == [1]
-    assert [index for index, frame in enumerate(frames) if frame.decision.speech_stopped] == [4]
-    assert frames[1].decision.audio_start_ms == max(0, 10 - prefix_padding_ms)
-    assert frames[4].decision.audio_end_ms == 50
-
-    pipeline.reset()
-    reset_batch = await pipeline.push(samples)
-    assert [index for index, frame in enumerate(reset_batch.frames) if frame.decision.speech_started] == [1]
-    assert [index for index, frame in enumerate(reset_batch.frames) if frame.decision.speech_stopped] == [4]
-    # Keep session-relative timestamps, but never reference prefix audio
-    # discarded by reset at 50 ms.
-    assert reset_batch.frames[1].decision.audio_start_ms == max(50, 60 - prefix_padding_ms)
-    assert reset_batch.frames[4].decision.audio_end_ms == 100
-
-
-@pytest.mark.asyncio
-async def test_server_vad_retained_audio_does_not_keep_input_chunk():
-    pipeline = ServerVADPipeline(SequenceDetector([]), ServerVADConfig())
-    session = DuplexSession("server-vad-memory", DuplexSessionConfig())
-    samples = np.zeros(160 * 100 + 1, dtype=np.float32)
-    source_ref = weakref.ref(samples)
-    batch = await pipeline.push(samples)
-    session.append_server_vad_frame(
-        batch.frames[-1].samples,
-        speech_started=False,
-        speech_stopped=False,
-        prefix_samples=80,
-    )
-    session.append_server_vad_frame(
-        batch.frames[-1].samples,
-        speech_started=True,
-        speech_stopped=False,
-        prefix_samples=80,
-    )
-    del batch, samples
-    # Allow the completed to_thread callback to release its result, too.
-    await asyncio.sleep(0)
-
-    assert source_ref() is None
-    assert pipeline.scratch_bytes == 4
-    assert session.server_vad_utterance_bytes == (80 + 160) * 4
-
-
-@pytest.mark.asyncio
-async def test_server_vad_pipeline_pcm16_resampling_is_split_invariant():
-    sample_index = np.arange(2_400, dtype=np.int32)
-    source = ((sample_index * 7919) % 65_536 - 32_768).astype("<i2")
-    # Supply ample silence after the signal so the streaming resampler can
-    # emit a complete set of VAD frames without depending on its FIR width.
-    right_context = np.zeros(240, dtype="<i2")
-    continuous_source = np.concatenate((source, right_context))
-
-    async def process(chunk_sizes: list[int]) -> tuple[np.ndarray, list[SpeechEndpointDecision]]:
-        pipeline = ServerVADPipeline(
-            SequenceDetector([0.0] * 10),
-            ServerVADConfig(),
-        )
-        frames: list[ServerVADFrame] = []
-        offset = 0
-        for chunk_size in chunk_sizes:
-            chunk = continuous_source[offset : offset + chunk_size]
-            batch = await pipeline.push_pcm16(chunk.tobytes(), source_sample_rate_hz=24_000)
-            frames.extend(batch.frames)
-            offset += chunk_size
-        assert offset == continuous_source.size
-        return np.concatenate([frame.samples for frame in frames]), [frame.decision for frame in frames]
-
-    whole_samples, whole_decisions = await process([continuous_source.size])
-    split_samples, split_decisions = await process([7, 13, 511, 512, 513, continuous_source.size - 1_556])
-
-    np.testing.assert_array_equal(split_samples, whole_samples)
-    assert whole_samples.size == 1_600
-    assert split_decisions == whole_decisions
-
-
-@pytest.mark.asyncio
-async def test_server_vad_pipeline_reset_clears_resampler_and_source_rate_lock():
-    pipeline = ServerVADPipeline(
-        SequenceDetector([0.0]),
-        ServerVADConfig(),
-    )
-
-    batch = await pipeline.push_pcm16(
-        np.asarray([30_000, -30_000], dtype="<i2").tobytes(),
-        source_sample_rate_hz=24_000,
-    )
-    assert not batch.frames
-
-    pipeline.reset()
-
-    source = np.zeros(160, dtype="<i2")
-    source[:3] = [-32768, 0, 32767]
-    batch = await pipeline.push_pcm16(source.tobytes(), source_sample_rate_hz=16_000)
-
-    assert len(batch.frames) == 1
-    np.testing.assert_array_equal(
-        batch.frames[0].samples[:3],
-        np.asarray([-1.0, 0.0, 32767 / 32768], dtype=np.float32),
-    )
-
-
-def test_threshold_endpoint_policy_uses_silero_v62_exit_hysteresis():
-    policy = ThresholdEndpointPolicy(
-        ServerVADConfig(threshold=0.5, silence_duration_ms=20),
-        sample_rate_hz=16_000,
-    )
-    frame_samples = 160
-
-    started = policy.update(0.8, frame_start_sample=0, frame_samples=frame_samples)
-    assert started.speech_started is True
-
-    # Values below the activation threshold but above threshold - 0.15 must
-    # not begin a silence candidate or close an active speech segment.
-    for frame_index in range(1, 5):
-        decision = policy.update(
-            0.4,
-            frame_start_sample=frame_index * frame_samples,
-            frame_samples=frame_samples,
-        )
-        assert decision.speech_stopped is False
-
-    first_silence = policy.update(
-        0.2,
-        frame_start_sample=5 * frame_samples,
-        frame_samples=frame_samples,
-    )
-    stopped = policy.update(
-        0.2,
-        frame_start_sample=6 * frame_samples,
-        frame_samples=frame_samples,
-    )
-
-    assert first_silence.speech_stopped is False
-    assert stopped.speech_stopped is True
-
-
-def test_threshold_endpoint_policy_honors_minimum_speech_duration():
-    policy = ThresholdEndpointPolicy(
-        ServerVADConfig(prefix_padding_ms=0, min_speech_duration_ms=25),
-        sample_rate_hz=16_000,
-    )
-    frame_samples = 160
-
-    assert not policy.update(0.9, frame_start_sample=0, frame_samples=frame_samples).speech_started
-    assert not policy.update(0.9, frame_start_sample=160, frame_samples=frame_samples).speech_started
-    started = policy.update(0.9, frame_start_sample=320, frame_samples=frame_samples)
-
-    assert started.speech_started is True
-    assert started.audio_start_ms == 0
-
-
-def test_threshold_endpoint_policy_clamps_silero_exit_threshold():
-    policy = ThresholdEndpointPolicy(
-        ServerVADConfig(threshold=0.1, silence_duration_ms=20),
-        sample_rate_hz=16_000,
-    )
-    frame_samples = 160
-
-    started = policy.update(0.9, frame_start_sample=0, frame_samples=frame_samples)
-    assert started.speech_started is True
-
-    first_silence = policy.update(
-        0.0,
-        frame_start_sample=frame_samples,
-        frame_samples=frame_samples,
-    )
-    stopped = policy.update(
-        0.0,
-        frame_start_sample=2 * frame_samples,
-        frame_samples=frame_samples,
-    )
-
-    assert first_silence.speech_stopped is False
-    assert stopped.speech_stopped is True
-    # The committed audio ends at 30 ms: 10 ms of speech followed by the
-    # 20 ms of silence required to detect the endpoint.
-    assert stopped.audio_end_ms == 30
-    assert stopped.endpoint_delay_ms == 20
-
-
-def test_silero_backend_matches_upstream_v62_streaming_contract(monkeypatch, tmp_path):
-    class FakeSessionOptions:
-        inter_op_num_threads = 0
-        intra_op_num_threads = 0
-
-    class FakeInferenceSession:
-        def __init__(self, path: str, *, providers: list[str], sess_options: object) -> None:
-            self.providers = providers
-            self.sess_options = sess_options
-            self.calls: list[dict[str, np.ndarray]] = []
-            self.run_barrier: threading.Barrier | None = None
-            sessions.append(self)
-
-        def get_inputs(self) -> list[SimpleNamespace]:
-            return [SimpleNamespace(name=name) for name in ("input", "state", "sr")]
-
-        def run(self, _outputs: object, inputs: dict[str, np.ndarray]) -> list[np.ndarray]:
-            self.calls.append({name: np.array(value, copy=True) for name, value in inputs.items()})
-            if self.run_barrier is not None:
-                self.run_barrier.wait(timeout=5)
-            return [
-                np.asarray([[0.75]], dtype=np.float32),
-                np.full((2, 1, 128), len(self.calls), dtype=np.float32),
-            ]
-
-    sessions: list[FakeInferenceSession] = []
-    monkeypatch.setitem(
-        sys.modules,
-        "onnxruntime",
-        SimpleNamespace(
-            SessionOptions=FakeSessionOptions,
-            InferenceSession=FakeInferenceSession,
-        ),
-    )
-
-    model_path = tmp_path / "silero_vad.onnx"
-    model_path.write_bytes(b"fake-model")
-    backend = SileroVADBackend(model_path)
-    session = sessions[0]
-
-    assert session.providers == ["CPUExecutionProvider"]
-    assert session.sess_options.inter_op_num_threads == 1
-    assert session.sess_options.intra_op_num_threads == 1
-    assert session.calls[0]["input"].shape == (1, 576)
-    assert session.calls[0]["state"].shape == (2, 1, 128)
-    np.testing.assert_array_equal(session.calls[0]["state"], np.zeros((2, 1, 128), dtype=np.float32))
-    assert session.calls[0]["sr"].shape == ()
-    assert session.calls[0]["sr"].item() == 16_000
-
-    state = backend.new_state()
-    first_frame = np.arange(backend.frame_samples, dtype=np.float32)
-    probability, state = backend.infer(first_frame, state)
-    first_call = session.calls[1]
-
-    assert probability == pytest.approx(0.75)
-    np.testing.assert_array_equal(
-        first_call["input"][:, : backend.context_samples],
-        np.zeros((1, backend.context_samples), dtype=np.float32),
-    )
-    np.testing.assert_array_equal(
-        first_call["input"][:, backend.context_samples :],
-        first_frame[None, :],
-    )
-    np.testing.assert_array_equal(first_call["state"], np.zeros((2, 1, 128), dtype=np.float32))
-
-    second_frame = -first_frame
-    backend.infer(second_frame, state)
-    second_call = session.calls[2]
-    np.testing.assert_array_equal(
-        second_call["input"][:, : backend.context_samples],
-        first_frame[None, -backend.context_samples :],
-    )
-    np.testing.assert_array_equal(
-        second_call["input"][:, backend.context_samples :],
-        second_frame[None, :],
-    )
-    np.testing.assert_array_equal(
-        second_call["state"],
-        np.full((2, 1, 128), 2, dtype=np.float32),
-    )
-
-    # Independent pipeline states may enter the shared ORT session concurrently.
-    session.run_barrier = threading.Barrier(2)
-    with ThreadPoolExecutor(max_workers=2) as executor:
-        futures = [
-            executor.submit(backend.infer, first_frame, backend.new_state()),
-            executor.submit(backend.infer, second_frame, backend.new_state()),
-        ]
-        assert [future.result()[0] for future in futures] == pytest.approx([0.75, 0.75])
-
-
-def test_duplex_session_owns_server_vad_prefix_and_utterance_audio():
-    session = DuplexSession("server-vad-session", DuplexSessionConfig())
-    frame = np.zeros(160, dtype=np.float32)
-
-    session.reserve_input_bytes(frame.nbytes * 3, limit=frame.nbytes * 4)
-    released = session.append_server_vad_frame(
-        frame,
-        speech_started=False,
-        speech_stopped=False,
-        prefix_samples=160,
-    )
-    assert released == 0
-    released = session.append_server_vad_frame(
-        frame,
-        speech_started=False,
-        speech_stopped=False,
-        prefix_samples=160,
-    )
-    assert released == frame.nbytes
-    session.release_input_bytes(released)
-    session.append_server_vad_frame(
-        frame,
-        speech_started=True,
-        speech_stopped=False,
-        prefix_samples=160,
-    )
-
-    assert session.server_vad_utterance_bytes == frame.nbytes * 2
-    assert session.stage_server_vad_audio_for_commit() is True
-    committed = session.commit_user_input()
-    assert committed is not None
-    assert committed.message["role"] == "user"
-    audio_url = committed.message["content"][0]["audio_url"]["url"]
-    assert audio_url.startswith("data:audio/wav;base64,")
-    wav_bytes = base64.b64decode(audio_url.partition(",")[2])
-    with wave.open(io.BytesIO(wav_bytes), "rb") as wav_file:
-        assert wav_file.getnchannels() == 1
-        assert wav_file.getsampwidth() == 2
-        assert wav_file.getframerate() == 16_000
-        assert wav_file.getnframes() == frame.size * 2
-
-
-def test_silero_provider_rejects_missing_or_invalid_local_artifact(tmp_path):
-    missing = SileroVADBackendProvider(model_path=str(tmp_path / "missing.onnx"))
-    with pytest.raises(RuntimeError, match="does not exist"):
-        missing.get()
-
-    invalid_path = tmp_path / "silero_vad.onnx"
-    invalid_path.write_bytes(b"not-the-pinned-model")
-    invalid = SileroVADBackendProvider(model_path=str(invalid_path))
-    with pytest.raises(RuntimeError, match="checksum mismatch"):
-        invalid.get()
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 0dea97179..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
 
@@ -538,3 +567,84 @@ def test_build_multistage_generation_inputs_no_stop_token_ids_without_size(servi
     assert sampling_params_list[0].stop_token_ids == [], (
         "Without bot_task, AR stage stop_token_ids must be the default empty list"
     )
+
+
+def test_build_multistage_generation_inputs_omitted_bot_task_matches_prompt_default(serving_chat):
+    """Regression: an omitted bot_task must resolve identically for the AR
+    prompt and for its stop_token_ids.
+
+    ``build_prompt_tokens``/``build_prompt`` default an omitted bot_task
+    per-task via the ``_DEFAULT_BOT_TASK`` sentinel (``"think"`` for the base
+    ``it2i`` task, which isn't itself a key in ``_TASK_PRESETS``).
+    ``resolve_stop_token_ids`` must normalize from that same omitted-or-not
+    starting point. Passing the raw -- still ``None`` -- outer ``bot_task``
+    variable instead of mirroring ``build_kwargs``'s own omitted-or-not
+    ``"bot_task"`` entry made it normalize ``bot_task=None`` (plain mode), so
+    it fell through to the full ``<img_ratio_*>`` range instead of the
+    think/recaption terminator pair.
+
+    An explicit (non-"auto") size is required to observe this: with
+    ``need_ratio=True`` the ratio range is returned regardless of bot_task, so
+    the two paths only visibly disagree once a concrete size selects the
+    narrower stop set.
+    """
+    from vllm_omni.diffusion.models.hunyuan_image3.prompt_utils import (
+        HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS,
+    )
+    from vllm_omni.entrypoints.openai.serving_chat import OmniOpenAIServingChat
+
+    class FakeTokenizer:
+        SPECIAL = {
+            "<|startoftext|>": 1,
+            "<img>": 2,
+            "<recaption>": 4,
+        }
+
+        def convert_tokens_to_ids(self, tok: str) -> int:
+            return self.SPECIAL.get(tok, 0)
+
+        def encode(self, text: str, add_special_tokens: bool = False) -> list[int]:
+            return list(range(100, 100 + len(text)))
+
+    def _build(extra_body):
+        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(),
+            ],
+        )
+        _, sampling_params_list = OmniOpenAIServingChat._build_multistage_generation_inputs(
+            serving_chat,
+            engine=engine,
+            prompt="draw a cat",
+            extra_body=extra_body,
+            reference_images=[Image.new("RGB", (32, 32), color="red")],
+            gen_params=OmniDiffusionSamplingParams(height=768, width=1024),
+            tokenizer=FakeTokenizer(),
+        )
+        return sampling_params_list[0].stop_token_ids
+
+    # bot_task omitted entirely; use_system_prompt is what carries the request
+    # into the AR-prompt path.
+    omitted = _build({"use_system_prompt": "en_recaption"})
+    # Same request with the default spelled out explicitly.
+    explicit = _build({"bot_task": "think", "use_system_prompt": "en_recaption"})
+
+    expected = [
+        HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS["</think>"],
+        HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS["</recaption>"],
+    ]
+    assert omitted == expected, (
+        f"omitted bot_task with an explicit size must resolve stop_token_ids for the "
+        f"default 'think' bot_task ({expected}); got {omitted}. A long list here is the "
+        f"full <img_ratio_*> range, meaning resolve_stop_token_ids normalized bot_task=None "
+        f"(plain mode) instead of agreeing with build_prompt_tokens's default."
+    )
+    assert omitted == explicit, (
+        "omitting bot_task must resolve the same stop_token_ids as passing the default "
+        f"explicitly; omitted={omitted} explicit={explicit}"
+    )
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 6040bede3..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
@@ -2241,6 +2322,7 @@ class TestTTSMethods:
 
         assert params["task_type"] == ["Base"]
         assert params["non_streaming_mode"] == [True]
+        assert "full_utterance_decode" not in params
 
     def test_build_tts_params_base_omits_non_streaming_mode_by_default(self, speech_server):
         """Base task should keep using the model default when no override is sent."""
@@ -2255,6 +2337,7 @@ class TestTTSMethods:
 
         assert params["task_type"] == ["Base"]
         assert "non_streaming_mode" not in params
+        assert "full_utterance_decode" not in params
 
     def test_build_tts_params_explicit_non_streaming_mode_overrides_voicedesign_default(self, speech_server):
         """Explicit false should not be replaced by the VoiceDesign fallback."""
@@ -2269,6 +2352,38 @@ class TestTTSMethods:
 
         assert params["task_type"] == ["VoiceDesign"]
         assert params["non_streaming_mode"] == [False]
+        assert "full_utterance_decode" not in params
+
+    def test_build_tts_params_streaming_voicedesign_keeps_prompt_mode_not_full_decode(self, speech_server):
+        """Streaming VoiceDesign defaults: prompt-mode True, no full_utterance_decode."""
+        req = OpenAICreateSpeechRequest(
+            input="Hello",
+            task_type="VoiceDesign",
+            instructions="warm and calm",
+            stream=True,
+            response_format="pcm",
+        )
+
+        params = speech_server._build_tts_params(req)
+
+        assert params["task_type"] == ["VoiceDesign"]
+        assert params["non_streaming_mode"] == [True]
+        assert "full_utterance_decode" not in params
+
+    def test_build_tts_params_streaming_customvoice_explicit_non_streaming_mode_still_windowed(self, speech_server):
+        """Explicit non_streaming_mode=True must not inject full_utterance_decode."""
+        req = OpenAICreateSpeechRequest(
+            input="Hello",
+            voice="Vivian",
+            non_streaming_mode=True,
+            stream=True,
+            response_format="pcm",
+        )
+
+        params = speech_server._build_tts_params(req)
+
+        assert params["non_streaming_mode"] == [True]
+        assert "full_utterance_decode" not in params
 
     def test_load_supported_speakers(self, mocker: MockerFixture):
         """Test _load_supported_speakers."""
@@ -3287,7 +3402,7 @@ class TestStreamingResponse:
         finalized_tts_params = {"_qwen3_tts_effective_max_tokens": [192]}
         captured: dict = {}
 
-        async def prepare(_request, request_id=None):
+        async def prepare(_request, request_id=None, arrival_time=None):
             return request_id, object(), finalized_tts_params
 
         async def generate_chunks(
@@ -3296,6 +3411,7 @@ class TestStreamingResponse:
             _response_format="pcm",
             raw_request=None,
             request_start_s=None,
+            request_arrival_ts=None,
             include_sample_rate=False,
             usage_acc=None,
             tts_params=None,
@@ -3758,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,
@@ -4919,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."""
 
@@ -5098,6 +5132,7 @@ class TestTTSAsyncOffloading:
 
     def test_prepare_speech_generation_awaits_voxtral_async(self, voxtral_server, mocker: MockerFixture):
         """Voxtral path in _prepare_speech_generation should call the async wrapper."""
+        voxtral_server._adapter._encoder_loaded = mocker.AsyncMock(return_value=False)
         voxtral_server._adapter._build_prompt_async = mocker.AsyncMock(
             return_value={
                 "prompt_token_ids": [1, 2, 3],
@@ -5176,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)
@@ -5253,6 +5334,7 @@ class TestTTSAsyncOffloading:
         """FINAL_ONLY streaming for async_chunk=False is scoped to qwen3_tts only."""
         voxtral_server.engine_client.model_config.async_chunk = False
         mocker.patch.object(voxtral_server._get_tts_adapter(), "validate", return_value=None)
+        voxtral_server._adapter._encoder_loaded = mocker.AsyncMock(return_value=False)
         voxtral_server._adapter._build_prompt_async = mocker.AsyncMock(
             return_value={
                 "prompt_token_ids": [1, 2, 3],
@@ -5286,9 +5368,34 @@ class TestTTSAsyncOffloading:
 
         assert tts_params["task_type"] == ["VoiceDesign"]
         assert tts_params["non_streaming_mode"] == [False]
+        assert "full_utterance_decode" not in tts_params
         prompt = qwen3_tts_server.engine_client.generate.call_args.kwargs["prompt"]
         assert prompt["additional_information"] is tts_params
         assert prompt["additional_information"]["non_streaming_mode"] == [False]
+        assert "full_utterance_decode" not in prompt["additional_information"]
+
+    def test_prepare_speech_generation_qwen3_streaming_voicedesign_default_params(
+        self, qwen3_tts_server, mocker: MockerFixture
+    ):
+        """Streaming VoiceDesign defaults keep prompt-mode True without full_utterance_decode."""
+        qwen3_tts_server._validate_tts_request = mocker.MagicMock(return_value=None)
+        qwen3_tts_server._estimate_prompt_len_async = mocker.AsyncMock(return_value=512)
+
+        request = OpenAICreateSpeechRequest(
+            input="hello",
+            task_type="VoiceDesign",
+            instructions="warm and calm",
+            stream=True,
+            response_format="pcm",
+        )
+        _request_id, _generator, tts_params = asyncio.run(qwen3_tts_server._prepare_speech_generation(request))
+
+        assert tts_params["task_type"] == ["VoiceDesign"]
+        assert tts_params["non_streaming_mode"] == [True]
+        assert "full_utterance_decode" not in tts_params
+        prompt = qwen3_tts_server.engine_client.generate.call_args.kwargs["prompt"]
+        assert prompt["additional_information"]["non_streaming_mode"] == [True]
+        assert "full_utterance_decode" not in prompt["additional_information"]
 
     def test_prepare_speech_generation_qwen3_base_non_streaming_mode_true(
         self, qwen3_tts_server, mocker: MockerFixture
@@ -5311,9 +5418,11 @@ class TestTTSAsyncOffloading:
         assert tts_params["task_type"] == ["Base"]
         assert tts_params["ref_text"] == ["reference transcript"]
         assert tts_params["non_streaming_mode"] == [True]
+        assert "full_utterance_decode" not in tts_params
         prompt = qwen3_tts_server.engine_client.generate.call_args.kwargs["prompt"]
         assert prompt["additional_information"] is tts_params
         assert prompt["additional_information"]["non_streaming_mode"] == [True]
+        assert "full_utterance_decode" not in prompt["additional_information"]
 
     def test_qwen3_repeated_ref_audio_hot_path_sends_cache_key_without_waveform(self, qwen3_tts_server):
         """After a ref artifact is marked ready, repeated requests avoid ref_audio payload IPC."""
@@ -5322,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,
         )
@@ -5358,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()}
@@ -5607,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")
 
@@ -5615,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")
 
@@ -5623,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_metrics.py b/tests/entrypoints/openai_api/test_serving_speech_metrics.py
new file mode 100644
index 000000000..a1fb74a46
--- /dev/null
+++ b/tests/entrypoints/openai_api/test_serving_speech_metrics.py
@@ -0,0 +1,466 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Prometheus metric coverage for the Speech API audio path."""
+
+import asyncio
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+import torch
+
+from vllm_omni.entrypoints.openai import serving_speech as speech_module
+from vllm_omni.entrypoints.openai.protocol.audio import OpenAICreateSpeechRequest
+from vllm_omni.entrypoints.openai.serving_speech import OmniOpenAIServingSpeech
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _MetricsStub:
+    def __init__(self) -> None:
+        self.ttfp_calls: list[tuple[str, str, float]] = []
+        self.underrun_calls: list[tuple[str, str, float]] = []
+        self.continuity_calls: list[tuple[str, str, int]] = []
+        self.abort_calls: list[str] = []
+        self.completed = 0
+
+    def inc_speech_stream_completed(self) -> None:
+        self.completed += 1
+
+    def inc_speech_stream_aborted(self, reason: str) -> None:
+        self.abort_calls.append(reason)
+
+    def observe_audio_ttfp(self, stage: str, replica: str, seconds: float) -> None:
+        self.ttfp_calls.append((stage, replica, seconds))
+
+    def observe_audio_underrun(self, stage: str, replica: str, seconds: float) -> None:
+        self.underrun_calls.append((stage, replica, seconds))
+
+    def inc_audio_continuity_ok(self, stage: str, replica: str, threshold_ms: int) -> None:
+        self.continuity_calls.append((stage, replica, threshold_ms))
+
+
+def _serving(metrics: _MetricsStub, *, adapter=None) -> OmniOpenAIServingSpeech:
+    serving = OmniOpenAIServingSpeech.__new__(OmniOpenAIServingSpeech)
+    serving._tts_model_type = "qwen3_tts"
+    serving.engine_client = SimpleNamespace(mod_metrics=metrics, request_states={})
+    serving._get_tts_adapter = lambda: adapter
+    serving._speech_output_policies = {}
+    serving.create_audio = lambda audio_obj: SimpleNamespace(
+        audio_data=b"\0\0" * int(audio_obj.audio_tensor.size),
+        media_type="audio/pcm",
+    )
+    serving._mark_ref_audio_artifact_ready_for_request = lambda request_id: None
+    serving._discard_ref_audio_artifact_warmup = lambda request_id: None
+    return serving
+
+
+def _result(samples: int = 320, *, stage_id: int = 1, replica_id: int | None = 2) -> SimpleNamespace:
+    return SimpleNamespace(
+        multimodal_output={"audio": torch.zeros(samples), "sr": 16000},
+        stage_id=stage_id,
+        replica_id=replica_id,
+    )
+
+
+async def _generate(*results):
+    for result in results:
+        yield result
+
+
+@pytest.mark.asyncio
+async def test_streaming_speech_observes_ttfp_once_on_first_pcm_payload(monkeypatch):
+    metrics = _MetricsStub()
+    serving = _serving(metrics)
+    monkeypatch.setattr("vllm_omni.entrypoints.openai.serving_speech.time.time", lambda: 100.25)
+
+    chunks = serving._generate_audio_chunks(
+        _generate(_result(), _result()),
+        request_id="speech-test",
+        request_arrival_ts=100.0,
+    )
+    assert len([chunk async for chunk in chunks]) == 2
+    assert metrics.ttfp_calls == [("1", "2", pytest.approx(0.25))]
+    assert metrics.underrun_calls == [("1", "2", pytest.approx(0.0))]
+    assert metrics.continuity_calls == [("1", "2", 100)]
+    assert metrics.abort_calls == []
+    assert metrics.completed == 1
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("before_pcm", [True, False])
+@pytest.mark.parametrize(
+    ("error_type", "reason"),
+    [(asyncio.CancelledError, "cancelled"), (speech_module.EngineDeadError, "engine_dead"), (RuntimeError, "error")],
+)
+async def test_speech_stream_abort_counted_once_without_continuity(before_pcm, error_type, reason):
+    metrics = _MetricsStub()
+    serving = _serving(metrics)
+
+    async def results():
+        if not before_pcm:
+            yield _result()
+        raise error_type()
+
+    chunks = serving._generate_audio_chunks(results(), request_id="speech-test", request_arrival_ts=100.0)
+    with pytest.raises(error_type):
+        _ = [chunk async for chunk in chunks]
+
+    assert metrics.abort_calls == [reason]
+    assert metrics.completed == 0
+    assert len(metrics.ttfp_calls) == (0 if before_pcm else 1)
+    assert metrics.underrun_calls == []
+    assert metrics.continuity_calls == []
+
+
+@pytest.mark.asyncio
+async def test_speech_stream_close_counted_once_without_continuity():
+    metrics = _MetricsStub()
+    serving = _serving(metrics)
+    chunks = serving._generate_audio_chunks(
+        _generate(_result(), _result()), request_id="speech-test", request_arrival_ts=100.0
+    )
+    assert await anext(chunks)
+    await chunks.aclose()
+    await chunks.aclose()
+    assert metrics.abort_calls == ["closed"]
+    assert metrics.completed == 0
+    assert metrics.underrun_calls == []
+    assert metrics.continuity_calls == []
+
+
+@pytest.mark.asyncio
+async def test_streaming_speech_retries_ttfp_labels_without_moving_first_packet_time(monkeypatch):
+    metrics = _MetricsStub()
+    serving = _serving(metrics)
+    clock = {"now": 100.25, "perf": 0.25}
+    monkeypatch.setattr(speech_module.time, "time", lambda: clock["now"])
+    monkeypatch.setattr(speech_module.time, "perf_counter", lambda: clock["perf"])
+
+    async def results():
+        yield _result(replica_id=None)
+        clock["now"] = 101.0
+        clock["perf"] = 0.26
+        yield _result(replica_id=2)
+        clock["now"] = 101.25
+        clock["perf"] = 0.27
+        yield _result(replica_id=2)
+
+    chunks = serving._generate_audio_chunks(
+        results(),
+        request_id="speech-test",
+        request_arrival_ts=100.0,
+    )
+    assert len([chunk async for chunk in chunks]) == 3
+    assert metrics.ttfp_calls == [("1", "2", pytest.approx(0.25))]
+    assert metrics.underrun_calls == [("1", "2", pytest.approx(0.0))]
+    assert metrics.continuity_calls == [("1", "2", 100)]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("mode", ["raw", "sse", "pcm"])
+async def test_speech_disconnect_during_send_closes_entire_generator_chain(mode):
+    metrics = _MetricsStub()
+    serving = _serving(metrics)
+    closed = []
+
+    async def source():
+        try:
+            yield _result()
+            yield _result()
+        finally:
+            closed.append(True)
+
+    # Retain the source to prove cleanup does not depend on garbage collection.
+    generator = source()
+    method = {
+        "raw": serving._generate_audio_chunks,
+        "sse": serving._generate_audio_sse_events,
+        "pcm": serving._generate_pcm_chunks,
+    }[mode]
+    stream = method(generator, request_id="speech-test", request_arrival_ts=100.0)
+
+    async def send(message):
+        if message["type"] == "http.response.body":
+            raise OSError("client disconnected")
+
+    if mode == "pcm":
+        # WebSocket handlers already explicitly close their PCM iterator.
+        assert await anext(stream)
+        await stream.aclose()
+    else:
+        response = speech_module._SpeechStreamingResponse(stream)
+        with pytest.raises(OSError, match="client disconnected"):
+            await response.stream_response(send)
+    assert closed == [True]
+    assert metrics.abort_calls == ["closed"]
+    assert metrics.completed == 0
+    assert metrics.underrun_calls == []
+    assert metrics.continuity_calls == []
+
+
+@pytest.mark.parametrize("arrival_ts", [0.0, -1.0])
+def test_speech_ttfp_invalid_arrival_does_not_consume_guard(arrival_ts):
+    metrics = _MetricsStub()
+    serving = _serving(metrics)
+    state = SimpleNamespace(
+        external_request_id="speech-test",
+        request_arrival_ts=arrival_ts,
+        first_audio_ts=None,
+        audio_emit_stage_id=None,
+        audio_emit_replica_id=None,
+    )
+    serving.engine_client.request_states = {"internal-test": state}
+
+    assert serving._observe_speech_audio_ttfp(request_id="speech-test", result=_result(), first_packet_ts=100.25) == (
+        1,
+        2,
+        False,
+    )
+    assert metrics.ttfp_calls == []
+    assert state.first_audio_ts is None
+    assert state.audio_emit_stage_id is None
+    assert state.audio_emit_replica_id is None
+
+    state.request_arrival_ts = 100.0
+    assert serving._observe_speech_audio_ttfp(request_id="speech-test", result=_result(), first_packet_ts=100.25) == (
+        1,
+        2,
+        True,
+    )
+    assert metrics.ttfp_calls == [("1", "2", pytest.approx(0.25))]
+    assert state.first_audio_ts == 100.25
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("during_send", [False, True])
+async def test_speech_response_task_cancellation_closes_source(during_send):
+    metrics = _MetricsStub()
+    serving = _serving(metrics)
+    waiting = asyncio.Event()
+    blocker = asyncio.Event()
+    closed = []
+
+    async def source():
+        try:
+            if not during_send:
+                waiting.set()
+                await blocker.wait()
+            yield _result()
+        finally:
+            closed.append(True)
+
+    async def send(message):
+        if during_send and message["type"] == "http.response.body":
+            waiting.set()
+            await blocker.wait()
+
+    generator = source()
+    stream = serving._generate_audio_chunks(generator, request_id="speech-test", request_arrival_ts=100.0)
+    response = speech_module._SpeechStreamingResponse(stream)
+    task = asyncio.create_task(response.stream_response(send))
+    try:
+        await asyncio.wait_for(waiting.wait(), timeout=5)
+    finally:
+        task.cancel()
+        with pytest.raises(asyncio.CancelledError):
+            await task
+    assert closed == [True]
+    assert metrics.abort_calls == ["closed" if during_send else "cancelled"]
+    assert metrics.completed == 0
+    assert metrics.underrun_calls == []
+
+
+@pytest.mark.asyncio
+async def test_streaming_speech_does_not_count_empty_payload_as_first_packet(monkeypatch):
+    metrics = _MetricsStub()
+    serving = _serving(metrics)
+    monkeypatch.setattr("vllm_omni.entrypoints.openai.serving_speech.time.time", lambda: 100.25)
+
+    chunks = serving._generate_audio_chunks(
+        _generate(_result(samples=0), _result()),
+        request_id="speech-test",
+        request_arrival_ts=100.0,
+    )
+    assert len([chunk async for chunk in chunks]) == 2
+    assert metrics.ttfp_calls == [("1", "2", pytest.approx(0.25))]
+    assert metrics.underrun_calls == [("1", "2", pytest.approx(0.0))]
+    assert metrics.continuity_calls == [("1", "2", 100)]
+
+
+@pytest.mark.asyncio
+async def test_streaming_speech_does_not_finalize_continuity_on_error(monkeypatch):
+    metrics = _MetricsStub()
+    serving = _serving(metrics)
+    monkeypatch.setattr("vllm_omni.entrypoints.openai.serving_speech.time.time", lambda: 100.25)
+
+    async def failing_stream():
+        yield _result()
+        raise RuntimeError("stream failed")
+
+    chunks = serving._generate_audio_chunks(
+        failing_stream(),
+        request_id="speech-test",
+        request_arrival_ts=100.0,
+    )
+    with pytest.raises(RuntimeError, match="stream failed"):
+        _ = [chunk async for chunk in chunks]
+
+    assert len(metrics.ttfp_calls) == 1
+    assert metrics.underrun_calls == []
+    assert metrics.continuity_calls == []
+
+
+@pytest.mark.asyncio
+async def test_streaming_speech_does_not_finalize_continuity_on_validation_error(monkeypatch):
+    metrics = _MetricsStub()
+
+    def reject_generation(_tts_params, **_kwargs):
+        raise RuntimeError("generation validation failed")
+
+    adapter = SimpleNamespace(validates_generation=True, validate_generation=reject_generation)
+    serving = _serving(metrics, adapter=adapter)
+    monkeypatch.setattr("vllm_omni.entrypoints.openai.serving_speech.time.time", lambda: 100.25)
+
+    chunks = serving._generate_audio_chunks(
+        _generate(_result()),
+        request_id="speech-test",
+        request_arrival_ts=100.0,
+        tts_params={"task_type": ["Base"]},
+    )
+    with pytest.raises(RuntimeError, match="generation validation failed"):
+        _ = [chunk async for chunk in chunks]
+
+    assert len(metrics.ttfp_calls) == 1
+    assert metrics.underrun_calls == []
+    assert metrics.continuity_calls == []
+
+
+@pytest.mark.asyncio
+async def test_streaming_speech_reports_late_chunk_as_underrun(monkeypatch):
+    metrics = _MetricsStub()
+    serving = _serving(metrics)
+    monkeypatch.setattr("vllm_omni.entrypoints.openai.serving_speech.time.time", lambda: 100.25)
+    perf_times = iter((0.0, 0.1, 0.1, 2.0, 2.0))
+    monkeypatch.setattr("vllm_omni.entrypoints.openai.serving_speech.time.perf_counter", lambda: next(perf_times))
+
+    chunks = serving._generate_audio_chunks(
+        _generate(_result(), _result()),
+        request_id="speech-test",
+        request_arrival_ts=100.0,
+    )
+    assert len([chunk async for chunk in chunks]) == 2
+    assert metrics.underrun_calls[0][:2] == ("1", "2")
+    assert metrics.underrun_calls[0][2] > 0.1
+    assert metrics.continuity_calls == []
+
+
+@pytest.mark.asyncio
+async def test_non_streaming_speech_does_not_observe_ttfp():
+    metrics = _MetricsStub()
+    serving = _serving(metrics)
+    serving._audio_encode_speed = lambda _request: 1.0
+
+    async def prepare(_request, **_kwargs):
+        result = _result()
+        result.metrics = {}
+        return "speech-test", _generate(result), {}
+
+    serving._prepare_speech_generation = prepare
+    request = OpenAICreateSpeechRequest(input="hello", response_format="pcm")
+
+    audio_data, media_type = await serving._generate_audio_bytes(request, request_arrival_ts=100.0)
+
+    assert audio_data
+    assert media_type == "audio/pcm"
+    assert metrics.ttfp_calls == []
+    assert metrics.completed == 0
+    assert metrics.abort_calls == []
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("flush_only", [False, True])
+@pytest.mark.parametrize("response_format", ["pcm", "wav"])
+async def test_resampled_speech_records_flush_with_audio_producer(monkeypatch, flush_only, response_format):
+    metrics = _MetricsStub()
+    serving = _serving(metrics)
+    clock = {"now": 0.0}
+    finalized = []
+    original_finalize = speech_module.observe_audio_streaming_finalize
+
+    def capture_finalize(*args, **kwargs):
+        finalized.append(kwargs)
+        original_finalize(*args, **kwargs)
+
+    class BufferedResampler:
+        def __init__(self, source_rate, target_rate):
+            assert (source_rate, target_rate) == (16000, 24000)
+
+        def process(self, chunk, *, final=False):
+            clock["now"] = 0.5 if final else 0.25
+            if not final and flush_only:
+                return np.empty(0, dtype=np.float32)
+            return np.zeros(2400, dtype=np.float32)
+
+    monkeypatch.setattr(speech_module, "StreamingAudioResampler", BufferedResampler)
+    monkeypatch.setattr(speech_module, "observe_audio_streaming_finalize", capture_finalize)
+    monkeypatch.setattr(speech_module.time, "time", lambda: 100.0 + clock["now"])
+    monkeypatch.setattr(speech_module.time, "perf_counter", lambda: clock["now"])
+    # The last result is not audio and must not supply the flush metric labels.
+    non_audio = SimpleNamespace(multimodal_output={"timestamps": []}, stage_id=9, replica_id=8)
+    chunks = [
+        chunk
+        async for chunk in serving._generate_audio_chunks(
+            _generate(_result(), non_audio),
+            request_id="speech-test",
+            response_format=response_format,
+            request_start_s=0.0,
+            request_arrival_ts=100.0,
+            target_sample_rate=24000,
+        )
+    ]
+
+    if response_format == "wav":
+        assert chunks.pop(0).startswith(b"RIFF")
+    expected_arrivals = [0.5] if flush_only else [0.25, 0.5]
+    assert [len(chunk) for chunk in chunks] == [4800] * len(expected_arrivals)
+    assert metrics.ttfp_calls == [("1", "2", pytest.approx(expected_arrivals[0]))]
+    assert len(finalized) == 1
+    assert finalized[0]["sample_rate"] == 24000
+    assert finalized[0]["channels"] == 1
+    assert finalized[0]["chunk_bytes"] == [4800] * len(expected_arrivals)
+    assert finalized[0]["chunk_arrival_times_s"] == expected_arrivals
+    assert metrics.underrun_calls == [("1", "2", pytest.approx(0.0 if flush_only else 0.15))]
+    assert metrics.continuity_calls == ([("1", "2", 100)] if flush_only else [])
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("empty_pcm", [False, True])
+async def test_resampled_speech_without_pcm_does_not_emit_metrics(monkeypatch, empty_pcm):
+    metrics = _MetricsStub()
+    serving = _serving(metrics)
+
+    class EmptyResampler:
+        def __init__(self, source_rate, target_rate):
+            pass
+
+        def process(self, chunk, *, final=False):
+            # Also cover a nonempty flush waveform whose encoder emits no PCM.
+            return np.zeros(10 if final and empty_pcm else 0, dtype=np.float32)
+
+    monkeypatch.setattr(speech_module, "StreamingAudioResampler", EmptyResampler)
+    serving.create_audio = lambda audio_obj: SimpleNamespace(audio_data=b"", media_type="audio/pcm")
+    chunks = [
+        chunk
+        async for chunk in serving._generate_audio_chunks(
+            _generate(_result()),
+            request_id="speech-test",
+            request_arrival_ts=100.0,
+            target_sample_rate=24000,
+        )
+    ]
+    assert not any(chunks)
+    assert metrics.ttfp_calls == []
+    assert metrics.underrun_calls == []
+    assert metrics.continuity_calls == []
diff --git a/tests/entrypoints/openai_api/test_serving_speech_stream.py b/tests/entrypoints/openai_api/test_serving_speech_stream.py
index 6414ab4ff..1d34b6e0b 100644
--- a/tests/entrypoints/openai_api/test_serving_speech_stream.py
+++ b/tests/entrypoints/openai_api/test_serving_speech_stream.py
@@ -48,7 +48,15 @@ def _build_test_app(
         speech_service.forced_aligner_enabled = False
 
         async def mock_generate_pcm_chunks(
-            _generator, _request_id, *, include_sample_rate=False, tts_params=None, collect=None
+            _generator,
+            _request_id,
+            *,
+            request_start_s=None,
+            request_arrival_ts=None,
+            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
@@ -249,6 +257,7 @@ class TestStreamingSpeechWebSocket:
 
     def test_streaming_multiple_binary_frames(self, mocker: MockerFixture):
         captured_requests = []
+        captured_timing = {}
         captured_tts_params = []
 
         speech_service = mocker.MagicMock(spec=OmniOpenAIServingSpeech)
@@ -257,13 +266,27 @@ class TestStreamingSpeechWebSocket:
         speech_service.engine_client.abort = mocker.AsyncMock()
         speech_service.forced_aligner_enabled = False
 
-        async def mock_prepare_speech_generation(request):
+        async def mock_prepare_speech_generation(request, *, arrival_time=None):
             captured_requests.append(request)
+            assert arrival_time is not None
+            captured_timing["prepare_arrival"] = arrival_time
             return "req-stream", object(), {"_qwen3_tts_effective_max_tokens": [192]}
 
         speech_service._prepare_speech_generation = mock_prepare_speech_generation
 
-        async def mock_generate_pcm_chunks(_generator, _request_id, *, include_sample_rate=False, tts_params=None):
+        async def mock_generate_pcm_chunks(
+            _generator,
+            _request_id,
+            *,
+            request_start_s=None,
+            request_arrival_ts=None,
+            include_sample_rate=False,
+            tts_params=None,
+        ):
+            assert request_start_s is not None
+            assert request_arrival_ts is not None
+            captured_timing["chunk_start"] = request_start_s
+            captured_timing["chunk_arrival"] = request_arrival_ts
             captured_tts_params.append(tts_params)
             for chunk in (b"\x01\x02", b"\x03\x04\x05", b"\x06"):
                 yield (chunk, 24000) if include_sample_rate else chunk
@@ -309,6 +332,8 @@ class TestStreamingSpeechWebSocket:
         assert captured_requests[0].stream is True
         assert captured_requests[0].response_format == "pcm"
         assert captured_requests[0].initial_codec_chunk_frames == 12
+        assert captured_timing["prepare_arrival"] == captured_timing["chunk_arrival"]
+        assert captured_timing["chunk_start"] > 0
         assert captured_tts_params == [{"_qwen3_tts_effective_max_tokens": [192]}]
         assert speech_service._generate_audio_bytes.await_count == 0
 
@@ -341,8 +366,9 @@ class TestStreamingSpeechWebSocket:
         speech_service.engine_client.abort = mocker.AsyncMock()
         speech_service.forced_aligner_enabled = True
 
-        async def mock_prepare_speech_generation(request):
+        async def mock_prepare_speech_generation(request, *, arrival_time=None):
             captured_requests.append(request)
+            assert arrival_time is not None
             return "req-stream", object(), {}
 
         speech_service._prepare_speech_generation = mock_prepare_speech_generation
@@ -353,8 +379,19 @@ class TestStreamingSpeechWebSocket:
         # The forced-aligner stage rides the same generator: its pooling output
         # is surfaced via the ``collect`` channel once the audio has streamed.
         async def mock_generate_pcm_chunks(
-            _generator, _request_id, *, include_sample_rate=False, tts_params=None, collect=None
+            _generator,
+            _request_id,
+            *,
+            request_start_s=None,
+            request_arrival_ts=None,
+            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:
@@ -438,7 +475,15 @@ class TestStreamingSpeechWebSocket:
         speech_service._prepare_speech_generation = mocker.AsyncMock(return_value=("req", object(), {}))
 
         async def mock_generate_pcm_chunks(
-            _generator, _request_id, *, include_sample_rate=False, tts_params=None, collect=None
+            _generator,
+            _request_id,
+            *,
+            request_start_s=None,
+            request_arrival_ts=None,
+            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
@@ -620,7 +665,15 @@ class TestStreamingSpeechWebSocket:
         speech_service.engine_client.abort = mocker.AsyncMock()
         speech_service.forced_aligner_enabled = False
 
-        async def mock_generate_pcm_chunks(_generator, _request_id, *, include_sample_rate=False, tts_params=None):
+        async def mock_generate_pcm_chunks(
+            _generator,
+            _request_id,
+            *,
+            request_start_s=None,
+            request_arrival_ts=None,
+            include_sample_rate=False,
+            tts_params=None,
+        ):
             yield b"\x01\x02"
             raise RuntimeError("stream boom")
 
@@ -716,7 +769,15 @@ class TestStreamingSpeechWebSocket:
         speech_service.engine_client.abort = mocker.AsyncMock()
         speech_service.forced_aligner_enabled = False
 
-        async def mock_generate_pcm_chunks(_generator, _request_id, *, include_sample_rate=False, tts_params=None):
+        async def mock_generate_pcm_chunks(
+            _generator,
+            _request_id,
+            *,
+            request_start_s=None,
+            request_arrival_ts=None,
+            include_sample_rate=False,
+            tts_params=None,
+        ):
             yield b"\x01\x02"
 
         speech_service._generate_pcm_chunks = mock_generate_pcm_chunks
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 e57e3e279..d8eccb6e4 100644
--- a/tests/entrypoints/openai_api/test_serving_video_output_stream.py
+++ b/tests/entrypoints/openai_api/test_serving_video_output_stream.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 `/v1/realtime/video` WebSocket video output streaming."""
 
 from __future__ import annotations
@@ -7,12 +7,13 @@ from __future__ import annotations
 import asyncio
 import json
 from collections.abc import AsyncGenerator, Callable
+from http import HTTPStatus
 from types import SimpleNamespace
 from unittest.mock import MagicMock
 
 import numpy as np
 import pytest
-from fastapi import FastAPI, WebSocket
+from fastapi import FastAPI, HTTPException, WebSocket
 from pytest_mock import MockerFixture
 from starlette.testclient import TestClient
 
@@ -957,3 +958,100 @@ class TestStreamingVideoOutputPromptUpdate:
                 "transition_chunks": 2,
             },
         )
+
+    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."""
+
+    @staticmethod
+    def _handler() -> OmniStreamingVideoOutputHandler:
+        handler = object.__new__(OmniStreamingVideoOutputHandler)
+        handler._engine_client = SimpleNamespace(default_sampling_params_list=[])
+        return handler
+
+    async def test_preencode_mp4_is_rejected_for_streaming_sessions(self):
+        """Worker-side pre-encoding emits one progressive MP4 the fMP4 encoder cannot consume."""
+        request = VideoGenerationRequest(prompt="p", extra_params={"preencode_mp4": True})
+
+        with pytest.raises(HTTPException) as excinfo:
+            await self._handler()._build_prompt_and_sampling_params(request)
+
+        assert excinfo.value.status_code == HTTPStatus.BAD_REQUEST.value
+        assert "preencode_mp4" in excinfo.value.detail
+
+    async def test_other_extra_params_still_reach_the_engine(self):
+        request = VideoGenerationRequest(prompt="p", extra_params={"flow_shift": 3.0})
+
+        _, gen_params, _ = await self._handler()._build_prompt_and_sampling_params(request)
+
+        assert gen_params.extra_args["flow_shift"] == 3.0
diff --git a/tests/entrypoints/openai_api/test_serving_video_stream.py b/tests/entrypoints/openai_api/test_serving_video_stream.py
index bc80fe0db..c9c4f6a4b 100644
--- a/tests/entrypoints/openai_api/test_serving_video_stream.py
+++ b/tests/entrypoints/openai_api/test_serving_video_stream.py
@@ -1,19 +1,26 @@
 # 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 the serving-layer streaming video WebSocket handler."""
 
 from __future__ import annotations
 
 import asyncio
 import base64
+import gc
 import io
 import json
 import threading
+import weakref
 from typing import Any
+from unittest.mock import AsyncMock, MagicMock
 
 import pytest
+import torch
 from PIL import Image
+from vllm.sampling_params import RequestOutputKind, SamplingParams
 
+from tests.helpers.serving_chat import build_serving_chat
+from vllm_omni.config.stage_config import StageConfig
 from vllm_omni.entrypoints.openai import video_stream_base, video_stream_envs
 from vllm_omni.entrypoints.openai.serving_video_stream import (
     QwenOmniStreamingVideoHandler,
@@ -38,10 +45,10 @@ def _b64(data: bytes) -> str:
 
 def _text_result(text: str) -> OmniRequestOutput:
     class Output:
-        pass
+        text: str
 
     class RequestOutput:
-        pass
+        outputs: list[Output]
 
     output = Output()
     output.text = text
@@ -52,10 +59,10 @@ def _text_result(text: str) -> OmniRequestOutput:
 
 def _audio_result(audio_data: Any) -> OmniRequestOutput:
     class Output:
-        pass
+        multimodal_output: dict[str, Any]
 
     class RequestOutput:
-        pass
+        outputs: list[Output]
 
     output = Output()
     output.multimodal_output = {"audio": audio_data}
@@ -138,6 +145,130 @@ async def test_receive_config_accepts_client_legacy_aliases():
     assert config.frame_filter_threshold == 0.87
 
 
+@pytest.fixture
+def run_sampling_session(monkeypatch):
+    async def run(config_overrides):
+        engine = MagicMock()
+        engine.stage_configs = [
+            StageConfig(stage_id=index, model_stage=name)
+            for index, name in enumerate(("thinker", "talker", "code2wav"))
+        ]
+        engine.default_sampling_params_list = [
+            SamplingParams(temperature=0.4, max_tokens=64, top_p=0.85),
+            SamplingParams(temperature=0.7, max_tokens=96),
+            SamplingParams(temperature=0.8, max_tokens=128),
+        ]
+
+        async def generate(**kwargs):
+            yield _text_result("answer")
+
+        engine.generate.side_effect = generate
+        handler = QwenOmniStreamingVideoHandler(
+            chat_service=build_serving_chat(engine_client=engine),
+            engine_client=engine,
+        )
+        monkeypatch.setattr(handler, "_preprocess_to_engine_prompt", AsyncMock(return_value={"prompt": "video"}))
+        ws = MockWebSocket(
+            [
+                json.dumps(
+                    {
+                        "type": "session.config",
+                        "model": "test",
+                        "modalities": ["text"],
+                        "enable_frame_filter": False,
+                        **config_overrides,
+                    }
+                ),
+                json.dumps({"type": "video.frame", "data": _b64(_make_jpeg())}),
+                json.dumps({"type": "video.query", "text": "describe"}),
+                json.dumps({"type": "video.done"}),
+            ]
+        )
+        await handler.handle_session(ws)
+        return ws, engine
+
+    return run
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("async_chunk_mode", ["on", "off"])
+@pytest.mark.parametrize("num_stage_overrides", [1, 3])
+async def test_video_sampling_params_reach_engine(
+    run_sampling_session, monkeypatch, async_chunk_mode, num_stage_overrides
+):
+    monkeypatch.setenv("VLLM_VIDEO_ASYNC_CHUNK", async_chunk_mode)
+    overrides = [
+        {"temperature": 0.2, "max_tokens": 1, "seed": 42},
+        {"temperature": 0.6, "max_tokens": 12},
+        {"temperature": 0.9, "max_tokens": 24},
+    ][:num_stage_overrides]
+
+    ws, engine = await run_sampling_session({"sampling_params_list": overrides})
+
+    assert not [msg for msg in ws.sent if msg["type"] == "error"]
+    engine.generate.assert_called_once()
+    params = engine.generate.call_args.kwargs["sampling_params_list"]
+    assert len(params) == 3
+    for index, param in enumerate(params):
+        assert isinstance(param, SamplingParams)
+        default = engine.default_sampling_params_list[index]
+        expected = (
+            overrides[index]
+            if index < len(overrides)
+            else {
+                "temperature": default.temperature,
+                "max_tokens": default.max_tokens,
+            }
+        )
+        assert param.temperature == expected["temperature"]
+        assert param.max_tokens == expected["max_tokens"]
+        assert param.output_kind == RequestOutputKind.DELTA
+        assert param is not default
+    assert params[0].seed == 42
+    assert all(param.output_kind == RequestOutputKind.CUMULATIVE for param in engine.default_sampling_params_list)
+    assert next(msg for msg in ws.sent if msg["type"] == "response.text.done")["text"] == "answer"
+
+
+@pytest.mark.asyncio
+async def test_video_sampling_params_provided_stage_uses_constructor_defaults(run_sampling_session):
+    ws, engine = await run_sampling_session({"sampling_params_list": [{"temperature": 0.2}]})
+
+    assert not [msg for msg in ws.sent if msg["type"] == "error"]
+    engine.generate.assert_called_once()
+    params = engine.generate.call_args.kwargs["sampling_params_list"]
+    constructor_defaults = SamplingParams()
+    assert params[0].temperature == 0.2
+    for field in ("max_tokens", "top_p"):
+        assert getattr(params[0], field) == getattr(constructor_defaults, field)
+        assert getattr(params[0], field) != getattr(engine.default_sampling_params_list[0], field)
+    assert len(params) == 3
+    for param, default in zip(params[1:], engine.default_sampling_params_list[1:]):
+        assert param.temperature == default.temperature
+        assert param.max_tokens == default.max_tokens
+        assert param.top_p == default.top_p
+        assert param is not default
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("config_overrides", [{}, {"sampling_params_list": None}, {"sampling_params_list": []}])
+async def test_video_sampling_params_omitted_preserve_engine_defaults(run_sampling_session, config_overrides):
+    ws, engine = await run_sampling_session(config_overrides)
+
+    assert not [msg for msg in ws.sent if msg["type"] == "error"]
+    engine.generate.assert_called_once()
+    assert engine.generate.call_args.kwargs.get("sampling_params_list") is None
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("invalid_params", [{"temperature": -1}, {"max_tokens": 0}, {"unknown_sampling_option": 1}])
+async def test_video_sampling_params_invalid_do_not_reach_engine(run_sampling_session, invalid_params):
+    ws, engine = await run_sampling_session({"sampling_params_list": [invalid_params]})
+
+    engine.generate.assert_not_called()
+    assert any(msg["type"] == "error" for msg in ws.sent)
+    assert ws.sent[-1]["type"] == "session.done"
+
+
 @pytest.mark.asyncio
 async def test_video_frame_ack_reports_receiver_buffer_state():
     ws = MockWebSocket(
@@ -244,6 +375,200 @@ async def test_video_frames_consumed_is_emitted_after_engine_uses_frame_prompt()
     )
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "num_frames,bad_index,expected_indices",
+    [
+        pytest.param(2, 4, [0], id="bad-last-no-refill"),
+        pytest.param(1, 4, [], id="all-selected-frames-bad"),
+        pytest.param(8, 4, [0, 1, 2, 3], id="below-sampling-limit"),
+        pytest.param(2, 1, [0, 4], id="bad-frame-not-selected"),
+        pytest.param(2, 0, [4], id="bad-first-frame"),
+    ],
+)
+async def test_video_frames_consumed_excludes_bad_frame_in_query_snapshot(
+    monkeypatch, num_frames, bad_index, expected_indices
+):
+    """A query queued before bad-frame cleanup must report only its prompt images."""
+    query_queued = asyncio.Event()
+    decode_failed = asyncio.Event()
+    release_decode = asyncio.Event()
+    pong_blocked = asyncio.Event()
+    release_pong = asyncio.Event()
+    turn_done = asyncio.Event()
+    original_to_thread = asyncio.to_thread
+    bad_image = b"not-a-jpeg"
+    frames = [_make_jpeg(r=index * 40) for index in range(5)]
+    frames[bad_index] = bad_image
+    engine_prompts = []
+
+    class ObservedQueue(asyncio.Queue):
+        def put_nowait(self, item):
+            super().put_nowait(item)
+            if isinstance(item, dict):
+                if item.get("type") == "video.query":
+                    query_queued.set()
+                elif item.get("type") == "_internal.frame_decode_failed":
+                    decode_failed.set()
+
+    async def gated_to_thread(function, *args, **kwargs):
+        if function is video_stream_base._decode_frame_bytes and args[0] == bad_image:
+            await release_decode.wait()
+        return await original_to_thread(function, *args, **kwargs)
+
+    class BackpressuredWebSocket(TimedWebSocket):
+        async def send_json(self, data):
+            await super().send_json(data)
+            if data["type"] == "pong":
+                pong_blocked.set()
+                await release_pong.wait()
+            elif data["type"] == "response.text.done":
+                turn_done.set()
+
+    class OneOutputEngine:
+        async def generate(self, **kwargs):
+            engine_prompts.append(kwargs["prompt"])
+            yield _text_result("visible")
+
+    class CapturingHandler(QwenOmniStreamingVideoHandler):
+        async def _preprocess_to_engine_prompt(self, request):
+            return {"messages": request.messages}
+
+    # Construct the client queue before observing the server's message queue.
+    ws = BackpressuredWebSocket()
+    monkeypatch.setattr(asyncio, "Queue", ObservedQueue)
+    monkeypatch.setattr(asyncio, "to_thread", gated_to_thread)
+    handler = CapturingHandler(chat_service=object(), engine_client=OneOutputEngine(), idle_timeout=5.0)
+    ws.put(
+        {
+            "type": "session.config",
+            "model": "test",
+            "modalities": ["text"],
+            "num_frames": num_frames,
+            "enable_frame_filter": False,
+        }
+    )
+    for index, frame in enumerate(frames):
+        ws.put({"type": "video.frame", "data": _b64(frame), "frame_id": f"frame-{index}", "pts_ms": index * 100})
+    ws.put({"type": "ping"})
+    ws.put({"type": "video.query", "text": "describe"})
+    task = asyncio.create_task(handler.handle_session(ws))
+    try:
+        # Hold the processor at a WebSocket send. Queue the query first, then
+        # finish the real failing decode so its cleanup lands behind the query.
+        await asyncio.wait_for(pong_blocked.wait(), timeout=5.0)
+        await asyncio.wait_for(query_queued.wait(), timeout=5.0)
+        release_decode.set()
+        await asyncio.wait_for(decode_failed.wait(), timeout=5.0)
+        release_pong.set()
+        await asyncio.wait_for(turn_done.wait(), timeout=5.0)
+        ws.put({"type": "video.done"})
+        await asyncio.wait_for(task, timeout=5.0)
+    finally:
+        release_decode.set()
+        release_pong.set()
+        if not task.done():
+            task.cancel()
+        await asyncio.gather(task, return_exceptions=True)
+
+    assert len(engine_prompts) == 1
+    images = [part for part in engine_prompts[0]["messages"][-1]["content"] if part["type"].startswith("image_")]
+    # Expected positions preserve sample-then-filter: do not refill a dropped
+    # position or shift the remaining metadata when a frame fails to decode.
+    assert len(images) == len(expected_indices)
+    for image, index in zip(images, expected_indices):
+        if image["type"] == "image_pil":
+            assert image["image_pil"].tobytes() == Image.open(io.BytesIO(frames[index])).convert("RGB").tobytes()
+        else:
+            assert image["image_url"]["url"] == f"data:image/jpeg;base64,{_b64(frames[index])}"
+    consumed_events = [message for message in ws.sent if message.get("type") == "video.frames.consumed"]
+    assert len(consumed_events) == 1
+    consumed = consumed_events[0]
+    expected_ids = [f"frame-{index}" for index in expected_indices]
+    assert consumed["frame_ids"] == expected_ids
+    assert [frame["frame_id"] for frame in consumed["frames"]] == expected_ids
+    assert [frame["pts_ms"] for frame in consumed["frames"]] == [index * 100 for index in expected_indices]
+    assert consumed["latest_pts_ms"] == (expected_indices[-1] * 100 if expected_indices else None)
+    assert {"type": "error", "message": "Frame decode failed"} in ws.sent
+    assert ws.sent[-1]["type"] == "session.done"
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "num_frames,frame_ids,repeat_image,expected_indices",
+    [
+        pytest.param(2, ["f0", "f1", "f2", "f3", "f4"], False, [0, 4], id="stride-and-last"),
+        pytest.param(1, ["f0", "f1", "f2"], False, [2], id="last-only"),
+        pytest.param(8, ["f0", "f1", "f2"], False, [0, 1, 2], id="below-sampling-limit"),
+        pytest.param(2, [None, "f1", None, "f3", None], False, [0, 4], id="unidentified-selected-frames"),
+        pytest.param(2, [None, None, None], False, [0, 2], id="no-frame-ids"),
+        pytest.param(2, ["same", "same", "same"], False, [0, 2], id="repeated-frame-id"),
+        pytest.param(2, ["f0", "f1", "f2"], True, [0, 2], id="repeated-image"),
+    ],
+)
+async def test_video_frame_selection_preserves_uncached_frames(
+    monkeypatch, num_frames, frame_ids, repeat_image, expected_indices
+):
+    """Prewarm misses still use image URLs, with metadata paired by buffer position."""
+    engine_prompts = []
+    pending_decode = asyncio.Event()
+
+    async def blocked_to_thread(*args, **kwargs):
+        await pending_decode.wait()
+
+    monkeypatch.setattr(asyncio, "to_thread", blocked_to_thread)
+
+    class OneOutputEngine:
+        async def generate(self, **kwargs):
+            engine_prompts.append(kwargs["prompt"])
+            yield _text_result("visible")
+
+    class CapturingHandler(QwenOmniStreamingVideoHandler):
+        async def _preprocess_to_engine_prompt(self, request):
+            return {"messages": request.messages}
+
+    frames = [_b64(_make_jpeg(r=0 if repeat_image else index * 40)) for index in range(len(frame_ids))]
+    messages = [
+        {
+            "type": "session.config",
+            "model": "test",
+            "modalities": ["text"],
+            "num_frames": num_frames,
+            "enable_frame_filter": False,
+        },
+        *[
+            {"type": "video.frame", "data": frame, "frame_id": frame_ids[index], "pts_ms": index * 100}
+            for index, frame in enumerate(frames)
+        ],
+        {"type": "video.query", "text": "describe"},
+        {"type": "video.done"},
+    ]
+    ws = MockWebSocket([json.dumps(message) for message in messages])
+    handler = CapturingHandler(chat_service=object(), engine_client=OneOutputEngine())
+    await asyncio.wait_for(handler.handle_session(ws), timeout=5.0)
+
+    assert not [message for message in ws.sent if message["type"] == "error"]
+    assert len(engine_prompts) == 1
+    content = engine_prompts[0]["messages"][-1]["content"]
+    assert content == [
+        *[
+            {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{frames[index]}"}}
+            for index in expected_indices
+        ],
+        {"type": "text", "text": "describe"},
+    ]
+    consumed_events = [message for message in ws.sent if message["type"] == "video.frames.consumed"]
+    if not any(frame_ids):
+        assert consumed_events == []
+    else:
+        assert len(consumed_events) == 1
+        consumed = consumed_events[0]
+        assert consumed["frame_ids"] == [frame_ids[index] for index in expected_indices if frame_ids[index] is not None]
+        assert [frame["frame_id"] for frame in consumed["frames"]] == [frame_ids[index] for index in expected_indices]
+        assert [frame["pts_ms"] for frame in consumed["frames"]] == [index * 100 for index in expected_indices]
+        assert consumed["latest_pts_ms"] == expected_indices[-1] * 100
+
+
 @pytest.mark.asyncio
 async def test_audio_in_video_sets_mm_processor_kwargs():
     captured_requests = []
@@ -455,6 +780,54 @@ async def test_async_chunk_mode_is_read_by_engine_path_at_runtime(monkeypatch):
     assert not any(m.get("type") == "response.text.delta" for m in ws_off.sent)
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize("async_chunk_mode", ["on", "off"])
+async def test_audio_events_use_output_audio_names(monkeypatch, async_chunk_mode):
+    class AudioEngine:
+        def generate(self, **_kwargs):
+            async def _gen():
+                yield _audio_result([torch.zeros(1)])
+
+            return _gen()
+
+    class AudioHandler(QwenOmniStreamingVideoHandler):
+        async def _preprocess_to_engine_prompt(self, request):
+            return {"prompt": "x"}
+
+    monkeypatch.setenv("VLLM_VIDEO_ASYNC_CHUNK", async_chunk_mode)
+    monkeypatch.setattr(
+        OmniStreamingVideoHandler,
+        "_encode_audio_wav_b64",
+        staticmethod(lambda _audio: "audio-b64"),
+    )
+
+    ws = MockWebSocket()
+    handler = AudioHandler(chat_service=object(), engine_client=AudioEngine())
+    config = StreamingVideoSessionConfig(model="test", modalities=["text", "audio"])
+
+    await handler._process_query_engine(
+        ws,
+        config,
+        [_b64(_make_jpeg())],
+        bytearray(),
+        [],
+        "describe",
+        "req-audio-events",
+        asyncio.Event(),
+        {},
+    )
+
+    audio_events = [message for message in ws.sent if "audio" in message.get("type", "")]
+    assert audio_events == [
+        {
+            "type": "response.output_audio.delta",
+            "data": "audio-b64",
+            "format": "wav",
+        },
+        {"type": "response.output_audio.done"},
+    ]
+
+
 @pytest.mark.asyncio
 async def test_query_without_engine_client_sends_error():
     ws = MockWebSocket()
@@ -513,6 +886,88 @@ async def test_new_query_cancels_in_flight_query():
     assert "session.done" in ws.sent_types()
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize("delay_abort", [False, True], ids=["immediate-ack", "delayed-ack"])
+async def test_interrupted_queries_wait_for_abort_without_fixed_delay(monkeypatch, delay_abort):
+    started: asyncio.Queue[str] = asyncio.Queue()
+    abort_started: asyncio.Queue[str] = asyncio.Queue()
+    allow_abort = asyncio.Event()
+    if not delay_abort:
+        allow_abort.set()
+    request_ids: list[str] = []
+    closed: list[str] = []
+    aborted: list[str] = []
+    delays: list[float] = []
+    original_sleep = asyncio.sleep
+
+    async def record_sleep(delay, result=None):
+        # Observe requested delays without a machine-dependent latency limit.
+        delays.append(delay)
+        return await original_sleep(0, result)
+
+    monkeypatch.setattr(video_stream_base.asyncio, "sleep", record_sleep)
+
+    class BlockingEngine:
+        async def generate(self, *, request_id, **kwargs):
+            if request_ids:
+                assert aborted[-1] == request_ids[-1]
+            request_ids.append(request_id)
+            started.put_nowait(request_id)
+            try:
+                if len(request_ids) <= 3:
+                    yield _text_result("partial")
+                    await asyncio.Event().wait()
+                else:
+                    yield _text_result("final")
+            finally:
+                closed.append(request_id)
+
+        async def abort(self, request_id):
+            assert request_id in closed
+            abort_started.put_nowait(request_id)
+            await allow_abort.wait()
+            aborted.append(request_id)
+
+    class PreprocessedHandler(QwenOmniStreamingVideoHandler):
+        async def _preprocess_to_engine_prompt(self, request):
+            return {"prompt_token_ids": [1]}
+
+    ws = TimedWebSocket()
+    handler = PreprocessedHandler(chat_service=object(), engine_client=BlockingEngine(), idle_timeout=5.0)
+    task = asyncio.create_task(handler.handle_session(ws))
+    try:
+        ws.put({"type": "session.config", "modalities": ["text"], "enable_frame_filter": False})
+        ws.put({"type": "video.frame", "data": _b64(_make_jpeg())})
+        ws.put({"type": "video.query", "text": "first"})
+        previous_id = await asyncio.wait_for(started.get(), timeout=2.0)
+
+        for _ in range(3):
+            ws.put({"type": "video.query", "text": "interrupt"})
+            assert await asyncio.wait_for(abort_started.get(), timeout=2.0) == previous_id
+            if delay_abort:
+                assert previous_id not in aborted
+                assert started.empty()
+                allow_abort.set()
+            previous_id = await asyncio.wait_for(started.get(), timeout=2.0)
+            if delay_abort:
+                allow_abort.clear()
+
+        ws.put({"type": "video.done"})
+        await asyncio.wait_for(task, timeout=2.0)
+
+        assert aborted == request_ids[:-1]
+        assert len(set(request_ids)) == 4
+        assert [msg["text"] for msg in ws.sent if msg["type"] == "response.text.done"] == ["final"]
+        assert "error" not in ws.sent_types()
+        assert "session.done" in ws.sent_types()
+        assert not [delay for delay in delays if delay > 0], "Restart must not add a timed grace period after abort"
+    finally:
+        allow_abort.set()
+        if not task.done():
+            task.cancel()
+        await asyncio.gather(task, return_exceptions=True)
+
+
 @pytest.mark.asyncio
 async def test_video_done_waits_for_in_flight_query():
     query_started = asyncio.Event()
@@ -588,6 +1043,68 @@ async def test_frame_prewarm_does_not_block_following_query(monkeypatch):
     assert "session.done" in ws.sent_types()
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize("max_frames", [1, 2], ids=["evicted", "retained"])
+async def test_frame_prewarm_only_keeps_retained_images(monkeypatch, max_frames):
+    frame_a = _make_jpeg(255, 0, 0)
+    frame_b = _make_jpeg(0, 255, 0)
+    decode_started = asyncio.Event()
+    release_decode = asyncio.Event()
+    frame_b_accepted = asyncio.Event()
+    decoded_images: dict[bytes, weakref.ReferenceType[Image.Image]] = {}
+    prewarm_task: asyncio.Task | None = None
+    original_to_thread = asyncio.to_thread
+
+    async def controlled_to_thread(function, *args, **kwargs):
+        nonlocal prewarm_task
+        if function is video_stream_base._decode_frame_bytes:
+            if args[0] == frame_a:
+                prewarm_task = asyncio.current_task()
+                decode_started.set()
+                await release_decode.wait()
+            image = await original_to_thread(function, *args, **kwargs)
+            decoded_images[args[0]] = weakref.ref(image)
+            return image
+        return await original_to_thread(function, *args, **kwargs)
+
+    class AckWebSocket(TimedWebSocket):
+        async def send_json(self, data):
+            await super().send_json(data)
+            if data.get("type") == "video.frame.ack" and data.get("frame_id") == "B":
+                frame_b_accepted.set()
+
+    monkeypatch.setattr(video_stream_base.asyncio, "to_thread", controlled_to_thread)
+    ws = AckWebSocket()
+    handler = QwenOmniStreamingVideoHandler(chat_service=object(), idle_timeout=5.0)
+    session_task = asyncio.create_task(handler.handle_session(ws))
+    ws.put({"type": "session.config", "max_frames": max_frames, "enable_frame_filter": False})
+    try:
+        ws.put({"type": "video.frame", "frame_id": "A", "data": _b64(frame_a)})
+        await asyncio.wait_for(decode_started.wait(), timeout=5.0)
+        ws.put({"type": "video.frame", "frame_id": "B", "data": _b64(frame_b)})
+        await asyncio.wait_for(frame_b_accepted.wait(), timeout=5.0)
+        ack = next(message for message in ws.sent if message.get("frame_id") == "B")
+        assert ack["accepted"] is True
+        assert ack.get("dropped_frame_id") == ("A" if max_frames == 1 else None)
+
+        # Finish A's real decode only after B has either evicted A or joined it.
+        release_decode.set()
+        assert prewarm_task is not None
+        await asyncio.wait_for(asyncio.shield(prewarm_task), timeout=5.0)
+        gc.collect()
+        assert not session_task.done()
+        # A finished task must not keep an evicted PIL image alive for the session.
+        assert (decoded_images[frame_a]() is not None) == (max_frames == 2)
+    finally:
+        release_decode.set()
+        ws.put({"type": "video.done"})
+        await asyncio.wait_for(session_task, timeout=5.0)
+
+    gc.collect()
+    assert decoded_images[frame_a]() is None
+    assert not any(message.get("type") == "error" for message in ws.sent)
+
+
 @pytest.mark.asyncio
 async def test_client_cannot_send_internal_frame_decode_failed_message():
     captured_frames: list[list[str]] = []
diff --git a/tests/entrypoints/openai_api/test_tts_adapter.py b/tests/entrypoints/openai_api/test_tts_adapter.py
index a17a6ccbd..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 (
@@ -65,10 +66,11 @@ EXPECTED_MODEL_TYPES = {
     "higgs_audio_v2",
     "higgs_audio_v3",
     "glm_tts",
+    "breeze_tts_2",
     "step_audio2",
     "indextts2",
     "indextts2_5",
-    "dots_tts",
+    "gepard",
 }
 
 
@@ -97,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.
 
@@ -142,6 +169,17 @@ def _build_moss_tts_request(adapter_cls, mocker, *, request_seed):
     )
 
 
+@pytest.mark.parametrize(
+    ("adapter_cls", "expect_accumulate"),
+    [(MossTTSAdapter, False), (MossTTSNanoAdapter, True)],
+)
+def test_moss_tts_accumulate_nonstreaming_follows_adapter_flag(adapter_cls, expect_accumulate, mocker):
+    prepared = _build_moss_tts_request(adapter_cls, mocker, request_seed=7)
+
+    assert adapter_cls.accumulate_nonstreaming is expect_accumulate
+    assert prepared.output_policy.accumulate_nonstreaming is expect_accumulate
+
+
 # Full-family coverage pins the adapter contract; only Nano consumes this seed end to end today.
 @pytest.mark.parametrize("adapter_cls", [MossTTSAdapter, MossTTSNanoAdapter])
 @pytest.mark.parametrize("request_seed", [0, 1234])
@@ -216,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 d54ce36d5..8ecb137a2 100644
--- a/tests/entrypoints/openai_api/test_tts_detection.py
+++ b/tests/entrypoints/openai_api/test_tts_detection.py
@@ -1,4 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """TTS model detection: registry-driven stage -> model-type resolution.
 
 ``serving_speech.py`` used to carry a hand-written 20-branch ladder mapping
@@ -138,6 +139,7 @@ _PIPELINE_STAGES = [
     "audio_tokenizer",
     "audio_vae",
     "aura",
+    "breeze_tts_2",
     "code2wav",
     "cosyvoice3_code2wav",
     "cosyvoice3_talker",
@@ -146,6 +148,7 @@ _PIPELINE_STAGES = [
     "dit",
     "fish_speech_slow_ar",
     "fused_thinker_talker",
+    "gepard",
     "glm_tts",
     "glm_tts_dit",
     "higgs_audio_v2",
@@ -184,6 +187,7 @@ _STAGES = [*_PIPELINE_STAGES, None, "vae", "not_a_real_stage"]
 _ARCHS = [
     None,
     "VoxCPM2TalkerForConditionalGeneration",
+    "BreezeForConditionalGeneration",
     "MingTTSForConditionalGeneration",
     "CovoAudioForConditionalGeneration",
     "MyCovoAudioThing",
@@ -259,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 b65b00e59..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
@@ -25,6 +26,7 @@ from PIL import Image
 from pytest_mock import MockerFixture
 from vllm import envs
 
+from vllm_omni.diffusion.data import DIFFUSION_REQUEST_LIFECYCLE_KEY, DIFFUSION_REQUEST_STARTED
 from vllm_omni.diffusion.utils.media_utils import mux_video_audio_bytes
 from vllm_omni.entrypoints.openai import api_server, video_api_utils
 from vllm_omni.entrypoints.openai.api_server import router
@@ -58,6 +60,7 @@ class MockVideoResult:
         multimodal_output=None,
         stage_durations=None,
         peak_memory_mb=0.0,
+        custom_output=None,
     ):
         self.multimodal_output = dict(multimodal_output or {"video": videos})
         if audios is not None:
@@ -66,6 +69,7 @@ class MockVideoResult:
             self.multimodal_output["audio_sample_rate"] = sample_rate
         self.stage_durations = stage_durations or {}
         self.peak_memory_mb = peak_memory_mb
+        self.custom_output = custom_output or {}
 
 
 class FakeAsyncOmni:
@@ -81,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
 
@@ -101,10 +106,22 @@ 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(
+                [],
+                custom_output={DIFFUSION_REQUEST_LIFECYCLE_KEY: DIFFUSION_REQUEST_STARTED},
+            )
         videos = [object() for _ in range(num_outputs)]
         yield MockVideoResult(videos)
 
+    async def abort(self, request_id, *, timeout=None):
+        del request_id, timeout
+
 
 def test_raw_and_base64_encoders_receive_persistent_converter(mocker: MockerFixture):
     engine = FakeAsyncOmni()
@@ -134,6 +151,60 @@ def test_raw_and_base64_encoders_receive_persistent_converter(mocker: MockerFixt
     handler.shutdown()
 
 
+@pytest.mark.parametrize("batch_frames", [0, -1, True, 1.5, "17", None])
+def test_preencode_rejects_invalid_batch_frames_before_generation(batch_frames):
+    engine = FakeAsyncOmni()
+    handler = OmniOpenAIServingVideo.for_diffusion(engine, model_name="test-model")
+    request = VideoGenerationRequest(
+        prompt="test", extra_params={"preencode_mp4": True, "preencode_batch_frames": batch_frames}
+    )
+    try:
+        with pytest.raises(HTTPException, match="preencode_batch_frames") as exc:
+            asyncio.run(handler.generate_video_bytes(request, "invalid-batch"))
+        assert exc.value.status_code == 400
+        assert engine.captured_prompt is None
+    finally:
+        handler.shutdown()
+
+
+def test_preencoded_video_bytes_preserve_metadata(mocker: MockerFixture):
+    from vllm_omni.entrypoints.openai.serving_video import VideoGenerationArtifacts
+
+    handler = OmniOpenAIServingVideo.for_diffusion(FakeAsyncOmni(), model_name="test-model")
+    # Resolved frame count differs from anything the request asked for, so the
+    # metadata has to come from the encoded stream rather than request defaults.
+    preencoded = _make_test_video_bytes((32, 24), num_frames=7)
+    artifacts = VideoGenerationArtifacts(
+        videos=[preencoded],
+        audios=[None],
+        actions=[None],
+        audio_sample_rate=24000,
+        output_fps=24.0,
+        stage_durations={"decode": 0.5},
+        peak_memory_mb=123.0,
+        metrics={"generation_time": 1.25},
+    )
+    mocker.patch.object(handler, "_run_and_extract", return_value=artifacts)
+    encoder = mocker.patch("vllm_omni.entrypoints.openai.serving_video._encode_video_bytes")
+    try:
+        result = asyncio.run(handler.generate_video_bytes(VideoGenerationRequest(prompt="test"), "preencoded"))
+        assert result == (
+            preencoded,
+            {"decode": 0.5},
+            123.0,
+            None,
+            {
+                "fps": 24.0,
+                "num_frames": 7,
+                "duration_s": 7 / 24.0,
+                "metrics": {"generation_time": 1.25},
+            },
+        )
+        encoder.assert_not_called()
+    finally:
+        handler.shutdown()
+
+
 def test_resolve_diffusion_od_config_falls_back_to_attribute():
     od_config = SimpleNamespace(model_class_name="WanPipeline")
     handler = OmniOpenAIServingVideo.for_diffusion(
@@ -159,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
@@ -170,9 +245,19 @@ class BlockingVideoHandler:
             self.stage_configs = stage_configs
 
     async def generate_video_bytes(
-        self, request, reference_id, *, reference_image=None, reference_video=None, reference_audio=None
+        self,
+        request,
+        reference_id,
+        *,
+        reference_image=None,
+        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()
         try:
             await asyncio.Future()
@@ -180,6 +265,106 @@ class BlockingVideoHandler:
             self.cancelled.set()
             raise
 
+    async def abort_request(self, request_id):
+        del request_id
+
+
+class HangingAbortHandler(BlockingVideoHandler):
+    """Engine abort never returns; DELETE must time out and still cancel."""
+
+    async def abort_request(self, request_id):
+        del request_id
+        await asyncio.sleep(30)
+
+
+class CompletingDuringAbortHandler(BlockingVideoHandler):
+    """Finishes and persists output while DELETE is still awaiting abort."""
+
+    def __init__(self):
+        super().__init__()
+        self._finish = asyncio.Event()
+
+    async def generate_video_bytes(
+        self,
+        request,
+        reference_id,
+        *,
+        reference_image=None,
+        reference_video=None,
+        reference_audio=None,
+        on_started=None,
+        latent_edit_input=None,
+    ):
+        del request, reference_image, reference_video, reference_audio, latent_edit_input
+        if on_started is not None:
+            await on_started()
+        self.started.set()
+        await self._finish.wait()
+        return b"late-complete", {}, 0.0, None
+
+    async def abort_request(self, request_id):
+        self._finish.set()
+        deadline = time.monotonic() + 2.0
+        while time.monotonic() < deadline:
+            job = await api_server.VIDEO_STORE.get(request_id)
+            if job is not None and job.status is VideoGenerationStatus.COMPLETED and job.file_name is not None:
+                return
+            await asyncio.sleep(0.01)
+        raise RuntimeError(f"video job {request_id} did not complete during abort")
+
+
+class SchedulerQueuedVideoHandler(BlockingVideoHandler):
+    """Parks after engine submission but before scheduler admission."""
+
+    def __init__(self):
+        super().__init__()
+        self.admit = threading.Event()
+        self.in_progress = threading.Event()
+
+    async def generate_video_bytes(
+        self,
+        request,
+        reference_id,
+        *,
+        reference_image=None,
+        reference_video=None,
+        reference_audio=None,
+        on_started=None,
+        latent_edit_input=None,
+    ):
+        del request, reference_id, reference_image, reference_video, reference_audio, latent_edit_input
+        self.started.set()
+        try:
+            while not self.admit.is_set():
+                await asyncio.sleep(0.01)
+            if on_started is not None:
+                await on_started()
+            self.in_progress.set()
+            await asyncio.Future()
+        except asyncio.CancelledError:
+            self.cancelled.set()
+            raise
+
+
+class AbortTrackingOmni(FakeAsyncOmni):
+    def __init__(self):
+        super().__init__()
+        self.aborted: list[str] = []
+        self.entered = threading.Event()
+
+    async def generate(self, prompt, request_id, sampling_params_list):
+        del prompt, request_id, sampling_params_list
+        self.entered.set()
+        yield MockVideoResult(
+            [],
+            custom_output={DIFFUSION_REQUEST_LIFECYCLE_KEY: DIFFUSION_REQUEST_STARTED},
+        )
+        await asyncio.Future()
+
+    async def abort(self, request_id, *, timeout=None):
+        assert timeout is not None
+        self.aborted.append(request_id)
+
 
 class FakeServerSocket:
     def __init__(self):
@@ -291,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(),
@@ -323,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)
@@ -538,12 +729,12 @@ def test_i2v_video_generation_resizes_input_to_requested_dimensions(test_client,
 
 def test_i2v_resize_policy_can_defer_to_pipeline(monkeypatch):
     engine = FakeAsyncOmni()
-    engine.get_diffusion_od_config = lambda: SimpleNamespace(
+    engine.get_diffusion_od_config = lambda: SimpleNamespace(  # type: ignore[method-assign]
         model="org/model",
         model_class_name="ExamplePipeline",
         revision="pinned-revision",
     )
-    captured = {}
+    captured: dict[str, str | None] = {}
 
     def fake_policy(model_class_name, *, model, revision=None):
         captured.update(
@@ -571,6 +762,7 @@ def test_i2v_resize_policy_can_defer_to_pipeline(monkeypatch):
         )
     )
 
+    assert engine.captured_prompt is not None
     input_image = engine.captured_prompt["multi_modal_data"]["image"]
     assert isinstance(input_image, Image.Image)
     assert input_image.size == (48, 32)
@@ -581,6 +773,32 @@ def test_i2v_resize_policy_can_defer_to_pipeline(monkeypatch):
     }
 
 
+def test_i2v_minimax_h3_preserves_reference_geometry():
+    engine = FakeAsyncOmni()
+    engine.model_class_name = "MiniMaxH3Pipeline"
+    handler = OmniOpenAIServingVideo.for_diffusion(
+        diffusion_engine=engine,
+        model_name="MiniMaxAI/MiniMax-H3",
+    )
+    image = Image.new("RGB", (48, 32))
+
+    asyncio.run(
+        handler._run_and_extract(
+            VideoGenerationRequest(prompt="A bear playing with yarn.", width=96, height=64),
+            "minimax-h3-reference-geometry",
+            reference_image=ReferenceImage(image),
+        )
+    )
+
+    assert engine.captured_prompt is not None
+    assert engine.captured_sampling_params_list is not None
+    input_image = engine.captured_prompt["multi_modal_data"]["image"]
+    assert isinstance(input_image, Image.Image)
+    assert input_image.size == (48, 32)
+    sampling_params = engine.captured_sampling_params_list[0]
+    assert (sampling_params.width, sampling_params.height) == (96, 64)
+
+
 def test_i2v_extra_params_dimensions_preserve_input_image_geometry(test_client, mocker: MockerFixture):
     image_bytes = _make_test_image_bytes((48, 48))
     mocker.patch(
@@ -638,6 +856,7 @@ def test_video_generation_bridges_request_fields(generation_request, expected_nu
 
     asyncio.run(handler._run_and_extract(generation_request, "field-bridge"))
 
+    assert engine.captured_sampling_params_list is not None
     sampling = engine.captured_sampling_params_list[0]
     # Top-level ``seconds`` bridges into extra_args["duration"]; num_frames is
     # passed through (or derived as seconds x fps when omitted). No private
@@ -934,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
@@ -991,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.",
@@ -1423,7 +1916,7 @@ def test_video_generation_response_exposes_action_payload(mocker: MockerFixture)
             },
         )
 
-    engine.generate = _generate
+    engine.generate = _generate  # type: ignore[method-assign]
     mocker.patch(
         "vllm_omni.entrypoints.openai.serving_video.encode_video_base64",
         return_value="encoded-video",
@@ -1549,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)
@@ -1773,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,
@@ -2016,6 +2537,80 @@ def test_delete_in_progress_job_cancels_task_and_removes_metadata(test_client):
     assert retrieve_resp.status_code == 404
 
 
+def test_async_video_stays_queued_until_scheduler_admission(test_client):
+    handler = SchedulerQueuedVideoHandler()
+    test_client.app.state.openai_serving_video = handler
+
+    create_resp = test_client.post("/v1/videos", data={"prompt": "Queue this video"})
+    assert create_resp.status_code == 200
+    video_id = create_resp.json()["id"]
+    assert handler.started.wait(timeout=2.0)
+
+    queued = test_client.get(f"/v1/videos/{video_id}")
+    assert queued.status_code == 200
+    assert queued.json()["status"] == VideoGenerationStatus.QUEUED.value
+
+    handler.admit.set()
+    assert handler.in_progress.wait(timeout=2.0)
+    in_progress = test_client.get(f"/v1/videos/{video_id}")
+    assert in_progress.status_code == 200
+    assert in_progress.json()["status"] == VideoGenerationStatus.IN_PROGRESS.value
+
+    assert test_client.delete(f"/v1/videos/{video_id}").status_code == 200
+
+
+def test_delete_times_out_engine_abort_and_still_cancels(test_client, monkeypatch):
+    monkeypatch.setattr(api_server, "VIDEO_ABORT_TIMEOUT_S", 0.05)
+    handler = HangingAbortHandler()
+    test_client.app.state.openai_serving_video = handler
+
+    create_resp = test_client.post("/v1/videos", data={"prompt": "Hang abort"})
+    assert create_resp.status_code == 200
+    video_id = create_resp.json()["id"]
+    assert handler.started.wait(timeout=2.0)
+
+    started = time.monotonic()
+    delete_resp = test_client.delete(f"/v1/videos/{video_id}")
+    assert time.monotonic() - started < 2.0
+    assert delete_resp.status_code == 200
+    assert handler.cancelled.wait(timeout=2.0)
+
+
+def test_delete_removes_artifact_if_job_completes_during_abort(test_client):
+    handler = CompletingDuringAbortHandler()
+    test_client.app.state.openai_serving_video = handler
+
+    create_resp = test_client.post("/v1/videos", data={"prompt": "Complete during delete"})
+    assert create_resp.status_code == 200
+    video_id = create_resp.json()["id"]
+    assert handler.started.wait(timeout=2.0)
+
+    assert test_client.delete(f"/v1/videos/{video_id}").status_code == 200
+    file_path = os.path.join(api_server.STORAGE_MANAGER.storage_path, video_id)
+    assert not os.path.exists(file_path)
+    assert asyncio.run(api_server.VIDEO_STORE.get(video_id)) is None
+
+
+def test_delete_aborts_engine_request_before_cancelling_task(test_client):
+    engine = AbortTrackingOmni()
+    test_client.app.state.openai_serving_video = OmniOpenAIServingVideo.for_diffusion(
+        engine,
+        model_name="Wan-AI/Wan2.2-T2V-A14B-Diffusers",
+    )
+
+    create_resp = test_client.post("/v1/videos", data={"prompt": "Abort this video"})
+    assert create_resp.status_code == 200
+    video_id = create_resp.json()["id"]
+    assert engine.entered.wait(timeout=2.0)
+    _wait_for_status(test_client, video_id, VideoGenerationStatus.IN_PROGRESS.value)
+
+    delete_resp = test_client.delete(f"/v1/videos/{video_id}")
+    assert delete_resp.status_code == 200
+    assert delete_resp.json()["deleted"] is True
+    _wait_until(lambda: engine.aborted == [video_id])
+    assert asyncio.run(api_server.VIDEO_STORE.get(video_id)) is None
+
+
 def test_video_response_file_extension_is_robust():
     response = VideoResponse(model="test-model", prompt="Make something beautiful")
     assert response.file_extension == "mp4"
@@ -2461,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.py b/tests/entrypoints/test_async_omni.py
index 2549889b3..2379db78e 100644
--- a/tests/entrypoints/test_async_omni.py
+++ b/tests/entrypoints/test_async_omni.py
@@ -12,6 +12,7 @@ from vllm.sampling_params import RequestOutputKind, SamplingParams
 from tests.helpers.mark import hardware_test
 from tests.helpers.stage_config import get_deploy_config_path
 from vllm_omni.engine.async_omni_engine import AsyncOmniEngine
+from vllm_omni.entrypoints import async_omni as async_omni_mod
 from vllm_omni.entrypoints.async_omni import AsyncOmni
 from vllm_omni.outputs import OmniRequestOutput
 
@@ -38,7 +39,8 @@ def get_fake_add_request(submitted_request_ids, submitted_lora_requests=None):
 
 
 def get_fake_abort(aborted_request_batches):
-    async def fake_abort_async(request_ids):
+    async def fake_abort_async(request_ids, timeout=None):
+        del timeout
         aborted_request_batches.append(list(request_ids))
 
     return fake_abort_async
@@ -196,8 +198,8 @@ def test_abort_keeps_request_states_until_generate_cleanup():
         release = asyncio.Event()
         seen_during_wait: list[int] = []
 
-        async def slow_abort_async(request_ids):
-            del request_ids
+        async def slow_abort_async(request_ids, timeout=None):
+            del request_ids, timeout
             seen_during_wait.append(len(omni.request_states))
             await release.wait()
 
@@ -224,8 +226,8 @@ def test_abort_keeps_request_states_until_generate_cleanup():
 @pytest.mark.cpu
 def test_abort_propagates_engine_errors_without_popping_state():
     async def run():
-        async def failing_abort_async(request_ids):
-            del request_ids
+        async def failing_abort_async(request_ids, timeout=None):
+            del request_ids, timeout
             raise RuntimeError("orchestrator abort failed")
 
         omni = get_async_omni_instance(fake_abort_request=failing_abort_async)
@@ -253,7 +255,8 @@ def test_abort_enqueues_prefix_tokens_from_engine():
 
         queue: asyncio.Queue = asyncio.Queue()
 
-        async def abort_with_prefix(request_ids):
+        async def abort_with_prefix(request_ids, timeout=None):
+            del timeout
             rid = request_ids[0]
             engine_output = OmniRequestOutput(
                 request_id=rid,
@@ -308,8 +311,8 @@ def test_abort_enqueues_synthetic_finished_when_engine_returns_empty():
     async def run():
         queue: asyncio.Queue = asyncio.Queue()
 
-        async def empty_abort_async(request_ids):
-            del request_ids
+        async def empty_abort_async(request_ids, timeout=None):
+            del request_ids, timeout
             return []
 
         omni = get_async_omni_instance(fake_abort_request=empty_abort_async)
@@ -329,6 +332,95 @@ def test_abort_enqueues_synthetic_finished_when_engine_returns_empty():
     asyncio.run(run())
 
 
+@pytest.mark.cpu
+def test_abort_drops_consumed_metric_message_ids_with_state():
+    """Exercise the production leak path from #6462: a metric-bearing
+    ``OutputMessage`` goes through ``_handle_output_message`` (which populates
+    the per-request de-dup set), the request is aborted (which, since #6367,
+    keeps ``request_states`` registered and enqueues a terminal abort output),
+    and the set must be released with the state by ``generate()``'s normal
+    cleanup — with no independent request-keyed metric state surviving on the
+    instance at any point. A reintroduced
+    class-level ``_consumed_metric_messages``-style map populated by the
+    production handler fails the sweep below.
+    """
+    import time as _time
+    from collections.abc import Mapping
+
+    from vllm_omni.engine.messages import OutputMessage
+    from vllm_omni.entrypoints.client_request_state import ClientRequestState
+    from vllm_omni.metrics.stats import OrchestratorAggregator
+
+    async def run():
+        omni = get_async_omni_instance()
+        omni.engine.get_stage_metadata = lambda stage_id: SimpleNamespace(
+            stage_type="llm",
+            final_output=True,
+            final_output_type="text",
+        )
+
+        rid = "req-1-cccc"
+        state = ClientRequestState(request_id=rid, external_request_id="req-1")
+        state.metrics = OrchestratorAggregator(
+            num_stages=1,
+            log_stats=False,
+            wall_start_ts=_time.time(),
+            final_stage_id_for_e2e=0,
+        )
+        state.input_stream_task = None
+        omni.request_states[rid] = state
+
+        msg = OutputMessage(
+            request_id=rid,
+            stage_id=0,
+            engine_outputs=SimpleNamespace(final_output_type="text"),
+            metrics=SimpleNamespace(
+                num_tokens_in=3,
+                num_tokens_out=5,
+                stage_gen_time_ms=1.0,
+                rx_transfer_bytes=0,
+                rx_decode_time_ms=0.0,
+                rx_in_flight_time_ms=0.0,
+            ),
+            finished=False,
+        )
+        handled, out_rid, out_stage, out_state = omni._handle_output_message(msg)
+        assert handled is False and out_state is state
+        # The production handler recorded the de-dup entry on the state...
+        assert id(msg) in state.consumed_metric_message_ids
+        # ...and de-duplicates a replay of the same message object.
+        omni._handle_output_message(msg)
+        assert len(state.consumed_metric_message_ids) == 1
+
+        assert not hasattr(omni, "_consumed_metric_messages")
+
+        # #6367 contract: abort() keeps the state registered and enqueues a
+        # terminal abort output; generate()'s ``finally`` owns the cleanup.
+        await omni.abort("req-1")
+        assert rid in omni.request_states
+        terminal = state.queue.get_nowait()
+        assert terminal.finished is True
+        assert terminal.engine_outputs.outputs[0].finish_reason == "abort"
+        # The de-dup set still lives only on the (still-registered) state.
+        for name, value in vars(omni).items():
+            if name == "request_states":
+                continue
+            assert not (isinstance(value, Mapping) and rid in value), (
+                f"request-keyed metric state kept outside request_states in {name!r}"
+            )
+
+        # generate()'s normal cleanup releases the state and the set with it.
+        omni._log_summary_and_cleanup(rid)
+        assert rid not in omni.request_states
+        for name, value in vars(omni).items():
+            assert not (isinstance(value, Mapping) and rid in value), (
+                f"request-keyed state survived cleanup in {name!r}"
+            )
+        assert not hasattr(omni, "_consumed_metric_messages")
+
+    asyncio.run(run())
+
+
 @pytest.mark.cpu
 def test_generate_accepts_request_after_repeated_cancellations():
     async def run_test():
@@ -378,6 +470,42 @@ def test_generate_accepts_request_after_repeated_cancellations():
     asyncio.run(run_test())
 
 
+@pytest.mark.cpu
+def test_generate_cancel_bounds_cleanup_abort(monkeypatch):
+    """Cancelled generate() must not wait forever on a wedged orchestrator abort."""
+    monkeypatch.setattr(async_omni_mod, "ABORT_TIMEOUT_S", 0.05)
+
+    async def run():
+        seen_timeouts: list[float | None] = []
+
+        async def hanging_abort_async(request_ids, timeout=None):
+            del request_ids
+            seen_timeouts.append(timeout)
+            await asyncio.Event().wait()
+
+        omni = get_async_omni_instance(fake_abort_request=hanging_abort_async)
+
+        async def collect():
+            async for _ in omni.generate(
+                prompt={"prompt": "prompt"},
+                request_id="cancel-hang-abort",
+                sampling_params_list=[SimpleNamespace()],
+                output_modalities=["image"],
+            ):
+                pass
+
+        task = asyncio.create_task(collect())
+        await asyncio.sleep(0)
+        task.cancel()
+        with pytest.raises(asyncio.CancelledError):
+            await asyncio.wait_for(task, timeout=1.0)
+        assert seen_timeouts
+        assert seen_timeouts[-1] == 0.05
+        assert omni.request_states == {}
+
+    asyncio.run(run())
+
+
 @pytest.mark.cpu
 def test_generate_cancellation_converges_after_engine_shutdown_starts(mocker):
     async def run_test():
diff --git a/tests/entrypoints/test_async_omni_diffusion_config.py b/tests/entrypoints/test_async_omni_diffusion_config.py
index dda9ab38c..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"]
 
@@ -674,7 +772,7 @@ def test_resolve_stage_configs_delegates_overrides_to_resolver(mocker):
         engine_args=SimpleNamespace(additional_config=additional_config),
     )
     resolve_config = mocker.patch(
-        "vllm_omni.engine.async_omni_engine.resolve_omni_config",
+        "vllm_omni.engine.omni_engine_base.resolve_omni_config",
         return_value=OmniConfigResolution(
             config_path="dummy.yaml",
             stage_configs=(fake_diffusion_stage,),
@@ -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_async_omni_duplex.py b/tests/entrypoints/test_async_omni_duplex.py
deleted file mode 100644
index 81e0d75cb..000000000
--- a/tests/entrypoints/test_async_omni_duplex.py
+++ /dev/null
@@ -1,601 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-from types import SimpleNamespace
-
-import pytest
-
-from vllm_omni.engine.duplex.lease import DuplexLeaseActivity
-from vllm_omni.engine.duplex.messages import DuplexFence
-from vllm_omni.engine.duplex.runtime import (
-    DuplexOutputAction,
-    DuplexOutputDecision,
-    duplex_resource_request_id,
-)
-from vllm_omni.engine.messages import OutputMessage
-from vllm_omni.entrypoints.async_omni import AsyncOmni
-from vllm_omni.entrypoints.client_request_state import ClientRequestState
-from vllm_omni.entrypoints.duplex_request_client import DuplexRequestClient
-from vllm_omni.metrics.stats import OrchestratorAggregator, StageRequestStats, StageStats
-from vllm_omni.outputs import OmniRequestOutput
-from vllm_omni.outputs.duplex import attach_duplex_output_decision
-
-
-def test_async_omni_uses_extracted_duplex_request_client():
-    app = object.__new__(AsyncOmni)
-    app.engine = SimpleNamespace(num_stages=2)
-    app.request_states = {}
-    app._duplex_request_client = None
-
-    client = app._get_duplex_request_client()
-
-    assert isinstance(client, DuplexRequestClient)
-    assert not hasattr(client, "_async_omni")
-
-
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
-
-
-@pytest.mark.asyncio
-async def test_async_omni_open_duplex_forwards_session_config_and_timeout():
-    calls = []
-    output_handler_starts = 0
-
-    async def open_duplex_session_async(session_id, **kwargs):
-        calls.append((session_id, kwargs))
-        return {"ok": True}
-
-    app = object.__new__(AsyncOmni)
-    app.engine = SimpleNamespace(open_duplex_session_async=open_duplex_session_async)
-
-    def start_output_handler():
-        nonlocal output_handler_starts
-        output_handler_starts += 1
-
-    app._final_output_handler = start_output_handler
-
-    result = await app.open_duplex_session_async(
-        "sid",
-        fence=DuplexFence("sid"),
-        capabilities={"implementation_level": "model_native_duplex"},
-        session_config={"instructions": "Be brief.", "idle_timeout_s": 30},
-        timeout=7.5,
-    )
-
-    assert result == {"ok": True}
-    assert output_handler_starts == 1
-    assert calls == [
-        (
-            "sid",
-            {
-                "session_mode": "duplex",
-                "capabilities": {"implementation_level": "model_native_duplex"},
-                "session_config": {"instructions": "Be brief.", "idle_timeout_s": 30},
-                "fence": DuplexFence("sid"),
-                "timeout": 7.5,
-            },
-        )
-    ]
-
-
-@pytest.mark.asyncio
-async def test_async_omni_duplex_runtime_controls_forward_timeout():
-    calls = []
-    cancelled_fence = DuplexFence("sid", epoch=2, turn_id=3)
-    next_fence = DuplexFence("sid", epoch=3, turn_id=3)
-
-    async def append_duplex_input_async(session_id, **kwargs):
-        calls.append(("append", session_id, kwargs))
-        return {"ok": True}
-
-    async def signal_duplex_turn_async(session_id, **kwargs):
-        calls.append(("signal", session_id, kwargs))
-        return {"ok": True}
-
-    async def close_duplex_session_async(session_id, **kwargs):
-        calls.append(("close", session_id, kwargs))
-        return {"ok": True}
-
-    async def touch_duplex_session_async(session_id, **kwargs):
-        calls.append(("touch", session_id, kwargs))
-        return {"ok": True}
-
-    async def resume_duplex_session_async(session_id, **kwargs):
-        calls.append(("resume", session_id, kwargs))
-        return {"ok": True}
-
-    app = object.__new__(AsyncOmni)
-    app.request_states = {}
-    app._final_output_handler = lambda: None
-    app.engine = SimpleNamespace(
-        append_duplex_input_async=append_duplex_input_async,
-        signal_duplex_turn_async=signal_duplex_turn_async,
-        close_duplex_session_async=close_duplex_session_async,
-        touch_duplex_session_async=touch_duplex_session_async,
-        resume_duplex_session_async=resume_duplex_session_async,
-    )
-
-    await app.append_duplex_input_async(
-        "sid",
-        mode="append_audio_chunk",
-        payload={},
-        fence=cancelled_fence,
-        timeout=12.5,
-    )
-    await app.signal_duplex_turn_async(
-        "sid",
-        event="barge_in",
-        fence=cancelled_fence,
-        next_fence=next_fence,
-        timeout=13.5,
-    )
-    await app.close_duplex_session_async("sid", reason="done", fence=next_fence, timeout=14.5)
-    await app.touch_duplex_session_async(
-        "sid",
-        fence=next_fence,
-        activity=DuplexLeaseActivity.HEARTBEAT,
-        timeout=15.5,
-    )
-    await app.resume_duplex_session_async(
-        "sid",
-        fence=next_fence,
-        expected_lease_generation=3,
-        timeout=16.5,
-    )
-
-    assert calls == [
-        (
-            "append",
-            "sid",
-            {
-                "mode": "append_audio_chunk",
-                "payload": {},
-                "final": False,
-                "expected_epoch": None,
-                "fence": cancelled_fence,
-                "timeout": 12.5,
-            },
-        ),
-        (
-            "signal",
-            "sid",
-            {
-                "event": "barge_in",
-                "fence": cancelled_fence,
-                "next_fence": next_fence,
-                "timeout": 13.5,
-            },
-        ),
-        (
-            "close",
-            "sid",
-            {
-                "reason": "done",
-                "fence": next_fence,
-                "timeout": 14.5,
-            },
-        ),
-        (
-            "touch",
-            "sid",
-            {
-                "fence": next_fence,
-                "activity": DuplexLeaseActivity.HEARTBEAT,
-                "timeout": 15.5,
-            },
-        ),
-        (
-            "resume",
-            "sid",
-            {
-                "fence": next_fence,
-                "expected_lease_generation": 3,
-                "timeout": 16.5,
-            },
-        ),
-    ]
-
-
-@pytest.mark.asyncio
-async def test_async_omni_duplex_append_can_defer_data_plane_output_collection():
-    app = object.__new__(AsyncOmni)
-    request_id = duplex_resource_request_id(DuplexFence("sid"), "stage0")
-
-    async def append_duplex_input_async(session_id, **kwargs):
-        del session_id, kwargs
-        request_state = app.request_states.get(request_id)
-        assert request_state is not None
-        assert request_state.metrics is not None
-        return {
-            "stage_results": [
-                {
-                    "result": {
-                        "data_plane_append": True,
-                        "request_id": request_id,
-                        "response_stage_id": 1,
-                    }
-                }
-            ]
-        }
-
-    app.engine = SimpleNamespace(append_duplex_input_async=append_duplex_input_async)
-    app.request_states = {}
-    app._final_output_handler = lambda: None
-
-    result = await app.append_duplex_input_async(
-        "sid",
-        mode="append_audio_chunk",
-        payload={},
-        fence=DuplexFence("sid"),
-        collect_outputs=False,
-    )
-
-    assert "data_plane_outputs" not in result
-
-
-@pytest.mark.asyncio
-async def test_async_omni_duplex_append_forwards_fence():
-    calls = []
-
-    async def append_duplex_input_async(session_id, **kwargs):
-        calls.append((session_id, kwargs))
-        return {"ok": True}
-
-    app = object.__new__(AsyncOmni)
-    app.request_states = {}
-    app._final_output_handler = lambda: None
-    app.engine = SimpleNamespace(append_duplex_input_async=append_duplex_input_async)
-    fence = DuplexFence("sid", epoch=1, turn_id=2)
-
-    await app.append_duplex_input_async(
-        "sid",
-        mode="append_audio_chunk",
-        payload={},
-        fence=fence,
-        collect_outputs=False,
-    )
-
-    assert calls[0][1]["fence"] is fence
-
-
-@pytest.mark.asyncio
-async def test_async_omni_duplex_collect_waits_for_response_stage():
-    app = object.__new__(AsyncOmni)
-    req_state = ClientRequestState("duplex-sid-e0-stage0")
-    stage0_output = OmniRequestOutput(
-        request_id="duplex-sid-e0-stage0",
-        stage_id=0,
-        finished=False,
-    )
-    stage1_output = OmniRequestOutput(
-        request_id="duplex-sid-e0-stage0",
-        stage_id=1,
-        final_output_type="audio",
-        finished=False,
-    )
-    await req_state.queue.put(
-        OutputMessage(
-            request_id="duplex-sid-e0-stage0",
-            stage_id=0,
-            engine_outputs=stage0_output,
-            finished=False,
-        )
-    )
-    await req_state.queue.put(
-        OutputMessage(
-            request_id="duplex-sid-e0-stage0",
-            stage_id=1,
-            engine_outputs=stage1_output,
-            finished=False,
-        )
-    )
-
-    outputs = await app._collect_duplex_data_plane_outputs(
-        "duplex-sid-e0-stage0",
-        req_state,
-        response_stage_id=1,
-        timeout=1.0,
-    )
-
-    assert outputs == [stage1_output]
-
-
-@pytest.mark.asyncio
-async def test_duplex_request_client_retains_output_route_at_segment_terminal():
-    request_id = "duplex-sid-e0-stage0"
-    request_state = ClientRequestState(request_id)
-    request_states = {request_id: request_state}
-    output = OmniRequestOutput(
-        request_id=request_id,
-        stage_id=1,
-        final_output_type="audio",
-        finished=True,
-    )
-    await request_state.queue.put(
-        OutputMessage(
-            request_id=request_id,
-            stage_id=1,
-            engine_outputs=output,
-            finished=True,
-        )
-    )
-    client = DuplexRequestClient(
-        SimpleNamespace(),
-        SimpleNamespace(
-            request_states=request_states,
-            num_stages=2,
-            log_stats=False,
-        ),
-    )
-
-    outputs = await client.collect_outputs(
-        request_id,
-        request_state,
-        response_stage_id=1,
-        timeout=1.0,
-    )
-
-    assert outputs == [output]
-    assert request_states[request_id] is request_state
-
-
-@pytest.mark.asyncio
-async def test_async_omni_duplex_direct_output_keeps_stage_metrics():
-    app = object.__new__(AsyncOmni)
-    app._duplex_request_client = None
-    app._final_output_handler = lambda: None
-    request_id = "duplex-sid-e0-stage0"
-    req_state = ClientRequestState(request_id)
-    decision = DuplexOutputDecision(
-        action=DuplexOutputAction.DIRECT_RESPONSE,
-        metadata={
-            "duplex_direct_response": True,
-            "duplex_native_decision": "speak",
-        },
-    )
-    direct_output = attach_duplex_output_decision(
-        OmniRequestOutput(
-            request_id=request_id,
-            stage_id=0,
-            final_output_type="text",
-            finished=True,
-        ),
-        decision,
-    )
-    await req_state.queue.put(
-        OutputMessage(
-            request_id=request_id,
-            stage_id=0,
-            engine_outputs=direct_output,
-            metrics=StageRequestStats(
-                batch_id=1,
-                batch_size=1,
-                num_tokens_in=160,
-                num_tokens_out=8,
-                stage_gen_time_ms=80.0,
-                rx_transfer_bytes=0,
-                rx_decode_time_ms=0.0,
-                rx_in_flight_time_ms=0.0,
-                stage_stats=StageStats(total_token=8, total_gen_time_ms=80.0),
-                vllm_ttft_ms=12.5,
-                vllm_tpot_ms=9.0,
-                vllm_itl_ms=8.75,
-                vllm_itls_ms=[8.0, 9.5],
-            ),
-            finished=True,
-        )
-    )
-
-    outputs = await app._collect_duplex_data_plane_outputs(
-        request_id,
-        req_state,
-        response_stage_id=1,
-        timeout=1.0,
-    )
-
-    assert outputs == [direct_output]
-    assert direct_output.metrics["stage_metrics"]["0"]["vllm_ttft_ms"] == 12.5
-    assert direct_output.metrics["stage_metrics"]["0"]["vllm_tpot_ms"] == 9.0
-    assert direct_output.metrics["stage_metrics"]["0"]["vllm_itls_ms"] == [8.0, 9.5]
-
-
-@pytest.mark.asyncio
-async def test_duplex_metrics_cursor_isolates_resumable_collect_windows():
-    app = object.__new__(AsyncOmni)
-    app._duplex_request_client = None
-    app._final_output_handler = lambda: None
-    request_id = "duplex-sid-e0-stage0"
-    req_state = ClientRequestState(request_id)
-    req_state.metrics = OrchestratorAggregator(
-        num_stages=2,
-        log_stats=False,
-        wall_start_ts=0.0,
-        final_stage_id_for_e2e=1,
-    )
-
-    def stage_message(*, batch_id: int, tokens: int, ttft_ms: float, itls: list[float]) -> OutputMessage:
-        decision = DuplexOutputDecision(
-            action=DuplexOutputAction.DIRECT_RESPONSE,
-            metadata={"duplex_direct_response": True, "duplex_native_decision": "speak"},
-        )
-        output = attach_duplex_output_decision(
-            OmniRequestOutput(
-                request_id=request_id,
-                stage_id=0,
-                final_output_type="text",
-                finished=True,
-            ),
-            decision,
-        )
-        return OutputMessage(
-            request_id=request_id,
-            stage_id=0,
-            engine_outputs=output,
-            metrics=StageRequestStats(
-                batch_id=batch_id,
-                batch_size=1,
-                num_tokens_in=160,
-                num_tokens_out=tokens,
-                stage_gen_time_ms=80.0,
-                rx_transfer_bytes=0,
-                rx_decode_time_ms=0.0,
-                rx_in_flight_time_ms=0.0,
-                stage_stats=StageStats(total_token=tokens, total_gen_time_ms=80.0),
-                vllm_ttft_ms=ttft_ms,
-                vllm_tpot_ms=9.0,
-                vllm_itl_ms=sum(itls) / len(itls),
-                vllm_itls_ms=itls,
-            ),
-            finished=True,
-        )
-
-    await req_state.queue.put(stage_message(batch_id=1, tokens=71, ttft_ms=62.5, itls=[10.0, 11.0]))
-    first = await app._collect_duplex_data_plane_outputs(
-        request_id,
-        req_state,
-        response_stage_id=1,
-        timeout=1.0,
-    )
-    await req_state.queue.put(stage_message(batch_id=2, tokens=155, ttft_ms=81.0, itls=[12.0, 13.0, 14.0]))
-    second = await app._collect_duplex_data_plane_outputs(
-        request_id,
-        req_state,
-        response_stage_id=1,
-        timeout=1.0,
-    )
-
-    assert first[0].metrics["stage_metrics"]["0"]["num_tokens_out"] == 71
-    second_stage0 = second[0].metrics["stage_metrics"]["0"]
-    assert second_stage0["num_tokens_out"] == 155
-    assert second_stage0["vllm_ttft_ms"] == 81.0
-    assert second_stage0["vllm_itls_ms"] == [12.0, 13.0, 14.0]
-
-
-def test_async_omni_duplex_direct_output_prefers_outer_control_metadata():
-    decision = DuplexOutputDecision(
-        action=DuplexOutputAction.DIRECT_RESPONSE,
-        metadata={
-            "duplex_direct_response": True,
-            "duplex_native_decision": "listen",
-        },
-    )
-    output = attach_duplex_output_decision(
-        OmniRequestOutput(
-            request_id="duplex-sid-e0-stage0",
-            stage_id=0,
-            outputs=[],
-            _multimodal_output={"kind": "processed-payload"},
-            _custom_output={"inner": "completion"},
-        ),
-        decision,
-    )
-
-    assert AsyncOmni._is_direct_duplex_data_plane_response(output)
-
-
-def test_async_omni_drops_unregistered_duplex_prefixed_output():
-    app = object.__new__(AsyncOmni)
-    app.request_states = {}
-    output = OmniRequestOutput(request_id="duplex-unregistered-e0-stage0", stage_id=0)
-
-    keep_processing, request_id, stage_id, request_state = app._handle_output_message(
-        OutputMessage(
-            request_id=output.request_id,
-            stage_id=0,
-            engine_outputs=output,
-            finished=False,
-        )
-    )
-
-    assert keep_processing is True
-    assert request_id is stage_id is request_state is None
-    assert app.request_states == {}
-
-
-@pytest.mark.asyncio
-async def test_async_omni_duplex_collect_wraps_raw_response_stage_output():
-    app = object.__new__(AsyncOmni)
-    app.log_stats = False
-    app._enable_ar_profiler = False
-    app.request_states = {}
-    app.prom_metrics = SimpleNamespace(
-        set_running=lambda value: None,
-        set_waiting=lambda value: None,
-    )
-    app.engine = SimpleNamespace(
-        num_stages=2,
-        get_stage_metadata=lambda stage_id: SimpleNamespace(
-            final_output=stage_id == 1,
-            final_output_type="audio",
-        ),
-    )
-    req_state = ClientRequestState("duplex-sid-e0-stage0")
-    raw_stage1_output = SimpleNamespace(
-        finished=False,
-        outputs=[],
-        stage_durations={},
-        peak_memory_mb=0.0,
-        final_output_type="audio",
-    )
-    await req_state.queue.put(
-        OutputMessage(
-            request_id="duplex-sid-e0-stage0",
-            stage_id=1,
-            engine_outputs=raw_stage1_output,
-            finished=False,
-        )
-    )
-
-    outputs = await app._collect_duplex_data_plane_outputs(
-        "duplex-sid-e0-stage0",
-        req_state,
-        response_stage_id=1,
-        timeout=1.0,
-    )
-
-    assert len(outputs) == 1
-    assert outputs[0].request_id == "duplex-sid-e0-stage0"
-    assert outputs[0].finished is False
-    assert outputs[0].stage_id == 1
-    assert outputs[0].final_output_type == "audio"
-    assert outputs[0].peak_memory_mb == raw_stage1_output.peak_memory_mb
-
-
-def test_async_omni_duplex_request_info_includes_response_stage():
-    request_id, response_stage_id = AsyncOmni._duplex_data_plane_request_info(
-        {
-            "stage_results": [
-                {
-                    "result": {
-                        "data_plane_append": True,
-                        "request_id": "duplex-sid-e0-stage0",
-                        "response_stage_id": 1,
-                    }
-                }
-            ]
-        }
-    )
-
-    assert request_id == "duplex-sid-e0-stage0"
-    assert response_stage_id == 1
-
-
-@pytest.mark.asyncio
-async def test_duplex_request_client_retains_output_route_when_close_fails():
-    fence = DuplexFence("sid-close-route")
-    request_id = duplex_resource_request_id(fence, "stage0")
-    request_states = {request_id: ClientRequestState(request_id)}
-
-    async def close_duplex_session_async(session_id, **kwargs):
-        del session_id, kwargs
-        raise RuntimeError("close failed")
-
-    client = DuplexRequestClient(
-        SimpleNamespace(close_duplex_session_async=close_duplex_session_async),
-        SimpleNamespace(request_states=request_states),
-    )
-
-    with pytest.raises(RuntimeError, match="close failed"):
-        await client.close(fence.session_id, reason="test", fence=fence, timeout=1.0)
-
-    assert request_id in request_states
diff --git a/tests/entrypoints/test_disable_log_stats_routing.py b/tests/entrypoints/test_disable_log_stats_routing.py
index f9dd2da4a..623cc9af4 100644
--- a/tests/entrypoints/test_disable_log_stats_routing.py
+++ b/tests/entrypoints/test_disable_log_stats_routing.py
@@ -53,7 +53,7 @@ def test_async_engine_consumes_disable_log_stats_before_resolution(monkeypatch:
         )
 
     monkeypatch.setattr(
-        "vllm_omni.engine.async_omni_engine.load_and_resolve_stage_configs",
+        "vllm_omni.engine.omni_engine_base.load_and_resolve_stage_configs",
         fake_resolve,
     )
     engine = SimpleNamespace(_apply_strategy_lb_policy=lambda *args, **kwargs: None)
diff --git a/tests/entrypoints/test_duplex_fence_propagation.py b/tests/entrypoints/test_duplex_fence_propagation.py
deleted file mode 100644
index 550723ec8..000000000
--- a/tests/entrypoints/test_duplex_fence_propagation.py
+++ /dev/null
@@ -1,126 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-import pytest
-
-from tests.entrypoints.openai_api.test_duplex_handler import FakeChatService, TimedWebSocket
-from vllm_omni.engine.duplex.messages import DuplexFence
-from vllm_omni.entrypoints.async_omni import AsyncOmni
-from vllm_omni.entrypoints.duplex.protocol import DuplexSession, DuplexSessionConfig
-from vllm_omni.entrypoints.duplex.serving import OmniDuplexSessionHandler
-
-pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
-
-
-class FenceRecordingEngine:
-    output_modalities = ["text", "audio"]
-
-    def __init__(self) -> None:
-        self.calls: list[tuple[str, DuplexFence | None]] = []
-        self.signal_next_fences: list[DuplexFence | None] = []
-
-    async def open_duplex_session_async(self, session_id, *, fence=None, **kwargs):
-        del session_id, kwargs
-        self.calls.append(("open", fence))
-        return {"ok": True}
-
-    async def append_duplex_input_async(self, session_id, *, fence=None, **kwargs):
-        del session_id, kwargs
-        self.calls.append(("append", fence))
-        return {"ok": True}
-
-    async def signal_duplex_turn_async(
-        self,
-        session_id,
-        *,
-        event,
-        fence=None,
-        next_fence=None,
-        timeout=None,
-    ):
-        del session_id, event, timeout
-        self.calls.append(("signal", fence))
-        self.signal_next_fences.append(next_fence)
-        return {"ok": True}
-
-    async def close_duplex_session_async(self, session_id, *, fence=None, **kwargs):
-        del session_id, kwargs
-        self.calls.append(("close", fence))
-        return {"ok": True}
-
-
-@pytest.mark.asyncio
-async def test_async_omni_forwards_fence_for_all_runtime_operations():
-    engine = FenceRecordingEngine()
-    app = object.__new__(AsyncOmni)
-    app.engine = engine
-    app.request_states = {}
-    app._final_output_handler = lambda: None
-    fence = DuplexFence("sid", epoch=1, turn_id=2)
-
-    await app.open_duplex_session_async("sid", fence=fence)
-    await app.append_duplex_input_async(
-        "sid", mode="append_audio_chunk", payload={}, fence=fence, collect_outputs=False
-    )
-    await app.signal_duplex_turn_async("sid", event="turn.end", fence=fence)
-    await app.close_duplex_session_async("sid", reason="done", fence=fence)
-
-    assert engine.calls == [(operation, fence) for operation in ("open", "append", "signal", "close")]
-
-
-@pytest.mark.asyncio
-async def test_openai_handler_passes_current_session_fence_for_runtime_controls():
-    engine = FenceRecordingEngine()
-    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(engine))
-    session = DuplexSession(
-        session_id="sid",
-        config=DuplexSessionConfig(extra_body={"native_duplex": True}),
-        epoch=1,
-        turn_id=2,
-    )
-    ws = TimedWebSocket()
-    fence = DuplexFence("sid", epoch=1, turn_id=2)
-
-    await handler._open_runtime_session(session, ws.send_json)
-    await handler._signal_runtime_session(session, "turn.end", send_json=ws.send_json)
-    await handler._close_runtime_session(session, reason="done", send_json=ws.send_json)
-
-    assert engine.calls == [(operation, fence) for operation in ("open", "signal", "close")]
-
-
-@pytest.mark.asyncio
-async def test_runtime_signal_uses_fence_captured_before_session_turn_advances():
-    engine = FenceRecordingEngine()
-    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(engine))
-    session = DuplexSession(session_id="sid", config=DuplexSessionConfig(extra_body={"native_duplex": True}))
-    captured_fence = DuplexFence("sid", epoch=0, turn_id=0)
-    session.turn_id = 1
-
-    await handler._signal_runtime_session(
-        session,
-        "input.commit",
-        fence=captured_fence,
-    )
-
-    assert engine.calls == [("signal", captured_fence)]
-
-
-@pytest.mark.asyncio
-async def test_openai_handler_forwards_cancel_fence_through_async_omni_facade():
-    engine = FenceRecordingEngine()
-    app = object.__new__(AsyncOmni)
-    app.engine = engine
-    handler = OmniDuplexSessionHandler(chat_service=FakeChatService(app))
-    session = DuplexSession(session_id="sid-cancel", config=DuplexSessionConfig(extra_body={"native_duplex": True}))
-    cancelled_fence = DuplexFence("sid-cancel", epoch=2, turn_id=3)
-    next_fence = DuplexFence("sid-cancel", epoch=3, turn_id=3)
-
-    assert await handler._signal_runtime_session(
-        session,
-        "input.cancel",
-        fence=cancelled_fence,
-        next_fence=next_fence,
-    )
-
-    assert engine.calls == [("signal", cancelled_fence)]
-    assert engine.signal_next_fences == [next_fence]
diff --git a/tests/entrypoints/test_duplex_omni.py b/tests/entrypoints/test_duplex_omni.py
new file mode 100644
index 000000000..f33b3ea4d
--- /dev/null
+++ b/tests/entrypoints/test_duplex_omni.py
@@ -0,0 +1,326 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""``DuplexOmni`` / ``DuplexSessionHandle``: the thin Python API over a fake engine."""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import replace
+from typing import Any
+
+import pytest
+
+from tests.entrypoints.test_omni_entrypoints import FakeAsyncOmniEngine
+from vllm_omni.config.stage_config import DuplexSessionRuntimeConfig
+from vllm_omni.engine.duplex import commands
+from vllm_omni.engine.duplex.config import DuplexCapabilities, DuplexSessionConfig
+from vllm_omni.engine.duplex.events import (
+    AudioDelta,
+    DuplexEvent,
+    SessionClosed,
+    SessionCreated,
+    SessionExpired,
+)
+from vllm_omni.engine.duplex.messages import (
+    DuplexControlResultMessage,
+    DuplexSessionError,
+    DuplexSessionEventMessage,
+)
+from vllm_omni.engine.messages import ErrorMessage
+from vllm_omni.entrypoints.duplex_omni import DuplexOmni, DuplexSessionHandle
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class FakeDuplexEngine(FakeAsyncOmniEngine):
+    """The engine surface ``DuplexOmni`` uses; every call is recorded."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.duplex_session_config = DuplexSessionRuntimeConfig(max_sessions=2)
+        self.duplex_capabilities = DuplexCapabilities(supports_session_resume=True)
+        self.opened: list[tuple[str, DuplexSessionConfig]] = []
+        self.closed: list[tuple[str, str]] = []
+        self.resumed: list[tuple[str, int]] = []
+        self.touched: list[tuple[str, str]] = []
+        self.commands: list[tuple[str, commands.DuplexCommand]] = []
+        self.open_error: DuplexSessionError | None = None
+        self.close_error: DuplexSessionError | None = None
+
+    def _result(self, operation: str, session_id: str, **fields: Any) -> DuplexControlResultMessage:
+        return DuplexControlResultMessage(control_id="c", operation=operation, session_id=session_id, ok=True, **fields)
+
+    async def open_session_async(self, session_id, session_config, *, timeout=None):
+        self.opened.append((session_id, session_config))
+        if self.open_error is not None:
+            raise self.open_error
+        return self._result(
+            "open",
+            session_id,
+            capabilities=self.duplex_capabilities,
+            public_session={"id": session_id, "idle_timeout_s": 7},
+            lease_generation=0,
+        )
+
+    async def close_session_async(self, session_id, *, reason="client_close", timeout=None):
+        self.closed.append((session_id, reason))
+        if self.close_error is not None:
+            raise self.close_error
+        # The runner emits session.closed before answering the RPC.
+        self.emit(session_id, SessionClosed(reason=reason))
+        return self._result("close", session_id)
+
+    async def resume_session_async(self, session_id, *, expected_lease_generation, timeout=None):
+        self.resumed.append((session_id, expected_lease_generation))
+        return self._result("resume", session_id, lease_generation=expected_lease_generation + 1)
+
+    async def touch_session_async(self, session_id, *, activity, timeout=None):
+        self.touched.append((session_id, activity))
+        return self._result("touch", session_id)
+
+    async def submit_command_async(self, session_id, command):
+        self.commands.append((session_id, command))
+
+    def emit(self, session_id: str, event: DuplexEvent) -> None:
+        # The session manager binds the session identity to every event it emits.
+        event = replace(event, session_id=session_id)
+        self.output_q.put(DuplexSessionEventMessage(session_id=session_id, event=event))
+
+
+def _make_omni(monkeypatch: pytest.MonkeyPatch) -> tuple[DuplexOmni, FakeDuplexEngine]:
+    engine = FakeDuplexEngine()
+    monkeypatch.setattr("vllm_omni.entrypoints.duplex_omni.DuplexOmniEngine", lambda *args, **kwargs: engine)
+    monkeypatch.setattr("vllm_omni.entrypoints.omni_base.omni_snapshot_download", lambda model: model)
+    return DuplexOmni("dummy-model"), engine
+
+
+async def _collect(handle: DuplexSessionHandle, count: int, *, timeout_s: float = 2.0) -> list[DuplexEvent]:
+    events: list[DuplexEvent] = []
+
+    async def consume() -> None:
+        async for event in handle.events():
+            events.append(event)
+            if len(events) >= count:
+                break
+
+    await asyncio.wait_for(consume(), timeout=timeout_s)
+    return events
+
+
+@pytest.mark.asyncio
+async def test_open_session_allocates_the_id_and_ignores_client_ids(monkeypatch) -> None:
+    omni, engine = _make_omni(monkeypatch)
+    try:
+        handle = await omni.open_session({"session_id": "mine", "id": "mine-too", "instructions": "hi"})
+
+        assert handle.session_id.startswith("duplex-") and len(handle.session_id) == len("duplex-") + 32
+        assert handle.session_id != "mine"
+        ((session_id, config),) = engine.opened
+        assert session_id == handle.session_id
+        assert isinstance(config, DuplexSessionConfig)
+        assert config.model == "dummy-model" and config.instructions == "hi"
+        assert handle.capabilities is engine.duplex_capabilities
+        assert handle.public_session["id"] == handle.session_id
+        assert omni.sessions == {handle.session_id: handle}
+        assert omni.get_session(handle.session_id) is handle
+        assert omni.active_session_count() == 1
+
+        second = await omni.open_session(DuplexSessionConfig(instructions="typed"))
+        assert second.session_id != handle.session_id
+        assert engine.opened[1][1].model == "dummy-model"
+        assert omni.duplex_session_config.max_sessions == 2
+        assert omni.duplex_capabilities.supports_session_resume is True
+    finally:
+        omni.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_open_failure_drops_the_pending_handle_and_raises_the_engine_code(monkeypatch) -> None:
+    omni, engine = _make_omni(monkeypatch)
+    engine.open_error = DuplexSessionError("full", code="resource_exhausted", retryable=True)
+    try:
+        with pytest.raises(DuplexSessionError) as excinfo:
+            await omni.open_session()
+        assert excinfo.value.code == "resource_exhausted"
+        assert omni.sessions == {}
+    finally:
+        omni.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_events_are_routed_to_their_handle_and_end_on_session_closed(monkeypatch) -> None:
+    omni, engine = _make_omni(monkeypatch)
+    try:
+        handle = await omni.open_session()
+        engine.emit("duplex-unknown", AudioDelta(delta="zzz"))  # dropped
+        engine.emit(handle.session_id, SessionCreated(session={"id": handle.session_id}))
+        engine.emit(handle.session_id, AudioDelta(response_id="r1", delta="abc"))
+        engine.emit(handle.session_id, SessionClosed(reason="client_close"))
+
+        events = await _collect(handle, 10)
+
+        assert [event.type for event in events] == ["session.created", "response.output_audio.delta", "session.closed"]
+        assert events[0].session_id == handle.session_id
+        assert handle.closed and handle.close_reason == "client_close"
+        assert await handle.wait_closed() == "client_close"
+        assert handle.session_id not in omni.sessions
+        with pytest.raises(DuplexSessionError) as excinfo:
+            await handle.submit(commands.Heartbeat())
+        assert excinfo.value.code == "session_closed"
+    finally:
+        omni.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_events_is_single_consumer_but_may_be_reentered(monkeypatch) -> None:
+    omni, engine = _make_omni(monkeypatch)
+    try:
+        handle = await omni.open_session()
+        engine.emit(handle.session_id, AudioDelta(delta="one"))
+        first = handle.events()
+        assert (await first.__anext__()).type == "response.output_audio.delta"
+        with pytest.raises(RuntimeError, match="active events"):
+            await handle.events().__anext__()
+        await first.aclose()
+
+        engine.emit(handle.session_id, SessionExpired(reason="idle_ttl_expired"))
+        events = await _collect(handle, 1)
+        assert events[0].type == "session.expired" and events[0].is_terminal
+        assert handle.closed and handle.close_reason == "idle_ttl_expired"
+    finally:
+        omni.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_close_session_waits_for_the_typed_session_closed_event(monkeypatch) -> None:
+    omni, engine = _make_omni(monkeypatch)
+    try:
+        handle = await omni.open_session()
+        consumer = asyncio.create_task(_collect(handle, 1))
+        await handle.close(reason="done")
+
+        assert engine.closed == [(handle.session_id, "done")]
+        assert handle.closed and handle.close_reason == "done"
+        assert (await consumer)[0].type == "session.closed"
+        # Idempotent: a second close is a no-op.
+        await omni.close_session(handle.session_id)
+        assert len(engine.closed) == 1
+    finally:
+        omni.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_close_failure_marks_the_handle_closed_and_propagates(monkeypatch) -> None:
+    omni, engine = _make_omni(monkeypatch)
+    engine.close_error = DuplexSessionError("boom", code="engine_error")
+    try:
+        handle = await omni.open_session()
+        with pytest.raises(DuplexSessionError, match="boom"):
+            await omni.close_session(handle.session_id)
+        assert handle.closed
+        # A failed close must not leave a dead handle shadowing the id.
+        assert omni.sessions == {}
+    finally:
+        omni.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_engine_death_ends_every_session_handle(monkeypatch) -> None:
+    omni, engine = _make_omni(monkeypatch)
+    try:
+        handle = await omni.open_session()
+        engine.output_q.put(ErrorMessage(error="orchestrator died", fatal=True))
+
+        await asyncio.wait_for(handle.wait_closed(), timeout=2.0)
+        assert handle.closed
+        assert "engine_dead" in (handle.close_reason or "")
+        assert omni.sessions == {}
+    finally:
+        omni.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_resume_detach_and_touch_forward_to_the_engine(monkeypatch) -> None:
+    omni, engine = _make_omni(monkeypatch)
+    try:
+        handle = await omni.open_session()
+        resumed = await omni.resume_session(handle.session_id, expected_lease_generation=0)
+        assert resumed is handle and handle.lease_generation == 1
+        assert engine.resumed == [(handle.session_id, 0)]
+
+        await omni.detach_session(handle.session_id)
+        await omni.touch_session(handle.session_id, activity="heartbeat")
+        assert engine.touched == [(handle.session_id, "detach"), (handle.session_id, "heartbeat")]
+
+        for call in (
+            omni.resume_session("duplex-nope", expected_lease_generation=0),
+            omni.detach_session("duplex-nope"),
+        ):
+            with pytest.raises(DuplexSessionError) as excinfo:
+                await call
+            assert excinfo.value.code == "unknown_session"
+    finally:
+        omni.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_handle_wrappers_build_typed_commands_in_caller_order(monkeypatch) -> None:
+    omni, engine = _make_omni(monkeypatch)
+    try:
+        handle = await omni.open_session()
+        await handle.append_audio(b"\x00\x01", sample_rate_hz=16000, is_speech=True)
+        await handle.commit(create_response=True)
+        await handle.create_response({"instructions": "x"})
+        await handle.cancel_response("resp-1")
+        await handle.barge_in()
+        await handle.ack_playback(120.7, response_id="resp-1", committed_ms=100)
+        await handle.update({"temperature": 0.2})
+        await handle.create_item({"id": "item_1", "type": "message"}, previous_item_id="root")
+        await handle.delete_item("item_1")
+        await handle.truncate_item("item_1", audio_end_ms=50)
+        await handle.signal_turn("user_started", {"x": 1})
+        await handle.heartbeat()
+
+        submitted = [command for session_id, command in engine.commands if session_id == handle.session_id]
+        assert [type(command) for command in submitted] == [
+            commands.AppendAudio,
+            commands.Commit,
+            commands.CreateResponse,
+            commands.CancelResponse,
+            commands.BargeIn,
+            commands.AckPlayback,
+            commands.UpdateSession,
+            commands.CreateItem,
+            commands.DeleteItem,
+            commands.TruncateItem,
+            commands.SignalTurn,
+            commands.Heartbeat,
+        ]
+        append, commit, create, cancel, _, ack, update, item, delete, truncate, signal, _ = submitted
+        assert append.audio == b"\x00\x01" and append.sample_rate_hz == 16000 and append.is_speech is True
+        assert commit.create_response is True and commit.final is True
+        assert create.options == {"instructions": "x"}
+        assert cancel.response_id == "resp-1"
+        assert ack.played_ms == 120 and ack.committed_ms == 100 and ack.response_id == "resp-1"
+        assert update.patch == {"temperature": 0.2}
+        assert item.previous_item_id == "root" and item.item["id"] == "item_1"
+        assert delete.item_id == "item_1"
+        assert truncate.audio_end_ms == 50
+        assert signal.event == "user_started" and signal.signal_payload == {"x": 1}
+    finally:
+        omni.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_shutdown_closes_every_handle(monkeypatch) -> None:
+    omni, engine = _make_omni(monkeypatch)
+    first = await omni.open_session()
+    second = await omni.open_session()
+
+    omni.shutdown()
+
+    assert first.closed and second.closed
+    assert first.close_reason == "shutdown"
+    assert omni.sessions == {}
+    assert engine.shutdown_called
diff --git a/tests/entrypoints/test_omni_base_profiler.py b/tests/entrypoints/test_omni_base_profiler.py
index 827ab67b6..d343e2f03 100644
--- a/tests/entrypoints/test_omni_base_profiler.py
+++ b/tests/entrypoints/test_omni_base_profiler.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 """Unit tests for OmniBase and AsyncOmni profiler methods."""
 
 from types import SimpleNamespace
@@ -28,10 +31,14 @@ class TestOmniBaseProfiler:
     @pytest.fixture
     def omni_base_instance(self, mock_engine, mocker: MockerFixture):
         """Create an OmniBase instance with mocked dependencies."""
-        mocker.patch("vllm_omni.entrypoints.omni_base.AsyncOmniEngine", return_value=mock_engine)
+        from vllm_omni.entrypoints.omni_base import OmniBase
+
+        # ``OmniBase`` builds its engine through the ``_create_engine`` seam that
+        # ``AsyncOmni`` / ``DuplexOmni`` implement; there is no module-level
+        # engine class to patch any more.
+        mocker.patch.object(OmniBase, "_create_engine", return_value=mock_engine)
         mocker.patch("vllm_omni.entrypoints.omni_base.omni_snapshot_download", side_effect=lambda x: x)
         mocker.patch("vllm_omni.entrypoints.omni_base.weakref.finalize")
-        from vllm_omni.entrypoints.omni_base import OmniBase
 
         instance = OmniBase(model="test-model")
         return instance
@@ -48,10 +55,14 @@ class TestOmniBaseProfiler:
 
     def test_removed_diffusion_batch_size_fails_loudly(self, mock_engine, mocker: MockerFixture):
         """Legacy diffusion_batch_size callers receive an actionable error."""
-        mocker.patch("vllm_omni.entrypoints.omni_base.AsyncOmniEngine", return_value=mock_engine)
+        from vllm_omni.entrypoints.omni_base import OmniBase
+
+        # ``OmniBase`` builds its engine through the ``_create_engine`` seam that
+        # ``AsyncOmni`` / ``DuplexOmni`` implement; there is no module-level
+        # engine class to patch any more.
+        mocker.patch.object(OmniBase, "_create_engine", return_value=mock_engine)
         mocker.patch("vllm_omni.entrypoints.omni_base.omni_snapshot_download", side_effect=lambda x: x)
         mocker.patch("vllm_omni.entrypoints.omni_base.weakref.finalize")
-        from vllm_omni.entrypoints.omni_base import OmniBase
 
         with pytest.raises(TypeError, match="diffusion_batch_size.*max_num_seqs"):
             OmniBase(model="test-model", diffusion_batch_size=8)
diff --git a/tests/entrypoints/test_omni_entrypoints.py b/tests/entrypoints/test_omni_entrypoints.py
index 6fe04fdb7..969bbaf91 100644
--- a/tests/entrypoints/test_omni_entrypoints.py
+++ b/tests/entrypoints/test_omni_entrypoints.py
@@ -3,6 +3,8 @@
 
 from __future__ import annotations
 
+import asyncio
+import gc
 import queue
 from collections.abc import Callable
 from types import SimpleNamespace
@@ -15,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
@@ -117,8 +121,6 @@ class FakeAsyncOmniEngine:
         self.output_processors = [SimpleNamespace(tokenizer=None) for _ in range(self.num_stages)]
         self.input_processor = None
         self.endpoint_restrictions = ()
-        self.duplex_session_config = None
-        self.duplex_serving_adapter_path = None
 
         self.output_q: queue.Queue[Any] = queue.Queue()
         self.submitted: list[dict[str, Any]] = []
@@ -166,7 +168,8 @@ class FakeAsyncOmniEngine:
     def abort(self, request_ids: list[str]) -> None:
         self.aborted.append(list(request_ids))
 
-    async def abort_async(self, request_ids: list[str]) -> None:
+    async def abort_async(self, request_ids: list[str], timeout=None) -> None:
+        del timeout
         self.abort(request_ids)
 
     async def collective_rpc_async(self, **_: Any) -> list[Any]:
@@ -181,7 +184,8 @@ class FakeAsyncOmniEngine:
 
 
 def _patch_engine(monkeypatch: pytest.MonkeyPatch, engine: FakeAsyncOmniEngine) -> None:
-    monkeypatch.setattr("vllm_omni.entrypoints.omni_base.AsyncOmniEngine", lambda *args, **kwargs: engine)
+    monkeypatch.setattr("vllm_omni.entrypoints.omni.AsyncOmniEngine", lambda *args, **kwargs: engine)
+    monkeypatch.setattr("vllm_omni.entrypoints.async_omni.AsyncOmniEngine", lambda *args, **kwargs: engine)
     monkeypatch.setattr("vllm_omni.entrypoints.omni_base.omni_snapshot_download", lambda model: model)
     # Don't add random UUIDs to requests calling .generate since we usually
     # just want to check for present requests anyway, and would need to just
@@ -200,33 +204,75 @@ def _make_base():
     return obj
 
 
-def test_resolve_sampling_params_list_preserves_stage_constraints():
+@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])]
-    base.engine.stage_configs = [
-        StageConfig(
+    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]}]
-    caller_params = SamplingParams(seed=1234, max_tokens=7, detokenize=True, stop_token_ids=[7])
 
+    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 == [42]
+    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
+    required_stop_ids = [151704, 151645]
+    base.default_sampling_params_list = [
+        SamplingParams(max_tokens=1000, detokenize=False, stop_token_ids=[99, *required_stop_ids])
+    ]
+    base.engine.stage_configs = [
+        StageConfig(
+            stage_id=0,
+            model_stage="dummy-model",
+            sampling_constraints={"detokenize": False, "stop_token_ids": required_stop_ids},
+        ).to_omegaconf()
+    ]
+    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}]
+
+
+def test_sampling_constraints_are_forwarded_by_typed_stage_configs():
+    config = VllmOmniConfig.from_pipeline_config(OMNI_PIPELINES["qwen3_tts"])
+
+    constraints = OmniBase._get_sampling_constraints_list(config.stage_configs)
+
+    assert constraints == [dict(stage.stage_pipeline_config.sampling_constraints) for stage in config.stage_configs]
+
+
 @pytest.mark.parametrize("use_defaults", [False, True])
 def test_moss_local_output_policy_preserves_codec_streaming(use_defaults):
     from vllm_omni.model_executor.models.moss_tts.pipeline import MOSS_TTS_LOCAL_PIPELINE
@@ -625,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)
@@ -758,7 +841,7 @@ def test_omni_generate_py_generator_yields_final_outputs_for_each_request(monkey
         f"{engine.submitted[1]['request_id']}-stage0-0",
         f"{engine.submitted[1]['request_id']}-stage2-final",
     ]
-    assert engine.shutdown_called is True
+    assert engine.shutdown_called is not True
 
 
 def test_omni_generate_returns_list_when_not_using_generator(monkeypatch: pytest.MonkeyPatch):
@@ -804,7 +887,7 @@ def test_omni_generate_diffusion_only_yields_single_image_per_request(monkeypatc
         [f"{engine.submitted[0]['request_id']}-image"],
         [f"{engine.submitted[1]['request_id']}-image"],
     ]
-    assert engine.shutdown_called is True
+    assert engine.shutdown_called is not True
 
 
 def test_omni_generate_llm_diffusion_yields_final_text_then_image_per_request(
@@ -837,7 +920,7 @@ def test_omni_generate_llm_diffusion_yields_final_text_then_image_per_request(
         [f"{engine.submitted[1]['request_id']}-image"],
     ]
     assert engine.submitted[0]["sampling_params_list"][0].output_kind == RequestOutputKind.FINAL_ONLY
-    assert engine.shutdown_called is True
+    assert engine.shutdown_called is not True
 
 
 def test_omni_abort_forwards_to_engine(monkeypatch: pytest.MonkeyPatch):
@@ -1318,3 +1401,57 @@ def test_omni_errored_property_dead_stage(monkeypatch: pytest.MonkeyPatch):
         assert app.errored is False
     finally:
         app.shutdown()
+
+
+def test_omni_pygenerator_does_not_kill_engine(monkeypatch: pytest.MonkeyPatch):
+    engine = FakeAsyncOmniEngine(
+        stage_metadata=THREE_STAGE_META,
+        on_add_request=_enqueue_async_three_stage_outputs,
+    )
+
+    _patch_engine(monkeypatch, engine)
+
+    app = Omni("dummy-model")
+    # Evaluating the generator should not shut down the engine
+    list(app.generate(["hello"], py_generator=True))
+    assert not engine.shutdown_called
+
+
+def test_omni_generator_close_cleans_up(monkeypatch: pytest.MonkeyPatch):
+    """Ensure that a closed generator cleans things up properly."""
+    engine = FakeAsyncOmniEngine(
+        stage_metadata=THREE_STAGE_META,
+        on_add_request=_enqueue_async_three_stage_outputs,
+    )
+
+    _patch_engine(monkeypatch, engine)
+
+    app = Omni("dummy-model")
+
+    # Create a generator and start to evaluate it to make sure the request isn't aborted yet
+    my_gen = app.generate(["hello"], py_generator=True)
+    next(my_gen)
+    request_id = engine.submitted[0]["request_id"]
+    assert engine.aborted == []
+    assert request_id in app.request_states
+
+    # Close it and make sure the sure it's aborted, but without killing engine
+    my_gen.close()
+    assert engine.aborted == [[request_id]]
+    assert request_id not in app.request_states
+    assert not engine.shutdown_called
+
+
+def test_del_shutsdown_engine(monkeypatch: pytest.MonkeyPatch):
+    engine = FakeAsyncOmniEngine(
+        stage_metadata=THREE_STAGE_META,
+        on_add_request=_enqueue_async_three_stage_outputs,
+    )
+
+    _patch_engine(monkeypatch, engine)
+
+    app = Omni("dummy-model")
+    assert not engine.shutdown_called
+    del app
+    gc.collect()
+    assert engine.shutdown_called
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 b64758e5d..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,113 @@ 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:
+    """Parse a ``serve`` argv through the real Omni parser, returning the
+    TrackingNamespace (with ``explicit_keys``) that ``validate`` receives."""
+    parser = TrackingArgumentParser()
+    subparsers = parser.add_subparsers(dest="subcommand")
+    OmniServeCommand().subparser_init(subparsers)
+    return parser.parse_args(argv)
+
+
+def test_omni_serve_requires_model_when_none_provided() -> None:
+    """Regression for https://github.com/vllm-project/vllm-omni/issues/4158:
+    ``vllm serve --omni`` with no model must fail fast instead of silently
+    falling back to vLLM's default model and crashing in the diffusion worker.
+    """
+    args = _parse_serve_args(["serve", "--omni"])
+    cmd = OmniServeCommand()
+    with pytest.raises(ValueError, match="requires an explicit model"):
+        cmd.validate(args)
+
+
+@pytest.mark.parametrize(
+    "argv",
+    [
+        # A deploy YAML supplied *without* an explicit model must still trip
+        # the guard. It carries per-stage engine args only -- the
+        # checkpoint is always threaded in from ``args.model`` -- so its mere
+        # presence does not establish that a model was provided. Without an
+        # explicit model ``args.model`` stays at vLLM's default and the launch
+        # reproduces the issue-4158 diffusion-registry crash.
+        ["serve", "--omni", "--deploy-config", "deploy.yaml"],
+        # An empty/whitespace model must not satisfy the guard either -- this is
+        # the ``--model "$MODEL"``-with-unset-var footgun. Otherwise the empty
+        # value flows downstream and crashes with the same confusing error.
+        ["serve", "", "--omni"],  # empty positional
+        ["serve", "--omni", "--model", ""],  # empty --model
+        ["serve", "--omni", "--model", "   "],  # whitespace-only --model
+    ],
+)
+def test_omni_serve_rejects_missing_or_empty_model(argv: list[str]) -> None:
+    """Regression for review feedback on PR #4167: a deploy YAML is not a
+    model source, so ``--deploy-config`` alone must not bypass the
+    require-a-model guard; neither may an empty/whitespace model value."""
+    args = _parse_serve_args(argv)
+    cmd = OmniServeCommand()
+    with pytest.raises(ValueError, match="requires an explicit model"):
+        cmd.validate(args)
+
+
+@pytest.mark.parametrize(
+    "argv",
+    [
+        ["serve", "fake-model", "--omni"],  # positional model
+        ["serve", "--omni", "--model", "fake-model"],  # --model flag
+        # An explicit model with a deploy YAML is the legitimate multi-stage
+        # path and must pass the guard.
+        ["serve", "fake-model", "--omni", "--deploy-config", "deploy.yaml"],
+    ],
+)
+def test_omni_serve_accepts_explicit_model(argv: list[str], mocker: MockerFixture) -> None:
+    """A model supplied positionally or via ``--model`` -- with or without a
+    deploy YAML -- must NOT trip the require-a-model guard. Downstream
+    validation is mocked so only the new guard is exercised."""
+    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")
+
+    args = _parse_serve_args(argv)
+    cmd = OmniServeCommand()
+    # Must not raise the "requires a model" error for any of these.
+    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:
@@ -69,6 +208,277 @@ def test_serve_parser_accepts_deploy_config() -> None:
     assert args.get_explicit_kwargs_dict()["deploy_config"] == "/tmp/deploy.yaml"
 
 
+def test_serve_parser_accepts_video_output_transport() -> None:
+    parser = TrackingArgumentParser()
+    subparsers = parser.add_subparsers(dest="subcommand")
+    OmniServeCommand().subparser_init(subparsers)
+
+    args = parser.parse_args(
+        ["serve", "fake-model", "--omni", "--video-output-transport", '{"enable_device_postprocess": true}']
+    )
+
+    expected = {"enable_device_postprocess": True}
+    assert args.video_output_transport == expected
+    assert args.get_explicit_kwargs_dict()["video_output_transport"] == expected
+
+
+@pytest.mark.parametrize("value", ["{not json", "[]"])
+def test_serve_parser_rejects_invalid_video_output_transport(value: str) -> None:
+    parser = TrackingArgumentParser()
+    subparsers = parser.add_subparsers(dest="subcommand")
+    OmniServeCommand().subparser_init(subparsers)
+
+    with pytest.raises(SystemExit):
+        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")
@@ -88,6 +498,26 @@ def test_serve_parser_accepts_four_way_cfg_parallelism() -> None:
     assert args.cfg_parallel_size == 4
 
 
+def test_serve_parser_accepts_robot_openpi_idle_timeout() -> None:
+    parser = TrackingArgumentParser()
+    subparsers = parser.add_subparsers(dest="subcommand")
+    OmniServeCommand().subparser_init(subparsers)
+
+    args = parser.parse_args(["serve", "fake-model", "--omni", "--robot-openpi-idle-timeout", "0"])
+
+    assert args.robot_openpi_idle_timeout == 0
+    assert args.get_explicit_kwargs_dict()["robot_openpi_idle_timeout"] == 0
+
+
+def test_serve_parser_rejects_negative_robot_openpi_idle_timeout() -> None:
+    parser = TrackingArgumentParser()
+    subparsers = parser.add_subparsers(dest="subcommand")
+    OmniServeCommand().subparser_init(subparsers)
+
+    with pytest.raises(SystemExit):
+        parser.parse_args(["serve", "fake-model", "--omni", "--robot-openpi-idle-timeout", "-1"])
+
+
 def test_serve_parser_accepts_ulysses_a2a_permute() -> None:
     parser = TrackingArgumentParser()
     subparsers = parser.add_subparsers(dest="subcommand")
@@ -216,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
@@ -588,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
@@ -636,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_image_to_video.py b/tests/examples/offline_inference/test_image_to_video.py
index b53648cb3..182187298 100644
--- a/tests/examples/offline_inference/test_image_to_video.py
+++ b/tests/examples/offline_inference/test_image_to_video.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 """
 Offline inference tests: image-to-video.
 See examples/offline_inference/image_to_video/README.md
@@ -17,7 +20,7 @@ pytestmark = [
     pytest.mark.usefixtures("clean_gpu_memory_between_tests"),
     pytest.mark.full_model,
     pytest.mark.example,
-    *hardware_marks(res={"cuda": "H100"}),
+    *hardware_marks(res={"cuda": ["H100", "B200"]}),
 ]
 
 I2V_SCRIPT = EXAMPLES / "offline_inference" / "image_to_video" / "image_to_video.py"
diff --git a/tests/examples/offline_inference/test_internvla_a1.py b/tests/examples/offline_inference/test_internvla_a1.py
index 791d380f0..f8ea50689 100644
--- a/tests/examples/offline_inference/test_internvla_a1.py
+++ b/tests/examples/offline_inference/test_internvla_a1.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
 
 """Offline E2E test for InternVLA-A1 open-loop inference."""
 
@@ -26,6 +26,7 @@ def _required_env(name: str) -> str:
     value = os.getenv(name)
     if not value:
         pytest.skip(f"{name} is not set")
+    assert value
     return value
 
 
diff --git a/tests/examples/offline_inference/test_lingbot_world_v2.py b/tests/examples/offline_inference/test_lingbot_world_v2.py
new file mode 100644
index 000000000..d83288853
--- /dev/null
+++ b/tests/examples/offline_inference/test_lingbot_world_v2.py
@@ -0,0 +1,48 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import json
+from pathlib import Path
+
+import pytest
+
+from examples.offline_inference.diffusion import ar_diffusion_streaming_decode as streaming_example
+from examples.offline_inference.diffusion import lingbot_world_v2 as example
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.diffusion]
+
+
+def test_offline_ulysses_argument(tmp_path):
+    argv = ["--image", "frame.jpg", "--action-dir", "forward", "--prompt", "A lake"]
+    paths = example.LingBotPaths(
+        tmp_path / "frame.jpg", tmp_path / "forward", tmp_path, Path("forward"), 9, tmp_path / "out.mp4"
+    )
+    assert example.parse_args(argv).ulysses_degree == 1
+    args = example.parse_args([*argv, "--ulysses-degree", "4"])
+    kwargs = example.build_omni_kwargs(args, paths)
+    assert kwargs["ulysses_degree"] == 4 and kwargs["tensor_parallel_size"] == 1
+    args.ulysses_degree = 0
+    with pytest.raises(ValueError, match="--ulysses-degree"):
+        example.build_omni_kwargs(args, paths)
+
+
+@pytest.mark.parametrize(("num_blocks", "num_frames"), [(10, 117), (11, 129)])
+def test_streaming_action_script_accepts_long_rollouts(tmp_path, num_blocks, num_frames):
+    action_script = tmp_path / "actions.json"
+    action_script.write_text(json.dumps([[["w"], [], ["a"]] for _ in range(num_blocks)]))
+
+    script = streaming_example._load_action_script(action_script)
+
+    assert len(script) == num_blocks
+    assert (
+        streaming_example._validate_against_checkpoint(script, frames_per_block=3, temporal_compression=4) == num_frames
+    )
+
+
+def test_streaming_action_script_rejects_wrong_frame_count_in_eleventh_block(tmp_path):
+    action_script = tmp_path / "actions.json"
+    action_script.write_text(json.dumps([[[], [], []] for _ in range(10)] + [[[], []]]))
+    script = streaming_example._load_action_script(action_script)
+
+    with pytest.raises(ValueError, match="block 10 holds 2 frame action lists"):
+        streaming_example._validate_against_checkpoint(script, frames_per_block=3, temporal_compression=4)
diff --git a/tests/examples/offline_inference/test_text_to_image.py b/tests/examples/offline_inference/test_text_to_image.py
index 5ee2a2fae..6289dcd33 100644
--- a/tests/examples/offline_inference/test_text_to_image.py
+++ b/tests/examples/offline_inference/test_text_to_image.py
@@ -18,7 +18,7 @@ pytestmark = [
     pytest.mark.usefixtures("clean_gpu_memory_between_tests"),
     pytest.mark.full_model,
     pytest.mark.example,
-    *hardware_marks(res={"cuda": "H100"}),
+    *hardware_marks(res={"cuda": ["H100", "B200"]}),
 ]
 
 T2I_SCRIPT = EXAMPLES / "offline_inference" / "text_to_image" / "text_to_image.py"
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/offline_inference/test_vace_video_generation.py b/tests/examples/offline_inference/test_vace_video_generation.py
index e4f6ca93d..fd23f0734 100644
--- a/tests/examples/offline_inference/test_vace_video_generation.py
+++ b/tests/examples/offline_inference/test_vace_video_generation.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 """VACE coverage through the shared text-to-video and image-to-video examples."""
 
 from pathlib import Path
@@ -14,7 +17,7 @@ pytestmark = [
     pytest.mark.full_model,
     pytest.mark.diffusion,
     pytest.mark.example,
-    *hardware_marks(res={"cuda": "H100"}),
+    *hardware_marks(res={"cuda": ["H100", "B200"]}),
 ]
 
 TEXT_TO_VIDEO_README = EXAMPLES / "offline_inference" / "text_to_video" / "text_to_video.md"
diff --git a/tests/examples/online_serving/test_qwen2_5_omni.py b/tests/examples/online_serving/test_qwen2_5_omni.py
index 0d0ec6f46..d56b6f958 100644
--- a/tests/examples/online_serving/test_qwen2_5_omni.py
+++ b/tests/examples/online_serving/test_qwen2_5_omni.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 """
 Online serving tests: Qwen2.5-Omni-7B.
 See examples/online_serving/qwen2_5_omni/README.md
@@ -42,7 +45,7 @@ test_params = [
 common_args = ["python", os.path.join(example_dir, "openai_chat_completion_client_for_multimodal_generation.py")]
 
 
-@hardware_test(res={"cuda": "L4", "rocm": "MI325"}, num_cards={"cuda": 4, "rocm": 2})
+@hardware_test(res={"cuda": ["L4", "B200"], "rocm": "MI325"}, num_cards={"cuda": 4, "rocm": 2})
 @pytest.mark.parametrize("omni_server", test_params, indirect=True)
 def test_send_multimodal_request_001(omni_server) -> None:
     command = common_args + [
@@ -77,7 +80,7 @@ def test_send_multimodal_request_001(omni_server) -> None:
     # TODO: Verify the E2E latency after confirmation baseline.
 
 
-@hardware_test(res={"cuda": "L4", "rocm": "MI325"}, num_cards={"cuda": 4, "rocm": 2})
+@hardware_test(res={"cuda": ["L4", "B200"], "rocm": "MI325"}, num_cards={"cuda": 4, "rocm": 2})
 @pytest.mark.parametrize("omni_server", test_params, indirect=True)
 def test_send_multimodal_request_002(omni_server) -> None:
     command = common_args + [
@@ -112,7 +115,7 @@ def test_send_multimodal_request_002(omni_server) -> None:
     # TODO: Verify the E2E latency after confirmation baseline.
 
 
-@hardware_test(res={"cuda": "L4", "rocm": "MI325"}, num_cards={"cuda": 4, "rocm": 2})
+@hardware_test(res={"cuda": ["L4", "B200"], "rocm": "MI325"}, num_cards={"cuda": 4, "rocm": 2})
 @pytest.mark.parametrize("omni_server", test_params, indirect=True)
 def test_send_multimodal_request_003(omni_server) -> None:
     command = [
@@ -137,7 +140,7 @@ def test_send_multimodal_request_003(omni_server) -> None:
     # TODO: Verify the E2E latency after confirmation baseline.
 
 
-@hardware_test(res={"cuda": "L4", "rocm": "MI325"}, num_cards={"cuda": 4, "rocm": 2})
+@hardware_test(res={"cuda": ["L4", "B200"], "rocm": "MI325"}, num_cards={"cuda": 4, "rocm": 2})
 @pytest.mark.parametrize("omni_server", test_params, indirect=True)
 def test_modality_control_001(omni_server) -> None:
     command = common_args + [
@@ -165,7 +168,7 @@ def test_modality_control_001(omni_server) -> None:
     # TODO: Verify the E2E latency after confirmation baseline.
 
 
-@hardware_test(res={"cuda": "L4", "rocm": "MI325"}, num_cards={"cuda": 4, "rocm": 2})
+@hardware_test(res={"cuda": ["L4", "B200"], "rocm": "MI325"}, num_cards={"cuda": 4, "rocm": 2})
 @pytest.mark.parametrize("omni_server", test_params, indirect=True)
 def test_modality_control_002(omni_server) -> None:
     command = common_args + [
@@ -192,7 +195,7 @@ def test_modality_control_002(omni_server) -> None:
     # TODO: Verify the E2E latency after confirmation baseline.
 
 
-@hardware_test(res={"cuda": "L4", "rocm": "MI325"}, num_cards={"cuda": 4, "rocm": 2})
+@hardware_test(res={"cuda": ["L4", "B200"], "rocm": "MI325"}, num_cards={"cuda": 4, "rocm": 2})
 @pytest.mark.parametrize("omni_server", test_params, indirect=True)
 def test_modality_control_003(omni_server) -> None:
     command = common_args + [
@@ -228,7 +231,7 @@ def test_modality_control_003(omni_server) -> None:
     # TODO: Verify the E2E latency after confirmation baseline.
 
 
-@hardware_test(res={"cuda": "L4", "rocm": "MI325"}, num_cards={"cuda": 4, "rocm": 2})
+@hardware_test(res={"cuda": ["L4", "B200"], "rocm": "MI325"}, num_cards={"cuda": 4, "rocm": 2})
 @pytest.mark.parametrize("omni_server", test_params, indirect=True)
 def test_stream_001(omni_server) -> None:
     command = common_args + [
diff --git a/tests/examples/online_serving/test_qwen3_omni.py b/tests/examples/online_serving/test_qwen3_omni.py
index 711b7236a..23e2ba184 100644
--- a/tests/examples/online_serving/test_qwen3_omni.py
+++ b/tests/examples/online_serving/test_qwen3_omni.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 """
 Online serving tests: Qwen3-Omni.
 See examples/online_serving/qwen3_omni/README.md
@@ -41,7 +44,7 @@ test_params = [
 common_args = ["python", os.path.join(example_dir, "openai_chat_completion_client_for_multimodal_generation.py")]
 
 
-@hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
+@hardware_test(res={"cuda": ["H100", "B200"], "rocm": "MI325"}, num_cards=2)
 @pytest.mark.parametrize("omni_server", test_params, indirect=True)
 def test_send_multimodal_request_001(omni_server) -> None:
     command = common_args + [
@@ -69,7 +72,7 @@ def test_send_multimodal_request_001(omni_server) -> None:
     # TODO: Verify the E2E latency after confirmation baseline.
 
 
-@hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
+@hardware_test(res={"cuda": ["H100", "B200"], "rocm": "MI325"}, num_cards=2)
 @pytest.mark.parametrize("omni_server", test_params, indirect=True)
 def test_send_multimodal_request_002(omni_server) -> None:
     command = common_args + [
@@ -100,7 +103,7 @@ def test_send_multimodal_request_002(omni_server) -> None:
     # TODO: Verify the E2E latency after confirmation baseline.
 
 
-@hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
+@hardware_test(res={"cuda": ["H100", "B200"], "rocm": "MI325"}, num_cards=2)
 @pytest.mark.parametrize("omni_server", test_params, indirect=True)
 def test_send_multimodal_request_003(omni_server) -> None:
     command = ["bash", os.path.join(example_dir, "qwen3_omni/run_curl_multimodal_generation.sh"), "use_image"]
@@ -115,7 +118,7 @@ def test_send_multimodal_request_003(omni_server) -> None:
     # TODO: Verify the E2E latency after confirmation baseline.
 
 
-@hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
+@hardware_test(res={"cuda": ["H100", "B200"], "rocm": "MI325"}, num_cards=2)
 @pytest.mark.parametrize("omni_server", test_params, indirect=True)
 def test_modality_control_001(omni_server) -> None:
     command = common_args + [
@@ -137,7 +140,7 @@ def test_modality_control_001(omni_server) -> None:
     # TODO: Verify the E2E latency after confirmation baseline.
 
 
-@hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
+@hardware_test(res={"cuda": ["H100", "B200"], "rocm": "MI325"}, num_cards=2)
 @pytest.mark.parametrize("omni_server", test_params, indirect=True)
 def test_modality_control_002(omni_server) -> None:
     command = common_args + [
@@ -159,7 +162,7 @@ def test_modality_control_002(omni_server) -> None:
     # TODO: Verify the E2E latency after confirmation baseline.
 
 
-@hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
+@hardware_test(res={"cuda": ["H100", "B200"], "rocm": "MI325"}, num_cards=2)
 @pytest.mark.parametrize("omni_server", test_params, indirect=True)
 def test_modality_control_003(omni_server) -> None:
     command = common_args + [
@@ -189,7 +192,7 @@ def test_modality_control_003(omni_server) -> None:
     # TODO: Verify the E2E latency after confirmation baseline.
 
 
-@hardware_test(res={"cuda": "H100", "rocm": "MI325"}, num_cards=2)
+@hardware_test(res={"cuda": ["H100", "B200"], "rocm": "MI325"}, num_cards=2)
 @pytest.mark.parametrize("omni_server", test_params, indirect=True)
 def test_stream_001(omni_server) -> None:
     command = common_args + [
diff --git a/tests/examples/online_serving/test_text_to_image.py b/tests/examples/online_serving/test_text_to_image.py
index 25970502b..f251cd16c 100644
--- a/tests/examples/online_serving/test_text_to_image.py
+++ b/tests/examples/online_serving/test_text_to_image.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 """
 Online serving tests: text-to-image.
 See examples/online_serving/text_to_image/README.md
@@ -18,7 +21,7 @@ from tests.helpers.assertions import assert_image_valid
 from tests.helpers.mark import hardware_marks
 from tests.helpers.runtime import OmniServer, OmniServerParams
 
-pytestmark = [pytest.mark.full_model, pytest.mark.example, *hardware_marks(res={"cuda": "H100"})]
+pytestmark = [pytest.mark.full_model, pytest.mark.example, *hardware_marks(res={"cuda": ["H100", "B200"]})]
 
 T2I_ONLINE_CLIENT = EXAMPLES / "online_serving" / "text_to_image" / "openai_chat_client.py"
 EXAMPLE_OUTPUT_SUBFOLDER = "example_online_t2i"
diff --git a/tests/examples/test_minicpmo_realtime_duplex_simple_demo.py b/tests/examples/test_minicpmo_realtime_duplex_simple_demo.py
index d4a70e1b5..ba17ec656 100644
--- a/tests/examples/test_minicpmo_realtime_duplex_simple_demo.py
+++ b/tests/examples/test_minicpmo_realtime_duplex_simple_demo.py
@@ -60,7 +60,7 @@ def test_post_commit_decision_accepts_drained_speak_after_commit_ack():
     events = [
         {"type": "input_audio_buffer.committed"},
         {"type": "response.created", "response": {"id": "resp-a"}},
-        {"type": "response.audio.delta", "response_id": "resp-a", "delta": "AAAA"},
+        {"type": "response.output_audio.delta", "response_id": "resp-a", "delta": "AAAA"},
         {"type": "response.done", "response_id": "resp-a"},
     ]
 
@@ -267,7 +267,7 @@ def test_streaming_output_writer_persists_audio_deltas_as_they_arrive(tmp_path,
 
     writer.handle(
         {
-            "type": "response.audio.delta",
+            "type": "response.output_audio.delta",
             "response_id": "resp-a",
             "delta": base64.b64encode(first_pcm).decode("ascii"),
             "sample_rate_hz": 24_000,
@@ -275,14 +275,14 @@ def test_streaming_output_writer_persists_audio_deltas_as_they_arrive(tmp_path,
     )
     writer.handle(
         {
-            "type": "response.audio_transcript.delta",
+            "type": "response.output_audio_transcript.delta",
             "response_id": "resp-a",
             "delta": "你好",
         }
     )
     writer.handle(
         {
-            "type": "response.audio.delta",
+            "type": "response.output_audio.delta",
             "response_id": "resp-a",
             "delta": base64.b64encode(second_pcm).decode("ascii"),
             "sample_rate_hz": 24_000,
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 5fdab87d1..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 "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
-    assert "url.searchParams.set('native_duplex', '1')" 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.audio.delta" in source
-    assert "response.audio_transcript.delta" in source
-    assert "conversation.item.input_audio_transcription" in source
-    assert "force_barge_in" not in source
+    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 "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")
-
+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 "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 dd25aca71..5df9dfa7e 100644
--- a/tests/helpers/assertions.py
+++ b/tests/helpers/assertions.py
@@ -171,6 +171,38 @@ def _short_transcript_contains_expected(transcript: str, expected: str) -> bool:
     return short_text and small_word_delta and expected_clean in transcript_clean
 
 
+_MAX_TAIL_WORDS_FLOOR = 2
+_TAIL_WORD_RATIO = 0.2
+
+
+def _transcript_has_bounded_tail(transcript: str, expected: str) -> bool:
+    """Pass when the expected text is spoken verbatim, only trailed by noise.
+
+    A short, unrelated tail after the complete expected sentence is the exact
+    case #6828's rationale anticipated: a different valid TTS sample can append
+    an audible tail even when the spoken text is identical, and Whisper can
+    hallucinate brief words on a non-speech tail. The length-penalized n-gram
+    cosine stays below the gate for such tails, so accept the match when the
+    expected text is a word-aligned prefix of the transcript and the trailing
+    words stay within the floor/ratio bounds.
+    """
+    transcript_clean = preprocess_text(transcript)
+    expected_clean = preprocess_text(expected)
+    if not transcript_clean or not expected_clean:
+        return False
+
+    transcript_words = transcript_clean.split()
+    expected_words = expected_clean.split()
+    if not transcript_words or not expected_words:
+        return False
+
+    if transcript_words[: len(expected_words)] != expected_words:
+        return False
+    tail_words = len(transcript_words) - len(expected_words)
+    max_tail_words = max(_MAX_TAIL_WORDS_FLOOR, math.ceil(_TAIL_WORD_RATIO * len(expected_words)))
+    return tail_words <= max_tail_words
+
+
 def assert_image_diffusion_response(
     response: "DiffusionResponse",
     request_config: dict[str, Any],
@@ -834,7 +866,16 @@ def assert_omni_response(response: Any, request_config: dict[str, Any], run_leve
                         text_output.lower(),
                     )
                     print(f"similarity is: {similarity}")
-                    assert similarity > similarity_threshold, AUDIO_MISMATCH_MESSAGE
+                    if similarity <= similarity_threshold and _transcript_has_bounded_tail(transcript, text_output):
+                        # The full answer is spoken verbatim and only a short
+                        # noise tail follows it; see #6828's rationale.
+                        print(
+                            "bounded-tail containment check passed: "
+                            f"text={text_output!r} is a word-aligned prefix of "
+                            f"transcript={transcript!r}"
+                        )
+                    else:
+                        assert similarity > similarity_threshold, AUDIO_MISMATCH_MESSAGE
             if audio_ref_text:
                 assert transcript is not None, "No audio transcript for reference-text validation"
                 audio_similarity = cosine_similarity_text(
@@ -914,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 66e0cefab..5c9c8076f 100644
--- a/tests/helpers/runtime.py
+++ b/tests/helpers/runtime.py
@@ -23,6 +23,7 @@ from typing import Any, NamedTuple
 import numpy as np
 import psutil
 import yaml
+from filelock import FileLock, Timeout
 from vllm import TextPrompt
 from vllm.logger import init_logger
 
@@ -37,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
@@ -170,9 +173,54 @@ class OmniServer:
         self.use_omni = use_omni
         self.proc: subprocess.Popen | None = None
         self.host = "127.0.0.1"
+        self._auto_port = port is None
+        self._port_lock: FileLock | None = None
         self.port = get_open_port() if port is None else port
 
+    def _reserve_port(self) -> None:
+        # bind(0)/close does not reserve a port across concurrent pytest workers.
+        # Keep an advisory lock until teardown, including the long import phase
+        # before the subprocess binds its HTTP socket. Never unlink lock files:
+        # another worker may already have the same inode open.
+        for attempt in range(128):
+            if attempt:
+                self.port = get_open_port(self.host)
+            lock_path = Path(tempfile.gettempdir()) / f"vllm-omni-test-port-{os.getuid()}-{self.port}.lock"
+            lock = FileLock(lock_path)
+            try:
+                lock.acquire(timeout=0)
+            except Timeout as error:
+                if not self._auto_port:
+                    raise RuntimeError(f"HTTP test port {self.port} is already reserved") from error
+                continue
+            try:
+                with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as probe:
+                    probe.bind((self.host, self.port))
+            except OSError as error:
+                lock.release()
+                if not self._auto_port or error.errno != errno.EADDRINUSE:
+                    raise
+                continue
+            self._port_lock = lock
+            return
+        raise RuntimeError("Could not reserve an HTTP test port after 128 attempts")
+
+    def _owns_listening_port(self) -> bool:
+        assert self.proc is not None
+        try:
+            parent = psutil.Process(self.proc.pid)
+            processes = [parent, *parent.children(recursive=True)]
+            return any(
+                conn.status == psutil.CONN_LISTEN and conn.laddr.port == self.port
+                for process in processes
+                for conn in process.net_connections(kind="tcp")
+            )
+        except psutil.NoSuchProcess:
+            # A child can exit between enumeration and inspecting its sockets.
+            return False
+
     def _start_server(self) -> None:
+        self._reserve_port()
         env = os.environ.copy()
         if self.env_dict is not None:
             env.update(self.env_dict)
@@ -200,15 +248,19 @@ 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.")
             with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
                 sock.settimeout(1)
-                if sock.connect_ex((self.host, self.port)) == 0:
+                if sock.connect_ex((self.host, self.port)) == 0 and self._owns_listening_port():
+                    ret = self.proc.poll()
+                    if ret is not None:
+                        raise RuntimeError(f"Server processes exited with code {ret} before becoming ready.")
                     startup_s = time.perf_counter() - startup_t0
                     if self.log_stats:
                         print(
@@ -368,9 +420,14 @@ class OmniServer:
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        if self.proc:
-            self._kill_process_tree(self.proc.pid)
-        cleanup_test_environment()
+        try:
+            if self.proc:
+                self._kill_process_tree(self.proc.pid)
+        finally:
+            if self._port_lock is not None:
+                self._port_lock.release()
+                self._port_lock = None
+            cleanup_test_environment()
 
 
 class OmniServerStageCli(OmniServer):
@@ -496,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)
@@ -1112,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
@@ -1130,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 98deaa511..55956a6f2 100644
--- a/tests/helpers/tests/test_assertions.py
+++ b/tests/helpers/tests/test_assertions.py
@@ -126,3 +126,73 @@ def test_escalated_transcript_keeps_declared_language(monkeypatch):
 
     assert captured["model_size"] == "large-v3"
     assert captured["language"] == "en"
+
+
+def test_bounded_tail_after_complete_answer_passes():
+    # The exact shape from the #6815 nightly failure: the full answer is spoken
+    # verbatim, then a two-word unrelated tail trips the cosine gate.
+    assert assertions._transcript_has_bounded_tail(
+        "The squares in this image are black. nack shit.",
+        "The squares in this image are black.",
+    )
+
+
+def test_bounded_tail_exact_match_passes():
+    assert assertions._transcript_has_bounded_tail(
+        "The squares in this image are black.",
+        "The squares in this image are black.",
+    )
+
+
+def test_bounded_tail_rejects_different_content():
+    assert not assertions._transcript_has_bounded_tail(
+        "The circles in this picture are black and white.",
+        "The squares in this image are black.",
+    )
+
+
+def test_bounded_tail_rejects_long_tail():
+    # Eight expected words allow at most max(2, ceil(0.2 * 8)) = 2 tail words.
+    assert not assertions._transcript_has_bounded_tail(
+        "The squares in this image are black and some extra words follow here",
+        "The squares in this image are black.",
+    )
+
+
+def test_bounded_tail_rejects_word_boundary_split():
+    assert not assertions._transcript_has_bounded_tail(
+        "The squares in this image are blacks.",
+        "The squares in this image are black.",
+    )
+
+
+def test_bounded_tail_allows_ratio_bound_for_long_answers():
+    expected = " ".join(["word"] * 20)
+    four_word_tail = expected + " one two three four"
+    five_word_tail = expected + " one two three four five"
+    # 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_server_ports.py b/tests/helpers/tests/test_runtime_server_ports.py
new file mode 100644
index 000000000..1d8c0b2f1
--- /dev/null
+++ b/tests/helpers/tests/test_runtime_server_ports.py
@@ -0,0 +1,109 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""A listening port alone must not make a different test's server ready."""
+
+import socket
+import subprocess
+import sys
+
+import pytest
+from filelock import FileLock
+
+from tests.helpers import runtime
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_server_does_not_accept_another_process_listener(monkeypatch):
+    monkeypatch.setattr(runtime, "cleanup_test_environment", lambda: None)
+    server = runtime.OmniServer("fake-model", [])
+    popen = subprocess.Popen
+
+    # Occupy the chosen port after allocation, while the requested subprocess
+    # is still importing. The old TCP-only probe returns ready for this socket.
+    with socket.socket() as foreign_listener:
+
+        def launch(*args, **kwargs):
+            foreign_listener.bind((server.host, server.port))
+            foreign_listener.listen()
+            return popen([sys.executable, "-c", "import time; time.sleep(0.2); raise SystemExit(7)"])
+
+        monkeypatch.setattr(runtime.subprocess, "Popen", launch)
+        with pytest.raises(RuntimeError, match="exited with code 7"):
+            with server:
+                pass
+    # Failed __enter__ must also release the lease for a later server.
+    retry = runtime.OmniServer("retry-model", [], port=server.port)
+    try:
+        retry._reserve_port()
+    finally:
+        retry.__exit__(None, None, None)
+
+
+def test_auto_ports_are_reserved_before_subprocesses_bind(monkeypatch, tmp_path):
+    monkeypatch.setattr(runtime, "cleanup_test_environment", lambda: None)
+    monkeypatch.setattr(runtime.tempfile, "gettempdir", lambda: str(tmp_path))
+    # Both constructors see the same free port before either server has bound.
+    first = runtime.OmniServer("first-model", [])
+    candidate = first.port
+    monkeypatch.setattr(runtime, "get_open_port", lambda *args: candidate)
+    second = runtime.OmniServer("second-model", [])
+    first._reserve_port()
+    with socket.socket() as occupied, socket.socket() as probe:
+        occupied.bind((first.host, candidate))
+        probe.bind((first.host, 0))
+        alternative = probe.getsockname()[1]
+    monkeypatch.setattr(runtime, "get_open_port", lambda *args: alternative)
+    try:
+        second._reserve_port()
+        assert first.port == candidate
+        assert second.port == alternative
+        # Check OS-level lock exclusion, not only the Python object's state.
+        lock_path = next(tmp_path.glob(f"*-{candidate}.lock"))
+        contender = FileLock(lock_path)
+        result = subprocess.run(
+            [
+                sys.executable,
+                "-c",
+                "import sys\nfrom filelock import FileLock, Timeout\n"
+                "try:\n FileLock(sys.argv[1]).acquire(timeout=0)\n"
+                "except Timeout:\n sys.exit(23)\n",
+                str(lock_path),
+            ],
+            timeout=10,
+            check=False,
+        )
+        assert result.returncode == 23
+        explicit = runtime.OmniServer("explicit-model", [], port=candidate)
+        with pytest.raises(RuntimeError, match="already reserved"):
+            with explicit:
+                pass
+    finally:
+        first.__exit__(None, None, None)
+        second.__exit__(None, None, None)
+    with contender.acquire(timeout=0):
+        pass
+
+
+@pytest.mark.parametrize("in_child", [False, True])
+def test_server_accepts_its_own_listener(monkeypatch, in_child):
+    monkeypatch.setattr(runtime, "cleanup_test_environment", lambda: None)
+    server = runtime.OmniServer("fake-model", [])
+    popen = subprocess.Popen
+
+    def launch(*args, **kwargs):
+        code = (
+            "import socket,time; s=socket.socket(); "
+            f"s.bind(({server.host!r}, {server.port})); s.listen(); time.sleep(30)"
+        )
+        if in_child:
+            code = f"import subprocess,sys; child=subprocess.Popen([sys.executable,'-c',{code!r}]); child.wait()"
+        return popen([sys.executable, "-c", code])
+
+    monkeypatch.setattr(runtime.subprocess, "Popen", launch)
+    with server:
+        assert server.proc is not None
+        assert server.proc.poll() is None
+        with socket.create_connection((server.host, server.port), timeout=1):
+            pass
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/host_weight_runtime/test_filesystem_store.py b/tests/host_weight_runtime/test_filesystem_store.py
index 7fe716c5d..d149d34bd 100644
--- a/tests/host_weight_runtime/test_filesystem_store.py
+++ b/tests/host_weight_runtime/test_filesystem_store.py
@@ -20,6 +20,7 @@ from collections.abc import Sequence
 from dataclasses import replace
 from multiprocessing.process import BaseProcess
 from pathlib import Path
+from typing import IO, Any
 
 import pytest
 import torch
@@ -408,6 +409,154 @@ def _make_store(
     return FilesystemHostWeightStore(domain, capacity or CapacityPolicy(), integrity or IntegrityPolicy())
 
 
+class _FaultyTemporaryFile:
+    """NamedTemporaryFile proxy that injects a write or close failure."""
+
+    def __init__(
+        self,
+        handle: IO[bytes],
+        *,
+        write_error: BaseException | None = None,
+        close_error: BaseException | None = None,
+    ) -> None:
+        self._handle = handle
+        self._write_error = write_error
+        self._close_error = close_error
+
+    def __getattr__(self, name: str) -> object:
+        return getattr(self._handle, name)
+
+    def __enter__(self) -> _FaultyTemporaryFile:
+        return self
+
+    def __exit__(self, *exc_info: object) -> None:
+        self._handle.close()
+        if self._close_error is not None:
+            raise self._close_error
+
+    def write(self, data: bytes) -> int:
+        if self._write_error is not None:
+            raise self._write_error
+        return self._handle.write(data)
+
+
+def _inject_temporary_file_failure(
+    monkeypatch: pytest.MonkeyPatch,
+    *,
+    write_error: BaseException | None = None,
+    close_error: BaseException | None = None,
+) -> None:
+    original = tempfile.NamedTemporaryFile
+
+    def faulty(*args: Any, **kwargs: Any) -> _FaultyTemporaryFile:
+        handle: IO[bytes] = original(*args, **kwargs)
+        return _FaultyTemporaryFile(handle, write_error=write_error, close_error=close_error)
+
+    monkeypatch.setattr(tempfile, "NamedTemporaryFile", faulty)
+
+
+def test_atomic_json_replace_failure_removes_temporary_file(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    path = tmp_path / "domain.json"
+    path.write_bytes(b"existing metadata")
+    replace_error = OSError(errno.EIO, "injected replace failure")
+
+    def fail_replace(source: os.PathLike[str], destination: os.PathLike[str]) -> None:
+        raise replace_error
+
+    monkeypatch.setattr(os, "replace", fail_replace)
+
+    with pytest.raises(OSError) as error:
+        filesystem_store_module._write_atomic_json(path, {"schema_version": 1})
+
+    assert error.value is replace_error
+    assert path.read_bytes() == b"existing metadata"
+    assert not list(tmp_path.glob(".domain.json.*.tmp"))
+
+
+def test_atomic_json_cleanup_failure_preserves_replace_error(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    path = tmp_path / "domain.json"
+    replace_error = OSError(errno.EIO, "injected replace failure")
+    original_unlink = Path.unlink
+    cleanup_attempted = False
+
+    def fail_replace(source: os.PathLike[str], destination: os.PathLike[str]) -> None:
+        raise replace_error
+
+    def fail_temporary_unlink(target: Path, missing_ok: bool = False) -> None:
+        nonlocal cleanup_attempted
+        if target.parent == tmp_path and target.name.startswith(".domain.json."):
+            cleanup_attempted = True
+            raise PermissionError(errno.EACCES, "injected cleanup failure")
+        original_unlink(target, missing_ok=missing_ok)
+
+    monkeypatch.setattr(os, "replace", fail_replace)
+    monkeypatch.setattr(Path, "unlink", fail_temporary_unlink)
+
+    with pytest.raises(OSError) as error:
+        filesystem_store_module._write_atomic_json(path, {"schema_version": 1})
+
+    assert cleanup_attempted
+    assert error.value is replace_error
+    assert len(list(tmp_path.glob(".domain.json.*.tmp"))) == 1
+
+
+@pytest.mark.parametrize("close_fails", [False, True])
+def test_atomic_json_write_failure_preserves_error_when_cleanup_fails(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    close_fails: bool,
+) -> None:
+    path = tmp_path / "domain.json"
+    write_error = OSError(errno.EIO, "injected write failure")
+    original_unlink = Path.unlink
+    cleanup_attempted = False
+
+    def fail_temporary_unlink(target: Path, missing_ok: bool = False) -> None:
+        nonlocal cleanup_attempted
+        if target.parent == tmp_path and target.name.startswith(".domain.json."):
+            cleanup_attempted = True
+            raise PermissionError(errno.EACCES, "injected cleanup failure")
+        original_unlink(target, missing_ok=missing_ok)
+
+    _inject_temporary_file_failure(
+        monkeypatch,
+        write_error=write_error,
+        close_error=OSError(errno.EIO, "injected close failure") if close_fails else None,
+    )
+    monkeypatch.setattr(Path, "unlink", fail_temporary_unlink)
+
+    with pytest.raises(OSError) as error:
+        filesystem_store_module._write_atomic_json(path, {"schema_version": 1})
+
+    assert cleanup_attempted
+    assert error.value is write_error
+    assert not path.exists()
+    assert len(list(tmp_path.glob(".domain.json.*.tmp"))) == 1
+
+
+def test_atomic_json_close_failure_removes_temporary_file(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    path = tmp_path / "domain.json"
+    close_error = OSError(errno.EIO, "injected close failure")
+
+    _inject_temporary_file_failure(monkeypatch, close_error=close_error)
+
+    with pytest.raises(OSError) as error:
+        filesystem_store_module._write_atomic_json(path, {"schema_version": 1})
+
+    assert error.value is close_error
+    assert not path.exists()
+    assert not list(tmp_path.glob(".domain.json.*.tmp"))
+
+
 def _publish_test_artifact(
     store: FilesystemHostWeightStore,
     identity: WeightArtifactIdentity | None = None,
diff --git a/tests/host_weight_runtime/test_runtime_resolution.py b/tests/host_weight_runtime/test_runtime_resolution.py
index 21bab37de..cd2de2816 100644
--- a/tests/host_weight_runtime/test_runtime_resolution.py
+++ b/tests/host_weight_runtime/test_runtime_resolution.py
@@ -4,6 +4,10 @@
 
 from __future__ import annotations
 
+import multiprocessing as mp
+import threading
+import time
+from multiprocessing.connection import Connection
 from pathlib import Path
 from typing import cast
 
@@ -15,6 +19,7 @@ from vllm_omni.host_weight_runtime import (
     CanonicalJson,
     ComponentIdentity,
     FailureCode,
+    HostWeightError,
     HostWeightFailure,
     HostWeightLease,
     HostWeightLeaseCarrier,
@@ -40,12 +45,14 @@ from vllm_omni.host_weight_runtime import (
     StoreStatus,
     TensorWriteSpec,
     ValidationLevel,
+    WaitPolicy,
     WeightArtifactIdentity,
     WeightProductionSpec,
     WeightRepresentation,
     WeightSourceIdentity,
 )
 from vllm_omni.host_weight_runtime.filesystem import FilesystemHostWeightStore, detect_storage_class
+from vllm_omni.host_weight_runtime.filesystem.locks import FileLock, lock_is_active
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
@@ -518,6 +525,107 @@ def test_retryable_store_initialization_failure_obeys_runtime_mode(
     assert resolution.report.attempts[0].failure.retryable
 
 
+def _initialize_contended_runtime(config: HostWeightRuntimeConfig, output: Connection) -> None:
+    try:
+        output.send("starting")
+        started = time.monotonic()
+        runtime = HostWeightRuntime.from_config(config)
+        resolution = runtime.resolve(_identity())
+        try:
+            output.send((time.monotonic() - started, resolution.report))
+        finally:
+            if resolution.lease is not None:
+                resolution.lease.close()
+    finally:
+        output.close()
+
+
+@pytest.mark.parametrize(
+    ("mode", "expected"),
+    [
+        (RuntimeMode.PREFERRED, ResolutionOutcome.CANONICAL_FALLBACK),
+        (RuntimeMode.REQUIRED, ResolutionOutcome.FAILED),
+    ],
+)
+def test_domain_lock_timeout_and_fresh_runtime_recovery(
+    tmp_path: Path, mode: RuntimeMode, expected: ResolutionOutcome
+) -> None:
+    config = HostWeightRuntimeConfig(mode=mode, domain=_domain(tmp_path), wait=WaitPolicy(0.1))
+    initial = HostWeightRuntime.from_config(config)
+    built = initial.resolve(_identity(), producer=CountingProducer(_identity()))
+    assert built.lease is not None
+    built.lease.close()
+    metadata = {name: (tmp_path / name).read_bytes() for name in ("domain.json", "domain-policy.json")}
+    lock_path = tmp_path / "locks" / "domain-init.lock"
+    ctx = mp.get_context("spawn")
+    reader, writer = ctx.Pipe(duplex=False)
+    process = ctx.Process(target=_initialize_contended_runtime, args=(config, writer))
+
+    with FileLock(lock_path, exclusive=True, deadline=None):
+        process.start()
+        writer.close()
+        try:
+            # Import/bootstrap is outside the short coordination budget.
+            assert reader.poll(60), "waiter did not start"
+            assert reader.recv() == "starting"
+            assert reader.poll(5), "domain initialization did not respect the coordination timeout"
+            elapsed, report = reader.recv()
+            assert 0.1 <= elapsed < 5
+            assert report.outcome is expected
+            failure = report.attempts[0].failure
+            assert failure is not None
+            assert failure.stage is ResolutionStage.DOMAIN
+            assert failure.code is FailureCode.DOMAIN_UNAVAILABLE
+            assert failure.retryable
+            assert "timed out waiting for" in failure.message
+            assert "domain-init.lock" in failure.message
+            assert lock_is_active(lock_path), "waiter must not unlock the owner"
+            process.join(5)
+            assert process.exitcode == 0
+        finally:
+            if process.is_alive():
+                process.kill()
+            process.join(5)
+            process.close()
+            reader.close()
+
+    assert {name: (tmp_path / name).read_bytes() for name in metadata} == metadata
+    recovered = HostWeightRuntime.from_config(config).resolve(_identity())
+    assert recovered.report.outcome is ResolutionOutcome.LOCAL_HIT
+    assert recovered.lease is not None
+    recovered.lease.close()
+
+
+def test_direct_store_waits_for_domain_lock_released_before_deadline(tmp_path: Path) -> None:
+    config = HostWeightRuntimeConfig(mode=RuntimeMode.PREFERRED, domain=_domain(tmp_path))
+    assert config.domain is not None
+    initial = HostWeightRuntime.from_config(config)
+    assert initial.store is not None
+    lock_path = tmp_path / "locks" / "domain-init.lock"
+    with FileLock(lock_path, exclusive=True, deadline=None) as owner:
+        release = threading.Timer(0.1, owner.close)
+        release.start()
+        try:
+            store = FilesystemHostWeightStore(config.domain, config.capacity, config.integrity, wait=WaitPolicy(5))
+        finally:
+            release.join(5)
+    assert store.root == tmp_path
+
+
+def test_direct_store_domain_timeout_is_typed(tmp_path: Path) -> None:
+    config = HostWeightRuntimeConfig(mode=RuntimeMode.PREFERRED, domain=_domain(tmp_path))
+    assert config.domain is not None
+    HostWeightRuntime.from_config(config)
+    lock_path = tmp_path / "locks" / "domain-init.lock"
+    with FileLock(lock_path, exclusive=True, deadline=None):
+        with pytest.raises(HostWeightError) as caught:
+            FilesystemHostWeightStore(config.domain, config.capacity, config.integrity, wait=WaitPolicy(0.01))
+        assert caught.value.failure.code is FailureCode.DOMAIN_UNAVAILABLE
+        assert caught.value.failure.retryable
+        assert lock_is_active(lock_path)
+    assert not lock_is_active(lock_path)
+
+
 @pytest.mark.parametrize(
     ("stage", "code"),
     [
diff --git a/tests/metrics/test_emit_calls.py b/tests/metrics/test_emit_calls.py
index b46f4080f..02a98fc00 100644
--- a/tests/metrics/test_emit_calls.py
+++ b/tests/metrics/test_emit_calls.py
@@ -41,7 +41,6 @@ def _make_omni_base_with_mock_prom(mocker):
     obj = object.__new__(OmniBase)
     obj.prom_metrics = mocker.Mock(spec=OmniPrometheusMetrics)
     obj.request_states = {}
-    obj._consumed_metric_messages = {}
     obj.log_stats = True
     return obj, obj.prom_metrics
 
@@ -270,7 +269,7 @@ class TestStageWorkloadMetricScope:
 
         obj = object.__new__(OmniBase)
         obj._enable_ar_profiler = False
-        obj._consumed_metric_messages = {}
+        obj.request_states = {"req-replay": SimpleNamespace(consumed_metric_message_ids=set())}
         obj.prom_metrics = mocker.Mock(spec=OmniPrometheusMetrics)
         obj.mod_metrics = mocker.Mock()
         obj.engine = SimpleNamespace(
diff --git a/tests/metrics/test_modality.py b/tests/metrics/test_modality.py
index 14bb4f309..a918dce53 100644
--- a/tests/metrics/test_modality.py
+++ b/tests/metrics/test_modality.py
@@ -48,6 +48,8 @@ _EXPECTED_FAMILIES = [
     defs.AUDIO_UNDERRUN_S,
     defs.AUDIO_CONTINUITY_OK_METRIC,
     defs.AUDIO_SKIPPED_REQUESTS_METRIC,
+    defs.SPEECH_STREAM_ABORTED_METRIC,
+    defs.SPEECH_STREAM_COMPLETED_METRIC,
     defs.DIFFUSION_EXEC_S,
     defs.DIFFUSION_EXEC_PER_STEP_S,
     defs.DIFFUSION_PREPROCESS_S,
@@ -70,6 +72,8 @@ class TestRegistration:
         mod.observe_audio_underrun("s", "r", 0.01)
         mod.inc_audio_continuity_ok("s", "r", 100)
         mod.inc_audio_skipped("s", "r", "malformed_codec")
+        mod.inc_speech_stream_aborted("error")
+        mod.inc_speech_stream_completed()
         mod.observe_diffusion_exec("s", "r", 0.5)
         mod.observe_diffusion_exec_per_step("s", "r", 0.01)
         mod.observe_diffusion_preprocess("s", "r", 0.01)
@@ -91,6 +95,23 @@ class TestRegistration:
 
 
 class TestAudio:
+    def test_speech_stream_abort_counter_and_disabled_logging(self):
+        model = "test-speech-stream-abort-counter"
+        metrics = OmniModalityMetrics(model_name=model)
+        disabled = OmniModalityMetrics(model_name=model, log_stats=False)
+        metrics.inc_speech_stream_completed()
+        disabled.inc_speech_stream_completed()
+        assert REGISTRY.get_sample_value(defs.SPEECH_STREAM_COMPLETED_METRIC + "_total", {"model_name": model}) == 1.0
+        for reason in ("cancelled", "closed", "engine_dead", "error"):
+            metrics.inc_speech_stream_aborted(reason)
+            disabled.inc_speech_stream_aborted(reason)
+            assert (
+                REGISTRY.get_sample_value(
+                    defs.SPEECH_STREAM_ABORTED_METRIC + "_total", {"model_name": model, "reason": reason}
+                )
+                == 1.0
+            )
+
     def test_audio_ttfp_observed(self, mod: OmniModalityMetrics) -> None:
         stage, replica = "talker_ttfp", "0"
         mod.observe_audio_ttfp(stage, replica, 0.42)
@@ -242,6 +263,9 @@ class _StubModMetrics:
     def observe_audio_rtf(self, s, r, rtf):
         self.calls.append(("observe_audio_rtf", s, r, rtf))
 
+    def observe_audio_ttfp(self, s, r, t):
+        self.calls.append(("observe_audio_ttfp", s, r, t))
+
     def observe_audio_underrun(self, s, r, u):
         self.calls.append(("observe_audio_underrun", s, r, u))
 
@@ -599,7 +623,6 @@ class TestObserveDiffusionFinalize:
 class TestObserveAudioFirstPacket:
     def test_observes_with_valid_inputs(self):
         stub = _StubModMetrics()
-        stub.observe_audio_ttfp = lambda s, r, t: stub.calls.append(("observe_audio_ttfp", s, r, t))
 
         observe_audio_first_packet(
             stub,
@@ -612,19 +635,16 @@ class TestObserveAudioFirstPacket:
 
     def test_replica_none_skipped(self):
         stub = _StubModMetrics()
-        stub.observe_audio_ttfp = lambda s, r, t: stub.calls.append(("observe_audio_ttfp", s, r, t))
         observe_audio_first_packet(stub, stage_id=1, replica_id=None, arrival_ts=100.0, now_ts=100.5)
         assert stub.calls == []
 
     def test_arrival_ts_zero_skipped(self):
         stub = _StubModMetrics()
-        stub.observe_audio_ttfp = lambda s, r, t: stub.calls.append(("observe_audio_ttfp", s, r, t))
         observe_audio_first_packet(stub, stage_id=1, replica_id=0, arrival_ts=0.0, now_ts=100.5)
         assert stub.calls == []
 
     def test_clock_skew_clamped_to_zero(self):
         stub = _StubModMetrics()
-        stub.observe_audio_ttfp = lambda s, r, t: stub.calls.append(("observe_audio_ttfp", s, r, t))
         observe_audio_first_packet(stub, stage_id=1, replica_id=0, arrival_ts=100.5, now_ts=100.0)
         assert stub.calls == [("observe_audio_ttfp", "1", "0", 0.0)]
 
@@ -668,6 +688,24 @@ class TestObserveAudioStreamingFinalize:
         assert underrun_calls[0][-1] > 0.1
         assert not any(c[0] == "inc_audio_continuity_ok" for c in stub.calls)
 
+    def test_stereo_channel_count_is_used_for_playback_rate(self):
+        stub = _StubModMetrics()
+        # At 100 Hz, s16le stereo consumes 400 bytes/s. The first 200-byte
+        # chunk buffers 0.5s, so a second chunk arriving at 1.0s underruns by 0.5s.
+        observe_audio_streaming_finalize(
+            stub,
+            stage_id=1,
+            replica_id=0,
+            chunk_arrival_times_s=[0.0, 1.0],
+            chunk_bytes=[200, 200],
+            sample_rate=100,
+            channels=2,
+            threshold_s=0.1,
+        )
+        underrun_calls = [c for c in stub.calls if c[0] == "observe_audio_underrun"]
+        assert underrun_calls == [("observe_audio_underrun", "1", "0", pytest.approx(0.5))]
+        assert not any(c[0] == "inc_audio_continuity_ok" for c in stub.calls)
+
     def test_empty_arrivals_skipped(self):
         stub = _StubModMetrics()
         observe_audio_streaming_finalize(
diff --git a/tests/metrics/test_prometheus.py b/tests/metrics/test_prometheus.py
index e45365cf1..ca8dd8d5e 100644
--- a/tests/metrics/test_prometheus.py
+++ b/tests/metrics/test_prometheus.py
@@ -154,7 +154,6 @@ class TestRequestLifecycleGauges:
         obj.engine = SimpleNamespace(_running_counter=OmniRequestCounter())
         obj.prom_metrics = OmniPrometheusMetrics(model_name="lifecycle-test")
         obj.request_states = {}
-        obj._consumed_metric_messages = {}
         obj.log_stats = False
 
         # Simulate request lifecycle: start (counter 0→1, dict {} → {req}),
@@ -183,7 +182,6 @@ class TestRequestLifecycleGauges:
         obj.engine = SimpleNamespace(_running_counter=OmniRequestCounter())
         obj.prom_metrics = OmniPrometheusMetrics(model_name="lifecycle-test-2")
         obj.request_states = {}
-        obj._consumed_metric_messages = {}
         obj.log_stats = False
 
         # Two in flight, one finalizes — running should report 1, waiting 0.
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/__init__.py b/tests/model_executor/models/breeze_tts_2/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/model_executor/models/breeze_tts_2/test_audio_tokenizer.py b/tests/model_executor/models/breeze_tts_2/test_audio_tokenizer.py
new file mode 100644
index 000000000..75dcbb1fb
--- /dev/null
+++ b/tests/model_executor/models/breeze_tts_2/test_audio_tokenizer.py
@@ -0,0 +1,128 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+import torch
+
+from vllm_omni.model_executor.models.breeze_tts_2.audio_tokenizer import (
+    BreezeReferenceAudioTokenizer,
+    resolve_audio_tokenizer_path,
+)
+
+
+def _patch_hf_api(monkeypatch, snapshot_download):
+    """Point the resolver's tagged HF helper at a fake API object."""
+    from vllm.transformers_utils import repo_utils
+
+    monkeypatch.setattr(repo_utils, "hf_api", lambda: SimpleNamespace(snapshot_download=snapshot_download))
+
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _Tokenizer:
+    def encode(self, audio, sr=None):
+        assert isinstance(audio, np.ndarray)
+        assert sr == 16000
+        return {"audio_codes": [torch.arange(32).reshape(16, 2)]}
+
+
+def test_reference_audio_tokenizer_normalizes_codebook_major_output():
+    adapter = BreezeReferenceAudioTokenizer(_Tokenizer())
+
+    codes = adapter.encode(np.zeros(32, dtype=np.float32), 16000)
+
+    assert tuple(codes.shape) == (2, 16)
+    assert codes.dtype == torch.int16
+    assert codes.device.type == "cpu"
+
+
+def test_reference_audio_tokenizer_rejects_waveform_without_sample_rate():
+    adapter = BreezeReferenceAudioTokenizer(_Tokenizer())
+
+    try:
+        adapter.encode(np.zeros(32, dtype=np.float32))
+    except ValueError as exc:
+        assert "sample_rate is required" in str(exc)
+    else:
+        raise AssertionError("missing sample rate should be rejected")
+
+
+def test_resolve_prefers_local_directory_without_hub_access(tmp_path, monkeypatch):
+    bundled = tmp_path / "audio_tokenizer"
+    bundled.mkdir()
+
+    def _no_hub(*_args, **_kwargs):
+        raise AssertionError("local directories must not touch the hub")
+
+    _patch_hf_api(monkeypatch, _no_hub)
+
+    assert resolve_audio_tokenizer_path(str(tmp_path)) == bundled
+
+
+def test_resolve_local_directory_without_bundled_tokenizer_returns_none(tmp_path, monkeypatch):
+    def _no_hub(*_args, **_kwargs):
+        raise AssertionError("local directories must not touch the hub")
+
+    _patch_hf_api(monkeypatch, _no_hub)
+
+    assert resolve_audio_tokenizer_path(str(tmp_path)) is None
+
+
+def test_resolve_repo_id_uses_hf_snapshot(tmp_path, monkeypatch):
+    snapshot_root = tmp_path / "snapshot"
+    (snapshot_root / "audio_tokenizer").mkdir(parents=True)
+    calls = []
+
+    def _fake_snapshot_download(repo_id, **kwargs):
+        calls.append((repo_id, kwargs))
+        if kwargs.get("local_files_only"):
+            raise FileNotFoundError("cold cache")
+        return str(snapshot_root)
+
+    _patch_hf_api(monkeypatch, _fake_snapshot_download)
+
+    resolved = resolve_audio_tokenizer_path("BreezeBlue/Breeze-TTS-2")
+
+    assert resolved == snapshot_root / "audio_tokenizer"
+    # The cold-cache probe runs first; the online fetch carries the pattern.
+    assert calls[0] == (
+        "BreezeBlue/Breeze-TTS-2",
+        {"allow_patterns": ["audio_tokenizer/*"], "local_files_only": True},
+    )
+    assert calls[1] == ("BreezeBlue/Breeze-TTS-2", {"allow_patterns": ["audio_tokenizer/*"]})
+
+
+def test_resolve_repo_id_prefers_complete_cached_snapshot(tmp_path, monkeypatch):
+    snapshot_root = tmp_path / "snapshot"
+    (snapshot_root / "audio_tokenizer").mkdir(parents=True)
+    calls = []
+
+    def _fake_snapshot_download(repo_id, **kwargs):
+        calls.append((repo_id, kwargs))
+        assert kwargs.get("local_files_only"), "cached snapshot must not hit the network"
+        return str(snapshot_root)
+
+    _patch_hf_api(monkeypatch, _fake_snapshot_download)
+
+    resolved = resolve_audio_tokenizer_path("BreezeBlue/Breeze-TTS-2")
+
+    assert resolved == snapshot_root / "audio_tokenizer"
+    assert len(calls) == 1
+
+
+def test_resolve_repo_id_without_bundled_tokenizer_returns_none(tmp_path, monkeypatch):
+    snapshot_root = tmp_path / "snapshot"
+    snapshot_root.mkdir()
+
+    def _fake_snapshot_download(repo_id, **kwargs):
+        if kwargs.get("local_files_only"):
+            raise FileNotFoundError("cold cache")
+        return str(snapshot_root)
+
+    _patch_hf_api(monkeypatch, _fake_snapshot_download)
+
+    assert resolve_audio_tokenizer_path("BreezeBlue/Breeze-TTS-2") is None
diff --git a/tests/model_executor/models/breeze_tts_2/test_batching.py b/tests/model_executor/models/breeze_tts_2/test_batching.py
new file mode 100644
index 000000000..41fc0b9ba
--- /dev/null
+++ b/tests/model_executor/models/breeze_tts_2/test_batching.py
@@ -0,0 +1,95 @@
+# 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_omni.model_executor.models.breeze_tts_2.modeling_breeze_tts_2_talker import (
+    BreezeTTS2TalkerForGeneration,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _RequestHead:
+    def __call__(self, hidden: torch.Tensor) -> torch.Tensor:
+        # Hidden row 0 selects codec id 2; row 1 selects codec id 3.
+        code0 = 2 + int(hidden.reshape(-1)[0].item())
+        logits = torch.zeros((hidden.shape[0], 9), dtype=hidden.dtype)
+        logits[:, code0] = 1.0
+        return logits
+
+
+def _model() -> BreezeTTS2TalkerForGeneration:
+    model = object.__new__(BreezeTTS2TalkerForGeneration)
+    model.num_codebooks = 4
+    model.codebook_vocab_size = 8
+    model.codebook_size = 8
+    model.codebook_eos_token_id = 0
+    model.audio_token_id = 100
+    model.audio_eos_token_id = 101
+    model.lm_head = _RequestHead()
+    model.logits_processor = lambda head, hidden: head(hidden)
+    model._codec_disallowed_mask = None
+    model._batch_state = None
+    model._batch_state_spans = None
+    model._async_chunk = True
+    model._golden_dump_dir = None
+    model._generate_depth_codes = lambda _hidden, code0: _frame(code0).unsqueeze(0)
+    return model
+
+
+def _frame(code0: int) -> torch.Tensor:
+    return torch.tensor([code0, code0 + 1, code0 + 2, code0 + 3], dtype=torch.long)
+
+
+def _step(model: BreezeTTS2TalkerForGeneration, infos: list[dict[str, Any]], hidden: torch.Tensor):
+    return model.make_omni_output(
+        hidden,
+        model_intermediate_buffer=infos,
+        request_token_spans=[(0, 1), (1, 2)],
+    )
+
+
+def test_two_requests_accumulate_and_emit_independent_frames():
+    model = _model()
+    infos = [
+        {
+            "breeze_generated_frames": 1,
+            "breeze_max_new_frames": 2,
+            "breeze_audio_codes": _frame(2).reshape(1, 4),
+        },
+        {"breeze_generated_frames": 0, "breeze_max_new_frames": 3},
+    ]
+    hidden = torch.tensor([[0.0], [1.0]], dtype=torch.float32)
+
+    first = _step(model, infos, hidden)
+    assert [tuple(item.shape) for item in first.multimodal_outputs["codes"]["audio"]] == [(1, 4), (1, 4)]
+    assert torch.equal(first.multimodal_outputs["codes"]["audio"][0][0], _frame(2))
+    assert torch.equal(first.multimodal_outputs["codes"]["audio"][1][0], _frame(3))
+
+    second = _step(model, infos, hidden)
+    # Request 0 reaches its two-frame budget and emits only a finish marker;
+    # request 1 still has budget and emits its next tail frame.
+    assert second.multimodal_outputs["codes"]["audio"][0].numel() == 0
+    assert torch.equal(second.multimodal_outputs["codes"]["audio"][1][0], _frame(3))
+    # Async streaming only maintains the per-frame tail; the cumulative
+    # buffer is deliberately not grown (request 0 keeps its pre-seeded
+    # entry untouched, request 1 never gains one).
+    assert infos[0]["breeze_audio_codes"].shape == (1, 4)
+    assert "breeze_audio_codes" not in infos[1]
+    assert infos[0]["breeze_force_eos"] is True
+    assert infos[1]["breeze_force_eos"] is False
+
+
+def test_finished_requests_only_clear_model_owned_batch_mapping():
+    model = _model()
+    model._batch_state = [{"id": "a"}, {"id": "b"}]
+    model._batch_state_spans = [(0, 1), (1, 2)]
+
+    model.on_requests_finished(["a", "b"])
+
+    assert model._batch_state is None
+    assert model._batch_state_spans is None
diff --git a/tests/model_executor/models/breeze_tts_2/test_codec_loading.py b/tests/model_executor/models/breeze_tts_2/test_codec_loading.py
new file mode 100644
index 000000000..f558d067a
--- /dev/null
+++ b/tests/model_executor/models/breeze_tts_2/test_codec_loading.py
@@ -0,0 +1,68 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from typing import Any
+
+import pytest
+import torch
+from torch import nn
+
+from vllm_omni.model_executor.models.breeze_tts_2.modeling_breeze_tts_2_codec import (
+    BreezeTTS2MimiCodec,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _BundledTokenizer:
+    def __init__(self) -> None:
+        self.model = nn.Linear(2, 2)
+
+    def named_parameters(self):
+        for name, parameter in self.model.named_parameters():
+            yield f"model.{name}", parameter
+
+    def decode(self, _encoded: Any) -> tuple[list[torch.Tensor], int]:
+        return [torch.zeros(4)], 24_000
+
+
+def test_bundled_qwen_tokenizer_consumes_unused_root_fallback_weights(tmp_path):
+    bundled = tmp_path / "audio_tokenizer"
+    bundled.mkdir()
+    codec = object.__new__(BreezeTTS2MimiCodec)
+    codec.model_path = str(tmp_path)
+    codec.vllm_config = None
+    # load_weights reuses the path resolved once in __init__.
+    codec._tokenizer_path = bundled
+    codec._codec = None
+    codec._audio_tokenizer = _BundledTokenizer()
+    codec._loaded_local_weights = False
+
+    weights = [
+        ("backbone_model.layers.0.norm.weight", torch.ones(2)),
+        ("codec_model.decoder.layers.0.conv.weight", torch.ones(2)),
+        ("lm_head.weight", torch.ones(2, 2)),
+    ]
+
+    loaded = codec.load_weights(iter(weights))
+
+    assert "_audio_tokenizer.model.weight" in loaded
+    assert "_audio_tokenizer.model.bias" in loaded
+    # The bundled tokenizer was preloaded, so load_weights must not try to copy
+    # the root Mimi fallback into the nonexistent ``self._codec`` module.
+    assert codec._codec is None
+
+
+def test_codec_warmup_with_single_token_returns_empty_audio():
+    codec = object.__new__(BreezeTTS2MimiCodec)
+    codec._num_codebooks = 4
+    codec._codebook_size = 8
+    codec._sample_rate = 24_000
+    codec._audio_tokenizer = None
+    codec._codec = None
+    codec._async_chunk = False
+
+    output = codec.forward(torch.tensor([1], dtype=torch.long), seq_token_counts=[1])
+
+    assert output.multimodal_outputs["model_outputs"][0].numel() == 0
+    assert output.multimodal_outputs["sr"][0].item() == 24_000
diff --git a/tests/model_executor/models/breeze_tts_2/test_configuration.py b/tests/model_executor/models/breeze_tts_2/test_configuration.py
new file mode 100644
index 000000000..950f420cf
--- /dev/null
+++ b/tests/model_executor/models/breeze_tts_2/test_configuration.py
@@ -0,0 +1,113 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import pytest
+from transformers.models.qwen3 import Qwen3Config
+
+from vllm_omni.model_executor.models.breeze_tts_2.configuration_breeze_tts_2 import (
+    BreezeTTS2Config,
+    BreezeTTS2DepthDecoderConfig,
+    BreezeTTS2TextEncoderConfig,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _config() -> BreezeTTS2Config:
+    return BreezeTTS2Config(
+        backbone_config={
+            "model_type": "qwen3",
+            "hidden_size": 32,
+            "intermediate_size": 64,
+            "num_hidden_layers": 2,
+            "num_attention_heads": 4,
+            "num_key_value_heads": 2,
+            "head_dim": 8,
+            "vocab_size": 128,
+            "max_position_embeddings": 512,
+        },
+        text_encoder_config={
+            "model_type": "t5gemma2_text",
+            "hidden_size": 24,
+            "intermediate_size": 48,
+            "num_hidden_layers": 6,
+            "num_attention_heads": 2,
+            "num_key_value_heads": 1,
+            "head_dim": 8,
+            "vocab_size": 256,
+        },
+        depth_decoder_config={
+            "model_type": "breeze_depth_decoder_model",
+            "hidden_size": 32,
+            "backbone_hidden_size": 32,
+            "audio_embed_size": 32,
+            "intermediate_size": 64,
+            "num_hidden_layers": 2,
+            "num_attention_heads": 4,
+            "num_key_value_heads": 2,
+            "head_dim": 8,
+            "num_codebooks": 16,
+            "vocab_size": 2051,
+            "rope_scaling": {
+                "rope_type": "llama3",
+                "factor": 32.0,
+                "low_freq_factor": 0.001953125,
+                "high_freq_factor": 0.0078125,
+                "original_max_position_embeddings": 16,
+            },
+        },
+        codec_config={"model_type": "mimi", "codebook_size": 2048, "num_quantizers": 32},
+        num_codebooks=16,
+        vocab_size=2051,
+        text_vocab_size=262158,
+    )
+
+
+def test_nested_configs_and_text_config_use_qwen_backbone():
+    config = _config()
+
+    assert isinstance(config.backbone_config, Qwen3Config)
+    assert config.get_text_config() is config.backbone_config
+    assert config.get_text_config().vocab_size == 128
+    assert isinstance(config.text_encoder_config, BreezeTTS2TextEncoderConfig)
+    assert isinstance(config.depth_decoder_config, BreezeTTS2DepthDecoderConfig)
+    assert config.num_codebooks == config.depth_decoder_config.num_codebooks == 16
+    assert config.codec_config["codebook_size"] == 2048
+
+
+def test_transformers_five_roundtrip_preserves_nested_configs_and_rope():
+    config = _config()
+
+    roundtrip = BreezeTTS2Config(**dict(config.to_dict()))
+
+    assert isinstance(roundtrip.backbone_config, Qwen3Config)
+    assert isinstance(roundtrip.text_encoder_config, BreezeTTS2TextEncoderConfig)
+    assert isinstance(roundtrip.depth_decoder_config, BreezeTTS2DepthDecoderConfig)
+    assert roundtrip.depth_decoder_config.rope_parameters["rope_theta"] == 500_000.0
+
+
+def test_nested_autoconfig_registration_is_idempotent():
+    import importlib
+
+    module = importlib.import_module("vllm_omni.model_executor.models.breeze_tts_2.configuration_breeze_tts_2")
+    importlib.reload(module)
+
+    assert module.BreezeTTS2Config.model_type == "breeze"
+
+
+def test_text_encoder_defaults_to_upstream_layer_pattern():
+    config = BreezeTTS2TextEncoderConfig(num_hidden_layers=6)
+
+    assert config.layer_types == [
+        "sliding_attention",
+        "sliding_attention",
+        "sliding_attention",
+        "sliding_attention",
+        "sliding_attention",
+        "full_attention",
+    ]
+
+
+def test_invalid_codebook_layout_is_rejected():
+    with pytest.raises(ValueError, match="positive"):
+        BreezeTTS2DepthDecoderConfig(num_codebooks=0)
diff --git a/tests/model_executor/models/breeze_tts_2/test_instruction.py b/tests/model_executor/models/breeze_tts_2/test_instruction.py
new file mode 100644
index 000000000..c7f2fef66
--- /dev/null
+++ b/tests/model_executor/models/breeze_tts_2/test_instruction.py
@@ -0,0 +1,157 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+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 (
+    BreezeTTS2PromptBuilder,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _Tokenizer:
+    unk_token_id = -1
+
+    def convert_tokens_to_ids(self, token):
+        return {"<|AUDIO|>": 262144, "<|audio_eos|>": 262145}.get(token, self.unk_token_id)
+
+    def __call__(self, texts, *, add_special_tokens=True, padding=False):
+        if isinstance(texts, str):
+            texts = [texts]
+        ids = [[1000 + ord(char) % 1000 for char in text] for text in texts]
+        if add_special_tokens:
+            ids = [[2, *row, 1] for row in ids]
+        return {"input_ids": ids}
+
+    def decode(self, ids, *, skip_special_tokens=False):
+        del skip_special_tokens
+        return "".join(chr(int(token_id) - 1000) for token_id in ids if token_id not in (1, 2))
+
+
+def test_instruction_prompt_remains_one_independent_text_segment():
+    builder = BreezeTTS2PromptBuilder(
+        _Tokenizer(),
+        SimpleNamespace(
+            audio_token_id=262144,
+            audio_eos_token_id=262145,
+            pad_token_id=0,
+            backbone_config=SimpleNamespace(vocab_size=100000),
+            num_codebooks=16,
+            codec_config={"codebook_size": 2048},
+        ),
+    )
+
+    prompt = builder.build(
+        {
+            "template": "tts_instruction",
+            "speaker": "S2",
+            "instruction": "Use a bright and friendly delivery.",
+            "text": "Hello from Breeze.",
+        }
+    )
+
+    info = prompt["additional_information"]
+    assert info["template"] == "tts_instruction"
+    assert "input_values" not in info
+    assert bool(info["text_ids_mask"].all())
+    assert info["text_ids_len"].tolist() == [len(info["prompt_ids"])]
+
+
+def _request(extra_params=None, **overrides):
+    base = dict(
+        input="Hello.",
+        ref_text=None,
+        ref_audio=None,
+        task_type=None,
+        speed=1.0,
+        max_new_tokens=None,
+        language=None,
+        speaker_embedding=None,
+        x_vector_only_mode=None,
+        extra_params=extra_params or {},
+    )
+    base.update(overrides)
+    return SimpleNamespace(**base)
+
+
+def _adapter() -> BreezeTTS2Adapter:
+    adapter = object.__new__(BreezeTTS2Adapter)
+    adapter.ctx = SimpleNamespace(server=SimpleNamespace())
+    return adapter
+
+
+def test_cfg_scale_one_is_explicitly_supported_without_companion_request():
+    adapter = _adapter()
+
+    assert adapter.validate(_request({"guidance_scale": 1.0})) is None
+    assert adapter.validate(_request({"cfg_scale": 1.0})) is None
+
+
+def test_non_unit_cfg_is_rejected_until_negative_branch_exists():
+    adapter = _adapter()
+
+    assert "guidance_scale=1.0" in adapter.validate(_request({"guidance_scale": 2.0}))
+    assert "guidance_scale=1.0" in adapter.validate(_request({"cfg_scale": 0.5}))
+    assert "negative_prompt" in adapter.validate(_request({"negative_prompt": "noisy"}))
+
+
+def test_unsupported_conditioning_fields_are_rejected_not_ignored():
+    adapter = _adapter()
+
+    assert "language" in adapter.validate(_request(language="en"))
+    assert "speaker_embedding" in adapter.validate(_request(speaker_embedding=[0.1, 0.2]))
+    assert "x_vector_only_mode" in adapter.validate(_request(x_vector_only_mode=True))
+    # Absent fields must keep the request valid.
+    assert adapter.validate(_request()) is None
+    assert adapter.validate(_request(x_vector_only_mode=False)) is None
+
+
+def test_multiple_reference_clips_are_rejected_not_silently_truncated():
+    adapter = _adapter()
+    adapter.ctx.server._validate_ref_audio_format = lambda _uri: None
+
+    error = adapter.validate(_request(ref_audio=["a.wav", "b.wav"], ref_text="hello"))
+    assert "exactly one reference clip" in error
+    assert "2" in error
+    # A single-element list stays valid and reaches format validation.
+    assert adapter.validate(_request(ref_audio=["a.wav"], ref_text="hello")) is None
+
+
+def test_non_greedy_sampling_overrides_are_rejected():
+    adapter = _adapter()
+
+    # Greedy values, including the deploy-config defaults, stay valid.
+    assert adapter.validate(_request({"temperature": 0.0, "top_p": 1.0, "top_k": -1})) is None
+    assert adapter.validate(_request({"temperature": 0})) is None
+    # The talker ignores the sampled code0, so any non-greedy override must be
+    # refused instead of silently producing greedy audio.
+    assert "greedy" in adapter.validate(_request({"temperature": 0.7}))
+    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_local_modules.py b/tests/model_executor/models/breeze_tts_2/test_local_modules.py
new file mode 100644
index 000000000..2ce54b09a
--- /dev/null
+++ b/tests/model_executor/models/breeze_tts_2/test_local_modules.py
@@ -0,0 +1,152 @@
+# 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.breeze_tts_2.configuration_breeze_tts_2 import (
+    BreezeTTS2DepthDecoderConfig,
+    BreezeTTS2TextEncoderConfig,
+)
+from vllm_omni.model_executor.models.breeze_tts_2.modeling_breeze_tts_2_depth import (
+    BreezeDepthDecoderForCausalLM,
+)
+from vllm_omni.model_executor.models.breeze_tts_2.modeling_breeze_tts_2_text import (
+    BreezeTTS2TextEncoder,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _depth_config() -> BreezeTTS2DepthDecoderConfig:
+    return BreezeTTS2DepthDecoderConfig(
+        hidden_size=16,
+        backbone_hidden_size=16,
+        audio_embed_size=16,
+        intermediate_size=32,
+        num_hidden_layers=1,
+        num_attention_heads=4,
+        num_key_value_heads=2,
+        head_dim=4,
+        max_position_embeddings=8,
+        num_codebooks=4,
+        vocab_size=8,
+        rope_scaling={
+            "rope_type": "llama3",
+            "rope_theta": 100.0,
+            "factor": 1.0,
+            "low_freq_factor": 0.5,
+            "high_freq_factor": 1.0,
+            "original_max_position_embeddings": 4,
+        },
+    )
+
+
+def test_depth_decoder_position_specific_logits_and_offsets():
+    config = _depth_config()
+    decoder = BreezeDepthDecoderForCausalLM(config)
+
+    output = decoder(
+        input_ids=torch.tensor([[0, 2]]),
+        backbone_last_hidden_state=torch.randn(1, 16),
+        use_cache=False,
+    )
+
+    assert output.logits.shape == (1, 1, 8)
+    with torch.no_grad():
+        embedding = decoder.model.embed_tokens.weight
+        expected_first = embedding[2] @ decoder.model.inputs_embeds_projector.weight.T
+        # The first hidden row is replaced by the backbone state, so compare the
+        # second input row (codebook 0, id 2 + 0 * vocab_size).
+        actual_input = decoder.model.embed_tokens(torch.tensor([[2]]))[0, 0]
+        actual_projected = actual_input @ decoder.model.inputs_embeds_projector.weight.T
+    assert torch.allclose(expected_first, actual_projected)
+
+
+def _text_config() -> BreezeTTS2TextEncoderConfig:
+    return BreezeTTS2TextEncoderConfig(
+        hidden_size=16,
+        intermediate_size=32,
+        num_hidden_layers=2,
+        num_attention_heads=2,
+        num_key_value_heads=1,
+        head_dim=8,
+        vocab_size=32,
+        layer_types=["sliding_attention", "full_attention"],
+        rope_parameters={
+            "sliding_attention": {"rope_type": "default", "rope_theta": 100.0},
+            "full_attention": {"rope_type": "default", "rope_theta": 100.0},
+        },
+    )
+
+
+def test_text_encoder_masks_right_padding_independently(monkeypatch):
+    import vllm_omni.model_executor.models.breeze_tts_2.modeling_breeze_tts_2_text as text_module
+
+    class _ParallelEmbedding(torch.nn.Embedding):
+        def __init__(self, num_embeddings: int, embedding_dim: int):
+            super().__init__(num_embeddings, embedding_dim)
+
+    class _QKVLinear(torch.nn.Module):
+        def __init__(
+            self,
+            hidden_size: int,
+            head_size: int,
+            total_num_heads: int,
+            total_num_kv_heads: int,
+            **_: object,
+        ):
+            super().__init__()
+            output_size = (total_num_heads + 2 * total_num_kv_heads) * head_size
+            self.linear = torch.nn.Linear(hidden_size, output_size, bias=False)
+
+        def forward(self, hidden_states: torch.Tensor) -> tuple[torch.Tensor, None]:
+            return self.linear(hidden_states), None
+
+    class _RowLinear(torch.nn.Module):
+        def __init__(self, input_size: int, output_size: int, **_: object):
+            super().__init__()
+            self.linear = torch.nn.Linear(input_size, output_size, bias=False)
+
+        def forward(self, hidden_states: torch.Tensor) -> tuple[torch.Tensor, None]:
+            return self.linear(hidden_states), None
+
+    class _MergedLinear(torch.nn.Module):
+        def __init__(self, input_size: int, output_sizes: list[int], **_: object):
+            super().__init__()
+            self.linear = torch.nn.Linear(input_size, sum(output_sizes), bias=False)
+
+        def forward(self, hidden_states: torch.Tensor) -> tuple[torch.Tensor, None]:
+            return self.linear(hidden_states), None
+
+    monkeypatch.setattr(text_module, "get_tensor_model_parallel_world_size", lambda: 1)
+    monkeypatch.setattr(text_module, "VocabParallelEmbedding", _ParallelEmbedding)
+    monkeypatch.setattr(text_module, "QKVParallelLinear", _QKVLinear)
+    monkeypatch.setattr(text_module, "RowParallelLinear", _RowLinear)
+    monkeypatch.setattr(text_module, "MergedColumnParallelLinear", _MergedLinear)
+
+    config = _text_config()
+    encoder = BreezeTTS2TextEncoder(config).eval()
+    ids = torch.tensor([[3, 4]])
+    padded_ids = torch.tensor([[3, 4, 0, 0]])
+    mask = torch.tensor([[True, True, False, False]])
+
+    with torch.inference_mode():
+        short = encoder(ids)
+        padded = encoder(padded_ids, attention_mask=mask)
+
+    assert short.shape == (1, 2, 16)
+    assert padded.shape == (1, 4, 16)
+    assert torch.allclose(short[0, :2], padded[0, :2], atol=1e-5)
+
+
+def test_text_encoder_weight_loader_reports_fused_target_names():
+    encoder = object.__new__(BreezeTTS2TextEncoder)
+    parameter = torch.nn.Parameter(torch.zeros(2, 2))
+    parameter.weight_loader = lambda param, tensor, shard_id: param.data.copy_(tensor)
+    encoder.__dict__["named_parameters"] = lambda: [("layers.0.qkv_proj.weight", parameter)]
+
+    loaded = encoder.load_weights([("layers.0.q_proj.weight", torch.ones(2, 2))])
+
+    assert loaded == {"layers.0.qkv_proj.weight"}
+    assert torch.equal(parameter.detach(), torch.ones(2, 2))
diff --git a/tests/model_executor/models/breeze_tts_2/test_model_registration.py b/tests/model_executor/models/breeze_tts_2/test_model_registration.py
new file mode 100644
index 000000000..12a2b31f3
--- /dev/null
+++ b/tests/model_executor/models/breeze_tts_2/test_model_registration.py
@@ -0,0 +1,28 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import pytest
+from vllm.model_executor.models.registry import ModelRegistry
+
+from vllm_omni.model_executor.models.registry import OmniModelRegistry
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_breeze_architectures_resolve_to_omni_classes():
+    assert "BreezeForConditionalGeneration" in OmniModelRegistry.get_supported_archs()
+    assert "BreezeTTS2MimiCodec" in OmniModelRegistry.get_supported_archs()
+
+    talker = OmniModelRegistry._try_load_model_cls("BreezeForConditionalGeneration")
+    codec = OmniModelRegistry._try_load_model_cls("BreezeTTS2MimiCodec")
+    assert talker.__name__ == "BreezeTTS2TalkerForGeneration"
+    assert codec.__name__ == "BreezeTTS2MimiCodec"
+
+
+def test_plugin_registration_publishes_architectures_to_upstream_registry():
+    from vllm_omni.engine.arg_utils import register_omni_models_to_vllm
+
+    register_omni_models_to_vllm()
+
+    assert "BreezeForConditionalGeneration" in ModelRegistry.get_supported_archs()
+    assert "BreezeTTS2MimiCodec" in ModelRegistry.get_supported_archs()
diff --git a/tests/model_executor/models/breeze_tts_2/test_pipeline_registration.py b/tests/model_executor/models/breeze_tts_2/test_pipeline_registration.py
new file mode 100644
index 000000000..069296942
--- /dev/null
+++ b/tests/model_executor/models/breeze_tts_2/test_pipeline_registration.py
@@ -0,0 +1,36 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from pathlib import Path
+
+import pytest
+import yaml
+
+from vllm_omni.config.pipeline_registry import OMNI_PIPELINES
+from vllm_omni.model_executor.models.breeze_tts_2.pipeline import BREEZE_TTS_2_PIPELINE
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_breeze_pipeline_is_registered_with_talker_and_codec_stages():
+    assert OMNI_PIPELINES["breeze"] is BREEZE_TTS_2_PIPELINE
+    assert [stage.model_stage for stage in BREEZE_TTS_2_PIPELINE.stages] == [
+        "breeze_tts_2",
+        "breeze_tts_2_codec",
+    ]
+    assert BREEZE_TTS_2_PIPELINE.stages[1].requires_full_payload_input is True
+    assert BREEZE_TTS_2_PIPELINE.stages[0].async_chunk_process_next_stage_input_func.endswith(
+        "talker2codec_async_chunk"
+    )
+    assert BREEZE_TTS_2_PIPELINE.stages[1].retains_state_across_chunks is True
+
+
+def test_breeze_default_deploy_is_streaming():
+    deploy_path = Path(__file__).parents[4] / "vllm_omni" / "deploy" / "breeze_tts_2.yaml"
+    config = yaml.safe_load(deploy_path.read_text(encoding="utf-8"))
+    assert config["async_chunk"] is True
+    assert len(config["stages"]) == 2
+    # Stage 0 must prefill each prompt in one step: the talker builds a codec
+    # frame from the last hidden row of every scheduled request.
+    assert config["stages"][0]["enable_chunked_prefill"] is False
+    assert config["connectors"]["connector_of_shared_memory"]["extra"]["breeze_codec_chunk_frames"] == 8
diff --git a/tests/model_executor/models/breeze_tts_2/test_prompt_builder.py b/tests/model_executor/models/breeze_tts_2/test_prompt_builder.py
new file mode 100644
index 000000000..3bd26fce6
--- /dev/null
+++ b/tests/model_executor/models/breeze_tts_2/test_prompt_builder.py
@@ -0,0 +1,189 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from types import SimpleNamespace
+
+import pytest
+import torch
+
+from vllm_omni.model_executor.models.breeze_tts_2.prompt_builder import (
+    BreezeTTS2PromptBuilder,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _Tokenizer:
+    pad_token_id = 0
+    eos_token_id = 1
+    unk_token_id = -1
+    _special = {
+        "<|AUDIO|>": 262144,
+        "<|audio_eos|>": 262145,
+    }
+
+    def convert_tokens_to_ids(self, token):
+        return self._special.get(token, self.unk_token_id)
+
+    def __call__(self, texts, *, add_special_tokens=True, padding=False):
+        if isinstance(texts, str):
+            texts = [texts]
+        ids = []
+        for text in texts:
+            values = [1000 + ord(char) % 1000 for char in text]
+            if add_special_tokens:
+                values = [2, *values, 1]
+            ids.append(values)
+        return {"input_ids": ids}
+
+    def decode(self, ids, *, skip_special_tokens=False):
+        del skip_special_tokens
+        rendered = []
+        for token_id in ids:
+            if token_id == 262144:
+                rendered.append("<|AUDIO|>")
+            elif token_id == 262145:
+                rendered.append("<|audio_eos|>")
+            elif token_id in (2, 1):
+                continue
+            else:
+                rendered.append(chr(int(token_id) - 1000))
+        return "".join(rendered)
+
+
+class _RenderingTokenizer(_Tokenizer):
+    """Tiny tokenizer that preserves Breeze placeholders after decode."""
+
+    def __call__(self, texts, *, add_special_tokens=True, padding=False):
+        if isinstance(texts, str):
+            texts = [texts]
+        ids = []
+        for text in texts:
+            row = []
+            cursor = 0
+            while cursor < len(text):
+                if text.startswith("<|AUDIO|>", cursor):
+                    row.append(262144)
+                    cursor += len("<|AUDIO|>")
+                elif text.startswith("<|audio_eos|>", cursor):
+                    row.append(262145)
+                    cursor += len("<|audio_eos|>")
+                else:
+                    row.append(1000 + ord(text[cursor]) % 1000)
+                    cursor += 1
+            if add_special_tokens:
+                row = [2, *row, 1]
+            ids.append(row)
+        return {"input_ids": ids}
+
+
+class _ReferenceEncoder:
+    def __init__(self):
+        self.calls = []
+
+    def encode(self, audio, sample_rate=None):
+        self.calls.append((audio, sample_rate))
+        return torch.arange(32, dtype=torch.int16).reshape(2, 16)
+
+
+def _config():
+    return SimpleNamespace(
+        audio_token_id=262144,
+        audio_eos_token_id=262145,
+        pad_token_id=0,
+        backbone_config=SimpleNamespace(vocab_size=100000),
+        num_codebooks=16,
+        codec_config={"codebook_size": 2048},
+    )
+
+
+def test_builder_accepts_missing_codec_config():
+    config = _config()
+    config.codec_config = None
+
+    builder = BreezeTTS2PromptBuilder(_Tokenizer(), config)
+
+    assert builder.codebook_size == 2048
+
+
+def test_build_instruction_prompt():
+    builder = BreezeTTS2PromptBuilder(_Tokenizer(), _config())
+
+    prompt = builder.build({"text": "hello", "instruction": "happy", "speaker": "S0"})
+
+    assert prompt["prompt_token_ids"]
+    info = prompt["additional_information"]
+    assert "input_values" not in info
+    assert set(prompt["prompt_token_ids"]) == {0}
+    assert info["prompt_ids"].numel() == len(prompt["prompt_token_ids"])
+    assert info["text_ids_mask"].dtype == torch.bool
+    assert info["text_ids_len"].tolist() == [len(prompt["prompt_token_ids"])]
+    assert bool(info["text_ids_mask"].all())
+
+
+def test_build_reference_prompt_and_reuse_encoder():
+    encoder = _ReferenceEncoder()
+    builder = BreezeTTS2PromptBuilder(_RenderingTokenizer(), _config(), encoder)
+
+    prompt = builder.build(
+        {
+            "template": "ref_edit_tata",
+            "text": "target",
+            "instruction": "calm",
+            "ref_text": "reference",
+            "ref_audio": "ref.wav",
+            "ref_audio_sample_rate": 16000,
+        }
+    )
+
+    info = prompt["additional_information"]
+    codes = info["input_values"]
+    assert tuple(codes.shape) == (2, 16)
+    assert codes.dtype == torch.int16
+    assert set(prompt["prompt_token_ids"]) == {0}
+    assert info["prompt_ids"].tolist().count(262144) == 2
+    assert info["prompt_ids"].tolist().count(262145) == 1
+    assert int((~info["text_ids_mask"]).sum()) == 3
+    assert info["text_ids_len"].numel() == 2
+    assert encoder.calls == [("ref.wav", 16000)]
+
+
+def test_build_reference_prompt_preserves_special_tokens_after_rendering():
+    encoder = _ReferenceEncoder()
+    builder = BreezeTTS2PromptBuilder(_RenderingTokenizer(), _config(), encoder)
+
+    prompt = builder.build(
+        {
+            "template": "ref_clone_tata",
+            "text": "target",
+            "ref_text": "reference",
+            "ref_audio": "ref.wav",
+            "ref_audio_sample_rate": 16000,
+        }
+    )
+
+    info = prompt["additional_information"]
+    prompt_ids = info["prompt_ids"].tolist()
+    assert prompt_ids.count(262144) == 2
+    assert prompt_ids.count(262145) == 1
+    assert int((~info["text_ids_mask"]).sum()) == 3
+    assert len(info["text_ids_len"]) == 2
+    assert sum(info["text_ids_len"].tolist()) == int(info["text_ids_mask"].sum())
+
+
+def test_build_reference_prompt_accepts_preencoded_codes_mapping():
+    builder = BreezeTTS2PromptBuilder(_RenderingTokenizer(), _config())
+    codes = torch.arange(32, dtype=torch.int16).reshape(2, 16)
+
+    prompt = builder.build(
+        {
+            "template": "ref_clone_tata",
+            "text": "target",
+            "ref_text": "reference",
+            "codes": {"ref": codes},
+        }
+    )
+
+    info = prompt["additional_information"]
+    assert torch.equal(info["input_values"], codes)
+    assert info["ref_code_len"] == 2
diff --git a/tests/model_executor/models/breeze_tts_2/test_reference_voice.py b/tests/model_executor/models/breeze_tts_2/test_reference_voice.py
new file mode 100644
index 000000000..d29b863c4
--- /dev/null
+++ b/tests/model_executor/models/breeze_tts_2/test_reference_voice.py
@@ -0,0 +1,187 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import importlib.util
+from pathlib import Path
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+import soundfile as sf
+import torch
+
+from vllm_omni.model_executor.models.breeze_tts_2.prompt_builder import (
+    BreezeTTS2PromptBuilder,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+_EXAMPLE_PATH = (
+    Path(__file__).resolve().parents[4]
+    / "examples"
+    / "offline_inference"
+    / "text_to_speech"
+    / "breeze_tts_2"
+    / "end2end.py"
+)
+
+
+class _Tokenizer:
+    unk_token_id = -1
+
+    def convert_tokens_to_ids(self, token):
+        return {
+            "<|AUDIO|>": 262144,
+            "<|audio_eos|>": 262145,
+        }.get(token, self.unk_token_id)
+
+    def __call__(self, texts, *, add_special_tokens=True, padding=False):
+        if isinstance(texts, str):
+            texts = [texts]
+        ids = [[1000 + ord(char) % 1000 for char in text] for text in texts]
+        for row_index, text in enumerate(texts):
+            if "<|AUDIO|>" in text or "<|audio_eos|>" in text:
+                cursor = 0
+                row = []
+                while cursor < len(text):
+                    if text.startswith("<|AUDIO|>", cursor):
+                        row.append(262144)
+                        cursor += len("<|AUDIO|>")
+                    elif text.startswith("<|audio_eos|>", cursor):
+                        row.append(262145)
+                        cursor += len("<|audio_eos|>")
+                    else:
+                        row.append(1000 + ord(text[cursor]) % 1000)
+                        cursor += 1
+                ids[row_index] = row
+        if add_special_tokens:
+            ids = [[2, *row, 1] for row in ids]
+        return {"input_ids": ids}
+
+    def decode(self, ids, *, skip_special_tokens=False):
+        del skip_special_tokens
+        rendered = []
+        for token_id in ids:
+            if token_id == 262144:
+                rendered.append("<|AUDIO|>")
+            elif token_id == 262145:
+                rendered.append("<|audio_eos|>")
+            elif token_id in (1, 2):
+                continue
+            else:
+                rendered.append(chr(int(token_id) - 1000))
+        return "".join(rendered)
+
+
+class _ReferenceEncoder:
+    def __init__(self) -> None:
+        self.calls: list[tuple[object, int | None]] = []
+
+    def encode(self, audio, sample_rate=None):
+        self.calls.append((audio, sample_rate))
+        return torch.arange(32, dtype=torch.int16).reshape(2, 16)
+
+
+def _builder() -> tuple[BreezeTTS2PromptBuilder, _ReferenceEncoder]:
+    encoder = _ReferenceEncoder()
+    builder = BreezeTTS2PromptBuilder(
+        _Tokenizer(),
+        SimpleNamespace(
+            audio_token_id=262144,
+            audio_eos_token_id=262145,
+            pad_token_id=0,
+            backbone_config=SimpleNamespace(vocab_size=100000),
+            num_codebooks=16,
+            codec_config={"codebook_size": 2048},
+        ),
+        encoder,
+    )
+    return builder, encoder
+
+
+def test_reference_voice_uses_exact_transcript_and_audio_codes():
+    builder, encoder = _builder()
+
+    prompt = builder.build(
+        {
+            "template": "ref_clone_tata",
+            "speaker": "S1",
+            "ref_text": "exact reference transcript",
+            "ref_audio": "reference.wav",
+            "ref_audio_sample_rate": 24_000,
+            "text": "new target text",
+        }
+    )
+
+    info = prompt["additional_information"]
+    assert tuple(info["input_values"].shape) == (2, 16)
+    assert info["ref_code_len"] == 2
+    assert info["prompt_ids"].tolist().count(262144) == 2
+    assert info["text_ids_len"].numel() == 2
+    assert int(info["text_ids_mask"].sum()) == int(info["text_ids_len"].sum())
+    assert encoder.calls == [("reference.wav", 24_000)]
+
+
+def test_reference_plus_instruction_composes_voice_direction_prompt():
+    builder, _ = _builder()
+
+    prompt = builder.build(
+        {
+            "template": "ref_edit_tata",
+            "speaker": "S0",
+            "ref_text": "exact reference transcript",
+            "ref_audio": "reference.wav",
+            "instruction": "speak calmly and warmly",
+            "text": "new target text",
+        }
+    )
+
+    info = prompt["additional_information"]
+    assert info["template"] == "ref_edit_tata"
+    assert tuple(info["input_values"].shape) == (2, 16)
+    assert info["prompt_ids"].tolist().count(262144) == 2
+    assert info["text_ids_len"].numel() == 2
+
+
+def test_offline_example_reference_payload_feeds_prompt_builder(tmp_path):
+    """Smoke: the offline example's payload keys flow into the real builder.
+
+    Loads ``end2end.py`` (voxtral-style importlib), reads a real stereo wav
+    through its ``reference_payload`` helper, and feeds the result into the
+    real ``BreezeTTS2PromptBuilder`` — guarding the example↔builder field
+    contract that previously broke via an unread ``ref_audio_path`` key.
+    """
+    spec = importlib.util.spec_from_file_location("breeze_tts_2_end2end", _EXAMPLE_PATH)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+
+    sample_rate = 16_000
+    t = np.arange(sample_rate, dtype=np.float32) / sample_rate
+    tone = np.sin(2 * np.pi * 220.0 * t)
+    ref_path = tmp_path / "reference.wav"
+    sf.write(str(ref_path), np.stack([tone, tone], axis=1), sample_rate)
+
+    payload = module.reference_payload(str(ref_path))
+
+    # The helper emits exactly the keys the prompt builder consumes.
+    assert set(payload) == {"ref_audio", "ref_audio_sample_rate"}
+    assert payload["ref_audio_sample_rate"] == sample_rate
+    assert payload["ref_audio"].ndim == 1  # stereo down-mixed to one clip
+
+    builder, encoder = _builder()
+    prompt = builder.build(
+        {
+            "template": "ref_clone_tata",
+            "speaker": "S0",
+            "ref_text": "exact reference transcript",
+            "text": "new target text",
+            **payload,
+        }
+    )
+
+    info = prompt["additional_information"]
+    assert tuple(info["input_values"].shape) == (2, 16)
+    assert info["ref_code_len"] == 2
+    assert info["prompt_ids"].tolist().count(262144) == 2
+    # The builder received the example's waveform and sample rate verbatim.
+    assert encoder.calls == [(payload["ref_audio"], sample_rate)]
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_stage_input_processor.py b/tests/model_executor/models/breeze_tts_2/test_stage_input_processor.py
new file mode 100644
index 000000000..b9795f798
--- /dev/null
+++ b/tests/model_executor/models/breeze_tts_2/test_stage_input_processor.py
@@ -0,0 +1,133 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from types import SimpleNamespace
+
+import pytest
+import torch
+
+from vllm_omni.model_executor.stage_input_processors.breeze_tts_2 import (
+    talker2codec,
+    talker2codec_full_payload,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_talker2codec_flattens_codebook_major():
+    codes = torch.tensor([[1, 2], [3, 4], [5, 6]], dtype=torch.int16)
+    output = SimpleNamespace(multimodal_output={"codes": {"audio": codes}})
+
+    prompts = talker2codec([output])
+
+    assert prompts[0]["prompt_token_ids"] == [1, 3, 5, 2, 4, 6]
+    assert torch.equal(prompts[0]["multi_modal_data"]["codes"]["audio"], codes.transpose(0, 1))
+
+
+def test_talker2codec_keeps_empty_request_terminal():
+    output = SimpleNamespace(multimodal_output={"codes": {}})
+
+    prompts = talker2codec([output])
+
+    assert prompts == [{"prompt_token_ids": []}]
+
+
+def test_talker2codec_accepts_engine_core_output_wrapper():
+    codes = torch.tensor([[7, 8]], dtype=torch.int16)
+    output = SimpleNamespace(outputs=[SimpleNamespace(multimodal_output={"codes": {"audio": codes}})])
+
+    prompts = talker2codec([output])
+
+    assert prompts[0]["prompt_token_ids"] == [7, 8]
+
+
+def test_talker2codec_unwraps_per_request_audio_container():
+    codes = torch.tensor([[7, 8], [9, 10]], dtype=torch.int16)
+    output = SimpleNamespace(multimodal_output={"codes": {"audio": [codes]}})
+
+    prompts = talker2codec([output])
+
+    assert prompts[0]["prompt_token_ids"] == [7, 9, 8, 10]
+
+
+def test_talker2codec_accepts_flat_full_payload():
+    output = {"codes.audio": torch.tensor([1, 3, 2, 4], dtype=torch.int16)}
+
+    prompts = talker2codec([output])
+
+    assert prompts[0]["prompt_token_ids"] == [1, 3, 2, 4]
+    assert torch.equal(
+        prompts[0]["multi_modal_data"]["codes"]["audio"],
+        torch.tensor([1, 3, 2, 4], dtype=torch.int16),
+    )
+
+
+def test_talker2codec_full_payload_transposes_accumulated_frames():
+    payload = talker2codec_full_payload(
+        transfer_manager=None,
+        pooling_output={"codes.audio": torch.tensor([[1, 2], [3, 4], [5, 6]])},
+        request=None,
+    )
+
+    assert payload is not None
+    assert torch.equal(
+        payload.codes.audio,
+        torch.tensor([1, 3, 5, 2, 4, 6]),
+    )
+
+
+def test_talker2codec_full_payload_accepts_runner_pooling_output():
+    payload = talker2codec_full_payload(
+        pooling_output={"codes.audio": torch.tensor([[9, 8]], dtype=torch.int16)},
+        request=None,
+    )
+
+    assert payload is not None
+    assert torch.equal(payload.codes.audio, torch.tensor([9, 8]))
+
+
+def test_full_payload_zero_frame_finish_sends_explicit_terminal_marker():
+    payload = talker2codec_full_payload(
+        pooling_output={"codes.audio": torch.empty(0, 16, dtype=torch.long)},
+        request=None,
+        is_finished=True,
+    )
+
+    assert payload is not None
+    assert payload.codes.audio.numel() == 0
+    assert payload.meta.code_flat_numel == 0
+    assert bool(payload.meta.finished.item()) is True
+
+
+def test_full_payload_missing_codes_finish_sends_explicit_terminal_marker():
+    payload = talker2codec_full_payload(
+        pooling_output={},
+        request=None,
+        is_finished=True,
+    )
+
+    assert payload is not None
+    assert payload.codes.audio.numel() == 0
+    assert bool(payload.meta.finished.item()) is True
+
+
+def test_full_payload_empty_without_finish_stays_silent():
+    payload = talker2codec_full_payload(
+        pooling_output={"codes.audio": torch.empty(0, 16, dtype=torch.long)},
+        request=None,
+        is_finished=False,
+    )
+
+    assert payload is None
+
+
+def test_full_payload_carries_finished_flag_on_nonempty_frames():
+    payload = talker2codec_full_payload(
+        pooling_output={"codes.audio": torch.tensor([[1, 2], [3, 4]], dtype=torch.long)},
+        request=None,
+        is_finished=True,
+    )
+
+    assert payload is not None
+    assert payload.codes.audio.numel() == 4
+    assert bool(payload.meta.finished.item()) is True
diff --git a/tests/model_executor/models/breeze_tts_2/test_streaming.py b/tests/model_executor/models/breeze_tts_2/test_streaming.py
new file mode 100644
index 000000000..a630b90bc
--- /dev/null
+++ b/tests/model_executor/models/breeze_tts_2/test_streaming.py
@@ -0,0 +1,243 @@
+# 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
+
+import pytest
+import torch
+
+from vllm_omni.model_executor.models.breeze_tts_2.modeling_breeze_tts_2_codec import (
+    BreezeTTS2MimiCodec,
+)
+from vllm_omni.model_executor.stage_input_processors.breeze_tts_2 import (
+    talker2codec_async_chunk,
+)
+
+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[str, list[torch.Tensor]] = defaultdict(list)
+
+
+class _Request:
+    def __init__(self, request_id: str, finished: bool = False):
+        self.external_req_id = request_id
+        self._finished = finished
+
+    def is_finished(self):
+        return self._finished
+
+
+def test_async_processor_sends_only_unemitted_tail_and_flushes_finish():
+    manager = _TransferManager(chunk_frames=4)
+    request = _Request("req-1")
+
+    for code0 in range(3):
+        frame = torch.tensor([code0, code0 + 4, code0 + 8, code0 + 12], dtype=torch.long)
+        assert talker2codec_async_chunk(manager, {"codes": {"audio": frame}}, request) is None
+
+    payload = talker2codec_async_chunk(
+        manager,
+        {"codes": {"audio": torch.tensor([3, 7, 11, 15], dtype=torch.long)}},
+        request,
+    )
+    assert payload is not None
+    assert payload.codes.audio.tolist() == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
+    assert bool(payload.meta.finished.item()) is False
+    assert manager.code_prompt_token_ids["req-1"] == []
+
+    assert talker2codec_async_chunk(manager, {"codes": {"audio": torch.arange(4)}}, request) is None
+    payload = talker2codec_async_chunk(manager, None, _Request("req-1", finished=True))
+    assert payload.codes.audio.tolist() == [0, 1, 2, 3]
+    assert bool(payload.meta.finished.item()) is True
+    assert bool(payload.meta.stream_finished.item()) is True
+    assert payload.meta.codec_streaming is True
+
+
+class _Decoder:
+    def __init__(self):
+        self.calls = []
+
+    def batched_chunked_decode(self, codes, lengths, caches=None, **kwargs):
+        self.calls.append((codes.shape, tuple(lengths), tuple(caches), kwargs))
+        return [torch.ones(length * 1920, dtype=torch.float32) for length in lengths]
+
+
+def test_stateful_codec_batches_request_chunks_and_releases_finished_state():
+    decoder = _Decoder()
+    codec = object.__new__(BreezeTTS2MimiCodec)
+    codec._async_chunk = True
+    codec._num_codebooks = 4
+    codec._codebook_size = 8
+    codec._sample_rate = 24_000
+    codec._audio_tokenizer = SimpleNamespace(model=SimpleNamespace(decoder=decoder))
+    codec._decoder_state_cache = {}
+
+    input_ids = torch.tensor([0, 1, 2, 3, 4, 5, 6, 7], dtype=torch.long)
+    output = codec.forward(
+        input_ids,
+        runtime_additional_information=[
+            # ``stream_finished`` is the model-visible flag: the connector
+            # receiver strips ``meta.finished`` while merging runtime info.
+            {"meta": {"request_id": "live", "stream_finished": False}},
+            {"meta": {"request_id": "done", "stream_finished": True}},
+        ],
+        seq_token_counts=[4, 4],
+        request_ids=["scheduler-live", "scheduler-done"],
+    )
+
+    assert decoder.calls[0][0] == (2, 4, 1)
+    assert [len(item) for item in output.multimodal_outputs["model_outputs"]] == [1920, 1920]
+    assert set(codec._decoder_state_cache) == {"scheduler-live"}
+
+    codec.on_requests_finished(["scheduler-live"])
+    assert codec._decoder_state_cache == {}
+
+
+def test_stateful_codec_rejects_partial_frame_chunk():
+    decoder = _Decoder()
+    codec = object.__new__(BreezeTTS2MimiCodec)
+    codec._async_chunk = True
+    codec._num_codebooks = 4
+    codec._codebook_size = 8
+    codec._sample_rate = 24_000
+    codec._audio_tokenizer = SimpleNamespace(model=SimpleNamespace(decoder=decoder))
+    codec._decoder_state_cache = {}
+
+    # 5 codes cannot form a whole frame; a silent state reset would corrupt
+    # the rest of the stream, so the codec must fail loudly.
+    with pytest.raises(ValueError, match="not divisible"):
+        codec.forward(
+            torch.tensor([0, 1, 2, 3, 4], dtype=torch.long),
+            runtime_additional_information=[{"meta": {"request_id": "bad", "finished": False}}],
+            seq_token_counts=[5],
+            request_ids=["scheduler-bad"],
+        )
+    assert decoder.calls == []
+
+
+@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
+    codec._num_codebooks = 4
+    codec._codebook_size = 8
+    codec._sample_rate = 24_000
+    codec._audio_tokenizer = SimpleNamespace(model=SimpleNamespace(decoder=decoder))
+    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.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": {"finished": count == 0}}
+            for count in token_counts
+        ],
+        seq_token_counts=token_counts,
+        request_ids=request_ids,
+    )
+
+    # 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] == 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/breeze_tts_2/test_talker_state_machine.py b/tests/model_executor/models/breeze_tts_2/test_talker_state_machine.py
new file mode 100644
index 000000000..2f4a13df1
--- /dev/null
+++ b/tests/model_executor/models/breeze_tts_2/test_talker_state_machine.py
@@ -0,0 +1,243 @@
+# 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_omni.model_executor.models.breeze_tts_2.modeling_breeze_tts_2_talker import (
+    BreezeTTS2TalkerForGeneration,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _Head:
+    def __init__(self) -> None:
+        self.code0 = 2
+
+    def __call__(self, hidden: torch.Tensor) -> torch.Tensor:
+        logits = torch.zeros((hidden.shape[0], 9), dtype=hidden.dtype)
+        logits[:, self.code0] = 1.0
+        return logits
+
+
+class _Embedding:
+    def __init__(self) -> None:
+        self.weight = torch.randn(4 * 8, 16)
+
+    def __call__(self, ids: torch.Tensor) -> torch.Tensor:
+        return self.weight[ids.reshape(-1)].reshape(*ids.shape, -1)
+
+
+def _talker() -> BreezeTTS2TalkerForGeneration:
+    model = object.__new__(BreezeTTS2TalkerForGeneration)
+    model.num_codebooks = 4
+    model.codebook_vocab_size = 8
+    model.codebook_size = 8
+    model.hidden_size = 16
+    model.codebook_eos_token_id = 0
+    model.audio_token_id = 100
+    model.audio_eos_token_id = 101
+    # Bypass nn.Module registration; this fake is created with object.__new__.
+    model.__dict__["embed_audio_tokens"] = _Embedding()
+    model.audio_token_offsets = torch.arange(4) * 8
+    model.lm_head = _Head()
+    model.logits_processor = lambda head, hidden: head(hidden)
+    model._codec_disallowed_mask = None
+    model._batch_state = None
+    model._batch_state_spans = None
+    model._async_chunk = False
+    model._golden_dump_dir = None
+    return model
+
+
+def _depth_codes(_model: Any, _hidden: torch.Tensor, code0: int) -> torch.Tensor:
+    if code0 >= 8:
+        return torch.empty(0, dtype=torch.long)
+    return torch.tensor([code0, code0 + 1, code0 + 2, code0 + 3], dtype=torch.long).unsqueeze(0)
+
+
+def test_prefill_hidden_generates_and_stores_first_complete_frame():
+    model = _talker()
+    model._generate_depth_codes = lambda hidden, code0: _depth_codes(model, hidden, code0)
+    info = {"_omni_is_prefill": True, "breeze_generated_frames": 0, "breeze_max_new_frames": 3}
+    hidden = torch.arange(16, dtype=torch.float32).reshape(1, 16)
+
+    output = model.make_omni_output(
+        hidden,
+        model_intermediate_buffer=[info],
+        request_token_spans=[(0, 1)],
+    )
+
+    codes = output.multimodal_outputs["codes"]["audio"][0]
+    assert torch.equal(codes, torch.tensor([[2, 3, 4, 5]]))
+    assert torch.equal(info["breeze_current_frame"], codes[0])
+    assert info["breeze_generated_frames"] == 1
+    assert info["breeze_force_eos"] is False
+
+
+def test_first_decode_consumes_full_frame_instead_of_scalar_eos_fallback():
+    model = _talker()
+    model._generate_depth_codes = lambda hidden, code0: _depth_codes(model, hidden, code0)
+    info = {"_omni_is_prefill": True, "breeze_generated_frames": 0, "breeze_max_new_frames": 3}
+    hidden = torch.arange(16, dtype=torch.float32).reshape(1, 16)
+    output = model.make_omni_output(
+        hidden,
+        model_intermediate_buffer=[info],
+        request_token_spans=[(0, 1)],
+    )
+    frame = output.multimodal_outputs["codes"]["audio"][0][0]
+    decode_info = dict(info)
+    decode_info.pop("_omni_is_prefill", None)
+
+    safe_id, decode_embeds, update = model.preprocess(
+        torch.tensor([2], dtype=torch.long),
+        None,
+        **decode_info,
+    )
+
+    assert safe_id.item() == 2
+    assert update == {}
+    expected = model.embed_input_ids(frame.reshape(1, 1, -1)).reshape(1, -1)
+    assert torch.equal(decode_embeds, expected)
+
+
+def test_real_decode_rejects_missing_current_frame():
+    model = _talker()
+    info = {
+        "breeze_generated_frames": 1,
+        "breeze_audio_codes": torch.tensor([[2, 3, 4, 5]]),
+    }
+
+    try:
+        model.preprocess(torch.tensor([2], dtype=torch.long), None, **info)
+    except RuntimeError as exc:
+        assert "breeze_current_frame" in str(exc)
+        assert "codebooks 1..15" in str(exc)
+    else:
+        raise AssertionError("missing breeze_current_frame must fail explicitly")
+
+
+def test_embed_input_ids_rejects_scalar_codec_id():
+    model = _talker()
+
+    try:
+        model.embed_input_ids(torch.tensor([[2]]))
+    except ValueError as exc:
+        assert "complete codec frames" in str(exc)
+    else:
+        raise AssertionError("scalar codec ids must not be embedded")
+
+
+def test_decode_accumulates_frames_then_natural_eos_stops_without_fake_frame():
+    model = _talker()
+    model._generate_depth_codes = lambda hidden, code0: _depth_codes(model, hidden, code0)
+    info = {"breeze_generated_frames": 1, "breeze_max_new_frames": 3}
+    info["breeze_audio_codes"] = torch.tensor([[2, 3, 4, 5]])
+    model.lm_head.code0 = 3
+    hidden = torch.arange(16, dtype=torch.float32).reshape(1, 16)
+
+    output = model.make_omni_output(
+        hidden,
+        model_intermediate_buffer=[info],
+        request_token_spans=[(0, 1)],
+    )
+    assert output.multimodal_outputs["codes"]["audio"][0].shape == (2, 4)
+
+    # Main-head class 8 is the Breeze backbone EOS (one past vocab_size=8).
+    model.lm_head.code0 = 8
+    output = model.make_omni_output(
+        hidden,
+        model_intermediate_buffer=[info],
+        request_token_spans=[(0, 1)],
+    )
+    assert output.multimodal_outputs["codes"]["audio"][0].shape == (2, 4)
+    assert info["breeze_force_eos"] is True
+    assert info["breeze_force_eos"] is True
+
+    logits = model.compute_logits(hidden)
+    assert torch.equal(logits[0, :8], torch.full((8,), float("-inf")))
+    assert logits[0, 8].item() == 0.0
+
+
+def test_frame_budget_forces_eos_on_followup_step():
+    model = _talker()
+    model._generate_depth_codes = lambda hidden, code0: _depth_codes(model, hidden, code0)
+    info = {"breeze_generated_frames": 2, "breeze_max_new_frames": 2}
+    info["breeze_audio_codes"] = torch.tensor([[1, 2, 3, 4], [5, 6, 7, 0]])
+    hidden = torch.arange(16, dtype=torch.float32).reshape(1, 16)
+
+    output = model.make_omni_output(
+        hidden,
+        model_intermediate_buffer=[info],
+        request_token_spans=[(0, 1)],
+    )
+
+    assert output.multimodal_outputs["codes"]["audio"][0].shape == (2, 4)
+    assert info["breeze_generated_frames"] == 2
+    assert info["breeze_force_eos"] is True
+
+
+def test_async_chunk_mode_skips_full_accumulation():
+    model = _talker()
+    model._async_chunk = True
+    model._generate_depth_codes = lambda hidden, code0: _depth_codes(model, hidden, code0)
+    info = {"breeze_generated_frames": 0, "breeze_max_new_frames": 8}
+    hidden = torch.arange(16, dtype=torch.float32).reshape(1, 16)
+
+    for _ in range(3):
+        output = model.make_omni_output(
+            hidden,
+            model_intermediate_buffer=[info],
+            request_token_spans=[(0, 1)],
+        )
+        assert output.multimodal_outputs["codes"]["audio"][0].shape == (1, 4)
+
+    # Streaming keeps only the per-frame tail; the cumulative buffer (and its
+    # per-step torch.cat) must not exist without the opt-in golden dump.
+    assert "breeze_audio_codes" not in info
+    assert info["breeze_generated_frames"] == 3
+    assert torch.equal(info["breeze_current_frame"], torch.tensor([2, 3, 4, 5]))
+
+
+def test_async_chunk_mode_keeps_accumulation_for_golden_dump(tmp_path):
+    model = _talker()
+    model._async_chunk = True
+    model._golden_dump_dir = str(tmp_path)
+    model._generate_depth_codes = lambda hidden, code0: _depth_codes(model, hidden, code0)
+    info = {"breeze_generated_frames": 0, "breeze_max_new_frames": 8}
+    hidden = torch.arange(16, dtype=torch.float32).reshape(1, 16)
+
+    for _ in range(3):
+        output = model.make_omni_output(
+            hidden,
+            model_intermediate_buffer=[info],
+            request_token_spans=[(0, 1)],
+        )
+        assert output.multimodal_outputs["codes"]["audio"][0].shape == (1, 4)
+
+    assert info["breeze_audio_codes"].shape == (3, 4)
+    assert torch.equal(info["breeze_audio_codes"][-1], torch.tensor([2, 3, 4, 5]))
+
+
+def test_opt_in_golden_dump_writes_terminal_frames(tmp_path):
+    model = _talker()
+    model._golden_dump_dir = str(tmp_path)
+    info = {
+        "template": "tts_plain",
+        "prompt_ids": torch.tensor([1, 2, 3]),
+        "breeze_audio_codes": torch.tensor([[1, 2, 3, 4]]),
+        "breeze_generated_frames": 1,
+        "breeze_force_eos": True,
+    }
+
+    model._dump_golden_frames(info)
+
+    dump_path = next(tmp_path.glob("breeze_*.pt"))
+    payload = torch.load(dump_path, weights_only=False)
+    assert payload["template"] == "tts_plain"
+    assert torch.equal(payload["prompt_ids"], torch.tensor([1, 2, 3]))
+    assert torch.equal(payload["codes"], torch.tensor([[1, 2, 3, 4]]))
+    assert payload["finished"] is True
diff --git a/tests/model_executor/models/breeze_tts_2/test_weight_loading.py b/tests/model_executor/models/breeze_tts_2/test_weight_loading.py
new file mode 100644
index 000000000..f4c0da429
--- /dev/null
+++ b/tests/model_executor/models/breeze_tts_2/test_weight_loading.py
@@ -0,0 +1,73 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from types import SimpleNamespace
+
+import pytest
+import torch
+from torch import nn
+
+from vllm_omni.model_executor.models.breeze_tts_2.modeling_breeze_tts_2_talker import (
+    BreezeTTS2TalkerForGeneration,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _PaddedHead(nn.Module):
+    def __init__(self) -> None:
+        super().__init__()
+        self.weight = nn.Parameter(torch.zeros(2_112, 32), requires_grad=False)
+
+
+class _DepthDecoder:
+    def __init__(self) -> None:
+        self.loaded: list[tuple[str, torch.Tensor]] = []
+
+    def load_weights(self, weights):
+        self.loaded.extend(weights)
+        return {"model.embed_tokens.weight"}
+
+
+class _TalkerHost(nn.Module):
+    def __init__(self) -> None:
+        super().__init__()
+        self.config = SimpleNamespace(tie_codebooks_embeddings=True)
+        self.codebook_vocab_size = 2_051
+        self.hidden_size = 32
+        self.lm_head = _PaddedHead()
+        self.embed_audio_tokens = nn.Embedding(4 * 2_051, 32)
+        self.depth_decoder = _DepthDecoder()
+
+
+def _padded_loader(parameter: nn.Parameter, weight: torch.Tensor) -> None:
+    assert parameter.shape != weight.shape
+    parameter[: weight.shape[0]].copy_(weight)
+
+
+def test_lm_head_loader_accepts_vocab_padding():
+    host = _TalkerHost()
+    host.lm_head.weight.weight_loader = _padded_loader
+    checkpoint_weight = torch.full((2_052, 32), 1.5)
+
+    loaded = BreezeTTS2TalkerForGeneration.load_weights(
+        host,
+        iter([("lm_head.weight", checkpoint_weight)]),
+    )
+
+    assert "lm_head.weight" in loaded
+    assert torch.equal(host.lm_head.weight[:2_052], checkpoint_weight)
+    assert torch.count_nonzero(host.lm_head.weight[2_052:]).item() == 0
+
+
+def test_tied_audio_embedding_reports_both_strict_loading_aliases():
+    host = _TalkerHost()
+    checkpoint_weight = torch.full((4 * 2_051, 32), 2.0)
+
+    loaded = BreezeTTS2TalkerForGeneration.load_weights(
+        host,
+        iter([("depth_decoder.model.embed_tokens.weight", checkpoint_weight)]),
+    )
+
+    assert "embed_audio_tokens.weight" in loaded
+    assert "depth_decoder.model.embed_tokens.weight" in loaded
diff --git a/tests/model_executor/models/cosyvoice3/test_cosyvoice3_components.py b/tests/model_executor/models/cosyvoice3/test_cosyvoice3_components.py
index 4f01022f8..46255110c 100644
--- a/tests/model_executor/models/cosyvoice3/test_cosyvoice3_components.py
+++ b/tests/model_executor/models/cosyvoice3/test_cosyvoice3_components.py
@@ -2,6 +2,7 @@
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Unit tests for CosyVoice3 components."""
 
+import types
 from contextlib import contextmanager
 from types import SimpleNamespace
 
@@ -13,6 +14,7 @@ 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]
@@ -29,6 +31,23 @@ def _force_torch_sdpa():
         yield
 
 
+def test_batch_flow_runtime_flags_are_opt_in(monkeypatch):
+    from vllm_omni.model_executor.models.cosyvoice3.runtime import (
+        cosyvoice3_batch_flow_debug,
+        cosyvoice3_batch_flow_enabled,
+    )
+
+    monkeypatch.delenv("COSYVOICE3_BATCH_FLOW", raising=False)
+    monkeypatch.delenv("COSYVOICE3_BATCH_FLOW_DEBUG", raising=False)
+    assert not cosyvoice3_batch_flow_enabled()
+    assert not cosyvoice3_batch_flow_debug()
+
+    monkeypatch.setenv("COSYVOICE3_BATCH_FLOW", "1")
+    monkeypatch.setenv("COSYVOICE3_BATCH_FLOW_DEBUG", "1")
+    assert cosyvoice3_batch_flow_enabled()
+    assert cosyvoice3_batch_flow_debug()
+
+
 @pytest.fixture
 def causal_hift():
     return CausalHiFTGenerator(
@@ -57,6 +76,108 @@ 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")
+
+    tensor = NpuTensor()
+    stft_calls = []
+    istft_calls = []
+
+    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"
+    assert stft_calls == [tensor]
+    assert istft_calls == [(tensor, tensor)]
+
+
+def test_causal_hift_stft_cpu_fallback_uses_float32(causal_hift, monkeypatch):
+    original_stft = torch.stft
+
+    def assert_cpu_float32_stft(input, *args, window, **kwargs):
+        assert input.device.type == "cpu"
+        assert input.dtype == torch.float32
+        assert window.device.type == "cpu"
+        assert window.dtype == torch.float32
+        return original_stft(input, *args, window=window, **kwargs)
+
+    monkeypatch.setattr(torch, "stft", assert_cpu_float32_stft)
+
+    waveform = torch.randn(1, 64, dtype=torch.float64)
+    real, imag = causal_hift._stft_on_cpu(waveform)
+
+    assert real.device == waveform.device
+    assert imag.device == waveform.device
+    assert real.dtype == waveform.dtype
+    assert imag.dtype == waveform.dtype
+
+
+def test_causal_hift_istft_cpu_fallback_uses_float32(causal_hift, monkeypatch):
+    original_istft = torch.istft
+
+    def assert_cpu_complex64_istft(input, *args, window, **kwargs):
+        assert input.device.type == "cpu"
+        assert input.dtype == torch.complex64
+        assert window.device.type == "cpu"
+        assert window.dtype == torch.float32
+        return original_istft(input, *args, window=window, **kwargs)
+
+    monkeypatch.setattr(torch, "istft", assert_cpu_complex64_istft)
+
+    waveform = torch.randn(1, 64, dtype=torch.float32)
+    spec = torch.stft(waveform, 16, 4, 16, window=causal_hift.stft_window, return_complex=True)
+    magnitude = torch.abs(spec).to(torch.float64)
+    phase = torch.angle(spec).to(torch.float64)
+    reconstructed = causal_hift._istft_on_cpu(magnitude, phase)
+
+    assert reconstructed.device == magnitude.device
+    assert reconstructed.dtype == magnitude.dtype
+    torch.testing.assert_close(reconstructed, waveform.to(torch.float64), rtol=1e-5, atol=1e-5)
+
+
 class TestPreLookaheadLayer:
     """Tests for PreLookaheadLayer."""
 
@@ -139,6 +260,39 @@ class TestDiTAttention:
         assert attention.to_k.out_features == 512
         assert attention.to_v.out_features == 512
 
+    @pytest.mark.core_model
+    @pytest.mark.cpu
+    def test_forward_passes_2d_mask_without_casting_qkv(self):
+        """The float32 fallback receives the per-row validity mask."""
+        from vllm_omni.diffusion.models.cosyvoice3_audio.cosyvoice3_dit import DiTAttention
+
+        class CaptureAttention(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.last_metadata = None
+                self.last_dtype = None
+
+            def forward(self, q, k, v, attn_metadata=None):
+                self.last_metadata = attn_metadata
+                self.last_dtype = q.dtype
+                return torch.zeros_like(q)
+
+        attention = DiTAttention(dim=16, heads=2, dim_head=8, dropout=0.0)
+        capture = CaptureAttention()
+        attention.attn = capture
+
+        x = torch.randn(2, 5, 16)
+        mask = torch.tensor([[True, True, True, False, False], [True, True, True, True, False]])
+
+        out = attention(x, mask=mask)
+
+        assert out.shape == x.shape
+        assert capture.last_metadata is not None
+        assert torch.equal(capture.last_metadata.attn_mask, mask)
+        assert capture.last_dtype == x.dtype
+        assert out.dtype == x.dtype
+        assert torch.allclose(out[~mask], torch.zeros_like(out[~mask]))
+
 
 class TestDiTBlock:
     """Tests for DiTBlock."""
@@ -422,6 +576,52 @@ class TestCFM:
         assert reused_context is context
         assert reused_stream is stream
 
+    @pytest.mark.core_model
+    @pytest.mark.cpu
+    def test_causal_conditional_cfm_batches_cfg_estimator(self):
+        """Batched flow calls should invoke the CFG estimator with 2B rows."""
+        from omegaconf import DictConfig
+
+        from vllm_omni.model_executor.models.cosyvoice3.code2wav_core.cfm import CausalConditionalCFM
+
+        class RecordingEstimator(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.shapes: list[tuple[int, ...]] = []
+
+            def forward(self, x, mask, mu, t, spks=None, cond=None):
+                self.shapes.append(tuple(x.shape))
+                return torch.zeros_like(x)
+
+        estimator = RecordingEstimator()
+        cfm_params = DictConfig(
+            {
+                "sigma_min": 1e-6,
+                "solver": "euler",
+                "t_scheduler": "cosine",
+                "training_cfg_rate": 0.2,
+                "inference_cfg_rate": 0.7,
+            }
+        )
+        cfm = CausalConditionalCFM(
+            in_channels=80,
+            cfm_params=cfm_params,
+            n_spks=1,
+            spk_emb_dim=80,
+            estimator=estimator,
+        )
+
+        batch, mel_dim, seq_len = 3, 80, 16
+        mu = torch.randn(batch, mel_dim, seq_len)
+        mask = torch.ones(batch, 1, seq_len)
+        spks = torch.randn(batch, 80)
+        cond = torch.randn(batch, mel_dim, seq_len)
+
+        out, _ = cfm(mu, mask, n_timesteps=2, spks=spks, cond=cond)
+
+        assert out.shape == mu.shape
+        assert estimator.shapes == [(2 * batch, mel_dim, seq_len)] * 2
+
 
 class TestSDPAFallback:
     """Test SDPA fallback for float32 inputs."""
@@ -461,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)
@@ -484,3 +688,46 @@ def test_code2wav_forward_finalizes_hift_tail():
     assert out.shape == (1, 1, 8)
     assert model.hift.finalize_calls == [True]
     assert forward_mel_calls[0]["token_offset_tokens"] == 0
+
+
+def test_code2wav_streaming_batch_pads_codec_tokens_and_preserves_lengths():
+    from vllm_omni.model_executor.models.cosyvoice3.cosyvoice3_code2wav import CosyVoice3Code2Wav
+
+    model = object.__new__(CosyVoice3Code2Wav)
+    model.flow_model = SimpleNamespace(pre_lookahead_len=1, token_mel_ratio=2)
+    forward_mel_calls = []
+
+    def fake_forward_mel(self, **kwargs):
+        forward_mel_calls.append(kwargs)
+        return torch.arange(2 * 80 * 8, dtype=torch.float32).reshape(2, 80, 8)
+
+    def fake_stream_hift(self, feat, *, cache_state=None, finalize=False):
+        return feat, None
+
+    model._forward_mel = types.MethodType(fake_forward_mel, model)
+    model._stream_hift_from_feat = types.MethodType(fake_stream_hift, model)
+    items = [
+        {
+            "token": torch.ones(1, 3, dtype=torch.int32),
+            "prompt_token": torch.ones(1, 4, dtype=torch.int32),
+            "prompt_feat": torch.ones(1, 8, 80),
+            "embedding": torch.ones(1, 192),
+            "finalize": False,
+        },
+        {
+            "token": torch.ones(1, 5, dtype=torch.int32),
+            "prompt_token": torch.ones(1, 4, dtype=torch.int32),
+            "prompt_feat": torch.ones(1, 8, 80),
+            "embedding": torch.ones(1, 192),
+            "finalize": False,
+        },
+    ]
+
+    results = model.forward_streaming_batch(items)
+
+    assert len(forward_mel_calls) == 1
+    call = forward_mel_calls[0]
+    assert call["token"].shape == (2, 5)
+    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
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/cosyvoice3/test_cosyvoice3_model_helpers.py b/tests/model_executor/models/cosyvoice3/test_cosyvoice3_model_helpers.py
index e16927096..1d583de6c 100644
--- a/tests/model_executor/models/cosyvoice3/test_cosyvoice3_model_helpers.py
+++ b/tests/model_executor/models/cosyvoice3/test_cosyvoice3_model_helpers.py
@@ -42,6 +42,7 @@ class _DummyCode2Wav:
         self.outputs = list(outputs or [])
         self.forward_calls: list[dict[str, object]] = []
         self.forward_streaming_calls: list[dict[str, object]] = []
+        self.forward_streaming_batch_calls: list[list[dict[str, object]]] = []
 
     def forward(self, **kwargs):
         self.forward_calls.append(kwargs)
@@ -65,6 +66,22 @@ class _DummyCode2Wav:
             }
         return audio, new_state
 
+    def forward_streaming_batch(self, items, *, n_timesteps: int = 10):
+        self.forward_streaming_batch_calls.append(items)
+        return [
+            self.forward_streaming(
+                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)),
+            )
+            for item in items
+        ]
+
 
 def _make_code2wav_model(
     *,
@@ -373,6 +390,53 @@ def test_forward_clears_streaming_cache_on_terminal_chunk():
     assert "rid-stream" not in model._stream_vocoder_cache_by_req
 
 
+def test_forward_batches_streaming_flow_items(monkeypatch):
+    monkeypatch.setenv("COSYVOICE3_BATCH_FLOW", "1")
+    model = _make_code2wav_model()
+    runtime_info = [
+        {
+            "embed": {
+                "speech_token": torch.tensor([[1, 2, 3]], dtype=torch.long),
+                "speech_feat": torch.tensor([[[0.1, 0.2], [0.3, 0.4]]], dtype=torch.float32),
+                "embedding": torch.tensor([[0.5, 0.6]], dtype=torch.float32),
+            },
+            "meta": {
+                "req_id": ["rid-a"],
+                "stream_finished": torch.tensor(False),
+                "left_context_size": 0,
+            },
+        },
+        {
+            "embed": {
+                "speech_token": torch.tensor([[1, 2, 3]], dtype=torch.long),
+                "speech_feat": torch.tensor([[[0.1, 0.2], [0.3, 0.4]]], dtype=torch.float32),
+                "embedding": torch.tensor([[0.7, 0.8]], dtype=torch.float32),
+            },
+            "meta": {
+                "req_id": ["rid-b"],
+                "stream_finished": torch.tensor(False),
+                "left_context_size": 1,
+            },
+        },
+    ]
+
+    out = model.forward(
+        input_ids=torch.tensor([0, 1, 2, 0, 1, 2], dtype=torch.long),
+        positions=torch.arange(6, dtype=torch.long),
+        model_intermediate_buffer=runtime_info,
+        seq_token_counts=[3, 3],
+    )
+
+    assert len(out.multimodal_outputs["audio"]) == 2
+    assert len(model.code2wav.forward_streaming_batch_calls) == 1
+    batch_items = model.code2wav.forward_streaming_batch_calls[0]
+    assert [item["index"] for item in batch_items] == [0, 1]
+    assert torch.equal(batch_items[0]["token"], torch.tensor([[0, 1, 2]]))
+    assert batch_items[1]["token_offset_tokens"] == 1
+    assert "rid-a" in model._stream_vocoder_cache_by_req
+    assert "rid-b" in model._stream_vocoder_cache_by_req
+
+
 def test_sample_uses_ras_rejection_for_recent_repetition():
     model = _make_talker_model()
     metadata = _make_sampling_metadata(output_token_ids=[[1] * 10])
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/fish_speech/test_prompt_utils.py b/tests/model_executor/models/fish_speech/test_prompt_utils.py
new file mode 100644
index 000000000..98700da26
--- /dev/null
+++ b/tests/model_executor/models/fish_speech/test_prompt_utils.py
@@ -0,0 +1,23 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import pytest
+
+from vllm_omni.model_executor.models.fish_speech.prompt_utils import normalize_fish_speech_text
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_normalize_fish_speech_text_allows_phoneme_control_tokens():
+    text = "Deploy with <|phoneme_start|>K UW2 B ER0 N EH1 T IY0 Z<|phoneme_end|>."
+
+    assert normalize_fish_speech_text(text) == text
+
+
+def test_normalize_fish_speech_text_rejects_unknown_control_token():
+    with pytest.raises(ValueError, match=r"unsupported control token\(s\): <\|foo\|>"):
+        normalize_fish_speech_text("<|foo|>hello")
+
+
+def test_normalize_fish_speech_text_normalizes_legacy_speaker_tag():
+    assert normalize_fish_speech_text("<speaker:0>hello") == "<|speaker:0|>hello"
diff --git a/tests/model_executor/models/higgs_audio_v3/test_ref_audio_diagnostics.py b/tests/model_executor/models/higgs_audio_v3/test_ref_audio_diagnostics.py
new file mode 100644
index 000000000..c7417584d
--- /dev/null
+++ b/tests/model_executor/models/higgs_audio_v3/test_ref_audio_diagnostics.py
@@ -0,0 +1,168 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Reference-substitution diagnostics without loading a model checkpoint."""
+
+import pytest
+import torch
+from pytest_mock import MockerFixture
+
+from vllm_omni.model_executor.models.higgs_audio_v3 import higgs_audio_v3_talker as mod
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+@pytest.fixture
+def talker() -> mod.HiggsAudioV3TalkerForConditionalGeneration:
+    # Exercise the real method and fused embedding without constructing Qwen3.
+    instance = mod.HiggsAudioV3TalkerForConditionalGeneration.__new__(mod.HiggsAudioV3TalkerForConditionalGeneration)
+    torch.nn.Module.__init__(instance)
+    instance._last_step_query_start_loc = torch.tensor([0, 4])
+    instance.multimodal_embedding = mod.HiggsFusedMultiTextEmbedding(num_codebooks=1, vocab_size=32, hidden_size=1)
+    with torch.no_grad():
+        instance.multimodal_embedding.weight.copy_(torch.arange(32).reshape(32, 1))
+    return instance
+
+
+@pytest.mark.parametrize(
+    "ref_positions,mask,expected_positions,expected_codes",
+    [
+        ([], [True, True], 0, 2),
+        ([1], [True, True], 1, 2),
+        ([1, 2, 3], [True, False], 3, 1),
+    ],
+    ids=["empty-positions", "too-few-positions", "count-mismatch-after-masking"],
+)
+def test_explicit_mismatch_logs_counts_without_substitution(
+    talker: mod.HiggsAudioV3TalkerForConditionalGeneration,
+    mocker: MockerFixture,
+    ref_positions: list[int],
+    mask: list[bool],
+    expected_positions: int,
+    expected_codes: int,
+) -> None:
+    debug = mocker.spy(mod.logger, "debug")
+    hidden = torch.zeros(4, 1)
+    info = {
+        "audio_input_ids": torch.tensor([[5], [7]]),
+        "audio_input_ids_mask": torch.tensor(mask),
+        "audio_placeholder_positions": torch.tensor(ref_positions, dtype=torch.long),
+    }
+    result = talker._apply_ref_audio_substitution(hidden, torch.ones(4, dtype=torch.long), torch.arange(4), [info])
+
+    assert result is hidden
+    assert torch.count_nonzero(hidden) == 0
+    debug.assert_called_once()
+    message, request_index, position_count, code_count = debug.call_args.args
+    assert "reference audio" in message
+    assert "placeholder" in message
+    assert (request_index, position_count, code_count) == (0, expected_positions, expected_codes)
+
+
+@pytest.mark.parametrize("input_ids", [[1, -100, 2, 3], [1, 2, 3, 4]], ids=["one-slot", "no-slots"])
+def test_legacy_short_span_logs_counts_without_substitution(
+    talker: mod.HiggsAudioV3TalkerForConditionalGeneration,
+    mocker: MockerFixture,
+    input_ids: list[int],
+) -> None:
+    debug = mocker.spy(mod.logger, "debug")
+    hidden = torch.zeros(4, 1)
+    result = talker._apply_ref_audio_substitution(
+        hidden, torch.tensor(input_ids), torch.arange(4), [{"audio_input_ids": torch.tensor([[5], [7]])}]
+    )
+
+    assert result is hidden
+    debug.assert_called_once()
+    message, request_index, position_count, code_count = debug.call_args.args
+    assert "legacy" in message
+    assert (request_index, position_count, code_count) == (0, input_ids.count(-100), 2)
+
+
+@pytest.mark.parametrize(
+    "positions,expected",
+    [([0, 1, 2, 3], [0.0, 5.0, 7.0, 0.0]), ([2], [7.0]), ([0, 3], [0.0, 0.0])],
+    ids=["full-prefill", "chunk-intersects-reference", "chunk-outside-reference"],
+)
+def test_valid_explicit_positions_do_not_log_mismatch(
+    talker: mod.HiggsAudioV3TalkerForConditionalGeneration,
+    mocker: MockerFixture,
+    positions: list[int],
+    expected: list[float],
+) -> None:
+    debug = mocker.spy(mod.logger, "debug")
+    talker._last_step_query_start_loc = torch.tensor([0, len(positions)])
+    hidden = torch.zeros(len(positions), 1)
+    result = talker._apply_ref_audio_substitution(
+        hidden,
+        torch.ones(len(positions), dtype=torch.long),
+        torch.tensor(positions),
+        [{"audio_input_ids": torch.tensor([[5], [7]]), "audio_placeholder_positions": torch.tensor([1, 2])}],
+    )
+
+    assert result[:, 0].tolist() == expected
+    debug.assert_not_called()
+    assert torch.count_nonzero(hidden) == 0
+
+
+def test_matching_mask_filters_codes_and_positions_without_diagnostic(
+    talker: mod.HiggsAudioV3TalkerForConditionalGeneration, mocker: MockerFixture
+) -> None:
+    debug = mocker.spy(mod.logger, "debug")
+    result = talker._apply_ref_audio_substitution(
+        torch.zeros(4, 1),
+        torch.ones(4, dtype=torch.long),
+        torch.arange(4),
+        [
+            {
+                "audio_input_ids": torch.tensor([[5], [7]]),
+                "audio_input_ids_mask": torch.tensor([True, False]),
+                "audio_placeholder_positions": torch.tensor([1, 2]),
+            }
+        ],
+    )
+    assert result[:, 0].tolist() == [0.0, 5.0, 0.0, 0.0]
+    debug.assert_not_called()
+
+
+@pytest.mark.parametrize("masked", [False, True], ids=["empty-codes", "all-masked"])
+def test_empty_reference_does_not_log_mismatch(
+    talker: mod.HiggsAudioV3TalkerForConditionalGeneration, mocker: MockerFixture, masked: bool
+) -> None:
+    debug = mocker.spy(mod.logger, "debug")
+    info = {
+        "audio_input_ids": torch.tensor([[5], [7]]) if masked else torch.empty((0, 1), dtype=torch.long),
+        "audio_input_ids_mask": torch.tensor([False, False] if masked else [], dtype=torch.bool),
+        "audio_placeholder_positions": torch.tensor([1, 2] if masked else [], dtype=torch.long),
+    }
+    hidden = torch.zeros(4, 1)
+    result = talker._apply_ref_audio_substitution(hidden, torch.ones(4, dtype=torch.long), torch.arange(4), [info])
+    assert result is hidden
+    debug.assert_not_called()
+
+
+def test_legacy_decode_does_not_log_mismatch(
+    talker: mod.HiggsAudioV3TalkerForConditionalGeneration, mocker: MockerFixture
+) -> None:
+    debug = mocker.spy(mod.logger, "debug")
+    talker._last_step_query_start_loc = torch.tensor([0, 1])
+    hidden = torch.zeros(1, 1)
+    result = talker._apply_ref_audio_substitution(
+        hidden, torch.tensor([-100]), torch.tensor([2]), [{"audio_input_ids": torch.tensor([[5], [7]])}]
+    )
+    assert result is hidden
+    debug.assert_not_called()
+
+
+@pytest.mark.parametrize("input_ids", [[1, -100, -100, 2], [-100, -100, -100, 2]])
+def test_legacy_sufficient_slots_remain_supported(
+    talker: mod.HiggsAudioV3TalkerForConditionalGeneration, mocker: MockerFixture, input_ids: list[int]
+) -> None:
+    debug = mocker.spy(mod.logger, "debug")
+    hidden = torch.zeros(4, 1)
+    result = talker._apply_ref_audio_substitution(
+        hidden, torch.tensor(input_ids), torch.arange(4), [{"audio_input_ids": torch.tensor([[5], [7]])}]
+    )
+    targets = [i for i, token in enumerate(input_ids) if token == -100][:2]
+    assert result[targets, 0].tolist() == [5.0, 7.0]
+    assert torch.count_nonzero(result) == 2
+    assert torch.count_nonzero(hidden) == 0
+    debug.assert_not_called()
diff --git a/tests/model_executor/models/ming_tts/test_fused_istft.py b/tests/model_executor/models/ming_tts/test_fused_istft.py
new file mode 100644
index 000000000..fa7d072d7
--- /dev/null
+++ b/tests/model_executor/models/ming_tts/test_fused_istft.py
@@ -0,0 +1,147 @@
+# 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 vllm_omni.model_executor.models.common.ming.audio_dsp import ISTFT
+
+pytestmark = [pytest.mark.core_model, pytest.mark.tts]
+cuda = pytest.mark.skipif(
+    not torch.cuda.is_available() or torch.version.hip is not None or not HAS_TRITON,
+    reason="NVIDIA CUDA and Triton required",
+)
+
+
+def _assert_outputs_close(actual, expected):
+    for value, reference in zip(actual, expected, strict=True):
+        if reference is None:
+            assert value is None
+        else:
+            assert value.dtype == reference.dtype
+            torch.testing.assert_close(value, reference, atol=5e-7, rtol=1e-5)
+
+
+@cuda
+@pytest.mark.cuda
+@pytest.mark.parametrize("hop", [4, 320, 882])
+@pytest.mark.parametrize("window_dtype", [torch.float32, torch.bfloat16, torch.float16])
+@pytest.mark.parametrize("batch,frames", [(1, 2), (1, 25), (3, 7), (2, 100)])
+@pytest.mark.parametrize("mode", ["offline", "first", "middle", "last", "first_last"])
+@torch.inference_mode()
+def test_fused_istft_matches_native(hop, window_dtype, batch, frames, mode, monkeypatch):
+    torch.manual_seed(0)
+    module = ISTFT(4 * hop, hop, 4 * hop).to(device="cuda", dtype=window_dtype)
+    # Slice a larger spectrum so irfft must handle non-contiguous inputs.
+    spec = torch.randn(batch, 2 * hop + 1, 2 * frames, device="cuda", dtype=torch.complex64)[..., ::2]
+    kwargs = {"streaming": mode != "offline", "last_chunk": mode in ("last", "first_last")}
+    if mode in ("middle", "last"):
+        _, audio, window = module.forward_native(spec, streaming=True)
+        kwargs.update(audio_buffer=audio, window_buffer=window)
+        saved_audio, saved_window = audio.clone(), window.clone()
+    expected = module.forward_native(spec, **kwargs)
+
+    def no_fallback(*args, **kwargs):
+        pytest.fail("supported input fell back to native ISTFT")
+
+    monkeypatch.setattr(module, "forward_native", no_fallback)
+    _assert_outputs_close(module(spec, **kwargs), expected)
+    if mode in ("middle", "last"):
+        torch.testing.assert_close(audio, saved_audio, rtol=0, atol=0)
+        torch.testing.assert_close(window, saved_window, rtol=0, atol=0)
+
+
+@cuda
+@pytest.mark.cuda
+@pytest.mark.parametrize("hop", [320, 882])
+@pytest.mark.parametrize("window_dtype", [torch.float32, torch.bfloat16, torch.float16])
+@torch.inference_mode()
+def test_fused_istft_streaming_state(hop, window_dtype):
+    torch.manual_seed(1)
+    module = ISTFT(4 * hop, hop, 4 * hop).to(device="cuda", dtype=window_dtype)
+    spec = torch.randn(2, 2 * hop + 1, 40, device="cuda", dtype=torch.complex64)
+    # Reusing the same module for a new request must not reuse the old tails.
+    for _ in range(2):
+        actual_state = reference_state = (None, None)
+        actual_chunks, reference_chunks = [], []
+        for start, end in [(0, 4), (4, 29), (29, 31), (31, 40)]:
+            chunk = spec[..., start:end]
+            actual = module(chunk, *actual_state, streaming=True, last_chunk=end == 40)
+            expected = module.forward_native(chunk, *reference_state, streaming=True, last_chunk=end == 40)
+            _assert_outputs_close(actual, expected)
+            actual_state, reference_state = actual[1:], expected[1:]
+            actual_chunks.append(actual[0])
+            reference_chunks.append(expected[0])
+        output = torch.cat(actual_chunks, dim=-1)
+        torch.testing.assert_close(output, torch.cat(reference_chunks, dim=-1), atol=5e-7, rtol=1e-5)
+        if window_dtype == torch.float32:
+            # Low-precision window envelopes already round differently between
+            # streaming and offline native execution; preserve each contract.
+            torch.testing.assert_close(output, module.forward_native(spec)[0], atol=5e-7, rtol=1e-5)
+
+
+@cuda
+@pytest.mark.cuda
+@pytest.mark.parametrize("invalid", [False, True])
+@torch.inference_mode()
+def test_fused_istft_silence_and_invalid_envelope(invalid):
+    module = ISTFT(1280, 320, 1280).cuda()
+    spec = torch.zeros(2, 641, 25, device="cuda", dtype=torch.complex64)
+    if invalid:
+        module.window.zero_()
+        for forward in (module.forward_native, module.forward):
+            with pytest.raises(RuntimeError, match="window envelope underflowed"):
+                forward(spec)
+    else:
+        _assert_outputs_close(module(spec), module.forward_native(spec))
+        assert torch.count_nonzero(module(spec)[0]) == 0
+
+
+@pytest.mark.parametrize(
+    "device",
+    [pytest.param("cpu", marks=pytest.mark.cpu), pytest.param("cuda", marks=[pytest.mark.cuda, cuda])],
+)
+@pytest.mark.parametrize("padding", ["same", "center"])
+def test_istft_autograd_fallback(padding, device, monkeypatch):
+    module = ISTFT(32, 8, 32, padding=padding).to(device)
+    spec = torch.randn(2, 17, 7, device=device, dtype=torch.complex64, requires_grad=True)
+    native = module.forward_native
+    calls = []
+
+    def tracked(*args, **kwargs):
+        calls.append(True)
+        return native(*args, **kwargs)
+
+    monkeypatch.setattr(module, "forward_native", tracked)
+    result = module(spec)
+    assert calls == [True]
+    reference = native(spec)
+    if padding == "same":
+        _assert_outputs_close(result, reference)
+        result = result[0]
+    else:
+        torch.testing.assert_close(result, reference)
+    result.square().sum().backward()
+    assert spec.grad is not None and torch.isfinite(spec.grad).all()
+
+
+@cuda
+@pytest.mark.cuda
+@pytest.mark.parametrize(
+    "n_fft,hop,frames,dtype", [(32, 8, 1, torch.complex64), (30, 10, 7, torch.complex64), (32, 8, 7, torch.complex128)]
+)
+@torch.inference_mode()
+def test_istft_unsupported_cuda_falls_back(n_fft, hop, frames, dtype, monkeypatch):
+    module = ISTFT(n_fft, hop, n_fft).cuda()
+    spec = torch.randn(1, n_fft // 2 + 1, frames, device="cuda", dtype=dtype)
+    native = module.forward_native
+    calls = []
+
+    def tracked(*args, **kwargs):
+        calls.append(True)
+        return native(*args, **kwargs)
+
+    monkeypatch.setattr(module, "forward_native", tracked)
+    _assert_outputs_close(module(spec), native(spec))
+    assert calls == [True]
diff --git a/tests/model_executor/models/minicpmo_4_5/duplex/test_commit_policy.py b/tests/model_executor/models/minicpmo_4_5/duplex/test_commit_policy.py
index b933f7173..d7f3db633 100644
--- a/tests/model_executor/models/minicpmo_4_5/duplex/test_commit_policy.py
+++ b/tests/model_executor/models/minicpmo_4_5/duplex/test_commit_policy.py
@@ -5,7 +5,7 @@ from __future__ import annotations
 
 import pytest
 
-from vllm_omni.entrypoints.duplex.commit_policy import (
+from vllm_omni.engine.duplex.session.commit_policy import (
     CommitAction,
     CommitSnapshot,
     decide_commit_action,
@@ -24,7 +24,7 @@ pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
                 speech_since_commit=True,
                 active_response_id=None,
                 overlap_speech_ms=0,
-                native_response_in_progress=False,
+                response_in_progress=False,
                 playback_active=False,
             ),
             CommitAction.START_AUTO_RESPONSE,
@@ -36,7 +36,7 @@ pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
                 speech_since_commit=True,
                 active_response_id=None,
                 overlap_speech_ms=800,
-                native_response_in_progress=True,
+                response_in_progress=True,
                 playback_active=True,
             ),
             CommitAction.START_AUTO_RESPONSE,
@@ -48,7 +48,7 @@ pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
                 speech_since_commit=False,
                 active_response_id=None,
                 overlap_speech_ms=0,
-                native_response_in_progress=True,
+                response_in_progress=True,
                 playback_active=False,
             ),
             CommitAction.COMMIT_ONLY,
@@ -60,7 +60,7 @@ pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
                 speech_since_commit=True,
                 active_response_id=None,
                 overlap_speech_ms=800,
-                native_response_in_progress=True,
+                response_in_progress=True,
                 playback_active=False,
             ),
             CommitAction.DEFER_ACTIVE_RESPONSE,
@@ -72,7 +72,7 @@ pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
                 speech_since_commit=True,
                 active_response_id=None,
                 overlap_speech_ms=800,
-                native_response_in_progress=False,
+                response_in_progress=False,
                 playback_active=True,
             ),
             CommitAction.DEFER_ACTIVE_RESPONSE,
@@ -84,7 +84,7 @@ pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
                 speech_since_commit=True,
                 active_response_id=None,
                 overlap_speech_ms=0,
-                native_response_in_progress=False,
+                response_in_progress=False,
                 playback_active=False,
             ),
             CommitAction.COMMIT_ONLY,
diff --git a/tests/model_executor/models/minicpmo_4_5/duplex/test_data_plane_audio_cursor.py b/tests/model_executor/models/minicpmo_4_5/duplex/test_data_plane_audio_cursor.py
new file mode 100644
index 000000000..b2be91366
--- /dev/null
+++ b/tests/model_executor/models/minicpmo_4_5/duplex/test_data_plane_audio_cursor.py
@@ -0,0 +1,78 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""The cumulative Stage1 audio cursor.
+
+Stage1 hands the data plane a snapshot of every sample it has generated for the
+request so far, and only the new tail may reach the client. The cursor that
+makes that possible is the one piece of per-request state whose loss is silent
+and expensive: rewinding it re-sends the whole session as a single delta.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from vllm_omni.model_executor.models.minicpmo_4_5.duplex.data_plane import (
+    MiniCPMO45DataPlaneSession,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+REQUEST_ID = "duplex-s.c2Vzc2lvbg==.e.0.r.stage0"
+
+
+def _session() -> MiniCPMO45DataPlaneSession:
+    return MiniCPMO45DataPlaneSession(lambda *args, **kwargs: "")
+
+
+def _snapshot(num_samples: int) -> np.ndarray:
+    return np.arange(num_samples, dtype=np.float32)
+
+
+def _sliced_len(session: MiniCPMO45DataPlaneSession, num_samples: int) -> int:
+    sliced = session.slice_cumulative_audio(REQUEST_ID, _snapshot(num_samples))
+    if sliced is None:
+        return 0
+    return int(np.asarray(sliced).reshape(-1).size)
+
+
+def test_a_growing_snapshot_yields_only_the_new_tail() -> None:
+    session = _session()
+    assert _sliced_len(session, 24000) == 24000
+    assert _sliced_len(session, 48000) == 24000
+    assert _sliced_len(session, 48000) == 0  # unchanged snapshot emits nothing
+
+
+def test_a_placeholder_unit_does_not_rewind_the_cursor() -> None:
+    """The failure behind a 300s benchmark case producing 1373s of audio.
+
+    A continuation unit arrives as a one-sample snapshot. Taking that as "the
+    producer restarted" drops the cursor to 1, so the next real snapshot is
+    sliced from the start and the client is handed the entire session again.
+    """
+    session = _session()
+    assert _sliced_len(session, 637440) == 637440
+    assert _sliced_len(session, 1) == 1
+    assert _sliced_len(session, 1) == 1
+    assert _sliced_len(session, 1) == 1
+
+    # 649920 - 637440, not 649920 - 1.
+    assert _sliced_len(session, 649920) == 12480
+
+
+def test_a_genuinely_restarted_producer_is_still_picked_up() -> None:
+    """Two consecutive below-cursor snapshots that grow are a new buffer."""
+    session = _session()
+    assert _sliced_len(session, 48000) == 48000
+    assert _sliced_len(session, 1000) == 1000  # head of the new buffer
+    assert _sliced_len(session, 3000) == 2000  # its tail, not 3000 - 48000
+    assert _sliced_len(session, 5000) == 2000
+
+
+def test_close_stream_releases_the_cursor_for_the_next_stream() -> None:
+    session = _session()
+    assert _sliced_len(session, 48000) == 48000
+    session.close_stream(REQUEST_ID)
+    assert _sliced_len(session, 24000) == 24000
diff --git a/tests/model_executor/models/minicpmo_4_5/duplex/test_input.py b/tests/model_executor/models/minicpmo_4_5/duplex/test_input.py
index 4d6f3e46a..cf23d3ad1 100644
--- a/tests/model_executor/models/minicpmo_4_5/duplex/test_input.py
+++ b/tests/model_executor/models/minicpmo_4_5/duplex/test_input.py
@@ -177,3 +177,108 @@ def test_pcm_commit_reservation_rollback_restores_residual_audio():
     )
     assert retried.payload is not None
     assert base64.b64decode(retried.payload["audio"]) == (base64.b64decode(original["audio"]) + b"\x00" * (8_000 * 4))
+
+
+def _frame_payload(samples: int, frames: list[str]) -> dict[str, object]:
+    payload = pcm_payload(samples)
+    payload["video_frames"] = frames
+    return payload
+
+
+def test_append_attaches_every_frame_of_the_unit_closing_append():
+    """A base frame and its stacked composite arrive on one append and must
+    enter the same model unit (official ``frame_list``), not one per unit."""
+    buffer = MiniCPMO45PcmAppendBuffer()
+
+    emitted = buffer.append(_frame_payload(16_000, ["base-0", "stack-0"]), chunk_period_ms=1_000)
+
+    assert emitted is not None
+    assert emitted["video_frames"] == ["base-0", "stack-0"]
+    assert buffer._frame_queue == []
+
+
+def test_stacked_frames_do_not_accumulate_across_units():
+    buffer = MiniCPMO45PcmAppendBuffer()
+    attached: list[list[str]] = []
+
+    for unit in range(64):
+        emitted = buffer.append(
+            _frame_payload(16_000, [f"base-{unit}", f"stack-{unit}"]),
+            chunk_period_ms=1_000,
+        )
+        assert emitted is not None
+        attached.append(list(emitted["video_frames"]))
+
+    assert attached[0] == ["base-0", "stack-0"]
+    assert attached[-1] == ["base-63", "stack-63"]
+    assert buffer._frame_queue == []
+
+
+def test_frames_from_partial_appends_ride_the_unit_they_close():
+    """200 ms client chunks: the frames arrive with the 5th chunk of each
+    second and attach to the unit that chunk completes, one group per unit."""
+    buffer = MiniCPMO45PcmAppendBuffer()
+
+    emitted_units: list[dict[str, object]] = []
+    for unit in range(3):
+        for chunk in range(5):
+            frames = [f"base-{unit}", f"stack-{unit}"] if chunk == 4 else []
+            emitted = buffer.append(_frame_payload(3_200, frames), chunk_period_ms=1_000)
+            if emitted is not None:
+                emitted_units.append(emitted)
+
+    assert [unit["video_frames"] for unit in emitted_units] == [
+        ["base-0", "stack-0"],
+        ["base-1", "stack-1"],
+        ["base-2", "stack-2"],
+    ]
+    assert buffer._frame_queue == []
+
+
+def test_single_frame_per_unit_still_attaches_one_frame_per_unit():
+    buffer = MiniCPMO45PcmAppendBuffer()
+
+    first = buffer.append(_frame_payload(16_000, ["base-0"]), chunk_period_ms=1_000)
+    second = buffer.append(_frame_payload(16_000, ["base-1"]), chunk_period_ms=1_000)
+
+    assert first is not None and first["video_frames"] == ["base-0"]
+    assert second is not None and second["video_frames"] == ["base-1"]
+
+
+def test_frame_groups_stay_queued_when_audio_outruns_units():
+    """Two appends land before one unit closes: the later group waits for the
+    next unit instead of merging into the first."""
+    buffer = MiniCPMO45PcmAppendBuffer()
+
+    assert buffer.append(_frame_payload(8_000, ["base-0", "stack-0"]), chunk_period_ms=1_000) is None
+    first = buffer.append(_frame_payload(16_000, ["base-1", "stack-1"]), chunk_period_ms=1_000)
+    second = buffer.append(pcm_payload(8_000), chunk_period_ms=1_000)
+
+    assert first is not None and first["video_frames"] == ["base-0", "stack-0"]
+    assert second is not None and second["video_frames"] == ["base-1", "stack-1"]
+    assert buffer._frame_queue == []
+
+
+def test_rollback_restores_frame_groups_in_wire_order():
+    buffer = MiniCPMO45PcmAppendBuffer()
+
+    first = buffer.prepare_append(
+        _frame_payload(16_000, ["base-0", "stack-0"]),
+        operation_id="append-0",
+        chunk_period_ms=1_000,
+    )
+    second = buffer.prepare_append(
+        _frame_payload(16_000, ["base-1", "stack-1"]),
+        operation_id="append-1",
+        chunk_period_ms=1_000,
+    )
+    assert first is not None and second is not None
+    assert first.payload is not None and first.payload["video_frames"] == ["base-0", "stack-0"]
+
+    first.rollback()
+
+    assert buffer._frame_queue == [["base-0", "stack-0"], ["base-1", "stack-1"]]
+    retried = buffer.flush(chunk_period_ms=1_000)
+    assert retried is not None
+    assert retried["video_frames"] == ["base-0", "stack-0"]
+    assert buffer._frame_queue == [["base-1", "stack-1"]]
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_cfm_graph_bucketing.py b/tests/model_executor/models/minicpmo_4_5/test_cfm_graph_bucketing.py
new file mode 100644
index 000000000..c88fc6d5b
--- /dev/null
+++ b/tests/model_executor/models/minicpmo_4_5/test_cfm_graph_bucketing.py
@@ -0,0 +1,162 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Unit tests for the CFM mel-frame bucketing decision.
+
+Steady-state chunk lengths vary per request; without bucketing every length
+becomes its own CUDA-graph capture shape (428 captures / 13 flushes in the
+#6628 regression). ``_cfm_pad_frames`` aligns the frame axis onto a grid so
+steady-state calls share one capture shape; ``_decode_cfm`` trims the output
+back. These tests pin the decision math on CPU, no CUDA required.
+"""
+
+import pytest
+import torch
+
+from vllm_omni.model_executor.models.minicpmo_4_5.batched_token2wav import (
+    _cfm_pad_frames,
+    _zero_padded_frames,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_pads_partial_chunk_up_to_bucket():
+    # 50 frames on a 16-frame grid -> 14 padding frames.
+    assert _cfm_pad_frames(mel_frames=50, offset=0, noise_capacity=1000, bucket_frames=16, disabled=False) == 14
+
+
+def test_aligned_chunk_needs_no_padding():
+    assert _cfm_pad_frames(mel_frames=64, offset=0, noise_capacity=1000, bucket_frames=16, disabled=False) == 0
+
+
+def test_ragged_valid_lengths_path_disables_bucketing():
+    """The ragged per-request cache path must never be padded."""
+    for ragged in (True,):
+        for mel in (50, 64, 96):
+            assert (
+                _cfm_pad_frames(
+                    mel_frames=mel,
+                    offset=0,
+                    noise_capacity=1000,
+                    bucket_frames=16,
+                    disabled=ragged,
+                )
+                == 0
+            )
+
+
+def test_disabled_bucketing_returns_zero():
+    """bucket_frames <= 1 (or wrapper absent) means plain eager behavior."""
+    for bucket in (0, 1):
+        assert (
+            _cfm_pad_frames(
+                mel_frames=50,
+                offset=0,
+                noise_capacity=1000,
+                bucket_frames=bucket,
+                disabled=False,
+            )
+            == 0
+        )
+
+
+def test_padding_never_overflows_noise_buffer():
+    """Padding past the decoder's noise buffer must fall back to zero.
+
+    The padded call slices x from decoder.rand_noise[offset:end]; exceeding
+    its width would crash. Bucketing is best-effort, never required.
+    """
+    # 96 frames + 16 pad = 112 > 100 capacity -> give up, pad 0.
+    assert _cfm_pad_frames(mel_frames=96, offset=0, noise_capacity=100, bucket_frames=16, disabled=False) == 0
+    # Same mel length fits when un-padded: 96 <= 100.
+    assert _cfm_pad_frames(mel_frames=96, offset=0, noise_capacity=100, bucket_frames=1, disabled=False) == 0
+    # Cache offset eats into the capacity: 64 + 0 pad would fit, 64 + 48 pad
+    # would not, so the pad must be dropped.
+    assert _cfm_pad_frames(mel_frames=64, offset=50, noise_capacity=110, bucket_frames=16, disabled=False) == 0
+    # The original chunk fits while the padded one does not: 50 + 50 = 100
+    # <= 110, but 100 + 14 = 114 > 110, so the pad must be dropped.
+    assert _cfm_pad_frames(mel_frames=50, offset=50, noise_capacity=110, bucket_frames=16, disabled=False) == 0
+    # Same numbers with room for the padding: 114 <= 120, so it stands.
+    assert _cfm_pad_frames(mel_frames=50, offset=50, noise_capacity=120, bucket_frames=16, disabled=False) == 14
+
+
+def test_padding_applies_with_cache_offset_when_it_fits():
+    # offset 50 + mel 50 + pad 14 = 114 <= 200 -> pad stands.
+    assert _cfm_pad_frames(mel_frames=50, offset=50, noise_capacity=200, bucket_frames=16, disabled=False) == 14
+
+
+def test_steady_state_cache_width_saturates_on_bucket_grid():
+    """Pin the real recurrence: grow, then trim to ``prompt_len + 100``.
+
+    ``_decode_batch_once`` trims the estimator attention cache after every
+    decode, so the width saturates instead of growing without bound. What
+    matters for the graph cache is that the steady-state
+    ``(chunk_width, cache_width)`` pair settles on a single grid point.
+    """
+    bucket, prompt_len = 16, 304
+    cache_cap = prompt_len + 100
+    width = prompt_len
+    shapes = set()
+    for _ in range(20):
+        pad = _cfm_pad_frames(
+            mel_frames=50,
+            offset=width,
+            noise_capacity=30000,
+            bucket_frames=bucket,
+            disabled=False,
+        )
+        assert pad == 14
+        shapes.add((50 + pad, width))  # (chunk width, cache width) as used
+        width = min(width + 50 + pad, cache_cap)
+    assert width == cache_cap
+    # (64, 304) -> (64, 368) -> (64, 404), then stable.
+    assert shapes == {(64, 304), (64, 368), (64, 404)}
+
+
+def test_varied_chunk_lengths_collapse_onto_few_widths():
+    """Bucketing exists for the varied-length calls, not the steady 50-frame one.
+
+    The first/last chunk and the ``plan_token2wav_encode_slices`` splits land on
+    arbitrary lengths; those are the calls that would each become their own
+    capture shape. Pin that a realistic mix collapses onto a few padded widths.
+    """
+    varied = (7, 12, 17, 25, 33, 50, 51, 64)
+    padded = {
+        mel
+        + _cfm_pad_frames(
+            mel_frames=mel,
+            offset=300,
+            noise_capacity=30000,
+            bucket_frames=16,
+            disabled=False,
+        )
+        for mel in varied
+    }
+    assert len(padded) == 4, sorted(padded)  # 16 / 32 / 48 / 64
+    assert len(padded) < len(varied)
+
+
+def test_zero_padded_frames_survives_an_integration_step():
+    """The padded region must stay zero after ``x = x + dt * velocity``.
+
+    Zeroing once before the CFM loop is not enough: the update touches every
+    column, so the padded region becomes non-zero again (0 -> 0.010 -> 0.020
+    over the first steps). Pin the helper that re-zeroes it each step.
+    """
+    mel, pad = 50, 14
+    x = torch.zeros(2, 4, mel + pad)
+    x[..., :mel] = 0.05
+    _zero_padded_frames(x, mel)
+    assert torch.all(x[..., mel:] == 0.0)
+    for _ in range(3):
+        x = x + 0.02 * torch.ones_like(x)  # the integration step
+        _zero_padded_frames(x, mel)
+        assert torch.all(x[..., mel:] == 0.0)
+        assert torch.all(x[..., :mel] > 0.0)
+
+
+def test_zero_padded_frames_is_a_noop_without_padding():
+    x = torch.ones(1, 2, 32)
+    _zero_padded_frames(x, None)
+    _zero_padded_frames(x, 32)
+    assert torch.all(x == 1.0)
diff --git a/tests/model_executor/models/minicpmo_4_5/test_chat_template.py b/tests/model_executor/models/minicpmo_4_5/test_chat_template.py
index 8f1068392..2894b4a1c 100644
--- a/tests/model_executor/models/minicpmo_4_5/test_chat_template.py
+++ b/tests/model_executor/models/minicpmo_4_5/test_chat_template.py
@@ -6,7 +6,7 @@ from pathlib import Path
 
 import pytest
 from jinja2 import TemplateError
-from transformers.utils.chat_template_utils import _compile_jinja_template
+from transformers.utils.chat_template_utils import render_jinja_template
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
@@ -26,12 +26,15 @@ TEMPLATE = Path(__file__).resolve().parents[4] / "vllm_omni/transformers_utils/c
     ],
 )
 def test_native_content_concatenation(parts, expected):
-    rendered = _compile_jinja_template(TEMPLATE.read_text()).render(
-        messages=[{"role": "user", "content": parts}],
+    # render_jinja_template takes a batch of conversations and returns
+    # (rendered_conversations, continuation_chunks), so [0][0] is the string.
+    rendered = render_jinja_template(
+        [[{"role": "user", "content": parts}]],
+        chat_template=TEMPLATE.read_text(),
         add_generation_prompt=True,
         enable_thinking=False,
         use_tts_template=True,
-    )
+    )[0][0]
     assert rendered == (
         f"<|im_start|>user\n{expected}<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n<|tts_bos|>"
     )
@@ -39,7 +42,8 @@ def test_native_content_concatenation(parts, expected):
 
 def test_unsupported_part_is_not_silently_discarded():
     with pytest.raises(TemplateError, match="Unsupported MiniCPM-o content part"):
-        _compile_jinja_template(TEMPLATE.read_text()).render(
-            messages=[{"role": "user", "content": [{"type": "unknown"}]}],
+        render_jinja_template(
+            [[{"role": "user", "content": [{"type": "unknown"}]}]],
+            chat_template=TEMPLATE.read_text(),
             add_generation_prompt=True,
         )
diff --git a/tests/model_executor/models/minicpmo_4_5/test_code2wav_batching.py b/tests/model_executor/models/minicpmo_4_5/test_code2wav_batching.py
index a0e7ed4db..edb813af3 100644
--- a/tests/model_executor/models/minicpmo_4_5/test_code2wav_batching.py
+++ b/tests/model_executor/models/minicpmo_4_5/test_code2wav_batching.py
@@ -523,7 +523,7 @@ def test_cfm_graph_receives_bfloat16_cache_in_compute_dtype():
     seen_dtypes: list[torch.dtype] = []
 
     class RecordingGraph:
-        def replay(self, estimator_input, time_embedding, cnn_cache, att_cache, cnn_out, att_out):
+        def replay(self, estimator_input, time_embedding, cnn_cache, att_cache, cnn_out, att_out, attn_mask=None):
             del time_embedding, cnn_cache
             seen_dtypes.append(att_cache.dtype)
             return estimator_input[:, :1], cnn_out, att_out
@@ -1313,3 +1313,103 @@ def test_reference_voice_and_duplex_metadata_follow_request_lifecycle():
     assert prompt_key not in model._runtime_prompts
     assert not Path(prompt_wav).exists()
     assert (prompt_cache_id, prompt_wav) not in model.backend._prompt_features
+
+
+def _eager_cfm_wrapper(estimator: nn.Module) -> SimpleNamespace:
+    """A CFM graph wrapper that honours the contract but runs eagerly.
+
+    ``_decode_cfm`` only takes the padded path when a wrapper is present, so
+    CPU tests that need that path (CUDA graphs are unavailable here) supply
+    this in place of the real wrapper.
+    """
+
+    def replay(estimator_input, time_emb, cnn_cache, att_cache, cnn_out, att_out, attn_mask=None):
+        output = estimator.blocks_forward_chunk(
+            estimator_input,
+            time_emb,
+            attn_mask,
+            cnn_cache,
+            att_cache,
+            cnn_out,
+            att_out,
+        )
+        return output, cnn_out, att_out
+
+    return SimpleNamespace(enabled=True, replay=replay)
+
+
+def _padded_decode_adapter(bucket_frames: int) -> tuple[BatchedToken2Wav, int, int]:
+    """Build an adapter over a real ``DiT`` that exercises the CFM path.
+
+    Returns the adapter, the valid width, and the padding width. Every call
+    seeds the same way, so two adapters built here agree on weights and noise.
+    """
+    from cosyvoice2.flow.decoder_dit import DiT
+
+    torch.manual_seed(23)
+    estimator = DiT(
+        in_channels=4,
+        out_channels=1,
+        depth=2,
+        num_heads=2,
+        head_dim=2,
+        hidden_size=4,
+    ).eval()
+    token2wav = _FakeToken2Wav()
+    token2wav.flow.decoder.estimator = estimator
+    token2wav.flow.decoder.rand_noise = torch.randn(1, 1, 160)
+    adapter = BatchedToken2Wav(token2wav)
+    adapter._cfm_graph_wrapper = _eager_cfm_wrapper(estimator)
+    adapter._cfm_graph_bucket_frames = bucket_frames
+    mel_frames = 51  # the 16-frame grid pads this to 64
+    pad_frames = (-(-mel_frames // 16) * 16 - mel_frames) if bucket_frames else 0
+    return adapter, mel_frames, pad_frames
+
+
+def test_padded_chunk_keeps_the_cross_chunk_caches_on_the_valid_boundary():
+    """Caches the next chunk reads must not carry padding.
+
+    The padded steps still run, so ``step_cnn``/``step_att`` come back with
+    padding-derived values in them. Unless those positions are cleared, the
+    following chunk consumes them as its keys and as its CNN left context.
+    This drives a padded chunk through the real ``DiT`` and checks both caches
+    at the boundary.
+    """
+    adapter, mel_frames, pad_frames = _padded_decode_adapter(bucket_frames=16)
+    assert pad_frames == 13
+
+    mu = torch.randn(1, 1, mel_frames)
+    cond = torch.zeros(1, 1, mel_frames)
+    speakers = torch.randn(1, 1)
+    with torch.no_grad():
+        x, cnn, att = adapter._decode_cfm(mu, speakers, cond, cnn_cache=None, att_cache=None)
+
+    assert int(x.shape[2]) == mel_frames
+    assert int(att.shape[4]) == mel_frames + pad_frames
+    # These columns become the next chunk's keys.
+    assert torch.count_nonzero(att[..., mel_frames : mel_frames + pad_frames, :]) == 0
+    # This tail becomes the next chunk's CNN left context.
+    assert torch.count_nonzero(cnn[..., -pad_frames:]) == 0
+
+
+def test_padding_does_not_change_the_valid_frames():
+    """A padded chunk returns the same valid frames as an exact-width one.
+
+    Masking takes the padded keys out of the attention and the padded CNN tail
+    never reaches the valid positions, so the only difference between the two
+    runs is the capture shape -- not the audio the chunk produces.
+    """
+    padded, mel_frames, pad_frames = _padded_decode_adapter(bucket_frames=16)
+    exact, _, exact_pad = _padded_decode_adapter(bucket_frames=0)
+    assert pad_frames == 13
+    assert exact_pad == 0
+
+    mu = torch.randn(1, 1, mel_frames, generator=torch.Generator().manual_seed(5))
+    cond = torch.zeros(1, 1, mel_frames)
+    speakers = torch.randn(1, 1, generator=torch.Generator().manual_seed(7))
+    with torch.no_grad():
+        padded_x, _, _ = padded._decode_cfm(mu, speakers, cond, cnn_cache=None, att_cache=None)
+        exact_x, _, _ = exact._decode_cfm(mu, speakers, cond, cnn_cache=None, att_cache=None)
+
+    assert int(padded_x.shape[2]) == int(exact_x.shape[2]) == mel_frames
+    assert torch.allclose(padded_x, exact_x, atol=1e-5)
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 26daeff7b..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)):
@@ -252,6 +254,37 @@ def test_cfm_graph_replay_matches_eager_for_uncached_and_cached_shapes(
     wrapper._flush()
 
 
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA is required")
+def test_cfm_capture_keeps_the_real_mask(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Static buffers must be built from the real inputs, mask included.
+
+    Capturing from zero-filled placeholders would bake the "nothing is masked"
+    branch into the graph, while replay copies the real mask into those very
+    buffers -- so the captured branch has to come from the real value.
+    """
+    pool = torch.cuda.graph_pool_handle()
+    monkeypatch.setattr(current_platform, "get_global_graph_pool", lambda: pool)
+
+    torch.manual_seed(0)
+    estimator = _MiniDiT().eval().cuda()
+    wrapper = CFMGraphWrapper(graph_fn=estimator.blocks_forward_chunk, max_graphs=4)
+
+    inputs = _cfm_inputs(2, 12, 0)
+    frames = int(inputs[0].shape[2])
+    mask = torch.ones(2, frames, frames, dtype=torch.bool, device="cuda")
+    mask[:, :, -2:] = False  # two padded keys are masked out
+
+    with torch.inference_mode():
+        wrapper.replay(*inputs, mask)
+        assert wrapper._stats["captures"] == 1
+
+    static_inputs, _, _ = next(iter(wrapper._cache.values()))
+    static_mask = static_inputs[6]
+    assert static_mask is not None
+    assert torch.equal(static_mask, mask)
+    wrapper._flush()
+
+
 def test_importing_wrapper_does_not_resolve_platform() -> None:
     """Importing this module must not build the OmniPlatform singleton.
 
@@ -354,7 +387,8 @@ def test_cfm_unsupported_dtype_eagers_only_that_shape(monkeypatch: pytest.Monkey
     """A key that cannot round-trip is a property of one shape, not of the GPU.
 
     It must not disable the wrapper or retire the generation the way a capture
-    failure does.
+    failure does. `_tensors_from_key` is the fallback used when no real inputs
+    are available, so the probe drives `_capture` without them.
     """
     pool = torch.cuda.graph_pool_handle()
     monkeypatch.setattr(current_platform, "get_global_graph_pool", lambda: pool)
@@ -374,7 +408,10 @@ def test_cfm_unsupported_dtype_eagers_only_that_shape(monkeypatch: pytest.Monkey
     monkeypatch.setattr(wrapper_module, "_tensors_from_key", _reject_one_shape)
 
     with torch.inference_mode():
-        wrapper.replay(*_cfm_inputs(2, unbuildable_width, 0))
+        key = ("estimator_step",) + tuple(
+            wrapper_module._tensor_signature(t) for t in _cfm_inputs(2, unbuildable_width, 0)
+        )
+        assert wrapper._capture(key, None) is None
         assert wrapper.enabled is True
         assert wrapper._stats["captures"] == 0
 
@@ -382,11 +419,6 @@ def test_cfm_unsupported_dtype_eagers_only_that_shape(monkeypatch: pytest.Monkey
         wrapper.replay(*_cfm_inputs(2, 12, 0))
         assert wrapper._stats["captures"] == 1
 
-        # and the rejected shape stays eager without retrying the capture
-        wrapper.replay(*_cfm_inputs(2, unbuildable_width, 0))
-        assert wrapper._stats["captures"] == 1
-        assert wrapper._stats["eager"] == 2
-
     wrapper._flush()
 
 
diff --git a/tests/model_executor/models/minicpmo_4_5/test_llm2tts.py b/tests/model_executor/models/minicpmo_4_5/test_llm2tts.py
index 3fd4867cb..d93755fec 100644
--- a/tests/model_executor/models/minicpmo_4_5/test_llm2tts.py
+++ b/tests/model_executor/models/minicpmo_4_5/test_llm2tts.py
@@ -9,7 +9,7 @@ Covers ``vllm_omni.model_executor.stage_input_processors.minicpmo_4_5_omni.llm2t
   - both inputs missing -> raises
   - structured model_intermediate_buffer carries the thinker ids and text
   - scheduler prompt tokens follow the selected TTS region or output tokens
-  - MiniCPM-o 4.5 TTS region detection on 151703 / 151704 tokens
+  - MiniCPM-o 4.5 TTS region detection on 151703 / 151704 / 151645 tokens
   - plain chat without TTS markers conditions on the generated assistant span
   - prompt arg is normalized to a list and ``multi_modal_data`` is gated by
     ``requires_multimodal_data``
@@ -260,13 +260,14 @@ class TestTtsRegionDetection:
         )
         return result[0]["model_intermediate_buffer"], hidden
 
-    def test_4_5_markers_detected(self) -> None:
+    @pytest.mark.parametrize("tts_end_id", [151704, 151645])
+    def test_4_5_markers_detected(self, tts_end_id: int) -> None:
         # prompt:        [10, 11]
-        # output:        [151703, 30, 31, 151704, 40]
-        # full sequence: [10, 11, 151703, 30, 31, 151704, 40]
+        # output:        [151703, 30, 31, end, 40]
+        # full sequence: [10, 11, 151703, 30, 31, end, 40]
         #                  0   1     2    3   4     5     6
-        # 4.5 BOS at idx 2 -> slice starts at 3; EOS at idx 5 -> slice ends at 5.
-        buffer, hidden = self._run([10, 11], [151703, 30, 31, 151704, 40])
+        # 4.5 BOS at idx 2 -> slice starts at 3; end at idx 5 -> slice ends at 5.
+        buffer, hidden = self._run([10, 11], [151703, 30, 31, tts_end_id, 40])
         assert buffer["ids"]["tts"] == [30, 31]
         assert torch.equal(torch.tensor(buffer["hidden_states"]["tts"]), hidden[3:5])
 
diff --git a/tests/model_executor/models/minicpmo_4_5/test_minicpmo_4_5_omni_llm_embed.py b/tests/model_executor/models/minicpmo_4_5/test_minicpmo_4_5_omni_llm_embed.py
new file mode 100644
index 000000000..9f53fb7ec
--- /dev/null
+++ b/tests/model_executor/models/minicpmo_4_5/test_minicpmo_4_5_omni_llm_embed.py
@@ -0,0 +1,33 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+import pytest
+
+from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni_llm import (
+    MiniCPMO45OmniLLMForConditionalGeneration,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_embed_multimodal_delegates_to_get_multimodal_embeddings(monkeypatch):
+    """vLLM V1 encoder profiling calls embed_multimodal; without an override the
+    SupportsMultiModal protocol stub returns None and startup fails downstream."""
+    sentinel = (object(),)
+    seen: dict[str, object] = {}
+
+    def fake_get_multimodal_embeddings(self, **kwargs):
+        seen.update(kwargs)
+        return sentinel
+
+    monkeypatch.setattr(
+        MiniCPMO45OmniLLMForConditionalGeneration,
+        "get_multimodal_embeddings",
+        fake_get_multimodal_embeddings,
+    )
+    model = object.__new__(MiniCPMO45OmniLLMForConditionalGeneration)
+
+    out = model.embed_multimodal(pixel_values="pv", audio_features="af")
+
+    assert out is sentinel
+    assert seen == {"pixel_values": "pv", "audio_features": "af"}
diff --git a/tests/model_executor/models/minicpmo_4_5/test_minicpmo_4_5_omni_llm_forward.py b/tests/model_executor/models/minicpmo_4_5/test_minicpmo_4_5_omni_llm_forward.py
new file mode 100644
index 000000000..b1cc48177
--- /dev/null
+++ b/tests/model_executor/models/minicpmo_4_5/test_minicpmo_4_5_omni_llm_forward.py
@@ -0,0 +1,123 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from unittest.mock import MagicMock
+
+import pytest
+import torch
+
+from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni import (
+    MiniCPMO45OmniForConditionalGeneration,
+)
+from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni_llm import (
+    MiniCPMO45OmniLLMForConditionalGeneration,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_thinker_forward_returns_bare_hidden_states():
+    """Verify that MiniCPMO45OmniLLMForConditionalGeneration.forward returns
+    a bare hidden_states Tensor (not a tuple), which stock vLLM GPUModelRunner
+    expects.
+    """
+    model = MiniCPMO45OmniLLMForConditionalGeneration.__new__(MiniCPMO45OmniLLMForConditionalGeneration)
+    torch.nn.Module.__init__(model)
+    model.llm = MagicMock()
+    mock_hidden_states = torch.randn(4, 4096)
+    model.llm.model = MagicMock(return_value=mock_hidden_states)
+
+    out = model.forward(
+        input_ids=torch.tensor([1, 2, 3, 4]),
+        positions=torch.tensor([0, 1, 2, 3]),
+        inputs_embeds=torch.randn(4, 4096),
+    )
+
+    assert isinstance(out, torch.Tensor), f"Expected bare torch.Tensor, got {type(out)}"
+    assert out.shape == (4, 4096)
+    assert torch.equal(out, mock_hidden_states)
+
+
+def test_thinker_forward_builds_embeddings_once_when_inputs_embeds_none():
+    """Verify that when inputs_embeds is None, forward builds input embeddings
+    exactly once and forwards them to self.llm.model with input_ids=None."""
+    model = MiniCPMO45OmniLLMForConditionalGeneration.__new__(MiniCPMO45OmniLLMForConditionalGeneration)
+    torch.nn.Module.__init__(model)
+    model.llm = MagicMock()
+    mock_hidden_states = torch.randn(4, 4096)
+    model.llm.model = MagicMock(return_value=mock_hidden_states)
+
+    mock_mm_embeds = [torch.randn(2, 4096)]
+    mock_input_embeds = torch.randn(4, 4096)
+    model.get_multimodal_embeddings = MagicMock(return_value=mock_mm_embeds)
+    model.get_input_embeddings = MagicMock(return_value=mock_input_embeds)
+
+    input_ids = torch.tensor([1, 2, 3, 4])
+    positions = torch.tensor([0, 1, 2, 3])
+
+    out = model.forward(
+        input_ids=input_ids,
+        positions=positions,
+        inputs_embeds=None,
+    )
+
+    # Assert input embeddings are built exactly once
+    model.get_multimodal_embeddings.assert_called_once()
+    model.get_input_embeddings.assert_called_once_with(input_ids, mock_mm_embeds)
+
+    # Verify forwarded to self.llm.model with input_ids=None and inputs_embeds
+    model.llm.model.assert_called_once_with(
+        None,
+        positions,
+        None,
+        inputs_embeds=mock_input_embeds,
+    )
+
+    assert isinstance(out, torch.Tensor), f"Expected bare torch.Tensor, got {type(out)}"
+    assert torch.equal(out, mock_hidden_states)
+
+
+@pytest.mark.parametrize(
+    ("thinker_shape", "expected_shape"),
+    [
+        ((1, 4096), (1, 4096)),
+        ((5, 4096), (5, 4096)),
+        ((1, 1, 4096), (1, 4096)),
+        ((1, 5, 4096), (5, 4096)),
+    ],
+)
+def test_wrapper_shape_normalization(thinker_shape, expected_shape):
+    """Verify that MiniCPMO45OmniForConditionalGeneration normalizes 3D
+    hidden states of shape (1, seq_len, H) to (seq_len, H), while leaving
+    2D hidden states intact (especially (1, H) for single-token decode)."""
+    wrapper = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
+    torch.nn.Module.__init__(wrapper)
+    wrapper.model_stage = "llm"
+    wrapper.thinker = torch.nn.Module()
+    mock_hidden = torch.randn(*thinker_shape)
+    wrapper.thinker.forward = MagicMock(return_value=mock_hidden)
+
+    out = wrapper.forward(
+        input_ids=torch.tensor([1]),
+        positions=torch.tensor([0]),
+    )
+
+    assert out.text_hidden_states.shape == expected_shape, (
+        f"Expected text_hidden_states shape {expected_shape}, got {out.text_hidden_states.shape}"
+    )
+    assert out.multimodal_outputs["latent"].shape == expected_shape, (
+        f"Expected latent shape {expected_shape}, got {out.multimodal_outputs['latent'].shape}"
+    )
+
+
+if __name__ == "__main__":
+    test_thinker_forward_returns_bare_hidden_states()
+    test_thinker_forward_builds_embeddings_once_when_inputs_embeds_none()
+    for shape, exp in [
+        ((1, 4096), (1, 4096)),
+        ((5, 4096), (5, 4096)),
+        ((1, 1, 4096), (1, 4096)),
+        ((1, 5, 4096), (5, 4096)),
+    ]:
+        test_wrapper_shape_normalization(shape, exp)
+    print("ALL TESTS PASSED SUCCESSFULLY!")
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 f8fdfdcd2..92e96b25a 100644
--- a/tests/model_executor/models/minicpmo_4_5/test_pipeline.py
+++ b/tests/model_executor/models/minicpmo_4_5/test_pipeline.py
@@ -55,20 +55,18 @@ class TestRegistryDeclaration:
         assert pipeline.model_type == _PIPELINE_KEY
         assert pipeline.model_arch == "MiniCPMO45OmniForConditionalGeneration"
 
-    def test_native_duplex_control_is_explicit_without_a_fixed_session_cap(self) -> None:
+    def test_duplex_plugin_is_declared_without_a_fixed_session_cap(self) -> None:
         pipeline = OMNI_PIPELINES[_PIPELINE_KEY]
-        assert pipeline.duplex_control_enabled is True
-        assert pipeline.duplex_serving_adapter == (
-            "vllm_omni.model_executor.models.minicpmo_4_5.duplex.serving_adapter.MiniCPMO45ServingRuntimeAdapter"
+        assert pipeline.duplex_plugin == (
+            "vllm_omni.model_executor.models.minicpmo_4_5.duplex.plugin.MiniCPMO45DuplexPlugin"
         )
         assert not hasattr(pipeline, "max_native_duplex_sessions")
 
-    def test_ordinary_pipeline_defaults_to_no_duplex_control(self) -> None:
+    def test_ordinary_pipeline_declares_no_duplex_plugin(self) -> None:
         pipeline = PipelineConfig(
             model_type="ordinary", stages=(StagePipelineConfig(stage_id=0, model_stage="a", final_output=True),)
         )
-        assert pipeline.duplex_control_enabled is False
-        assert pipeline.duplex_serving_adapter is None
+        assert pipeline.duplex_plugin is None
         assert not hasattr(pipeline, "max_native_duplex_sessions")
 
 
@@ -91,6 +89,10 @@ class TestPipelineTopology:
         assert thinker.final_output_type == "text"
         assert thinker.owns_tokenizer is True
         assert thinker.requires_multimodal_data is True
+        assert thinker.sampling_constraints == {
+            "detokenize": True,
+            "stop_token_ids": [151704, 151645],
+        }
 
     def test_talker_stage(self, pipeline: PipelineConfig) -> None:
         talker = pipeline.get_stage(1)
@@ -176,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_reference_audio_normalization.py b/tests/model_executor/models/minicpmo_4_5/test_reference_audio_normalization.py
new file mode 100644
index 000000000..9b9bbf570
--- /dev/null
+++ b/tests/model_executor/models/minicpmo_4_5/test_reference_audio_normalization.py
@@ -0,0 +1,204 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Unit tests for the reference-audio normalization grid.
+
+Every request's reference audio is folded onto one sample rate and one fixed
+length so the CFM attention cache origin (L0) is a single constant; that is
+what collapsed the CFM CUDA-graph key space back from 58 shapes to a handful
+and cut the capture storm behind the #6628 regression. These tests pin the
+pure math so future edits cannot silently widen L0 again.
+"""
+
+import logging
+from types import SimpleNamespace
+
+import pytest
+import torch
+
+from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_code2wav import (
+    _REF_MAX_SECONDS,
+    _REF_TARGET_SAMPLE_RATE,
+    _normalize_reference,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+TARGET = _REF_TARGET_SAMPLE_RATE
+MAX_SAMPLES = int(_REF_MAX_SECONDS * TARGET)  # 6 s @ 24 kHz
+
+
+def test_mono_downmix_averages_channels_without_interleaving():
+    """(2, T) stereo must become channel-mean mono, not a reshape interleave.
+
+    reshape(-1) on (2, T) would alternate 1/0 samples; mean(dim=0) yields a
+    constant 0.5 waveform. The whole-output equality fails on any interleave.
+    """
+    stereo = torch.zeros(2, 16)
+    stereo[0] = 1.0
+    waveform, sr = _normalize_reference(stereo, TARGET)
+    assert sr == TARGET
+    assert waveform.shape == (MAX_SAMPLES,)
+    assert torch.all(waveform[:16] == 0.5)  # mono body
+    assert torch.all(waveform[16:] == 0.0)  # zero-padded tail
+
+
+def test_resample_48k_to_24k_halves_sample_count():
+    """Off-grid sample rates are resampled onto 24 kHz before padding."""
+    wav_48k = torch.arange(24000, dtype=torch.float32)
+    waveform, sr = _normalize_reference(wav_48k, 48000)
+    assert sr == TARGET
+    assert waveform.shape == (MAX_SAMPLES,)
+    assert torch.all(waveform[:12000] > 0)  # resampled body, then silence
+    assert torch.all(waveform[12000:] == 0)
+
+
+def test_long_reference_is_truncated_to_6s():
+    samples_7s = torch.arange(7 * TARGET, dtype=torch.float32)
+    waveform, sr = _normalize_reference(samples_7s, TARGET)
+    assert sr == TARGET
+    assert waveform.shape == (MAX_SAMPLES,)
+    assert torch.equal(waveform, samples_7s[:MAX_SAMPLES])
+
+
+def test_short_reference_is_zero_padded_to_6s():
+    """The zero-pad is the load-bearing half of S1b.
+
+    Truncation alone only caps long references; short ones would keep
+    distinct L0 values (verified experimentally: rtf 3.375 with truncation
+    only, 1.2 with zero-padding). Pin the padding behavior.
+    """
+    samples_1s = torch.arange(TARGET, dtype=torch.float32)
+    waveform, sr = _normalize_reference(samples_1s, TARGET)
+    assert sr == TARGET
+    assert waveform.shape == (MAX_SAMPLES,)
+    assert torch.equal(waveform[:TARGET], samples_1s)
+    assert torch.all(waveform[TARGET:] == 0)
+
+
+def test_exact_length_reference_passes_through_unchanged():
+    samples_6s = torch.arange(MAX_SAMPLES, dtype=torch.float32)
+    waveform, sr = _normalize_reference(samples_6s, TARGET)
+    assert sr == TARGET
+    assert torch.equal(waveform, samples_6s)
+
+
+def test_every_output_shares_one_length():
+    """Whatever comes in, one request's L0 equals any other's."""
+    for length in (TARGET // 4, TARGET, 3 * TARGET, MAX_SAMPLES + 1):
+        waveform, _ = _normalize_reference(torch.ones(length), TARGET)
+        assert waveform.numel() == MAX_SAMPLES
+
+
+def test_empty_reference_stays_empty():
+    """An empty waveform must not be padded into a valid-length reference.
+
+    ``_materialize_runtime_prompt`` relies on numel() == 0 to raise
+    "empty_ref_audio" and reject the request; zero-padding would turn a
+    broken input into a silently accepted all-silence reference.
+    """
+    waveform, sr = _normalize_reference(torch.zeros(0), TARGET)
+    assert waveform.numel() == 0
+    assert sr == TARGET
+
+
+def test_window_length_is_configurable():
+    """Deployments can widen the window via ``ref_audio_max_seconds``."""
+    samples_5s = torch.arange(5 * TARGET, dtype=torch.float32)
+    waveform, sr = _normalize_reference(samples_5s, TARGET, max_seconds=3.0)
+    assert sr == TARGET
+    assert waveform.numel() == 3 * TARGET
+    # A longer window keeps the whole 5s clip instead of truncating it.
+    waveform, _ = _normalize_reference(samples_5s, TARGET, max_seconds=8.0)
+    assert waveform.numel() == 8 * TARGET
+    assert torch.equal(waveform[: 5 * TARGET], samples_5s)
+
+
+def test_truncation_emits_warning(caplog):
+    """Silent truncation would hide a user-visible behavior change.
+
+    A bare ``caplog.at_level`` does not capture vLLM loggers (they do not
+    propagate to the root handlers the fixture taps), so attach the fixture
+    handler to the module logger directly -- same idiom as
+    ``tests/model_executor/stage_input_processors/test_qwen3_tts_async_chunk.py``.
+    """
+    samples_7s = torch.arange(7 * TARGET, dtype=torch.float32)
+    target_logger = logging.getLogger("vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_code2wav")
+    target_logger.addHandler(caplog.handler)
+    prev_level = target_logger.level
+    target_logger.setLevel(logging.WARNING)
+    try:
+        _normalize_reference(samples_7s, TARGET)
+    finally:
+        target_logger.removeHandler(caplog.handler)
+        target_logger.setLevel(prev_level)
+    assert any("truncating" in record.getMessage() for record in caplog.records)
+
+
+def test_soundfile_2d_output_is_transposed_before_the_normalizer(tmp_path):
+    """``sf.read`` gives (samples, channels); the normalizer wants the transpose.
+
+    Without it a stereo default prompt looks like a huge channel count, the
+    downmix guard rejects it, and the caller falls back to the raw file -- so
+    that prompt keeps a second L0 value next to the normalized request
+    references.
+    """
+    import soundfile as sf
+
+    from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_code2wav import (
+        _read_reference_wav,
+    )
+
+    frames = TARGET
+    # Opposite-signed channels: the downmix is a true mean only when the two
+    # channels were aligned as rows, so a wrong layout cannot look correct.
+    stereo = torch.stack((torch.full((frames,), 0.5), torch.full((frames,), -0.5)), dim=1)
+    path = tmp_path / "stereo.wav"
+    sf.write(str(path), stereo.numpy(), TARGET, format="WAV")
+
+    waveform, sample_rate_hz = _read_reference_wav(str(path))
+
+    assert sample_rate_hz == TARGET
+    assert waveform.shape == (2, frames)
+    normalized, target_sr = _normalize_reference(waveform, sample_rate_hz, max_seconds=1.0)
+    assert target_sr == TARGET
+    assert normalized.shape[-1] == TARGET
+    assert torch.allclose(normalized, torch.zeros_like(normalized), atol=1e-6)
+
+
+def test_default_prompt_uses_the_configured_window(tmp_path):
+    """The default prompt has to honour ``ref_audio_max_seconds``.
+
+    With a non-default window, a default prompt normalized at the fixed 6 s
+    constant would keep a different L0 from the request references, which is
+    the mismatch this normalization exists to remove.
+    """
+    import tempfile
+
+    import soundfile as sf
+
+    from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_code2wav import (
+        MiniCPMO45Code2Wav,
+        _read_reference_wav,
+    )
+
+    frames = 2 * TARGET  # shorter than the window, so it gets zero-padded
+    samples = torch.full((frames, 2), 0.25)
+    source = tmp_path / "default.wav"
+    sf.write(str(source), samples.numpy(), TARGET, format="WAV")
+
+    window_seconds = 8.0
+    with tempfile.TemporaryDirectory() as runtime_dir:
+        stub = SimpleNamespace(
+            _default_prompt_wav=str(source),
+            _default_prompt_id="HT_ref_audio",
+            _default_prompt_normalized=None,
+            _ref_max_seconds=window_seconds,
+            _runtime_prompt_dir=SimpleNamespace(name=runtime_dir),
+        )
+        prompt_wav, _ = MiniCPMO45Code2Wav._normalized_default_prompt(stub)
+        # Read inside the block: the temporary directory is removed on exit.
+        normalized, sample_rate_hz = _read_reference_wav(prompt_wav)
+
+    assert sample_rate_hz == TARGET
+    # The configured window, not the fixed 6 s default.
+    assert normalized.shape[-1] == int(window_seconds * TARGET)
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/moss_tts_nano/test_npu_compat.py b/tests/model_executor/models/moss_tts_nano/test_npu_compat.py
new file mode 100644
index 000000000..59882edc1
--- /dev/null
+++ b/tests/model_executor/models/moss_tts_nano/test_npu_compat.py
@@ -0,0 +1,32 @@
+# 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_nano.modeling_moss_tts_nano import (
+    _configure_attention_implementation,
+    _validate_max_num_seqs,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_non_cuda_attention_uses_sdpa():
+    class FakeModel:
+        attention_implementation = None
+
+        def _set_attention_implementation(self, implementation):
+            self.attention_implementation = implementation
+
+    model = FakeModel()
+    _configure_attention_implementation(model, torch.device("cpu"))
+
+    assert model.attention_implementation == "sdpa"
+
+
+def test_moss_tts_nano_rejects_concurrent_active_sequences():
+    _validate_max_num_seqs(1)
+
+    with pytest.raises(ValueError, match="requires max_num_seqs=1"):
+        _validate_max_num_seqs(2)
diff --git a/tests/model_executor/models/nemotron_voicechat/duplex/conftest.py b/tests/model_executor/models/nemotron_voicechat/duplex/conftest.py
new file mode 100644
index 000000000..134731bf6
--- /dev/null
+++ b/tests/model_executor/models/nemotron_voicechat/duplex/conftest.py
@@ -0,0 +1,20 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Nemotron VoiceChat duplex is not on the duplex plugin framework yet.
+
+RFC vllm-omni#7181 splits the port: this PR lands the unified framework with
+MiniCPM-o 4.5, and the follow-up PR moves Nemotron VoiceChat onto
+``DuplexModelPlugin``. Until then the modules under test still import the
+pre-framework duplex runtime / serving adapter that this PR removed, so
+collecting them would fail at import time and abort the whole pytest session.
+The tests themselves are unchanged and come back with the port.
+
+Listed per file rather than globbed, so the coverage loss is visible and shrinks
+file by file as the port lands. ``test_input.py`` imports nothing that was
+removed and keeps running.
+"""
+
+#: Both import ``DuplexFence`` from ``engine.duplex.messages``, which no longer
+#: exports it; ``test_data_plane`` also imports ``engine.duplex.runtime``.
+collect_ignore = ["test_data_plane.py", "test_runtime_contract.py"]
diff --git a/tests/model_executor/models/nemotron_voicechat/duplex/test_data_plane.py b/tests/model_executor/models/nemotron_voicechat/duplex/test_data_plane.py
index 4bdc835d9..04e57c397 100644
--- a/tests/model_executor/models/nemotron_voicechat/duplex/test_data_plane.py
+++ b/tests/model_executor/models/nemotron_voicechat/duplex/test_data_plane.py
@@ -7,9 +7,9 @@ from types import SimpleNamespace
 
 import numpy as np
 import pytest
+from vllm_omni.engine.duplex.runtime import duplex_resource_request_id
 
 from vllm_omni.engine.duplex.messages import DuplexFence
-from vllm_omni.engine.duplex.runtime import duplex_resource_request_id
 from vllm_omni.model_executor.models.nemotron_voicechat.duplex.data_plane import (
     NemotronVoiceChatDataPlaneContext,
     NemotronVoiceChatDataPlaneSession,
diff --git a/tests/model_executor/models/personaplex/duplex/conftest.py b/tests/model_executor/models/personaplex/duplex/conftest.py
new file mode 100644
index 000000000..d49e8c617
--- /dev/null
+++ b/tests/model_executor/models/personaplex/duplex/conftest.py
@@ -0,0 +1,21 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""PersonaPlex duplex is not on the duplex plugin framework yet.
+
+RFC vllm-omni#7181 splits the port: this PR lands the unified framework with
+MiniCPM-o 4.5, and the follow-up PR moves PersonaPlex onto ``DuplexModelPlugin``.
+Until then the modules under test still import the pre-framework duplex
+runtime / serving adapter that this PR removed, so collecting them would fail
+at import time and abort the whole pytest session. The tests themselves are
+unchanged and come back with the port.
+
+Listed per file rather than globbed, so the coverage loss is visible and shrinks
+file by file as the port lands.
+"""
+
+#: ``test_unified_runtime`` imports ``engine.duplex.runtime`` and
+#: ``entrypoints.duplex.runtime_adapter`` directly. ``test_stage0_runtime`` fails
+#: transitively: ``personaplex.duplex.runtime_extension`` imports ``DuplexFence``
+#: from ``engine.duplex.messages``, which no longer exports it.
+collect_ignore = ["test_stage0_runtime.py", "test_unified_runtime.py"]
diff --git a/tests/model_executor/models/personaplex/duplex/test_unified_runtime.py b/tests/model_executor/models/personaplex/duplex/test_unified_runtime.py
index 8d4c1b589..e4f9ad9b1 100644
--- a/tests/model_executor/models/personaplex/duplex/test_unified_runtime.py
+++ b/tests/model_executor/models/personaplex/duplex/test_unified_runtime.py
@@ -8,6 +8,12 @@ from types import SimpleNamespace
 import numpy as np
 import pytest
 from vllm.sampling_params import SamplingParams
+from vllm_omni.engine.duplex.runtime import (
+    DuplexInputMode,
+)
+from vllm_omni.entrypoints.duplex.runtime_adapter import (
+    ServingRuntimeConfigError,
+)
 
 from tests.e2e.online_serving import personaplex_realtime_duplex as e2e_driver
 from vllm_omni.config.stage_config import (
@@ -15,12 +21,6 @@ from vllm_omni.config.stage_config import (
     merge_pipeline_deploy,
 )
 from vllm_omni.engine.duplex.messages import DuplexFence
-from vllm_omni.engine.duplex.runtime import (
-    DuplexInputMode,
-)
-from vllm_omni.entrypoints.duplex.runtime_adapter import (
-    ServingRuntimeConfigError,
-)
 from vllm_omni.model_executor.models.personaplex.duplex.config import DEFAULT_PERSONA
 from vllm_omni.model_executor.models.personaplex.duplex.data_plane import (
     PersonaPlexDataPlaneContext,
@@ -61,7 +61,7 @@ def _audio_client(
     frames[:voiced_frames] = 1000
     raw = frames.tobytes()
     event = {
-        "type": "response.audio.delta",
+        "type": "response.output_audio.delta",
         "response_id": "response-1",
         "sample_rate_hz": e2e_driver.SAMPLE_RATE_HZ,
         "metadata": {
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 13899d47d..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
@@ -11,6 +11,7 @@ Regression test for: https://github.com/vllm-project/vllm/issues/34506
 """
 
 import functools
+from types import SimpleNamespace
 
 import pytest
 import torch
@@ -134,16 +135,15 @@ def make_mock_model(mocker: MockerFixture, hidden: int = 8, thinker_cls=None):
     that has enough structure to run embed_input_ids.
 
     ``thinker_cls`` selects whose ``embed_input_ids`` the mock dispatches to.
-    It defaults to upstream's. Only the interleaved case passes omni's override:
-    omni's non-interleaved path falls through to a zero-arg ``super()`` call,
-    which raises TypeError when ``self`` is a Mock rather than an instance.
+    It defaults to upstream's. Use the selected class as the mock spec so
+    zero-argument ``super()`` in omni's override resolves correctly.
     """
     m = _qwen2_5_omni_thinker_mod()
     Qwen2_5OmniThinkerForConditionalGeneration = m.Qwen2_5OmniThinkerForConditionalGeneration
     if thinker_cls is None:
         thinker_cls = Qwen2_5OmniThinkerForConditionalGeneration
 
-    model = mocker.Mock(spec=Qwen2_5OmniThinkerForConditionalGeneration)
+    model = mocker.Mock(spec=thinker_cls)
 
     # Config with token IDs
     cfg = mocker.Mock()
@@ -157,8 +157,7 @@ def make_mock_model(mocker: MockerFixture, hidden: int = 8, thinker_cls=None):
         # view with shared memory, which masked_scatter_ cannot handle).
         return ids.float().unsqueeze(-1).expand(-1, hidden).clone()
 
-    lang_model = mocker.Mock()
-    lang_model.embed_input_ids = fake_lm_embed
+    lang_model = SimpleNamespace(embed_input_ids=fake_lm_embed)
     model.get_language_model = mocker.Mock(return_value=lang_model)
 
     from vllm.model_executor.models.interfaces import SupportsMultiModal
@@ -271,6 +270,27 @@ class TestEmbedInputIds:
             "Text positions should keep text embeddings"
         )
 
+    @pytest.mark.parametrize(
+        "audio_n,image_n,video_n",
+        [(5, 0, 0), (0, 4, 0), (0, 0, 6), (5, 4, 6)],
+        ids=["audio", "image", "video", "mixed"],
+    )
+    def test_non_interleaved_multimodal_single_embedding(self, mocker: MockerFixture, audio_n, image_n, video_n):
+        """Omni's regular path embeds once through super() and preserves placement."""
+        hidden = 8
+        input_ids, is_multimodal = make_token_seq(audio_n, image_n, video_n)
+        mm_embeds = build_mm_embeds(audio_n, image_n, video_n, hidden)
+        model, _ = make_mock_model(mocker, hidden, thinker_cls=_omni_qwen2_5_thinker_cls())
+        embed = mocker.spy(model.get_language_model(), "embed_input_ids")
+
+        result = model.embed_input_ids(input_ids, mm_embeds, is_multimodal=is_multimodal)
+
+        embed.assert_called_once()
+        expected = input_ids.float().unsqueeze(-1).expand(-1, hidden).clone()
+        for token_id, value in ((AUDIO_TOKEN_ID, 10.0), (IMAGE_TOKEN_ID, 20.0), (VIDEO_TOKEN_ID, 30.0)):
+            expected[input_ids == token_id] = value
+        assert torch.equal(result, expected)
+
     def test_interleaved_use_audio_in_video(self, mocker: MockerFixture):
         """
         Interleaved (use_audio_in_video): video chunks interleaved with audio.
@@ -296,7 +316,9 @@ class TestEmbedInputIds:
         ]
 
         model, _ = make_mock_model(mocker, hidden, thinker_cls=_omni_qwen2_5_thinker_cls())
+        embed = mocker.spy(model.get_language_model(), "embed_input_ids")
         result = model.embed_input_ids(input_ids, mm_embeds, is_multimodal=is_multimodal)
+        embed.assert_called_once()
 
         video_pos = (input_ids == VIDEO_TOKEN_ID).nonzero(as_tuple=True)[0]
         audio_pos = (input_ids == AUDIO_TOKEN_ID).nonzero(as_tuple=True)[0]
@@ -309,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/fixtures/thinker_pp2.yaml b/tests/model_executor/models/qwen3_omni/fixtures/thinker_pp2.yaml
new file mode 100644
index 000000000..56720b49c
--- /dev/null
+++ b/tests/model_executor/models/qwen3_omni/fixtures/thinker_pp2.yaml
@@ -0,0 +1,66 @@
+async_chunk: true
+connectors:
+  connector_of_shared_memory:
+    name: SharedMemoryConnector
+    extra:
+      initial_codec_chunk_frames: 4
+      codec_chunk_frames: 25
+      codec_left_context_frames: 25
+stages:
+- stage_id: 0
+  max_num_batched_tokens: 4096
+  max_num_seqs: 2
+  gpu_memory_utilization: 0.65
+  moe_backend: triton
+  trust_remote_code: true
+  enable_prefix_caching: false
+  devices: 0,1
+  default_sampling_params:
+    temperature: 0.0
+    max_tokens: 128
+  enforce_eager: true
+  max_model_len: 4096
+  async_scheduling: false
+  tensor_parallel_size: 1
+  pipeline_parallel_size: 2
+- stage_id: 1
+  max_num_batched_tokens: 4096
+  max_num_seqs: 2
+  gpu_memory_utilization: 0.2
+  moe_backend: triton
+  trust_remote_code: true
+  enable_prefix_caching: false
+  devices: '1'
+  input_connectors:
+    from_stage_0: connector_of_shared_memory
+  default_sampling_params:
+    temperature: 0.0
+    top_k: 50
+    max_tokens: 1024
+    repetition_penalty: 1.05
+  enforce_eager: true
+  max_model_len: 4096
+  async_scheduling: false
+  tensor_parallel_size: 1
+  pipeline_parallel_size: 1
+- stage_id: 2
+  max_num_batched_tokens: 4096
+  max_num_seqs: 2
+  gpu_memory_utilization: 0.05
+  enforce_eager: true
+  trust_remote_code: true
+  enable_prefix_caching: false
+  enable_chunked_prefill: false
+  async_scheduling: false
+  devices: '1'
+  input_connectors:
+    from_stage_1: connector_of_shared_memory
+  default_sampling_params:
+    temperature: 0.0
+    top_p: 1.0
+    top_k: -1
+    max_tokens: 65536
+    repetition_penalty: 1.1
+  max_model_len: 4096
+  tensor_parallel_size: 1
+  pipeline_parallel_size: 1
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_code2wav_streaming.py b/tests/model_executor/models/qwen3_omni/test_qwen3_omni_code2wav_streaming.py
index 7be4f6afa..69dd4e9ce 100644
--- a/tests/model_executor/models/qwen3_omni/test_qwen3_omni_code2wav_streaming.py
+++ b/tests/model_executor/models/qwen3_omni/test_qwen3_omni_code2wav_streaming.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 ``Qwen3OmniMoeCode2Wav.chunked_decode_streaming``.
 
 Background
@@ -210,26 +210,50 @@ def test_no_shift_when_decoder_returns_nominal_length():
     torch.testing.assert_close(streamed, gt)
 
 
-def test_batched_streaming_only_shifts_the_boundary_row():
-    """Per-row tail: in a shared window the shorter row had right context from
-    the longer row's frames, so it lost nothing (tail==0, no shift); only the
-    row at the decoded boundary (code_seq_len == window length) is shifted."""
-    model = _ShortTrimDecoder()
-    # One window of W=30 frames, two rows. codes[:, 0, :] are absolute indices.
-    idx = torch.arange(30, dtype=torch.long)
-    window = idx.view(1, 1, 30).expand(2, _Q, 30).contiguous()
+@pytest.mark.parametrize("cudagraph", [False, True])
+@pytest.mark.parametrize("trim", [_TRIM, 0])
+@pytest.mark.parametrize("short_frames,left_context", [(1, 0), (4, 0), (29, 4), (26, 25), (37, 25)])
+@pytest.mark.parametrize("reverse", [False, True])
+def test_streaming_batch_matches_independent_requests(cudagraph, trim, short_frames, left_context, reverse):
+    """Padding a request beside a longer one cannot supply valid future codec frames.
 
-    long_frames, short_frames = 30, 20  # row0 spans the full window, row1 is shorter
-    lc = 5
-    out = Qwen3OmniMoeCode2Wav.chunked_decode_streaming(
+    Compare values as well as lengths: an incorrect start and end can shift
+    the whole chunk while preserving its duration. The independent request
+    is the oracle, rather than another copy of the slicing arithmetic.
+    """
+    model = _ShortTrimDecoder(trim=trim, cudagraph=cudagraph)
+    short = _make_codes(short_frames)
+    long = _make_codes(50) + 100
+    windows = [(short, left_context), (long, 25)]
+    if reverse:
+        windows.reverse()
+    batch = torch.zeros(2, _Q, 50, dtype=torch.long)
+    for i, (window, _) in enumerate(windows):
+        batch[i, :, : window.shape[-1]] = window[0]
+    actual = Qwen3OmniMoeCode2Wav.chunked_decode_streaming(
         model,
-        window,
-        left_context_size=[lc, lc],
-        seq_token_counts=[long_frames * _Q, short_frames * _Q],
+        batch,
+        left_context_size=[lc for _, lc in windows],
+        seq_token_counts=[window.numel() for window, _ in windows],
     )
+    assert len(actual) == len(windows)
+    for output, (window, lc) in zip(actual, windows):
+        expected = _decode_chunk(model, window, lc)
+        torch.testing.assert_close(output.reshape(-1), expected, rtol=0, atol=0)
 
-    batch_len = 30 * _UP - _TRIM  # actual decoder output width
-    # Row 0 (boundary row): tail == TRIM -> start = lc*up - TRIM
-    assert out[0].shape[-1] == batch_len - (lc * _UP - _TRIM)
-    # Row 1 (shorter): code_seq_len*up < batch_len -> tail == 0 -> start = lc*up
-    assert out[1].shape[-1] == short_frames * _UP - lc * _UP
+
+@pytest.mark.parametrize("cudagraph", [False, True])
+def test_streaming_preserves_samples_when_batch_composition_changes(cudagraph):
+    """A singleton -> mixed batch -> singleton stream cannot skip then repeat samples."""
+    model = _ShortTrimDecoder(cudagraph=cudagraph)
+    codes = _make_codes(54)
+    first = _decode_chunk(model, codes[:, :, :4], 0)
+    middle_batch = torch.zeros(2, _Q, 50, dtype=torch.long)
+    middle_batch[0, :, :29] = codes[0, :, :29]
+    middle_batch[1] = _make_codes(50)[0] + 100
+    middle = Qwen3OmniMoeCode2Wav.chunked_decode_streaming(
+        model, middle_batch, left_context_size=[4, 25], seq_token_counts=[29 * _Q, 50 * _Q]
+    )[0].reshape(-1)
+    last = _decode_chunk(model, codes[:, :, 4:54], 25)
+    streamed = torch.cat((first, middle, last))
+    torch.testing.assert_close(streamed, _single_shot(model, codes), rtol=0, atol=0)
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_omni/test_qwen3_omni_pp_capture.py b/tests/model_executor/models/qwen3_omni/test_qwen3_omni_pp_capture.py
new file mode 100644
index 000000000..de8d02e3e
--- /dev/null
+++ b/tests/model_executor/models/qwen3_omni/test_qwen3_omni_pp_capture.py
@@ -0,0 +1,115 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Required Thinker snapshots must survive consecutive pipeline ranks.
+
+Actual forward methods with deterministic decoder doubles test the contract
+without model weights. Distributed serving remains a separate integration gate.
+"""
+
+from types import SimpleNamespace
+
+import pytest
+import torch
+from torch import nn
+from vllm.model_executor.models.utils import make_empty_intermediate_tensors_factory
+from vllm.sequence import IntermediateTensors
+
+from vllm_omni.model_executor.models.qwen3_omni import qwen3_omni as combined_module
+from vllm_omni.model_executor.models.qwen3_omni import qwen3_omni_moe_thinker as thinker_module
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.parallel]
+
+
+class _Layer(nn.Module):
+    def forward(self, positions, hidden_states, residual):
+        total = hidden_states if residual is None else hidden_states + residual
+        return total * 0.01 + 0.125, total
+
+
+class _Norm(nn.Module):
+    def forward(self, hidden_states, residual):
+        return hidden_states + residual, None
+
+
+def _forward(monkeypatch, start, end, embeddings, intermediate=None, *, capture=True):
+    rank = SimpleNamespace(is_first_rank=start == 0, is_last_rank=end == 48)
+    monkeypatch.setattr(thinker_module, "get_pp_group", lambda: rank)
+    model = object.__new__(thinker_module.Qwen3MoeLLMModel)
+    nn.Module.__init__(model)
+    model.start_layer = start
+    model.end_layer = end
+    model.layers = nn.ModuleList([_Layer() for _ in range(48)])
+    model.norm = _Norm()
+    return model.forward(
+        input_ids=None,
+        positions=torch.arange(embeddings.shape[0]),
+        inputs_embeds=embeddings,
+        intermediate_tensors=intermediate,
+        capture_layer_indices=[0, 24] if capture else None,
+        return_hidden_states=capture,
+    )
+
+
+@pytest.mark.parametrize("tokens", [1, 4])
+@pytest.mark.parametrize("boundaries", [(0, 12, 48), (0, 24, 48), (0, 36, 48), (0, 16, 32, 48)])
+def test_required_captures_match_unsplit_forward(monkeypatch, tokens, boundaries):
+    embeddings = torch.arange(tokens * 8, dtype=torch.float32).reshape(tokens, 8) / 8
+    reference, captures = _forward(monkeypatch, 0, 48, embeddings)
+    intermediate = None
+    for start, end in zip(boundaries, boundaries[1:]):
+        result = _forward(monkeypatch, start, end, embeddings, intermediate)
+        if end < 48:
+            assert isinstance(result, IntermediateTensors)
+            assert all(isinstance(value, torch.Tensor) for value in result.tensors.values())
+            intermediate = result
+    actual, actual_captures = result
+    torch.testing.assert_close(actual, reference, rtol=0, atol=0)
+    actual_layers = actual_captures["hidden_states"]["layers"]
+    assert set(actual_layers) == {0, 24}
+    for key in (0, 24):
+        torch.testing.assert_close(actual_layers[key], captures["hidden_states"]["layers"][key], rtol=0, atol=0)
+    # A later receive into the rank's persistent buffers cannot rewrite snapshots.
+    assert intermediate is not None
+    for value in intermediate.tensors.values():
+        value.zero_()
+    for key in (0, 24):
+        torch.testing.assert_close(actual_layers[key], captures["hidden_states"]["layers"][key], rtol=0, atol=0)
+
+
+def test_capture_disabled_keeps_original_intermediate_schema(monkeypatch):
+    embeddings = torch.ones(4, 8)
+    first = _forward(monkeypatch, 0, 24, embeddings, capture=False)
+    assert set(first.tensors) == {"hidden_states", "residual"}
+    actual, captures = _forward(monkeypatch, 24, 48, embeddings, first, capture=False)
+    reference, _ = _forward(monkeypatch, 0, 48, embeddings, capture=False)
+    assert captures is None
+    torch.testing.assert_close(actual, reference, rtol=0, atol=0)
+
+
+@pytest.mark.parametrize(
+    "start,expected", [(0, set()), (16, {"capture_0"}), (24, {"capture_0"}), (32, {"capture_0", "capture_24"})]
+)
+@pytest.mark.parametrize("staged", [False, True])
+def test_factory_declares_only_captures_from_earlier_ranks(monkeypatch, start, expected, staged):
+    thinker_config = SimpleNamespace(text_config=SimpleNamespace(hidden_size=8))
+    config = SimpleNamespace(
+        thinker_config=thinker_config,
+        talker_config=SimpleNamespace(accept_hidden_layer=24),
+        code2wav_config=SimpleNamespace(),
+        tts_bos_token_id=1,
+        tts_eos_token_id=2,
+        tts_pad_token_id=3,
+    )
+    model_config = SimpleNamespace(hf_config=config, multimodal_config=None)
+    if staged:
+        model_config.model_stage = "thinker"
+    vllm_config = SimpleNamespace(model_config=model_config, with_hf_config=lambda *args, **kwargs: None)
+    thinker = nn.Module()
+    thinker.weight = nn.Parameter(torch.ones(1))
+    thinker.language_model = SimpleNamespace(model=SimpleNamespace(start_layer=start))
+    thinker.make_empty_intermediate_tensors = make_empty_intermediate_tensors_factory(["hidden_states", "residual"], 8)
+    monkeypatch.setattr(combined_module, "init_vllm_registered_model", lambda **kwargs: thinker)
+    model = combined_module.Qwen3OmniMoeForConditionalGeneration(vllm_config=vllm_config)
+    buffers = model.make_empty_intermediate_tensors(4, dtype=torch.float32, device="cpu")
+    assert set(buffers.tensors) == {"hidden_states", "residual"} | (expected if staged else set())
+    assert all(value.shape == (4, 8) for value in buffers.tensors.values())
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 438a5ec1d..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
@@ -572,6 +572,53 @@ class TestCodePredictorPerRowGenerators:
 class TestCodePredictorModelDtype:
     """Test the inner model forward with different dtypes."""
 
+    @pytest.mark.parametrize(
+        ("device_type", "expect_fp32"),
+        [("cpu", False), ("npu", False), ("xpu", True), ("musa", True), ("cuda", True)],
+    )
+    def test_fp32_fallback_excludes_cpu_and_npu(
+        self,
+        mocker: MockerFixture,
+        loaded_target_classes,
+        device_type: str,
+        expect_fp32: bool,
+    ) -> None:
+        """The stability fallback preserves accelerator behavior except on NPU."""
+        _, _, _, code_predictor_model, _ = loaded_target_classes
+        common_mod = sys.modules["vllm_omni.model_executor.models.common.qwen3_code_predictor"]
+
+        inputs = mocker.MagicMock()
+        inputs.dtype = torch.float16
+        inputs.device.type = device_type
+        fp32_inputs = mocker.MagicMock()
+        fp32_inputs.device.type = device_type
+        inputs.float.return_value = fp32_inputs
+        model = object.__new__(code_predictor_model)
+        torch.nn.Module.__init__(model)
+        model.rotary_emb = mocker.Mock(return_value=None)
+        model.layers = []
+        model.norm = mocker.Mock(side_effect=lambda hidden_states: hidden_states)
+        autocast = mocker.patch.object(
+            common_mod.torch.amp,
+            "autocast",
+            return_value=mocker.MagicMock(
+                __enter__=mocker.Mock(),
+                __exit__=mocker.Mock(return_value=False),
+            ),
+        )
+
+        code_predictor_model.forward(model, inputs, mocker.MagicMock())
+
+        if expect_fp32:
+            inputs.float.assert_called_once_with()
+        else:
+            inputs.float.assert_not_called()
+        autocast.assert_called_once_with(
+            device_type,
+            enabled=expect_fp32,
+            dtype=torch.float32,
+        )
+
     def test_model_forward_float16(self, loaded_target_classes) -> None:
         """Inner model forward should work in float16."""
         _, _, _, code_predictor_model, _ = loaded_target_classes
@@ -601,6 +648,68 @@ class TestCodePredictorModelDtype:
         assert output.shape == (bsz, seq_len, 32)
 
 
+class TestCodePredictorGraphReplay:
+    """Test nested device graph handling for the shared code predictor."""
+
+    @pytest.mark.parametrize("is_capturing", [False, True])
+    def test_npu_outer_capture_skips_inner_graph_replay(
+        self,
+        mocker: MockerFixture,
+        loaded_target_classes,
+        is_capturing: bool,
+    ) -> None:
+        _, _, code_predictor_wrapper, _, code_predictor_wrapper_config = loaded_target_classes
+        common_mod = sys.modules["vllm_omni.model_executor.models.common.qwen3_code_predictor"]
+
+        predictor = object.__new__(code_predictor_wrapper)
+        torch.nn.Module.__init__(predictor)
+        predictor._num_groups = 3
+        predictor._model_dtype = torch.float32
+        predictor._setup_compile = mocker.Mock()
+        predictor._padded_bsz = mocker.Mock(side_effect=lambda bsz: bsz)
+        predictor._ensure_buffers = mocker.Mock()
+        predictor._proj_buf = torch.zeros(1, 4, 4)
+        predictor.small_to_mtp_projection = torch.nn.Identity()
+        regular_output = torch.zeros(1, 4, 4)
+        predictor._compiled_model_fwd = mocker.Mock(return_value=regular_output)
+        predictor._lm_heads_list = [
+            torch.nn.Linear(4, 8, bias=False),
+            torch.nn.Linear(4, 8, bias=False),
+        ]
+        predictor._codec_embeds_list = [torch.nn.Embedding(8, 4)]
+        predictor._wrapper_config = code_predictor_wrapper_config(
+            sampling_mode="per_call",
+            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)
+        predictor._device_graphs = {1: (graph, graph_output)}
+
+        mocker.patch.object(common_mod.current_omni_platform, "is_npu", return_value=True)
+        npu_mock = mocker.MagicMock()
+        npu_mock.is_current_stream_capturing.return_value = is_capturing
+        mocker.patch.object(common_mod.torch, "npu", npu_mock, create=True)
+
+        result = predictor(
+            layer0_code=torch.zeros(1, dtype=torch.long),
+            layer0_embed=torch.zeros(1, 4),
+            last_talker_hidden=torch.zeros(1, 4),
+            do_sample=False,
+        )
+
+        assert result.shape == (1, 3)
+        npu_mock.is_current_stream_capturing.assert_called_once_with()
+        if is_capturing:
+            graph.replay.assert_not_called()
+            assert predictor._compiled_model_fwd.call_count == 2
+        else:
+            assert graph.replay.call_count == 2
+            predictor._compiled_model_fwd.assert_not_called()
+
+
 class TestCodePredictorWrapperConfig:
     """Test wrapper configuration for different models."""
 
@@ -1254,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_code2wav.py b/tests/model_executor/models/qwen3_tts/test_qwen3_tts_code2wav.py
index 64f9ac8de..8ad2b519f 100644
--- a/tests/model_executor/models/qwen3_tts/test_qwen3_tts_code2wav.py
+++ b/tests/model_executor/models/qwen3_tts/test_qwen3_tts_code2wav.py
@@ -23,7 +23,7 @@ class _FakeDecoder(nn.Module):
     def __init__(self, total_upsample: int = _TOTAL_UPSAMPLE):
         super().__init__()
         self.total_upsample = total_upsample
-        self.decode_calls: list[dict[str, int]] = []
+        self.decode_calls: list[dict[str, int | tuple[int, ...]]] = []
         self.batched_decode_calls: list[dict[str, object]] = []
         self.decode_codes: list[torch.Tensor] = []
         self.cudagraph_calls: list[dict[str, int | torch.device]] = []
@@ -63,7 +63,7 @@ class _FakeDecoder(nn.Module):
         chunk_size: int = 300,
         left_context_size: int = 25,
         max_batch_size: int = 0,
-    ) -> torch.Tensor:
+    ) -> list[torch.Tensor]:
         self.batched_decode_calls.append(
             {
                 "chunk_size": chunk_size,
@@ -91,8 +91,8 @@ class _FakeDecoder(nn.Module):
         wav_len = frames * self.total_upsample + 6
         wav = torch.arange(wav_len, dtype=torch.float32).view(1, 1, -1)
         offsets = torch.arange(batch, dtype=torch.float32).view(batch, 1, 1) * 1000
-        outputs = wav.expand(batch, 1, wav_len) + offsets
-        return [outputs[row, :, : lengths[row] * self.total_upsample] for row in range(batch)]
+        batched_wav = wav.expand(batch, 1, wav_len) + offsets
+        return [batched_wav[row, :, : lengths[row] * self.total_upsample] for row in range(batch)]
 
     def enable_cudagraph(self, **kwargs):
         self.cudagraph_calls.append(kwargs)
@@ -131,6 +131,7 @@ def _make_model(
                 load_config=SimpleNamespace(),
                 model_config=SimpleNamespace(
                     model="unused",
+                    dtype=torch.bfloat16,
                     revision=None,
                     stage_connector_config=stage_connector_config,
                     async_chunk=async_chunk,
@@ -708,3 +709,16 @@ def test_invalid_decode_chunking_is_rejected():
 
     with pytest.raises(ValueError, match="decode_chunk_frames=0"):
         _load_weights_noop(model)
+
+
+@pytest.mark.parametrize("dtype", [torch.float32, torch.bfloat16, torch.float16])
+def test_load_weights_uses_model_dtype_before_precomputing_caches(dtype):
+    model = _make_model()
+    model.vllm_config.model_config.dtype = dtype
+    model.decoder = nn.Linear(2, 2)
+    cache_dtypes = []
+    model.decoder.precompute_snake_caches = lambda: cache_dtypes.append(model.decoder.weight.dtype)
+
+    assert _load_weights_noop(model) == {"decoder.fake_weight"}
+    assert model.decoder.weight.dtype is dtype
+    assert cache_dtypes == [dtype]
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
new file mode 100644
index 000000000..110a0259a
--- /dev/null
+++ b/tests/model_executor/models/test_minimax_h3_encoder_payload.py
@@ -0,0 +1,591 @@
+# 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
+
+import pytest
+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
+
+    encoder, diffusion = MINIMAX_H3_PIPELINE.stages
+    assert encoder.model_arch == "MiniMaxH3Encoder"
+    assert encoder.custom_process_next_stage_input_func is None
+    assert diffusion.model_arch == "MiniMaxH3Pipeline"
+    assert diffusion.requires_multimodal_data is False
+    assert diffusion.requires_full_payload_input is False
+
+
+def _patch_encoder_constructors(monkeypatch, *, rank: int):
+    from vllm_omni.model_executor.models.minimax_h3 import encoder as encoder_module
+
+    group = SimpleNamespace(rank_in_group=rank, world_size=2, device_group=object())
+
+    class FakeVideoVAE(torch.nn.Module):
+        def __init__(self, path, *, device, encode_only, trust_remote_code):
+            super().__init__()
+            self.path = path
+            self.parallel_args = None
+            self.trust_remote_code = trust_remote_code
+
+        def set_parallel_size(self, size, *, process_group):
+            self.parallel_args = (size, process_group)
+
+    class FakeAudioVAE(torch.nn.Module):
+        def __init__(self, path, *, device, encode_only, trust_remote_code):
+            super().__init__()
+            self.path = path
+            self.trust_remote_code = trust_remote_code
+
+    def init_backbone(self, *, vllm_config, prefix):
+        torch.nn.Module.__init__(self)
+
+    monkeypatch.setattr(encoder_module.MiniMaxH3TextEncoderBackbone, "__init__", init_backbone)
+    monkeypatch.setattr(encoder_module, "get_tp_group", lambda: group)
+    monkeypatch.setattr(encoder_module, "get_local_device", lambda: torch.device("cpu"))
+    monkeypatch.setattr(encoder_module, "MiniMaxH3VideoVAE", FakeVideoVAE)
+    monkeypatch.setattr(encoder_module, "MiniMaxH3AudioVAE", FakeAudioVAE)
+    return encoder_module, group
+
+
+def _component_root(tmp_path):
+    root = tmp_path / "FL2VA"
+    for name in ("text_encoder", "video_vae", "audio_vae"):
+        (root / name).mkdir(parents=True)
+    return root
+
+
+def _encoder_config(root, *, video_mode="patch", roles=None, trust_remote_code=True):
+    components = (
+        {
+            "text_encoder": {"parallel_mode": "tp"},
+            "video_vae": {"parallel_mode": video_mode},
+            "audio_vae": {"parallel_mode": "leader"},
+        }
+        if roles is None
+        else roles
+    )
+    return SimpleNamespace(
+        model_config=SimpleNamespace(
+            model=str(root / "text_encoder"),
+            hf_config=SimpleNamespace(minimax_h3_encoder_components=components),
+            trust_remote_code=trust_remote_code,
+        )
+    )
+
+
+def test_encoder_requires_exactly_three_components(monkeypatch, tmp_path) -> None:
+    encoder_module, _ = _patch_encoder_constructors(monkeypatch, rank=0)
+    root = tmp_path / "FL2VA"
+    (root / "text_encoder").mkdir(parents=True)
+    (root / "video_vae").mkdir()
+    config = _encoder_config(root)
+
+    with pytest.raises(RuntimeError, match=r"requires all three encoders.*audio_vae"):
+        encoder_module.MiniMaxH3Encoder(vllm_config=config)
+
+
+@pytest.mark.parametrize(("rank", "has_audio_vae"), [(0, True), (1, False)])
+@pytest.mark.parametrize("trust_remote_code", [False, True])
+def test_encoder_uses_tp_patch_and_leader_on_the_same_rank_set(
+    monkeypatch,
+    tmp_path,
+    rank,
+    has_audio_vae,
+    trust_remote_code,
+) -> None:
+    encoder_module, group = _patch_encoder_constructors(monkeypatch, rank=rank)
+    root = _component_root(tmp_path)
+    config = _encoder_config(root, trust_remote_code=trust_remote_code)
+
+    model = encoder_module.MiniMaxH3Encoder(vllm_config=config)
+
+    assert model.component_config.text_parallel_mode == "tp"
+    assert model.component_config.video_parallel_mode == "patch"
+    assert model.component_config.audio_parallel_mode == "leader"
+    assert model.video_vae.parallel_args == (2, group.device_group)
+    assert model.video_vae.trust_remote_code is trust_remote_code
+    assert (model.audio_vae is not None) is has_audio_vae
+    if has_audio_vae:
+        assert model.audio_vae.trust_remote_code is trust_remote_code
+
+
+@pytest.mark.parametrize("component", ["video", "audio"])
+@pytest.mark.parametrize("trusted", [False, True])
+def test_encoder_only_vae_requires_remote_code_trust(monkeypatch, component, trusted) -> None:
+    from vllm_omni.diffusion.models.minimax_h3 import vae as vae_module
+
+    config = {"auto_map": {"AutoModel": "modeling.RemoteVAE"}, "sample_rate": 32000}
+    monkeypatch.setattr(vae_module, "_load_component_config", lambda _path: config)
+    remote = torch.nn.Module()
+    remote.model = torch.nn.Module()
+    calls = []
+
+    def load_encoder(path, config_dict):
+        calls.append((path, config_dict))
+        return remote
+
+    monkeypatch.setattr(vae_module, f"_load_{component}_vae_encoder", load_encoder)
+    vae_cls = vae_module.MiniMaxH3VideoVAE if component == "video" else vae_module.MiniMaxH3AudioVAE
+    if trusted:
+        model = vae_cls("unused", device=torch.device("cpu"), encode_only=True, trust_remote_code=True)
+        assert model.remote is remote
+        assert calls == [("unused", config)]
+    else:
+        with pytest.raises(ValueError, match="trust-remote-code"):
+            vae_cls("unused", device=torch.device("cpu"), encode_only=True)
+        assert calls == []
+
+
+def test_encoder_requires_all_role_policies(monkeypatch, tmp_path) -> None:
+    encoder_module, _ = _patch_encoder_constructors(monkeypatch, rank=0)
+    root = _component_root(tmp_path)
+    config = _encoder_config(
+        root,
+        roles={
+            "text_encoder": {"parallel_mode": "tp"},
+            "video_vae": {"parallel_mode": "patch"},
+        },
+    )
+
+    with pytest.raises(ValueError, match=r"requires exactly.*audio_vae"):
+        encoder_module.MiniMaxH3Encoder(vllm_config=config)
+
+
+def test_encoder_does_not_infer_role_policies(monkeypatch, tmp_path) -> None:
+    encoder_module, _ = _patch_encoder_constructors(monkeypatch, rank=0)
+    root = _component_root(tmp_path)
+    config = SimpleNamespace(
+        model_config=SimpleNamespace(
+            model=str(root / "text_encoder"),
+            hf_config=SimpleNamespace(),
+        )
+    )
+
+    with pytest.raises(ValueError, match="requires explicit minimax_h3_encoder_components"):
+        encoder_module.MiniMaxH3Encoder(vllm_config=config)
+
+
+def test_video_leader_policy_skips_nonleader(monkeypatch, tmp_path) -> None:
+    encoder_module, _ = _patch_encoder_constructors(monkeypatch, rank=1)
+    root = _component_root(tmp_path)
+    model = encoder_module.MiniMaxH3Encoder(vllm_config=_encoder_config(root, video_mode="leader"))
+
+    assert model.video_vae is None
+    assert model.audio_vae is None
+    assert (
+        model._encode_media(
+            MiniMaxH3EncoderMediaInput(
+                task="ref2va",
+                height=32,
+                width=32,
+                num_frames=48,
+                latent_t=1,
+                audio_t=80,
+                images=(torch.zeros(32, 32, 3, dtype=torch.uint8),),
+            )
+        )
+        is None
+    )
+
+
+def test_encoder_runs_video_and_audio_components_on_ar_model() -> None:
+    from vllm_omni.model_executor.models.minimax_h3.encoder import MiniMaxH3Encoder
+
+    class VideoVAE:
+        def encode_image(self, _image):
+            return torch.ones(1, 96)
+
+        def encode_video(self, _frames):
+            return torch.full((1, 96), 2.0), (1, 2, 2)
+
+    class AudioVAE:
+        def encode_waveform(self, waveform, _sample_rate):
+            return torch.ones(160, 32), waveform.shape[-1] // 800
+
+    model = MiniMaxH3Encoder.__new__(MiniMaxH3Encoder)
+    torch.nn.Module.__init__(model)
+    model._component_leader = True
+    model.video_vae = VideoVAE()
+    model.audio_vae = AudioVAE()
+    media = MiniMaxH3EncoderMediaInput(
+        task="ref2va",
+        height=32,
+        width=32,
+        num_frames=48,
+        latent_t=1,
+        audio_t=80,
+        images=(torch.zeros(32, 32, 3, dtype=torch.uint8),),
+        videos=(torch.zeros(1, 32, 32, 3, dtype=torch.uint8),),
+        video_audios=((torch.zeros(64_000), 32_000),),
+    )
+
+    conditioning = model._encode_media(media)
+
+    assert conditioning is not None
+    assert conditioning.visual_condition_shapes == ((1, 2, 2), (1, 2, 2))
+    assert conditioning.audio_condition_lengths == (80,)
+    assert conditioning.ref_blocks[1]["kind"] == "video_audio"
+
+
+def test_prepare_encoder_inputs_keeps_reference_audio_budgets_separate(monkeypatch) -> None:
+    from vllm_omni.model_executor.models.minimax_h3 import encoder_processing as processing
+
+    frames = torch.zeros(1, 32, 32, 3, dtype=torch.uint8).numpy()
+    waveform = torch.zeros(320_000)
+    monkeypatch.setattr(processing, "resolve_minimax_h3_shape", lambda *_args: (32, 32, 240, 60, 400))
+    monkeypatch.setattr(
+        processing,
+        "prepare_reference_videos",
+        lambda *_args, **_kwargs: [
+            {"prepared_path": "prepared.mp4", "original_path": "reference.mp4", "input_has_audio": True}
+        ],
+    )
+    monkeypatch.setattr(processing, "load_video_frames", lambda _path: frames)
+    monkeypatch.setattr(
+        processing,
+        "sample_reference_video_frames",
+        lambda *_args, **_kwargs: {"frames": [frames[0]], "block_timestamps": [[0.0]]},
+    )
+    monkeypatch.setattr(processing, "load_video_audio", lambda *_args, **_kwargs: (waveform, 32_000))
+
+    prepared = processing.prepare_encoder_inputs(
+        {
+            "prompt": "reference",
+            "multi_modal_data": {"video": "reference.mp4", "audio": (waveform, 32_000)},
+        },
+        SimpleNamespace(extra_args={"task": "ref2va"}),
+    )
+
+    assert prepared.media.video_audios[0][0].shape[-1] == 320_000
+    assert prepared.media.audios[0][0].shape[-1] == 320_000
+    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)],
+)
+def test_encode_media_keeps_audio_budgets_and_component_residency_separate(
+    embedded_lengths, standalone_lengths, valid
+) -> None:
+    from vllm_omni.model_executor.models.minimax_h3.encoder_processing import encode_media
+
+    active = None
+    scopes = []
+
+    class VideoVAE:
+        def encode_image(self, _image):
+            assert active is self
+            return torch.ones(1, 96)
+
+        def encode_video(self, _frames):
+            assert active is self
+            return torch.ones(1, 96), (1, 2, 2)
+
+    class AudioVAE:
+        def encode_waveform(self, waveform, _sample_rate):
+            assert active is self
+            length = waveform.shape[-1] // 800
+            return torch.ones(2 * length, 32), length
+
+    @contextmanager
+    def component_scope(component):
+        nonlocal active
+        assert active is None
+        active = component
+        scopes.append(component)
+        try:
+            yield
+        finally:
+            active = None
+
+    video_vae = VideoVAE()
+    audio_vae = AudioVAE()
+    media = MiniMaxH3EncoderMediaInput(
+        task="ref2va",
+        height=32,
+        width=32,
+        num_frames=360,
+        latent_t=90,
+        audio_t=600,
+        images=(torch.zeros(32, 32, 3, dtype=torch.uint8),),
+        videos=tuple(torch.zeros(1, 32, 32, 3, dtype=torch.uint8) for _ in embedded_lengths),
+        video_audios=tuple((torch.zeros(length * 800), 32_000) for length in embedded_lengths),
+        audios=tuple((torch.zeros(length * 800), 32_000) for length in standalone_lengths),
+    )
+    kwargs = dict(video_vae=video_vae, audio_vae=audio_vae, emit_conditioning=True, component_scope=component_scope)
+    if valid:
+        conditioning = encode_media(media, **kwargs)
+        assert conditioning.audio_condition_lengths == embedded_lengths + standalone_lengths
+        assert [block["kind"] for block in conditioning.ref_blocks] == ["image", "video_audio", "audio"]
+        conditioning.to_omni_components()
+    else:
+        with pytest.raises(ValueError, match="at most 15 seconds"):
+            encode_media(media, **kwargs)
+    assert scopes == [video_vae, audio_vae]
+
+
+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),
+        task="t2va",
+        height=256,
+        width=448,
+        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",
+        outputs=[SimpleNamespace(multimodal_output=flatten_payload(expected.to_omni_payload()))],
+    )
+    prompt = {
+        "prompt": "hello",
+        "additional_information": {"global_request_id": ["request-1"]},
+    }
+
+    result = encoder2diffusion([source], prompt)
+
+    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:
+    from vllm_omni.model_executor.models.minimax_h3 import encoder as encoder_module
+
+    model = encoder_module.MiniMaxH3Encoder.__new__(encoder_module.MiniMaxH3Encoder)
+    torch.nn.Module.__init__(model)
+    model._component_leader = True
+    model._token_tags = torch.tensor([1])
+    info = {
+        "meta": {"minimax_h3_encoder_request": {}},
+        "_minimax_h3_encoder_media_conditioning": MiniMaxH3EncoderMediaConditioning(
+            task="t2va",
+            height=256,
+            width=448,
+            num_frames=17,
+            latent_t=5,
+            audio_t=10,
+        ),
+    }
+    empty_cache_calls = 0
+
+    def empty_cache() -> None:
+        nonlocal empty_cache_calls
+        empty_cache_calls += 1
+
+    monkeypatch.setattr(torch.accelerator, "empty_cache", empty_cache)
+    output = model.make_omni_output(
+        torch.zeros(1, 5120),
+        model_intermediate_buffer=[info],
+        request_sample_eligible=[True],
+    )
+
+    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/test_minimax_music3_dit_attention.py b/tests/model_executor/models/test_minimax_music3_dit_attention.py
new file mode 100644
index 000000000..cdbb57796
--- /dev/null
+++ b/tests/model_executor/models/test_minimax_music3_dit_attention.py
@@ -0,0 +1,117 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Attention dtype routing for MiniMax Music 3's float32 acoustic stage."""
+
+from __future__ import annotations
+
+import pytest
+import torch
+from torch import nn
+
+from vllm_omni.model_executor.models.minimax_music3 import dit
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+_FLOAT32_INCOMPATIBLE_BACKENDS = [
+    "FLASH_ATTN",
+    "FLASH_ATTN_HUB",
+    "FLASH_ATTN_3_HUB",
+    "CUDNN_ATTN",
+    "FLASHINFER_ATTN",
+]
+
+
+class _BackendType:
+    def __init__(self, name: str) -> None:
+        self.name = name
+
+    def get_name(self) -> str:
+        return self.name
+
+
+class _Backend(nn.Module):
+    def __init__(self, *, name: str, explicit: bool) -> None:
+        super().__init__()
+        self.attn_backend = _BackendType(name)
+        self.backend_explicit = explicit
+        self.calls = 0
+
+    def forward(self, q, k, v):
+        del k, v
+        self.calls += 1
+        return torch.full_like(q, 7)
+
+
+def _attention(monkeypatch, *, backend_name: str, explicit: bool):
+    backend = _Backend(name=backend_name, explicit=explicit)
+    monkeypatch.setattr(dit, "_build_native_attention", lambda **_kwargs: backend)
+    return dit.Attention(8, head_dim=4), backend
+
+
+@pytest.mark.parametrize(
+    "backend_name",
+    _FLOAT32_INCOMPATIBLE_BACKENDS,
+)
+def test_float32_uses_sdpa_for_automatic_incompatible_backend(monkeypatch, backend_name):
+    attention, backend = _attention(monkeypatch, backend_name=backend_name, explicit=False)
+    q = torch.randn(2, 5, 2, 4)
+
+    actual = attention._attend(q, q, q)
+
+    expected = torch.nn.functional.scaled_dot_product_attention(
+        q.transpose(1, 2),
+        q.transpose(1, 2),
+        q.transpose(1, 2),
+        is_causal=False,
+        scale=attention.softmax_scale,
+    ).transpose(1, 2)
+    torch.testing.assert_close(actual, expected)
+    assert backend.calls == 0
+    assert attention.backend_name == f"TORCH_SDPA(float32)/{backend_name}(lower precision)"
+
+
+@pytest.mark.parametrize("backend_name", _FLOAT32_INCOMPATIBLE_BACKENDS)
+@pytest.mark.parametrize(
+    ("dtype", "explicit"),
+    [
+        (torch.float16, False),
+        (torch.bfloat16, False),
+        (torch.float32, True),
+    ],
+)
+def test_lower_precision_or_explicit_backend_remains_authoritative(monkeypatch, backend_name, dtype, explicit):
+    attention, backend = _attention(monkeypatch, backend_name=backend_name, explicit=explicit)
+    q = torch.zeros(1, 3, 2, 4, dtype=dtype)
+
+    actual = attention._attend(q, q, q)
+
+    assert backend.calls == 1
+    torch.testing.assert_close(actual, torch.full_like(q, 7))
+
+
+def test_float32_uses_sdpa_when_native_attention_is_unavailable(monkeypatch):
+    monkeypatch.setattr(dit, "_build_native_attention", lambda **_kwargs: None)
+    attention = dit.Attention(8, head_dim=4)
+    q = torch.randn(1, 3, 2, 4)
+
+    actual = attention._attend(q, q, q)
+
+    expected = torch.nn.functional.scaled_dot_product_attention(
+        q.transpose(1, 2),
+        q.transpose(1, 2),
+        q.transpose(1, 2),
+        is_causal=False,
+        scale=attention.softmax_scale,
+    ).transpose(1, 2)
+    torch.testing.assert_close(actual, expected)
+    assert attention.backend_name == "TORCH_SDPA"
+
+
+def test_float32_keeps_compatible_automatic_backend(monkeypatch):
+    attention, backend = _attention(monkeypatch, backend_name="SDPA", explicit=False)
+    q = torch.zeros(1, 3, 2, 4)
+
+    actual = attention._attend(q, q, q)
+
+    assert backend.calls == 1
+    torch.testing.assert_close(actual, torch.full_like(q, 7))
diff --git a/tests/model_executor/models/test_model_local_kv.py b/tests/model_executor/models/test_model_local_kv.py
new file mode 100644
index 000000000..5e2c9cdca
--- /dev/null
+++ b/tests/model_executor/models/test_model_local_kv.py
@@ -0,0 +1,404 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""A declaration must match the cache that actually gets allocated.
+
+Two earlier versions of this file could not fail. The first asserted hand-typed
+constants against each other. The second built real `transformers` caches but
+compared them to specs written in the test, so no production declaration was
+ever executed. What matters here is that a real declarer is called and its
+numbers are checked against a real cache built the way the model builds it.
+"""
+
+import ast
+import pathlib
+from types import SimpleNamespace
+
+import pytest
+import torch
+from transformers import Qwen2Config
+from transformers.cache_utils import DynamicCache, StaticCache
+
+from vllm_omni.model_executor.models.model_local_kv import (
+    HasModelLocalKV,
+    ModelLocalKVScope,
+    ModelLocalKVSpec,
+    RowDriver,
+    collect_model_local_kv_specs,
+    spec_from_hf_config,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+MODELS_DIR = pathlib.Path(__file__).resolve().parents[3] / "vllm_omni" / "model_executor" / "models"
+
+
+def _total_bytes(model: object, max_num_seqs: int = 1) -> int:
+    """Sum declared peak bytes across a model's declarations."""
+    return sum(spec.peak_bytes(max_num_seqs) for _, spec in collect_model_local_kv_specs(model))
+
+
+def _cache_bytes(cache) -> int:
+    total = 0
+    for layer in cache.layers:
+        for tensor in (layer.keys, layer.values):
+            if tensor is not None:
+                total += tensor.numel() * tensor.element_size()
+    return total
+
+
+def _qwen2_config(layers=4, kv_heads=2, heads=8, hidden=256) -> Qwen2Config:
+    return Qwen2Config(
+        num_hidden_layers=layers,
+        num_attention_heads=heads,
+        num_key_value_heads=kv_heads,
+        hidden_size=hidden,
+        intermediate_size=hidden * 2,
+        vocab_size=1000,
+    )
+
+
+# --------------------------------------------------------------------------
+# A real declarer, called, checked against a real cache.
+# --------------------------------------------------------------------------
+
+
+def test_ming_declaration_matches_the_cache_it_describes():
+    """Calls MingAudioGenerator.model_local_kv_specs and checks the bytes.
+
+    Builds the declarer without its weights -- only `_llm_config` and `_model`
+    are read -- then builds the `StaticCache` that `_init_kv_cache` builds from
+    the same config and compares. A wrong layer count, kv-head count, dtype or
+    capacity in the production declaration fails here.
+    """
+    from vllm_omni.model_executor.models.ming_flash_omni.talker_module import MingAudioGenerator
+
+    config = _qwen2_config()
+    generator = object.__new__(MingAudioGenerator)
+    generator._llm_config = config
+    generator._model = torch.nn.Linear(1, 1).to(torch.float16)
+
+    (spec,) = generator.model_local_kv_specs()
+
+    cache = StaticCache(
+        config=config,
+        max_batch_size=1,
+        max_cache_len=MingAudioGenerator._STATIC_CACHE_LEN,
+        device="cpu",
+        dtype=torch.float16,
+    )
+    head_dim = config.hidden_size // config.num_attention_heads
+    for layer_idx in range(config.num_hidden_layers):
+        keys = torch.zeros(1, config.num_key_value_heads, 1, head_dim, dtype=torch.float16)
+        cache.update(keys, keys.clone(), layer_idx)
+
+    assert spec.peak_bytes(1) == _cache_bytes(cache)
+
+
+def test_ming_does_not_scale_with_max_num_seqs():
+    """forward() takes runtime_additional_information[0] and loops inline.
+
+    One worker holds one of these no matter how many sequences the scheduler
+    admits. A previous revision derived the multiplier from scope and reported
+    `max_num_seqs` times the real figure.
+    """
+    from vllm_omni.model_executor.models.ming_flash_omni.talker_module import MingAudioGenerator
+
+    generator = object.__new__(MingAudioGenerator)
+    generator._llm_config = _qwen2_config()
+    generator._model = torch.nn.Linear(1, 1).to(torch.float16)
+
+    (spec,) = generator.model_local_kv_specs()
+    assert spec.peak_bytes(64) == spec.peak_bytes(1)
+
+
+def test_growing_cache_declaration_matches_a_real_dynamic_cache():
+    """The declared positions are the extent the tensor reaches when full."""
+    layers, kv_heads, head_dim, positions = 4, 2, 32, 11
+    config = _qwen2_config(layers=layers, kv_heads=kv_heads, heads=kv_heads, hidden=kv_heads * head_dim)
+    spec = spec_from_hf_config(
+        config,
+        name="local_transformer",
+        dtype=torch.bfloat16,
+        physical_capacity_positions=positions,
+        capacity_source="group_size + max(delay_pattern)",
+        scope=ModelLocalKVScope.INVOCATION,
+        rows=RowDriver.FIXED,
+        rows_reason="test",
+    )
+
+    cache = DynamicCache()
+    for layer_idx in range(layers):
+        keys = torch.zeros(1, kv_heads, positions, head_dim, dtype=torch.bfloat16)
+        cache.update(keys, torch.zeros_like(keys), layer_idx)
+
+    assert spec.peak_bytes() == _cache_bytes(cache)
+
+
+def test_multiplicity_does_not_claim_an_object_layout():
+    """One allocation B rows wide costs the same as B one-row allocations.
+
+    The protocol reports bytes and deliberately does not distinguish the two.
+    An earlier revision carried a separate `allocations` count and got the
+    object topology wrong in three of four declarers, which is worse than not
+    claiming it: the layout belongs in `allocation_note`, where it cannot be
+    mistaken for arithmetic.
+    """
+    config = _qwen2_config(layers=4, kv_heads=2, heads=2, hidden=64)
+    common = dict(
+        config=config,
+        name="c",
+        dtype=torch.bfloat16,
+        physical_capacity_positions=11,
+        capacity_source="test",
+        scope=ModelLocalKVScope.INVOCATION,
+    )
+    batched = spec_from_hf_config(rows=RowDriver.MAX_NUM_SEQS, **common)
+
+    assert batched.row_count(64) == 64
+    assert batched.peak_bytes(64) == batched.bytes_per_row * 64
+    assert not hasattr(batched, "allocations"), "the object-count axis was removed on purpose"
+
+
+def test_a_fixed_driver_ignores_concurrency():
+    """A serialized or capture-pinned cache does not widen with max_num_seqs."""
+    spec = spec_from_hf_config(
+        _qwen2_config(),
+        name="graph_pool",
+        dtype=torch.bfloat16,
+        physical_capacity_positions=11,
+        capacity_source="test",
+        scope=ModelLocalKVScope.MODEL,
+        rows=RowDriver.FIXED,
+        rows_fixed=261,
+        rows_reason="sum of captured buckets",
+    )
+    assert spec.row_count(1) == 261
+    assert spec.row_count(64) == 261
+    assert spec.peak_bytes(64) == spec.bytes_per_row * 261
+
+
+def test_qwen3_tts_declares_nothing_on_the_stateless_path():
+    """Calls the real decoder declarer with no cache-holding mode configured.
+
+    `_forward_exact` runs `pre_transformer` without `use_cache`, so stateless
+    decoding allocates no KV. A revision that declared a per-request cache
+    unconditionally invented over a gigabyte at max_num_seqs=256, and the
+    revision before it declared nothing at all under enforce_eager, where the
+    eager async-chunk path does allocate. Both are regressions this pins.
+    """
+    from vllm_omni.model_executor.models.qwen3_tts.tokenizer_12hz import (
+        modeling_qwen3_tts_tokenizer_v2 as mod,
+    )
+
+    decoder = object.__new__(mod.Qwen3TTSTokenizerV2Decoder)
+    # nn.Module.__setattr__ needs the machinery __init__ would have built, and
+    # this instance deliberately has none of it.
+    setattr_ = object.__setattr__
+    setattr_(
+        decoder,
+        "config",
+        SimpleNamespace(
+            sliding_window=72,
+            num_hidden_layers=8,
+            num_key_value_heads=16,
+            head_dim=64,
+            hidden_size=1024,
+            num_attention_heads=16,
+        ),
+    )
+    setattr_(decoder, "parameters", lambda: iter([torch.zeros(1, dtype=torch.float32)]))
+
+    setattr_(decoder, "_cudagraph_wrapper", None)
+    assert decoder.model_local_kv_specs() == []
+
+    setattr_(decoder, "_cudagraph_wrapper", SimpleNamespace(async_chunk=False, model_local_kv_specs=lambda: []))
+    assert decoder.model_local_kv_specs() == []
+
+    setattr_(decoder, "_cudagraph_wrapper", SimpleNamespace(async_chunk=True, model_local_kv_specs=lambda: []))
+    names = [s.name for s in decoder.model_local_kv_specs()]
+    assert names == ["codec_decoder_request", "codec_decoder_working_copy"], names
+
+
+def test_fixed_rejects_unreviewable_values():
+    """A bare or unexplained constant cannot be reviewed, so it is rejected."""
+    common = dict(
+        name="x",
+        layers=1,
+        kv_heads=1,
+        head_dim=1,
+        dtype=torch.float16,
+        physical_capacity_positions=1,
+        capacity_source="",
+        scope=ModelLocalKVScope.REQUEST,
+    )
+    with pytest.raises(ValueError, match="rows_reason"):
+        ModelLocalKVSpec(rows=RowDriver.FIXED, rows_fixed=1, rows_reason="   ", **common)
+    with pytest.raises(ValueError, match=">= 1"):
+        ModelLocalKVSpec(rows=RowDriver.FIXED, rows_fixed=0, rows_reason="test", **common)
+
+
+def test_rows_is_required():
+    """Defaulting the batch extent is how the previous guarantee died.
+
+    The dataclass declared it required while the helper every declarer uses
+    defaulted it to 1, so nothing enforced it where it mattered.
+    """
+    with pytest.raises(TypeError):
+        spec_from_hf_config(  # type: ignore[call-arg]
+            _qwen2_config(),
+            name="x",
+            dtype=torch.float16,
+            physical_capacity_positions=1,
+            capacity_source="",
+            scope=ModelLocalKVScope.REQUEST,
+        )
+
+
+def test_spec_from_hf_config_raises_rather_than_guessing():
+    class Empty:
+        pass
+
+    with pytest.raises(ValueError, match="layer count"):
+        spec_from_hf_config(
+            Empty(),
+            name="x",
+            dtype=torch.float16,
+            physical_capacity_positions=1,
+            capacity_source="",
+            scope=ModelLocalKVScope.REQUEST,
+            rows=RowDriver.FIXED,
+            rows_reason="test",
+        )
+
+
+# --------------------------------------------------------------------------
+# Collection
+# --------------------------------------------------------------------------
+
+
+def _spec(**overrides) -> ModelLocalKVSpec:
+    kwargs = dict(
+        name="c",
+        layers=2,
+        kv_heads=2,
+        head_dim=4,
+        dtype=torch.float16,
+        physical_capacity_positions=8,
+        capacity_source="test",
+        scope=ModelLocalKVScope.REQUEST,
+        rows=RowDriver.FIXED,
+        rows_reason="test",
+    )
+    kwargs.update(overrides)
+    return ModelLocalKVSpec(**kwargs)
+
+
+class _Owner(torch.nn.Module):
+    def model_local_kv_specs(self):
+        return [_spec()]
+
+
+class _CUDAGraphWrapperLike:
+    """Mirrors vllm.compilation.cuda_graph.CUDAGraphWrapper.
+
+    Not an nn.Module, and its __getattr__ forwards everything the runnable
+    has. That forwarding is why a previous revision's "unwrap fix" was
+    unnecessary, and why a walk that does not unwrap can enter the tree twice.
+    """
+
+    def __init__(self, runnable):
+        self.runnable = runnable
+
+    def unwrap(self):
+        return self.runnable
+
+    def __getattr__(self, key):
+        return getattr(self.runnable, key)
+
+
+def test_collector_finds_owners_nested_in_the_module_tree():
+    class Mid(torch.nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.inner = _Owner()
+
+    class Top(torch.nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.mid = Mid()
+
+    model = Top()
+    assert [path for path, _ in collect_model_local_kv_specs(model)] == ["mid.inner"]
+    # 2 layers * 2 kv * 4 head_dim * 8 positions * 2 bytes * 2 (K and V) = 512
+    assert _total_bytes(model) == 512
+
+
+def test_a_root_declarer_behind_a_wrapper_is_counted_once():
+    """The wrapper forwards attributes, so a naive walk sees it twice."""
+
+    class Root(_Owner):
+        pass
+
+    wrapped = _CUDAGraphWrapperLike(Root())
+    collected = collect_model_local_kv_specs(wrapped)
+
+    assert len(collected) == 1, collected
+    assert _total_bytes(wrapped) == 512
+
+
+def test_collector_reaches_owners_through_a_wrapper():
+    class Top(torch.nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.owner = _Owner()
+
+    wrapped = _CUDAGraphWrapperLike(Top())
+    assert [path for path, _ in collect_model_local_kv_specs(wrapped)] == ["owner"]
+
+
+def test_collector_survives_an_owner_that_raises():
+    class Broken(torch.nn.Module):
+        def model_local_kv_specs(self):
+            raise RuntimeError("checkpoint field missing")
+
+    class Top(torch.nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.broken = Broken()
+            self.ok = _Owner()
+
+    assert _total_bytes(Top()) == 512
+
+
+def test_undeclared_models_report_zero_not_an_error():
+    assert _total_bytes(object()) == 0
+    assert _total_bytes(torch.nn.Linear(2, 2)) == 0
+
+
+def test_protocol_is_structural():
+    assert isinstance(_Owner(), HasModelLocalKV)
+    assert not isinstance(torch.nn.Linear(2, 2), HasModelLocalKV)
+
+
+@pytest.mark.parametrize(
+    ("relative_path", "owner"),
+    [
+        ("qwen3_tts/segmented_graph_wrapper.py", "CUDAGraphDecoderWrapper"),
+        ("qwen3_tts/tokenizer_12hz/modeling_qwen3_tts_tokenizer_v2.py", "Qwen3TTSTokenizerV2Decoder"),
+        ("mimo_audio/mimo_audio_llm.py", "MiMoAudioLLMForConditionalGeneration"),
+        ("minicpmo_4_5/minicpmo_4_5_omni_llm.py", "MiniCPMWhisperEncoder"),
+        ("ming_flash_omni/talker_module.py", "MingAudioGenerator"),
+        ("ming_flash_omni/ming_flash_omni_talker.py", "MingFlashOmniTalkerForConditionalGeneration"),
+    ],
+)
+def test_known_cache_owners_still_declare(relative_path: str, owner: str):
+    """Parsed rather than imported: these modules need CUDA and real weights.
+
+    Weak by construction -- it only proves the method exists. The ming tests
+    above are the ones that check a declaration's contents.
+    """
+    tree = ast.parse((MODELS_DIR / relative_path).read_text())
+    classes = [node for node in ast.walk(tree) if isinstance(node, ast.ClassDef) and node.name == owner]
+    assert classes, f"{owner} not found in {relative_path}"
+    methods = {child.name for cls in classes for child in cls.body if isinstance(child, ast.FunctionDef)}
+    assert "model_local_kv_specs" in methods, f"{owner} no longer declares its model-local KV"
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_startup_lora.py b/tests/model_executor/models/voxcpm2/test_startup_lora.py
new file mode 100644
index 000000000..513cffca4
--- /dev/null
+++ b/tests/model_executor/models/voxcpm2/test_startup_lora.py
@@ -0,0 +1,177 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Native VoxCPM2 adapter validation and merge parity, without model weights."""
+
+import importlib.util
+import json
+from pathlib import Path
+
+import pytest
+import torch
+from safetensors.torch import save_file
+from torch import nn
+from torch.nn import functional as F
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+@pytest.fixture
+def merge_lora():
+    # Keep these L1 checks independent of vLLM custom-op/platform imports.
+    path = Path(__file__).resolve().parents[4] / "vllm_omni/model_executor/models/voxcpm2/lora.py"
+    spec = importlib.util.spec_from_file_location("voxcpm2_startup_lora", path)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module.merge_voxcpm2_lora
+
+
+@pytest.fixture
+def adapter(tmp_path):
+    def attention():
+        return nn.ModuleDict({name: nn.Linear(3, 4, bias=True) for name in ("q_proj", "k_proj", "v_proj", "o_proj")})
+
+    base_lm = nn.ModuleDict({"layers": nn.ModuleList([attention()])})
+    residual_lm = nn.ModuleDict({"layers": nn.ModuleList([attention()])})
+    tts = nn.ModuleDict(
+        {
+            "feat_decoder": nn.ModuleDict({"estimator": nn.ModuleDict({"decoder": attention()})}),
+            "fusion_concat_proj": nn.Linear(3, 4),
+            "stop_head": nn.Linear(3, 2),
+        }
+    )
+    roots = {"base_lm": base_lm, "residual_lm": residual_lm, "tts": tts}
+    native = nn.ModuleDict({"base_lm": base_lm, "residual_lm": residual_lm, **dict(tts.items())})
+    targets = {name: module for name, module in native.named_modules() if isinstance(module, nn.Linear)}
+    targets.pop("stop_head")
+    generator = torch.Generator().manual_seed(42)
+    tensors = {
+        f"{name}.lora_{suffix}": torch.randn(shape, generator=generator)
+        for name in targets
+        for suffix, shape in (("A", (2, 3)), ("B", (4, 2)))
+    }
+    config = {
+        "r": 2,
+        "alpha": 3,
+        "enable_lm": True,
+        "enable_dit": True,
+        "enable_proj": True,
+        "target_proj_modules": ["fusion_concat_proj"],
+    }
+
+    def save():
+        (tmp_path / "lora_config.json").write_text(json.dumps({"lora_config": config}))
+        save_file(tensors, str(tmp_path / "lora_weights.safetensors"))
+
+    save()
+    return tmp_path, roots, targets, tensors, config, save
+
+
+@pytest.mark.parametrize("dtype", [torch.float32, torch.bfloat16])
+def test_merge_matches_native_linear_output(merge_lora, adapter, dtype):
+    path, roots, targets, tensors, _, _ = adapter
+    inputs = torch.tensor([[0.5, -0.2, 0.1]], dtype=dtype)
+    expected = {}
+    identities = {}
+    for name, layer in targets.items():
+        layer.to(dtype=dtype)
+        identities[name] = id(layer.weight)
+        # Native LoRALinear: linear(x, W, bias) + linear(linear(x, A), B) * alpha/r.
+        expected[name] = F.linear(inputs.float(), layer.weight.float(), layer.bias.float()) + 1.5 * F.linear(
+            F.linear(inputs.float(), tensors[f"{name}.lora_A"]), tensors[f"{name}.lora_B"]
+        )
+    untouched = roots["tts"].stop_head.weight.detach().clone()
+    assert merge_lora(str(path), **roots) == 13
+    for name, layer in targets.items():
+        tolerance = 0.025 if dtype == torch.bfloat16 else 1e-6
+        torch.testing.assert_close(layer(inputs).float(), expected[name], atol=tolerance, rtol=tolerance)
+        assert id(layer.weight) == identities[name]
+        assert layer.weight.dtype == dtype
+        assert set(dict(layer.named_parameters())) == {"weight", "bias"}
+    torch.testing.assert_close(roots["tts"].stop_head.weight, untouched, rtol=0, atol=0)
+
+
+@pytest.mark.parametrize("group", ["lm", "dit", "proj"])
+def test_independently_enabled_groups(merge_lora, adapter, group):
+    path, roots, targets, tensors, config, save = adapter
+    for key in ("lm", "dit", "proj"):
+        config[f"enable_{key}"] = key == group
+    prefixes = {"lm": ("base_lm.", "residual_lm."), "dit": ("feat_decoder.",), "proj": ("fusion_concat_proj.",)}
+    for key in list(tensors):
+        if not key.startswith(prefixes[group]):
+            del tensors[key]
+    original = {name: layer.weight.detach().clone() for name, layer in targets.items()}
+    save()
+    assert merge_lora(str(path), **roots) == {"lm": 8, "dit": 4, "proj": 1}[group]
+    for name, layer in targets.items():
+        if not (name + ".").startswith(prefixes[group]):
+            torch.testing.assert_close(layer.weight, original[name], rtol=0, atol=0)
+
+
+@pytest.mark.parametrize(
+    "corruption", ["missing", "extra", "shape", "rank", "alpha", "nonfinite", "dtype", "target", "flag"]
+)
+def test_rejects_invalid_checkpoint_before_mutating_weights(merge_lora, adapter, corruption):
+    path, roots, targets, tensors, config, save = adapter
+    key = "fusion_concat_proj.lora_B"  # Validate even the last component before merging any layer.
+    if corruption == "missing":
+        del tensors[key]
+    elif corruption == "extra":
+        tensors["audio_vae.lora_A"] = torch.ones(2, 3)
+    elif corruption == "shape":
+        tensors[key] = torch.ones(5, 2)
+    elif corruption == "rank":
+        config["r"] = 0
+    elif corruption == "alpha":
+        config["alpha"] = float("nan")
+    elif corruption == "nonfinite":
+        tensors[key][0, 0] = float("nan")
+    elif corruption == "dtype":
+        tensors[key] = tensors[key].long()
+    elif corruption == "target":
+        config["target_modules_lm"] = ["does_not_exist"]
+    elif corruption == "flag":
+        config["enable_dit"] = "false"
+    save()
+    original = {name: layer.weight.detach().clone() for name, layer in targets.items()}
+    with pytest.raises(ValueError, match="VoxCPM2"):
+        merge_lora(str(path), **roots)
+    for name, layer in targets.items():
+        torch.testing.assert_close(layer.weight, original[name], rtol=0, atol=0)
+
+
+def test_requires_native_metadata_and_safetensors(merge_lora, adapter):
+    path, roots, _, _, _, save = adapter
+    (path / "lora_config.json").write_text(json.dumps({"r": 2, "alpha": 3}))
+    with pytest.raises(ValueError, match="lora_config object"):
+        merge_lora(str(path), **roots)
+    save()
+    (path / "lora_weights.safetensors").unlink()
+    with pytest.raises(FileNotFoundError):
+        merge_lora(str(path), **roots)
+
+
+def test_talker_loads_base_before_merge_and_rejects_reload(adapter):
+    pytest.importorskip("vllm")
+    from vllm_omni.model_executor.models.voxcpm2.runtime_config import _VoxCPM2RuntimeConfig
+    from vllm_omni.model_executor.models.voxcpm2.voxcpm2_talker import VoxCPM2TalkerForConditionalGeneration
+
+    path, roots, targets, tensors, _, _ = adapter
+    talker = VoxCPM2TalkerForConditionalGeneration.__new__(VoxCPM2TalkerForConditionalGeneration)
+    nn.Module.__init__(talker)
+    talker.model = roots["base_lm"]
+    talker.residual_model = roots["residual_lm"]
+    talker._tts = roots["tts"]
+    talker._runtime_config = _VoxCPM2RuntimeConfig(startup_lora_path=str(path))
+    talker._startup_lora_applied = False
+    talker._patch_size, talker._feat_dim, talker._side_dtype = 4, 64, torch.float32
+    weights = [(f"base_lm.{name}", torch.ones_like(param)) for name, param in talker.model.named_parameters()]
+    loaded = talker.load_weights(iter(weights))
+    name = "base_lm.layers.0.q_proj"
+    expected = 1 + 1.5 * tensors[f"{name}.lora_B"] @ tensors[f"{name}.lora_A"]
+    torch.testing.assert_close(targets[name].weight, expected)
+    assert "model.layers.0.q_proj.weight" in loaded
+    assert talker._startup_lora_applied
+    with pytest.raises(ValueError, match="restart the server"):
+        talker.load_weights(iter(weights))
+    torch.testing.assert_close(targets[name].weight, expected)
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_auk.py b/tests/model_executor/stage_input_processors/test_auk.py
new file mode 100644
index 000000000..b2904e1f7
--- /dev/null
+++ b/tests/model_executor/stage_input_processors/test_auk.py
@@ -0,0 +1,188 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Unit tests for the AuK encoder -> diffusion stage input processor."""
+
+from types import SimpleNamespace
+from typing import Any
+
+import numpy as np
+import pytest
+import torch
+
+from vllm_omni.model_executor.stage_input_processors.auk import encoder2dit
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+HIDDEN = 2048
+
+
+def _request_output(
+    mm_output: Any,
+    completion_mm_output: Any = None,
+    request_id: str | None = None,
+) -> SimpleNamespace:
+    """Build a minimal encoder-stage output mock."""
+    return SimpleNamespace(
+        outputs=[SimpleNamespace(token_ids=[0], multimodal_output=completion_mm_output)],
+        multimodal_output=mm_output,
+        request_id=request_id,
+    )
+
+
+def _payload(text_cond: Any) -> dict[str, Any]:
+    """The slot the encoder actually emits: hidden_states.output."""
+    return {"hidden_states": {"output": text_cond}}
+
+
+def _prompt(
+    *,
+    audio: bool = False,
+    gen_seconds: float | None = None,
+    has_audio: bool | None = None,
+) -> dict[str, Any]:
+    knobs: dict[str, Any] = {
+        "gen_seconds": gen_seconds,
+        "sway": -1.0,
+        "t_grid": None,
+        "vae_sample": False,
+    }
+    if has_audio is not None:
+        knobs["has_audio"] = has_audio
+    prompt: dict[str, Any] = {
+        "prompt": "<|im_start|>system\n",
+        "additional_information": {"auk": knobs},
+    }
+    if audio:
+        prompt["multi_modal_data"] = {"audio": (np.zeros(24000, dtype=np.float32), 24000)}
+    return prompt
+
+
+class TestTextCondExtraction:
+    def test_tensor_output(self):
+        cond = torch.zeros(7, HIDDEN, dtype=torch.bfloat16)
+        out = encoder2dit([_request_output(_payload(cond))], _prompt())
+        assert out is not None
+        assert out["prompt"] == ""
+        assert out["prompt_embeds"].shape == (7, HIDDEN)
+        assert out["prompt_embeds"].dtype == torch.bfloat16
+        assert not out["prompt_embeds"].is_cuda
+
+    def test_list_of_tensors_is_concatenated(self):
+        parts = [torch.zeros(3, HIDDEN), torch.ones(4, HIDDEN)]
+        out = encoder2dit([_request_output(_payload(parts))], _prompt())
+        assert out["prompt_embeds"].shape == (7, HIDDEN)
+        assert torch.equal(out["prompt_embeds"][3:], torch.ones(4, HIDDEN))
+
+    def test_single_element_list(self):
+        out = encoder2dit([_request_output(_payload([torch.zeros(5, HIDDEN)]))], _prompt())
+        assert out["prompt_embeds"].shape == (5, HIDDEN)
+
+    def test_numpy_output(self):
+        cond = np.zeros((4, HIDDEN), dtype=np.float32)
+        out = encoder2dit([_request_output(_payload(cond))], _prompt())
+        assert isinstance(out["prompt_embeds"], torch.Tensor)
+        assert out["prompt_embeds"].shape == (4, HIDDEN)
+
+    def test_completion_output_fallback(self):
+        cond = torch.zeros(6, HIDDEN)
+        out = encoder2dit(
+            [_request_output(None, completion_mm_output=_payload(cond))],
+            _prompt(),
+        )
+        assert out["prompt_embeds"].shape == (6, HIDDEN)
+
+    def test_hidden_states_as_a_struct(self):
+        """A deserialized payload arrives as a struct, not a mapping."""
+        cond = torch.zeros(9, HIDDEN)
+        mm_output = {"hidden_states": SimpleNamespace(output=cond, layers=None)}
+        out = encoder2dit([_request_output(mm_output)], _prompt())
+        assert out["prompt_embeds"].shape == (9, HIDDEN)
+
+    def test_flattened_payload_key(self):
+        cond = torch.zeros(8, HIDDEN)
+        out = encoder2dit([_request_output({"hidden_states.output": cond})], _prompt())
+        assert out["prompt_embeds"].shape == (8, HIDDEN)
+
+    def test_direct_text_cond_key(self):
+        cond = torch.zeros(2, HIDDEN)
+        out = encoder2dit([_request_output({"text_cond": cond})], _prompt())
+        assert out["prompt_embeds"].shape == (2, HIDDEN)
+
+    def test_no_source_outputs_returns_none(self):
+        assert encoder2dit([], _prompt()) is None
+
+    def test_missing_payload_raises(self):
+        with pytest.raises(ValueError, match="hidden_states.output"):
+            encoder2dit([_request_output({})], _prompt())
+
+    def test_empty_hidden_states_slot_raises(self):
+        with pytest.raises(ValueError, match="hidden_states.output"):
+            encoder2dit([_request_output({"hidden_states": {}})], _prompt())
+
+    def test_empty_multimodal_output_raises(self):
+        with pytest.raises(ValueError, match="hidden_states.output"):
+            encoder2dit([_request_output(None)], _prompt())
+
+    def test_empty_list_raises(self):
+        with pytest.raises(ValueError, match="empty text condition"):
+            encoder2dit([_request_output(_payload([]))], _prompt())
+
+    def test_wrong_rank_raises(self):
+        with pytest.raises(ValueError, match=r"\[tokens, hidden\]"):
+            encoder2dit([_request_output(_payload(torch.zeros(2, 7, HIDDEN)))], _prompt())
+
+
+class TestKnobPropagation:
+    def test_knobs_are_forwarded(self):
+        prompt = _prompt(audio=True, gen_seconds=6.0)
+        prompt["additional_information"]["auk"]["t_grid"] = [0.0, 0.5, 1.0]
+        prompt["additional_information"]["auk"]["vae_sample"] = True
+        out = encoder2dit([_request_output(_payload(torch.zeros(3, HIDDEN)))], prompt)
+        knobs = out["additional_information"]["auk"]
+        assert knobs["gen_seconds"] == 6.0
+        assert knobs["sway"] == -1.0
+        assert knobs["t_grid"] == [0.0, 0.5, 1.0]
+        assert knobs["vae_sample"] is True
+
+    def test_sampling_knobs_are_not_copied(self):
+        """nfe/cfg/seed ride the stage-1 sampling params, not the prompt."""
+        prompt = _prompt()
+        prompt["additional_information"]["auk"].update({"nfe": 8, "cfg": 1.0, "seed": 3})
+        out = encoder2dit([_request_output(_payload(torch.zeros(3, HIDDEN)))], prompt)
+        knobs = out["additional_information"]["auk"]
+        assert set(knobs) == {"gen_seconds", "sway", "t_grid", "vae_sample", "has_audio"}
+
+    def test_multi_modal_data_is_forwarded(self):
+        prompt = _prompt(audio=True)
+        out = encoder2dit(
+            [_request_output(_payload(torch.zeros(3, HIDDEN)))],
+            prompt,
+            requires_multimodal_data=True,
+        )
+        assert out["multi_modal_data"] is prompt["multi_modal_data"]
+
+    def test_text_only_request_has_no_multi_modal_data(self):
+        out = encoder2dit([_request_output(_payload(torch.zeros(3, HIDDEN)))], _prompt())
+        assert out["multi_modal_data"] is None
+        assert out["additional_information"]["auk"]["has_audio"] is False
+
+    def test_has_audio_declared_by_the_prompt_wins(self):
+        prompt = _prompt(audio=True, has_audio=True)
+        out = encoder2dit([_request_output(_payload(torch.zeros(3, HIDDEN)))], prompt)
+        assert out["additional_information"]["auk"]["has_audio"] is True
+
+    def test_has_audio_inferred_from_multi_modal_data(self):
+        prompt = _prompt(audio=True)
+        prompt["additional_information"]["auk"].pop("has_audio", None)
+        out = encoder2dit([_request_output(_payload(torch.zeros(3, HIDDEN)))], prompt)
+        assert out["additional_information"]["auk"]["has_audio"] is True
+
+    def test_prompt_as_list(self):
+        out = encoder2dit([_request_output(_payload(torch.zeros(3, HIDDEN)))], [_prompt(gen_seconds=2.0)])
+        assert out["additional_information"]["auk"]["gen_seconds"] == 2.0
+
+    def test_missing_prompt_yields_empty_knobs(self):
+        out = encoder2dit([_request_output(_payload(torch.zeros(3, HIDDEN)))], None)
+        knobs = out["additional_information"]["auk"]
+        assert knobs["gen_seconds"] is None
+        assert knobs["has_audio"] is False
diff --git a/tests/model_executor/stage_input_processors/test_mammoth_moda2.py b/tests/model_executor/stage_input_processors/test_mammoth_moda2.py
new file mode 100644
index 000000000..c404b6d58
--- /dev/null
+++ b/tests/model_executor/stage_input_processors/test_mammoth_moda2.py
@@ -0,0 +1,207 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""CPU regressions for MammothModa2's completed-AR to diffusion bridge."""
+
+from dataclasses import dataclass
+
+import pytest
+import torch
+
+from vllm_omni.diffusion.models.mammoth_moda2.pipeline_mammothmoda2_dit import (
+    MammothModa2DiTPipeline,
+)
+from vllm_omni.engine.serialization import (
+    deserialize_additional_information,
+    serialize_additional_information,
+)
+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 ar2diffusion
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+@dataclass
+class _CompletionOutputStub:
+    cumulative_token_ids: list[int]
+    multimodal_output: dict[str, torch.Tensor]
+
+
+@dataclass
+class _AROutputStub:
+    request_id: str
+    prompt_token_ids: list[int]
+    outputs: list[_CompletionOutputStub]
+
+
+@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 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],
+            }
+        },
+    )
+
+    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 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_ar2diffusion_rejects_multiple_source_requests() -> None:
+    with pytest.raises(ValueError, match="exactly one AR output"):
+        ar2diffusion([_source_output(), _source_output()], {})
+
+
+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_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(diffusion_input["additional_information"])
+    assert wire_payload is not None
+    restored = deserialize_additional_information(wire_payload)
+    restored_hidden_states = restored["full_hidden_states"]
+
+    assert isinstance(restored_hidden_states, torch.Tensor)
+    assert restored_hidden_states.dtype == dtype
+    assert restored_hidden_states.is_contiguous()
+    assert torch.equal(restored_hidden_states, hidden_states)
+
+
+@pytest.mark.parametrize("dtype", (torch.float16, torch.bfloat16))
+def test_dit_condition_split_preserves_compact_transfer_dtype(dtype: torch.dtype) -> None:
+    pipeline = object.__new__(MammothModa2DiTPipeline)
+    object.__setattr__(
+        pipeline,
+        "config",
+        _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 = torch.arange(20, dtype=dtype).reshape(5, 4)
+
+    text_cond, image_cond = pipeline._split_ar_conditions(
+        full_hidden_states=hidden_states,
+        full_token_ids=[7, 20, 8, 101, 102],
+        answer_start_index=3,
+    )
+
+    assert text_cond.dtype == dtype
+    assert image_cond.dtype == dtype
+    assert text_cond.is_contiguous()
+    assert image_cond.is_contiguous()
+    assert torch.equal(text_cond, hidden_states[[0, 2]])
+    assert torch.equal(image_cond, hidden_states[[3, 4]])
+
+
+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(".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:
+    source = _source_output()
+    client = object.__new__(StageEngineCoreClient)
+    client.custom_process_input_func = ar2diffusion
+    client.requires_multimodal_data = False
+
+    diffusion_input = client.process_engine_inputs(
+        [source],
+        {"mm_processor_kwargs": {"target_h": 512, "target_w": 768}},
+    )
+
+    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_minimax_h3.py b/tests/model_executor/stage_input_processors/test_minimax_h3.py
index 9fda89953..aac16d29f 100644
--- a/tests/model_executor/stage_input_processors/test_minimax_h3.py
+++ b/tests/model_executor/stage_input_processors/test_minimax_h3.py
@@ -2,8 +2,6 @@
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Regression tests for MiniMax H3's disaggregated text-encoder contract."""
 
-import os
-import shutil
 from types import SimpleNamespace
 from unittest.mock import Mock
 
@@ -12,39 +10,37 @@ import pytest
 import torch
 from PIL import Image
 
-from vllm_omni.data_entry_keys import OmniPayload, deserialize_payload, serialize_payload
-from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import (
-    _load_audio,
-    resolve_minimax_h3_diffusion_model_path,
+from vllm_omni.data_entry_keys import flatten_payload
+from vllm_omni.diffusion.models.minimax_h3.pipeline_minimax_h3 import resolve_minimax_h3_diffusion_model_path
+from vllm_omni.engine.serialization import (
+    deserialize_additional_information,
+    serialize_additional_information,
 )
+from vllm_omni.errors import OmniClientError
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 from vllm_omni.model_executor.models.minimax_h3.checkpoint import (
-    resolve_minimax_h3_model_root,
+    resolve_minimax_h3_encoder_model_root,
     resolve_minimax_h3_partition,
 )
 from vllm_omni.model_executor.models.minimax_h3.conditioning import (
     MINIMAX_H3_CONDITION_LABELS_KEY,
+    MINIMAX_H3_ENCODER_REQUEST_KEY,
     MINIMAX_H3_PRESENTATION_TASK_KEY,
-    MINIMAX_H3_TEXT_CONDITIONING_SCHEMA,
-    MiniMaxH3TextConditioning,
+    MiniMaxH3EncoderConditioning,
 )
+from vllm_omni.model_executor.models.minimax_h3.encoder_processing import _audio_items, _load_audio
 from vllm_omni.model_executor.models.minimax_h3.preprocessing import (
     minimax_h3_ref2va_presentation,
     minimax_h3_ref2va_video_presentation,
 )
-from vllm_omni.model_executor.models.minimax_h3.reference_video import (
-    MINIMAX_H3_PREPARED_REFERENCE_VIDEOS_KEY,
-    deserialize_prepared_reference_videos,
-)
 from vllm_omni.model_executor.models.minimax_h3.text_encoder import (
     MiniMaxH3MultiModalProcessor,
     _build_minimax_h3_presentation,
 )
 from vllm_omni.model_executor.stage_input_processors.minimax_h3 import (
-    _audio_items,
     _diffusion_sampling_params,
-    prepare_text_encoder_prompt,
-    text_encoder2diffusion,
+    encoder2diffusion,
+    prepare_encoder_prompt,
 )
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
@@ -66,13 +62,14 @@ class _SegmentTokenizer:
         return self._special_ids[token]
 
 
-def test_h3_processor_reprocesses_media_instead_of_using_partial_sender_cache(mocker):
+def test_h3_processor_reprocesses_media_instead_of_using_partial_sender_cache(monkeypatch):
     processor = object.__new__(MiniMaxH3MultiModalProcessor)
     sentinel = ([1, 2, 3], object(), True)
-    apply_processor = mocker.patch.object(
+    apply_processor = Mock(return_value=sentinel)
+    monkeypatch.setattr(
         MiniMaxH3MultiModalProcessor,
         "_apply_hf_processor",
-        return_value=sentinel,
+        apply_processor,
     )
     inputs = object()
     timing_ctx = object()
@@ -119,9 +116,11 @@ def test_fused_audio_loader_accepts_list_waveform_pair():
 def test_prepare_ref2va_keeps_original_text_and_exact_condition_order():
     prompt = {
         "prompt": "hello",
+        "additional_information": {"global_request_id": ["request-1"]},
+        "model_intermediate_buffer": {"private": "preserved"},
         "multi_modal_data": {
             "image": Image.new("RGB", (256, 256)),
-            "audio": [np.zeros(16), 16_000],
+            "audio": [np.zeros(32_000), 16_000],
         },
     }
     sampling = OmniDiffusionSamplingParams(
@@ -130,7 +129,7 @@ def test_prepare_ref2va_keeps_original_text_and_exact_condition_order():
         extra_args={"task": "ref2va"},
     )
 
-    transformed = prepare_text_encoder_prompt(prompt, [sampling])
+    transformed = prepare_encoder_prompt(prompt, [sampling])
 
     assert transformed["prompt"] == "hello"
     assert len(transformed["multi_modal_data"]["image"]) == 1
@@ -140,223 +139,148 @@ def test_prepare_ref2va_keeps_original_text_and_exact_condition_order():
         ("image", 1),
         ("audio", 1),
     ]
+    assert transformed["model_intermediate_buffer"] == {"private": "preserved"}
+    runner_info = transformed["additional_information"]
+    for _ in range(2):
+        wire = serialize_additional_information(runner_info)
+        runner_info = deserialize_additional_information(wire)
+    assert runner_info["global_request_id"] == ["request-1"]
+    request_metadata = runner_info["meta"][MINIMAX_H3_ENCODER_REQUEST_KEY]
+    assert request_metadata["task"] == "ref2va"
+    assert isinstance(
+        runner_info["hidden_states"]["layers"][0],
+        torch.Tensor,
+    )
+    assert isinstance(
+        runner_info["hidden_states"]["layers"][1],
+        torch.Tensor,
+    )
+    from vllm_omni.model_executor.models.minimax_h3.encoder import MiniMaxH3Encoder
+
+    media = MiniMaxH3Encoder._media_input(runner_info)
+    assert media.task == "ref2va"
+    assert len(media.images) == 1
+    assert len(media.audios) == 1
 
 
-def test_text_encoder_prompt_rejects_injected_prepared_video_descriptor():
-    prompt = {
-        "prompt": "hello",
-        "additional_information": {"meta": {MINIMAX_H3_PREPARED_REFERENCE_VIDEOS_KEY: '{"artifact_dir":"/tmp/user"}'}},
-    }
-    sampling = OmniDiffusionSamplingParams(height=256, width=448, extra_args={"task": "t2va"})
+def _mock_ref2va_video_with_audio(monkeypatch, *, duration_seconds: float) -> None:
+    from vllm_omni.model_executor.models.minimax_h3 import encoder_processing
 
-    transformed = prepare_text_encoder_prompt(prompt, [sampling])
-
-    assert MINIMAX_H3_PREPARED_REFERENCE_VIDEOS_KEY not in transformed["additional_information"]["meta"]
-
-
-def test_prepare_ref2va_video_uses_shared_frame_sampler_once(monkeypatch):
-    prepare_videos = Mock()
-
-    def prepare(_videos, *, target_frame_count, workdir, start_time_seconds):
-        prepare_videos(_videos, target_frame_count, workdir, start_time_seconds)
-        prepared_path = os.path.join(workdir, "prepared.mp4")
-        open(prepared_path, "wb").close()
-        return [
-            {
-                "original_path": "/tmp/input.mp4",
-                "prepared_path": prepared_path,
-                "input_has_audio": True,
-                "width": 448,
-                "height": 256,
-                "start_time_seconds": 0.0,
-                "duration_seconds": 5.2,
-                "audio_duration_seconds": 5.2,
-            }
-        ]
-
-    sample_frames = Mock(return_value={"frames": [np.zeros((4, 4, 3), dtype=np.uint8)]})
-    monkeypatch.setattr("vllm_omni.model_executor.stage_input_processors.minimax_h3.prepare_reference_videos", prepare)
+    sample_rate = 16_000
+    frames = np.zeros((4, 32, 32, 3), dtype=np.uint8)
     monkeypatch.setattr(
-        "vllm_omni.model_executor.stage_input_processors.minimax_h3.sample_reference_video_frames",
-        sample_frames,
+        encoder_processing,
+        "prepare_reference_videos",
+        lambda *args, **kwargs: [
+            {
+                "prepared_path": "prepared.mp4",
+                "original_path": "original.mp4",
+                "input_has_audio": True,
+                "duration_seconds": duration_seconds,
+                "audio_duration_seconds": duration_seconds,
+            }
+        ],
+    )
+    monkeypatch.setattr(encoder_processing, "load_video_frames", lambda path: frames)
+    monkeypatch.setattr(
+        encoder_processing,
+        "sample_reference_video_frames",
+        lambda *args, **kwargs: {"block_timestamps": [0.0], "frames": frames[:1]},
+    )
+    monkeypatch.setattr(
+        encoder_processing,
+        "load_video_audio",
+        lambda *args, **kwargs: (torch.zeros(round(duration_seconds * sample_rate)), sample_rate),
+    )
+
+
+def test_prepare_ref2va_rejects_short_embedded_video_audio(monkeypatch):
+    _mock_ref2va_video_with_audio(monkeypatch, duration_seconds=1.0)
+    sampling = OmniDiffusionSamplingParams(
+        height=256,
+        width=448,
+        num_frames=96,
+        extra_args={"task": "ref2va"},
+    )
+    prompt = {"prompt": "hello", "multi_modal_data": {"video": "original.mp4"}}
+
+    with pytest.raises(OmniClientError, match=r"duration must be in \[2, 15\] seconds, got 1\.000"):
+        prepare_encoder_prompt(prompt, [sampling])
+
+
+def test_prepare_ref2va_keeps_embedded_and_standalone_audio_budgets_separate(monkeypatch):
+    duration_seconds = 8.0
+    sample_rate = 16_000
+    _mock_ref2va_video_with_audio(monkeypatch, duration_seconds=duration_seconds)
+    sampling = OmniDiffusionSamplingParams(
+        height=256,
+        width=448,
+        num_frames=240,
+        extra_args={"task": "ref2va"},
     )
     prompt = {
         "prompt": "hello",
-        "multi_modal_data": {"video": "/tmp/input.mp4"},
+        "multi_modal_data": {
+            "video": "original.mp4",
+            "audio": (torch.zeros(int(duration_seconds * sample_rate)), sample_rate),
+        },
     }
-    sampling = OmniDiffusionSamplingParams(height=256, width=448, num_frames=124, extra_args={"task": "ref2va"})
 
-    transformed = prepare_text_encoder_prompt(prompt, [sampling])
-
-    prepare_videos.assert_called_once()
-    _, target_frame_count, artifact_dir, start_time_seconds = prepare_videos.call_args.args
-    assert target_frame_count == 124
-    assert start_time_seconds is None
-    descriptor = transformed["additional_information"]["meta"][MINIMAX_H3_PREPARED_REFERENCE_VIDEOS_KEY]
-    described_dir, described_videos = deserialize_prepared_reference_videos(descriptor)
-    assert described_dir == artifact_dir
-    assert os.path.isfile(described_videos[0]["prepared_path"])
-    sample_frames.assert_called_once_with(described_videos[0]["prepared_path"])
-    assert prompt["multi_modal_data"] == {"video": "/tmp/input.mp4"}
+    transformed = prepare_encoder_prompt(prompt, [sampling])
     assert transformed["mm_processor_kwargs"][MINIMAX_H3_CONDITION_LABELS_KEY] == [
         ("audio", 1),
         ("video", 1),
+        ("audio", 2),
     ]
-    shutil.rmtree(artifact_dir)
 
 
-def test_stage_wire_rejects_multiple_text_encoder_sources():
-    with pytest.raises(RuntimeError, match="exactly one text-encoder source"):
-        text_encoder2diffusion([SimpleNamespace(), SimpleNamespace()], prompt={"prompt": "hello"})
+def _encoder_output() -> dict:
+    return MiniMaxH3EncoderConditioning(
+        hidden_states=torch.randn(3, 5120, dtype=torch.bfloat16),
+        token_tags=torch.tensor([1, 0, 1], dtype=torch.int64),
+        task="t2va",
+        height=256,
+        width=448,
+        num_frames=17,
+        latent_t=5,
+        audio_t=10,
+    ).to_omni_payload()
 
 
-def test_stage_wire_rejects_request_id_mismatch():
-    source = SimpleNamespace(request_id="other", outputs=[SimpleNamespace()])
+def test_encoder2diffusion_reuses_encoder_handoff() -> None:
     prompt = {
-        "prompt": "hello",
-        "additional_information": {"global_request_id": ["req-1"]},
-    }
-
-    with pytest.raises(RuntimeError, match="request ID does not match"):
-        text_encoder2diffusion([source], prompt=prompt)
-
-
-def test_stage_wire_rejects_multiple_completions():
-    source = SimpleNamespace(request_id="req-1", outputs=[SimpleNamespace(), SimpleNamespace()])
-
-    with pytest.raises(RuntimeError, match="exactly one completion"):
-        text_encoder2diffusion([source], prompt={"prompt": "hello"})
-
-
-def _source_output(payload: dict) -> SimpleNamespace:
-    completion = SimpleNamespace(multimodal_output=payload)
-    return SimpleNamespace(request_id="request-1", outputs=[completion])
-
-
-def _diffusion_prompt() -> dict:
-    return {
-        "request_id": "request-1",
         "prompt": "test prompt",
-        "additional_information": {},
-    }
-
-
-def _valid_text_conditioning_payload() -> OmniPayload:
-    return {
-        "hidden_states": {
-            "output": torch.zeros(4, 5120, dtype=torch.bfloat16),
-        },
-        "meta": {
-            "token_role_ids": torch.tensor([[1], [1], [0], [0]], dtype=torch.int64),
+        "multi_modal_data": {"image": object()},
+        "additional_information": {
+            "private": "preserved",
+            "meta": {MINIMAX_H3_ENCODER_REQUEST_KEY: {"task": "t2va"}},
+            "hidden_states": {"layers": {0: torch.zeros(1)}},
         },
+        "model_intermediate_buffer": {"private": "encoder-only"},
     }
-
-
-def test_text_encoder2diffusion_reads_hidden_states_output_and_token_role_ids() -> None:
-    payload = _valid_text_conditioning_payload()
-    hidden = payload["hidden_states"]["output"]
-    token_role_ids = payload["meta"]["token_role_ids"]
-
-    result = text_encoder2diffusion(
-        [_source_output(payload)],
-        _diffusion_prompt(),
+    source = SimpleNamespace(
+        finished=True,
+        request_id="request-1",
+        outputs=[SimpleNamespace(multimodal_output=flatten_payload(_encoder_output()))],
     )
 
-    conditioning = result["additional_information"]["text_encoder_output"]
-    torch.testing.assert_close(conditioning["hidden_states"], hidden)
-    torch.testing.assert_close(conditioning["token_tags"], token_role_ids.squeeze(-1))
+    result = encoder2diffusion([source], prompt)
+
+    assert result["prompt"] == "test prompt"
+    assert result["multi_modal_data"] is None
+    assert "model_intermediate_buffer" not in result
+    additional_information = result["additional_information"]
+    assert additional_information["private"] == "preserved"
+    assert "hidden_states" not in additional_information
+    assert "meta" not in additional_information
+    parsed = MiniMaxH3EncoderConditioning.from_omni_payload(additional_information["encoder_output"])
+    assert parsed.task == "t2va"
 
 
-def test_text_conditioning_artifact_round_trips_through_omni_payload_wire_format() -> None:
-    payload = _valid_text_conditioning_payload()
-
-    wire = serialize_payload(payload)
-
-    assert wire is not None
-    restored = deserialize_payload(wire)
-    conditioning = MiniMaxH3TextConditioning.from_omni_payload(restored)
-    assert MINIMAX_H3_TEXT_CONDITIONING_SCHEMA == "minimax_h3.text_conditioning/v1"
-    torch.testing.assert_close(
-        conditioning.hidden_states,
-        payload["hidden_states"]["output"],
-    )
-    torch.testing.assert_close(
-        conditioning.token_tags,
-        payload["meta"]["token_role_ids"].squeeze(-1),
-    )
-    assert conditioning.hidden_states.dtype == torch.bfloat16
-    assert conditioning.hidden_states.is_contiguous()
-    assert conditioning.token_tags.dtype == torch.int64
-    assert conditioning.token_tags.is_contiguous()
-
-
-@pytest.mark.parametrize(
-    ("payload", "message"),
-    [
-        ({"meta": {"token_role_ids": torch.ones(4, 1)}}, "no hidden_states payload"),
-        ({"hidden_states": {}, "meta": {"token_role_ids": torch.ones(4, 1)}}, "no hidden_states.output tensor"),
-        ({"hidden_states": {"output": torch.randn(4, 5120)}}, "no conditioning metadata"),
-        ({"hidden_states": {"output": torch.randn(4, 5120)}, "meta": {}}, "no token_role_ids tensor"),
-        (
-            {
-                "hidden_states": {"output": torch.randn(4, 5120)},
-                "meta": {"token_role_ids": torch.ones(4)},
-            },
-            r"must have shape \[tokens, 1\]",
-        ),
-    ],
-)
-def test_text_encoder2diffusion_rejects_invalid_conditioning_payload(payload: dict, message: str) -> None:
-    with pytest.raises(RuntimeError, match=message):
-        text_encoder2diffusion([_source_output(payload)], _diffusion_prompt())
-
-
-@pytest.mark.parametrize(
-    ("case", "message"),
-    [
-        ("hidden_width", r"hidden_states must have shape \[tokens, 5120\]"),
-        ("hidden_dtype", "hidden_states must have dtype torch.bfloat16"),
-        ("hidden_noncontiguous", "hidden_states must use contiguous strided layout"),
-        ("hidden_non_strided", "hidden_states must use contiguous strided layout"),
-        ("token_dtype", "stage-wire token_role_ids must have dtype torch.int64"),
-        ("token_layout", "stage-wire token_role_ids must use contiguous strided layout"),
-        ("token_count", "token_tags must align with hidden_states"),
-        ("token_value", "token_tags must contain only 0 and 1"),
-    ],
-)
-def test_text_encoder2diffusion_rejects_h3_v1_contract_mismatch(case: str, message: str) -> None:
-    payload = _valid_text_conditioning_payload()
-
-    if case == "hidden_width":
-        payload["hidden_states"]["output"] = torch.zeros(4, 5119, dtype=torch.bfloat16)
-    elif case == "hidden_dtype":
-        payload["hidden_states"]["output"] = torch.zeros(4, 5120, dtype=torch.float32)
-    elif case == "hidden_noncontiguous":
-        payload["hidden_states"]["output"] = torch.empty(5120, 4, dtype=torch.bfloat16).t()
-    elif case == "hidden_non_strided":
-        payload["hidden_states"]["output"] = torch.empty(
-            (4, 5120),
-            dtype=torch.bfloat16,
-            layout=torch.sparse_coo,
-        )
-    elif case == "token_dtype":
-        payload["meta"]["token_role_ids"] = torch.tensor([[1], [1], [0], [0]], dtype=torch.int32)
-    elif case == "token_layout":
-        payload["meta"]["token_role_ids"] = torch.tensor(
-            [[1], [0], [1], [0], [1], [0], [1], [0]],
-            dtype=torch.int64,
-        )[::2]
-    elif case == "token_count":
-        payload["meta"]["token_role_ids"] = torch.tensor([[1], [0], [0]], dtype=torch.int64)
-    elif case == "token_value":
-        payload["meta"]["token_role_ids"] = torch.tensor([[1], [1], [2], [0]], dtype=torch.int64)
-    else:  # pragma: no cover - parameterization is exhaustive
-        raise AssertionError(f"unknown test case: {case}")
-
-    with pytest.raises(RuntimeError, match=message) as exc_info:
-        text_encoder2diffusion([_source_output(payload)], _diffusion_prompt())
-
-    assert MINIMAX_H3_TEXT_CONDITIONING_SCHEMA in str(exc_info.value)
+def test_encoder2diffusion_waits_for_one_finished_source() -> None:
+    assert encoder2diffusion([SimpleNamespace(finished=False)], {"prompt": "hello"}) is None
+    with pytest.raises(RuntimeError, match="exactly one encoder source"):
+        encoder2diffusion([SimpleNamespace(), SimpleNamespace()], {"prompt": "hello"})
 
 
 def test_ref2va_one_image_tokens_and_tags_match_fused_presentation():
@@ -421,15 +345,20 @@ def test_checkpoint_resolver_selects_local_partition(tmp_path):
     (root / "FL2VA" / "text_encoder").mkdir(parents=True)
     (root / "Ref2VA" / "text_encoder").mkdir(parents=True)
 
-    assert resolve_minimax_h3_model_root(str(root), None, "fl2va") == str(root / "FL2VA" / "text_encoder")
-    assert resolve_minimax_h3_model_root(str(root), None, "ref2va") == str(root / "Ref2VA" / "text_encoder")
-    assert resolve_minimax_h3_model_root(str(root / "Ref2VA"), None, None) == str(root / "Ref2VA" / "text_encoder")
-    assert resolve_minimax_h3_model_root(str(root / "FL2VA"), None, "ref2va") == str(root / "Ref2VA" / "text_encoder")
+    assert resolve_minimax_h3_encoder_model_root(str(root), None, "fl2va") == str(root / "FL2VA" / "text_encoder")
+    assert resolve_minimax_h3_encoder_model_root(str(root), None, "ref2va") == str(root / "Ref2VA" / "text_encoder")
+    assert resolve_minimax_h3_encoder_model_root(str(root), None, "combined") == str(root / "FL2VA" / "text_encoder")
+    assert resolve_minimax_h3_encoder_model_root(str(root / "Ref2VA"), None, None) == str(
+        root / "Ref2VA" / "text_encoder"
+    )
+    assert resolve_minimax_h3_encoder_model_root(str(root / "FL2VA"), None, "ref2va") == str(
+        root / "Ref2VA" / "text_encoder"
+    )
 
 
 def test_checkpoint_resolver_rejects_unknown_task(tmp_path):
     with pytest.raises(ValueError, match="task_type must be one of"):
-        resolve_minimax_h3_model_root(str(tmp_path), None, "unknown")
+        resolve_minimax_h3_encoder_model_root(str(tmp_path), None, "unknown")
 
 
 def test_partition_resolver_preserves_consumer_auto_default(tmp_path):
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 996486d49..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
@@ -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 collections import defaultdict
 from types import SimpleNamespace
@@ -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,15 +35,64 @@ _FRAME = [1, 2, 3, 4]
 _Q = len(_FRAME)
 
 
-def _req(rid, *, finished, initial_codec_chunk_frames=None):
-    ai = 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:
-        entry = SimpleNamespace(list_data=[initial_codec_chunk_frames])
-        ai = SimpleNamespace(entries={"initial_codec_chunk_frames": entry})
+        entries["initial_codec_chunk_frames"] = SimpleNamespace(list_data=[initial_codec_chunk_frames])
+    if non_streaming_mode is not None:
+        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])
     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 [],
     )
 
 
@@ -123,6 +175,191 @@ def test_flush_on_finish():
     assert len(p.codes.audio) == _Q * 24
 
 
+def test_full_utterance_decode_defers_until_finished():
+    """full_utterance_decode=True should not emit windowed chunks mid-utterance (#4371)."""
+    tm = _tm()
+    tm.code_prompt_token_ids["r"] = [_FRAME[:] for _ in range(50)]
+    p = talker2code2wav_async_chunk(
+        transfer_manager=tm,
+        multimodal_output=None,
+        request=_req("r", finished=False, full_utterance_decode=True),
+        is_finished=False,
+    )
+    assert p is None
+
+
+def test_full_utterance_decode_emits_full_utterance_on_finish():
+    tm = _tm()
+    tm.code_prompt_token_ids["r"] = [_FRAME[:] for _ in range(50)]
+    p = talker2code2wav_async_chunk(
+        transfer_manager=tm,
+        multimodal_output=None,
+        request=_req("r", finished=True, full_utterance_decode=True),
+        is_finished=True,
+    )
+    assert p is not None
+    assert p.meta.finished.item() is True
+    assert len(p.codes.audio) == _Q * 50
+
+
+def test_full_utterance_decode_false_keeps_windowed_emit():
+    # Dynamic IC defers emit at 25 frames (see _CASES); 41 hits the first
+    # steady-state window boundary and proves streaming path is unchanged.
+    tm = _tm()
+    tm.code_prompt_token_ids["r"] = [_FRAME[:] for _ in range(41)]
+    p = talker2code2wav_async_chunk(
+        transfer_manager=tm,
+        multimodal_output={"codes": {"audio": torch.zeros((0,))}},
+        request=_req("r", finished=False, full_utterance_decode=False),
+        is_finished=False,
+    )
+    assert p is not None
+    assert len(p.codes.audio) == _Q * 25
+
+
+def test_non_streaming_mode_alone_does_not_defer_async_chunk():
+    """Prompt-mode non_streaming_mode must not gate Code2Wav emits (#6898).
+
+    VoiceDesign serving defaults non_streaming_mode=True even for streaming
+    responses; those requests still need windowed async-chunk audio for TTFA.
+    """
+    tm = _tm()
+    tm.code_prompt_token_ids["r"] = [_FRAME[:] for _ in range(41)]
+    p = talker2code2wav_async_chunk(
+        transfer_manager=tm,
+        multimodal_output={"codes": {"audio": torch.zeros((0,))}},
+        request=_req("r", finished=False, non_streaming_mode=True),
+        is_finished=False,
+    )
+    assert p is not None
+    assert len(p.codes.audio) == _Q * 25
+
+
+def test_voicedesign_prompt_mode_with_streaming_keeps_windowed_emit():
+    """Streaming VoiceDesign-style defaults: prompt-mode True, decode False."""
+    tm = _tm()
+    tm.code_prompt_token_ids["r"] = [_FRAME[:] for _ in range(41)]
+    p = talker2code2wav_async_chunk(
+        transfer_manager=tm,
+        multimodal_output={"codes": {"audio": torch.zeros((0,))}},
+        request=_req(
+            "r",
+            finished=False,
+            non_streaming_mode=True,
+            full_utterance_decode=False,
+        ),
+        is_finished=False,
+    )
+    assert p is not None
+    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.
@@ -620,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",
@@ -945,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)
@@ -968,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)
@@ -1346,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_auk_requests.py b/tests/model_extras/test_auk_requests.py
new file mode 100644
index 000000000..1f319d092
--- /dev/null
+++ b/tests/model_extras/test_auk_requests.py
@@ -0,0 +1,157 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Unit tests for the AuK request helpers."""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+from vllm import SamplingParams
+
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+from vllm_omni.model_extras.auk import (
+    NO_PROMPT_AUDIO,
+    auk_prompt,
+    auk_sampling_params,
+    resolve_gen_frames,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+INSTRUCTION = "Say the following with the same voice: 'Ladies and gentlemen'"
+
+EXPECTED_WITH_AUDIO = (
+    "<|im_start|>system\n"
+    "You are a helpful assistant.<|im_end|>\n"
+    "<|im_start|>user\n"
+    f"{INSTRUCTION}<|audio_bos|><|AUDIO|><|audio_eos|><|im_end|>\n"
+    "<|im_start|>assistant\n"
+)
+
+EXPECTED_TEXT_ONLY = (
+    "<|im_start|>system\n"
+    "You are a helpful assistant.<|im_end|>\n"
+    "<|im_start|>user\n"
+    f"{INSTRUCTION}{NO_PROMPT_AUDIO}<|im_end|>\n"
+    "<|im_start|>assistant\n"
+)
+
+
+def _audio() -> tuple[np.ndarray, int]:
+    return np.zeros(24000, dtype=np.float32), 24000
+
+
+class TestPromptRendering:
+    def test_with_audio(self):
+        audio = _audio()
+        prompt = auk_prompt(INSTRUCTION, audio, gen_seconds=6.0)
+        assert prompt["prompt"] == EXPECTED_WITH_AUDIO
+        assert prompt["multi_modal_data"] == {"audio": audio}
+        assert prompt["additional_information"]["auk"]["has_audio"] is True
+
+    def test_text_only_appends_the_marker(self):
+        prompt = auk_prompt(INSTRUCTION, gen_seconds=6.0)
+        assert prompt["prompt"] == EXPECTED_TEXT_ONLY
+        assert "multi_modal_data" not in prompt
+        assert prompt["additional_information"]["auk"]["has_audio"] is False
+
+    def test_marker_is_not_appended_twice(self):
+        once = auk_prompt(INSTRUCTION, gen_seconds=6.0)
+        twice = auk_prompt(INSTRUCTION + NO_PROMPT_AUDIO, gen_seconds=6.0)
+        assert once["prompt"] == twice["prompt"]
+        assert twice["prompt"].count(NO_PROMPT_AUDIO) == 1
+
+    def test_marker_is_not_added_when_audio_is_present(self):
+        prompt = auk_prompt(INSTRUCTION, _audio())
+        assert NO_PROMPT_AUDIO not in prompt["prompt"]
+
+    def test_knob_defaults(self):
+        knobs = auk_prompt(INSTRUCTION, _audio())["additional_information"]["auk"]
+        assert knobs == {
+            "gen_seconds": None,
+            "sway": -1.0,
+            "t_grid": None,
+            "vae_sample": False,
+            "has_audio": True,
+        }
+
+    def test_knobs_are_carried(self):
+        grid = [0.0, 0.25, 1.0]
+        knobs = auk_prompt(
+            INSTRUCTION,
+            _audio(),
+            gen_seconds=3.5,
+            sway=0.0,
+            t_grid=grid,
+            vae_sample=True,
+        )["additional_information"]["auk"]
+        assert knobs["gen_seconds"] == 3.5
+        assert knobs["sway"] == 0.0
+        assert knobs["vae_sample"] is True
+        assert knobs["t_grid"] == grid
+        # A copy, so a caller mutating its list cannot reach the request.
+        assert knobs["t_grid"] is not grid
+
+    def test_sampling_knobs_are_absent_from_the_prompt(self):
+        knobs = auk_prompt(INSTRUCTION, _audio())["additional_information"]["auk"]
+        assert not {"nfe", "cfg", "seed"} & set(knobs)
+
+
+class TestSamplingParams:
+    def test_two_stages_in_order(self):
+        params = auk_sampling_params()
+        assert len(params) == 2
+        assert isinstance(params[0], SamplingParams)
+        assert isinstance(params[1], OmniDiffusionSamplingParams)
+
+    def test_encoder_stage_is_prefill_only(self):
+        encoder = auk_sampling_params()[0]
+        assert encoder.max_tokens == 1
+        assert encoder.temperature == 0.0
+        assert encoder.detokenize is False
+
+    def test_defaults_are_the_base_recipe(self):
+        diffusion = auk_sampling_params()[1]
+        assert diffusion.num_inference_steps == 32
+        assert diffusion.guidance_scale == 2.0
+        assert diffusion.seed == 0
+
+    def test_overrides(self):
+        encoder, diffusion = auk_sampling_params(nfe=4, cfg=0.0, seed=None)
+        assert diffusion.num_inference_steps == 4
+        assert diffusion.guidance_scale == 0.0
+        assert diffusion.seed is None
+        assert encoder.seed is None
+
+
+class TestDurationPolicy:
+    @pytest.mark.parametrize(
+        ("gen_seconds", "expected"),
+        [
+            (6.0, 300),
+            (0.02, 1),
+            (0.001, 1),
+            (5.59, 280),
+            (1.0, 50),
+        ],
+    )
+    def test_explicit_duration_rounds_up(self, gen_seconds: float, expected: int):
+        assert resolve_gen_frames(gen_seconds, 0) == expected
+
+    def test_explicit_duration_wins_over_the_source(self):
+        assert resolve_gen_frames(2.0, 500) == 100
+
+    def test_source_length_is_the_default(self):
+        assert resolve_gen_frames(None, 137) == 137
+
+    def test_text_only_without_a_duration_raises(self):
+        with pytest.raises(ValueError, match="gen_seconds is required"):
+            resolve_gen_frames(None, 0)
+
+    @pytest.mark.parametrize("gen_seconds", [0.0, -1.0])
+    def test_non_positive_duration_raises(self, gen_seconds: float):
+        with pytest.raises(ValueError, match="must be positive"):
+            resolve_gen_frames(gen_seconds, 100)
+
+    def test_custom_rate(self):
+        assert resolve_gen_frames(1.0, 0, sample_rate=16000, hop=320) == 50
diff --git a/tests/model_extras/test_model_extras.py b/tests/model_extras/test_model_extras.py
index 6bf823339..a187c570c 100644
--- a/tests/model_extras/test_model_extras.py
+++ b/tests/model_extras/test_model_extras.py
@@ -3,6 +3,7 @@
 
 from __future__ import annotations
 
+import sys
 from typing import Any
 
 import pytest
@@ -177,6 +178,7 @@ def test_cosmos3_extra_registry_declares_request_and_response_params(pipeline_na
             "resolution",
             "image_size",
             "use_state",
+            "format_prompt_as_json",
             "observation",
             "robot_obs",
             "deterministic_seed",
@@ -288,6 +290,16 @@ def test_reference_image_size_policy_threads_revision(monkeypatch: pytest.Monkey
     assert captured == {"model": "org/model", "revision": "pinned-revision"}
 
 
+@pytest.mark.core_model
+@pytest.mark.cpu
+@pytest.mark.parametrize("model_class_name", ["MiniMaxH3Pipeline", "MiniMaxH3ModularPipeline"])
+def test_minimax_h3_preserves_reference_image_size(model_class_name: str) -> None:
+    assert should_preserve_reference_image_size(
+        model_class_name,
+        model="MiniMaxAI/MiniMax-H3",
+    )
+
+
 @pytest.mark.core_model
 @pytest.mark.cpu
 def test_ming_flash_omni_extra_registry_declares_request_and_response_params() -> None:
@@ -591,6 +603,193 @@ def test_declared_extra_args_apply_to_existing_sampling_params() -> None:
     }
 
 
+@pytest.mark.core_model
+@pytest.mark.cpu
+def test_hunyuan_image3_extra_registry_declares_request_and_response_params() -> None:
+    assert get_extra_body_params("HunyuanImage3Pipeline") == frozenset(
+        {
+            "bot_task",
+            "use_system_prompt",
+            "system_prompt",
+            "negative_prompt",
+        }
+    )
+    assert get_extra_output_params("HunyuanImage3Pipeline") == frozenset()
+    assert should_init_extra_args_for_non_diffusion_stages("HunyuanImage3Pipeline") is True
+
+
+@pytest.mark.core_model
+@pytest.mark.cpu
+def test_hunyuan_image3_extra_registry_matches_runtime_model_class_name() -> None:
+    # od_config.model_class_name resolves to "HunyuanImage3ForCausalMM" at
+    # runtime; "HunyuanImage3Pipeline" is kept only as a compatibility alias.
+    assert get_extra_body_params("HunyuanImage3ForCausalMM") == get_extra_body_params("HunyuanImage3Pipeline")
+    assert get_extra_output_params("HunyuanImage3ForCausalMM") == get_extra_output_params("HunyuanImage3Pipeline")
+    assert should_init_extra_args_for_non_diffusion_stages(
+        "HunyuanImage3ForCausalMM"
+    ) == should_init_extra_args_for_non_diffusion_stages("HunyuanImage3Pipeline")
+
+
+class _FakeHunyuanTokenizer:
+    """Minimal tokenizer with distinct ids so AR token assertions are unambiguous."""
+
+    SPECIAL = {
+        "<|startoftext|>": 1,
+        "<img>": 2,
+        "<think>": 3,
+        "<recaption>": 4,
+    }
+
+    def convert_tokens_to_ids(self, tok: str) -> int:
+        return self.SPECIAL.get(tok, 0)
+
+    def encode(self, text: str, add_special_tokens: bool = False) -> list[int]:
+        # Offset well above the special-id range to avoid collisions.
+        return [500 + len(text)]
+
+
+@pytest.mark.core_model
+@pytest.mark.cpu
+def test_hunyuan_image3_ar_input_builder_registered() -> None:
+    from vllm_omni.model_extras import get_ar_input_builder
+
+    builder = get_ar_input_builder("HunyuanImage3Pipeline")
+    assert builder is not None
+    assert get_ar_input_builder("HunyuanImage3ForCausalMM") is builder
+    # Models without the hook return None.
+    assert get_ar_input_builder("WanVACEPipeline") is None
+    assert get_ar_input_builder(None) is None
+
+
+@pytest.mark.core_model
+@pytest.mark.cpu
+def test_hunyuan_image3_ar_tokenizer_validator_registered() -> None:
+    from vllm_omni.model_extras import get_ar_tokenizer_validator
+
+    validator = get_ar_tokenizer_validator("HunyuanImage3Pipeline")
+    assert validator is not None
+    assert get_ar_tokenizer_validator("HunyuanImage3ForCausalMM") is validator
+    # Models without the hook return None.
+    assert get_ar_tokenizer_validator("WanVACEPipeline") is None
+    assert get_ar_tokenizer_validator(None) is None
+
+
+@pytest.mark.core_model
+@pytest.mark.cpu
+def test_hunyuan_image3_build_ar_stage_inputs_t2i_string_fallback() -> None:
+    from vllm_omni.model_extras.hunyuan_image3 import build_ar_stage_inputs
+
+    ar = build_ar_stage_inputs(
+        prompt="a red panda",
+        tokenizer=None,
+        extra_body={"bot_task": "recaption"},
+        num_images=0,
+        height=1024,
+        width=1024,
+    )
+    # No tokenizer -> string prompt form; image modality; recaption + explicit
+    # size stops at </recaption> only.
+    assert ar.prompt_token_ids is None
+    assert ar.prompt and "a red panda" in ar.prompt
+    assert ar.modalities == ["image"]
+    assert ar.use_system_prompt
+    assert len(ar.stop_token_ids) == 1
+    # stop_token_ids belong to stage 0 (HunyuanImage3's single AR stage) --
+    # declared explicitly, not inferred by the caller from stage type.
+    assert ar.stage_indices == [0]
+
+
+@pytest.mark.core_model
+@pytest.mark.cpu
+def test_hunyuan_image3_build_ar_stage_inputs_t2i_tokenizer_parity() -> None:
+    from vllm_omni.diffusion.models.hunyuan_image3.prompt_utils import build_prompt_tokens
+    from vllm_omni.model_extras.hunyuan_image3 import build_ar_stage_inputs
+
+    ar = build_ar_stage_inputs(
+        prompt="a red panda",
+        tokenizer=_FakeHunyuanTokenizer(),
+        extra_body={"bot_task": "think"},
+        num_images=0,
+    )
+    expected = build_prompt_tokens("a red panda", _FakeHunyuanTokenizer(), task="t2i", bot_task="think")
+    assert ar.prompt is None
+    assert ar.prompt_token_ids == expected.token_ids
+    assert ar.modalities == ["image"]
+
+
+@pytest.mark.core_model
+@pytest.mark.cpu
+def test_hunyuan_image3_build_ar_stage_inputs_it2i_inserts_image_placeholders() -> None:
+    from vllm_omni.model_extras.hunyuan_image3 import build_ar_stage_inputs
+
+    ar = build_ar_stage_inputs(
+        prompt="edit it",
+        tokenizer=_FakeHunyuanTokenizer(),
+        extra_body={},
+        num_images=2,
+    )
+    # Two reference images -> two <img> placeholder ids (2) in the AR prefill.
+    assert ar.prompt_token_ids is not None
+    assert ar.prompt_token_ids.count(_FakeHunyuanTokenizer.SPECIAL["<img>"]) == 2
+
+
+@pytest.mark.core_model
+@pytest.mark.cpu
+def test_hunyuan_image3_build_ar_stage_inputs_comprehension_text_output() -> None:
+    from vllm_omni.diffusion.models.hunyuan_image3.prompt_utils import (
+        HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS,
+    )
+    from vllm_omni.model_extras.hunyuan_image3 import build_ar_stage_inputs
+
+    # t2t (no image, text output) -> text modality, stop on <answer>.
+    ar_t2t = build_ar_stage_inputs("hi", tokenizer=None, extra_body={}, num_images=0, text_output=True)
+    assert ar_t2t.modalities == ["text"]
+    assert ar_t2t.stop_token_ids == [HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS["<answer>"]]
+
+    # i2t (image, text output) -> single <img> placeholder in the prefill.
+    ar_i2t = build_ar_stage_inputs(
+        "describe", tokenizer=_FakeHunyuanTokenizer(), extra_body={}, num_images=1, text_output=True
+    )
+    assert ar_i2t.modalities == ["text"]
+    assert ar_i2t.prompt_token_ids.count(_FakeHunyuanTokenizer.SPECIAL["<img>"]) == 1
+
+
+class _RealIdHunyuanTokenizer:
+    """Mirrors HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS exactly, so validate_ar_tokenizer
+    accepts it -- unlike _FakeHunyuanTokenizer above, whose ids are deliberately
+    wrong to exercise the drift-detection failure path."""
+
+    unk_token_id = -1
+
+    def convert_tokens_to_ids(self, tok: str) -> int:
+        from vllm_omni.diffusion.models.hunyuan_image3.prompt_utils import (
+            HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS,
+        )
+
+        return HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS.get(tok, self.unk_token_id)
+
+    def encode(self, text: str, add_special_tokens: bool = False) -> list[int]:
+        return [900 + len(text)]
+
+
+def _patch_hunyuan_autotokenizer(monkeypatch: pytest.MonkeyPatch, tokenizer: object) -> list[str]:
+    """Patch the ``AutoTokenizer`` that ``hunyuan_image3.build_x_to_text_prompt``
+    imports locally, recording the models it was asked to load."""
+    calls: list[str] = []
+
+    class _FakeAutoTokenizer:
+        @staticmethod
+        def from_pretrained(model: str, trust_remote_code: bool = False) -> object:
+            calls.append(model)
+            assert trust_remote_code is True
+            return tokenizer
+
+    fake_transformers = type(sys)("transformers")
+    fake_transformers.AutoTokenizer = _FakeAutoTokenizer
+    monkeypatch.setitem(sys.modules, "transformers", fake_transformers)
+    return calls
+
+
 @pytest.mark.core_model
 @pytest.mark.cpu
 def test_mammothmoda2_extra_registry_declares_request_and_response_params() -> None:
@@ -618,6 +817,59 @@ def test_mammothmoda2_extra_registry_declares_request_and_response_params() -> N
     assert wrapper_prompt["additional_information"]["omni_task"] == ["t2i"]
 
 
+@pytest.mark.core_model
+@pytest.mark.cpu
+def test_hunyuan_image3_x_to_text_prompt_builder_t2t(monkeypatch: pytest.MonkeyPatch) -> None:
+    """t2t (no image) routes through build_ar_stage_inputs and stops on <answer>."""
+    from vllm_omni.diffusion.models.hunyuan_image3.prompt_utils import (
+        HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS,
+    )
+    from vllm_omni.model_extras.hunyuan_image3 import build_x_to_text_prompt as hunyuan_build_x_to_text_prompt
+
+    calls = _patch_hunyuan_autotokenizer(monkeypatch, _RealIdHunyuanTokenizer())
+    prompt_dict, stop_token_ids = hunyuan_build_x_to_text_prompt(
+        "tencent/HunyuanImage-3.0-Instruct", "What is the capital of France?", has_image=False
+    )
+
+    assert calls == ["tencent/HunyuanImage-3.0-Instruct"]
+    assert prompt_dict["modalities"] == ["text"]
+    assert prompt_dict["prompt_token_ids"] is not None
+    assert prompt_dict["prompt_token_ids"].count(HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS["<img>"]) == 0
+    assert stop_token_ids == [HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS["<answer>"]]
+
+
+@pytest.mark.core_model
+@pytest.mark.cpu
+def test_hunyuan_image3_x_to_text_prompt_builder_i2t(monkeypatch: pytest.MonkeyPatch) -> None:
+    """i2t (image) inserts exactly one <img> placeholder and still stops on <answer>."""
+    from vllm_omni.diffusion.models.hunyuan_image3.prompt_utils import (
+        HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS,
+    )
+    from vllm_omni.model_extras.hunyuan_image3 import build_x_to_text_prompt as hunyuan_build_x_to_text_prompt
+
+    _patch_hunyuan_autotokenizer(monkeypatch, _RealIdHunyuanTokenizer())
+    prompt_dict, stop_token_ids = hunyuan_build_x_to_text_prompt(
+        "tencent/HunyuanImage-3.0-Instruct", "Describe this image.", has_image=True
+    )
+
+    assert prompt_dict["modalities"] == ["text"]
+    assert prompt_dict["prompt_token_ids"].count(HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS["<img>"]) == 1
+    assert stop_token_ids == [HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS["<answer>"]]
+
+
+@pytest.mark.core_model
+@pytest.mark.cpu
+def test_hunyuan_image3_x_to_text_prompt_builder_validates_tokenizer(monkeypatch: pytest.MonkeyPatch) -> None:
+    """A tokenizer whose special-token ids have drifted must be rejected here too --
+    x_to_text.py (unlike text_to_image.py/image_edit.py) has no registry-driven
+    ar_tokenizer_validator wiring of its own, so this seam must self-validate."""
+    from vllm_omni.model_extras.hunyuan_image3 import build_x_to_text_prompt as hunyuan_build_x_to_text_prompt
+
+    _patch_hunyuan_autotokenizer(monkeypatch, _FakeHunyuanTokenizer())
+    with pytest.raises(ValueError, match="no longer match"):
+        hunyuan_build_x_to_text_prompt("tencent/HunyuanImage-3.0-Instruct", "Hello.", has_image=False)
+
+
 @pytest.mark.core_model
 @pytest.mark.cpu
 def test_mammothmoda2_text_to_image_prompt_builder() -> None:
diff --git a/tests/model_extras/test_shared_script_ar_integration.py b/tests/model_extras/test_shared_script_ar_integration.py
new file mode 100644
index 000000000..4c24134e6
--- /dev/null
+++ b/tests/model_extras/test_shared_script_ar_integration.py
@@ -0,0 +1,427 @@
+# SPDX-License-Identifier: Apache-2.0
+# 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
+``build_ar_stage_inputs`` in isolation, but nothing previously exercised the
+*glue* in ``text_to_image.py`` / ``image_edit.py`` that wires them together:
+resolving the model's declared ``ar_input_builder`` via the registry, loading
+the AR tokenizer, and writing the result onto ``prompt_dict`` /
+``sampling_params_list``. A regression in that glue -- e.g. the registry key
+mismatch fixed in this PR (``HunyuanImage3ForCausalMM`` vs
+``HunyuanImage3Pipeline``), or the ``trust_remote_code`` opt-in being
+silently bypassed -- would not have been caught by the isolated unit tests
+above, since they call ``build_ar_stage_inputs`` directly rather than going
+through the shared script's own code path.
+
+These tests dynamically load the example scripts by file path (``examples/``
+is not an installed package) and call ``_apply_ar_stage_inputs`` the same way
+``main()`` does, with a fake tokenizer standing in for a real HF download.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Any
+
+import pytest
+
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+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)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+class _FakeHunyuanTokenizer:
+    """Mirrors test_model_extras.py's fixture: distinct ids, no network I/O."""
+
+    SPECIAL = {"<|startoftext|>": 1, "<img>": 2, "<think>": 3, "<recaption>": 4}
+
+    def convert_tokens_to_ids(self, tok: str) -> int:
+        return self.SPECIAL.get(tok, 0)
+
+    def encode(self, text: str, add_special_tokens: bool = False) -> list[int]:
+        return [500 + len(text)]
+
+
+@dataclass
+class _FakeARSamplingParams:
+    """Stands in for an LLM (non-diffusion) stage's sampling params."""
+
+    stop_token_ids: list[int] | None = None
+
+
+def _patch_tokenizer_loader(monkeypatch: pytest.MonkeyPatch, module: Any) -> list[dict[str, Any]]:
+    """Patch the ``AutoTokenizer`` the module imports locally, recording calls."""
+    calls: list[dict[str, Any]] = []
+
+    class _FakeAutoTokenizer:
+        @staticmethod
+        def from_pretrained(model: str, trust_remote_code: bool = False) -> _FakeHunyuanTokenizer:
+            calls.append({"model": model, "trust_remote_code": trust_remote_code})
+            return _FakeHunyuanTokenizer()
+
+    monkeypatch.setattr("transformers.AutoTokenizer.from_pretrained", _FakeAutoTokenizer.from_pretrained)
+    return calls
+
+
+def _patch_failing_tokenizer_loader(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Patch AutoTokenizer.from_pretrained to always raise, simulating a
+    missing --trust-remote-code / network / cache failure."""
+
+    class _FailingAutoTokenizer:
+        @staticmethod
+        def from_pretrained(model: str, trust_remote_code: bool = False) -> Any:
+            raise OSError("simulated tokenizer load failure")
+
+    monkeypatch.setattr("transformers.AutoTokenizer.from_pretrained", _FailingAutoTokenizer.from_pretrained)
+
+
+@pytest.mark.parametrize(
+    "module_name,relpath",
+    [
+        ("_shared_text_to_image", "examples/offline_inference/text_to_image/text_to_image.py"),
+        ("_shared_image_edit", "examples/offline_inference/image_to_image/image_edit.py"),
+    ],
+)
+def test_apply_ar_stage_inputs_routes_through_real_registry(
+    monkeypatch: pytest.MonkeyPatch, module_name: str, relpath: str
+) -> None:
+    """The shared script's glue must resolve HunyuanImage3's *real* registry
+    entry (keyed on the runtime ``model_class_name``) and write its output
+    onto the request -- not a stub, not a hardcoded id."""
+    from vllm_omni.model_extras import get_ar_input_builder
+
+    module = _load_module(module_name, relpath)
+    tokenizer_calls = _patch_tokenizer_loader(monkeypatch, module)
+
+    ar_input_builder = get_ar_input_builder("HunyuanImage3ForCausalMM")
+    assert ar_input_builder is not None, (
+        "get_ar_input_builder('HunyuanImage3ForCausalMM') returned None -- "
+        "if this regresses, the shared script silently skips AR-stage "
+        "input building entirely (this is exactly how the registry-key bug "
+        "this PR fixes went undetected)."
+    )
+
+    prompt_dict: dict[str, Any] = {}
+    ar_params = _FakeARSamplingParams()
+    diffusion_params = OmniDiffusionSamplingParams()
+    sampling_params_list: list[Any] = [ar_params, diffusion_params]
+
+    module._apply_ar_stage_inputs(
+        ar_input_builder,
+        model="tencent/HunyuanImage-3.0-Instruct",
+        prompt_text="a red panda",
+        extra_body={"bot_task": "think", "use_system_prompt": "en_recaption"},
+        num_images=0,
+        height=1024,
+        width=1024,
+        prompt_dict=prompt_dict,
+        sampling_params_list=sampling_params_list,
+        trust_remote_code=False,
+    )
+
+    # The tokenizer was loaded exactly once, for the model the user asked for.
+    assert len(tokenizer_calls) == 1
+    assert tokenizer_calls[0]["model"] == "tencent/HunyuanImage-3.0-Instruct"
+
+    # Byte-for-byte tokenizer path: prompt_token_ids populated, not the string form.
+    assert prompt_dict.get("prompt_token_ids"), "AR prefill token-ids were not written onto the request"
+    assert "prompt" not in prompt_dict
+    assert prompt_dict.get("use_system_prompt") == "en_recaption"
+    assert prompt_dict.get("modalities") == ["image"]
+
+    # stop_token_ids reached the AR-stage params, and only those. The diffusion
+    # stage must be left untouched: OmniDiffusionSamplingParams has no
+    # stop_token_ids field, so the helper skipping it means the attribute is
+    # never created (reading it would raise AttributeError, not return None).
+    assert ar_params.stop_token_ids, "AR stage did not receive stop_token_ids"
+    assert not hasattr(diffusion_params, "stop_token_ids"), "diffusion stage params must not receive stop_token_ids"
+
+
+@pytest.mark.parametrize(
+    "module_name,relpath,cli_flag",
+    [
+        ("_shared_text_to_image_trc", "examples/offline_inference/text_to_image/text_to_image.py", False),
+        ("_shared_text_to_image_trc", "examples/offline_inference/text_to_image/text_to_image.py", True),
+    ],
+)
+def test_apply_ar_stage_inputs_respects_trust_remote_code_option(
+    monkeypatch: pytest.MonkeyPatch, module_name: str, relpath: str, cli_flag: bool
+) -> None:
+    """The tokenizer load must use the caller's resolved --trust-remote-code
+    value, not silently default to True regardless of user intent."""
+    from vllm_omni.model_extras import get_ar_input_builder
+
+    module = _load_module(module_name, relpath)
+    tokenizer_calls = _patch_tokenizer_loader(monkeypatch, module)
+    ar_input_builder = get_ar_input_builder("HunyuanImage3ForCausalMM")
+
+    module._apply_ar_stage_inputs(
+        ar_input_builder,
+        model="tencent/HunyuanImage-3.0-Instruct",
+        prompt_text="a red panda",
+        extra_body={},
+        num_images=0,
+        height=1024,
+        width=1024,
+        prompt_dict={},
+        sampling_params_list=[_FakeARSamplingParams(), OmniDiffusionSamplingParams()],
+        trust_remote_code=cli_flag,
+    )
+
+    assert tokenizer_calls[0]["trust_remote_code"] is cli_flag
+
+
+@pytest.mark.parametrize(
+    "module_name,relpath",
+    [
+        ("_shared_text_to_image_validate", "examples/offline_inference/text_to_image/text_to_image.py"),
+        ("_shared_image_edit_validate", "examples/offline_inference/image_to_image/image_edit.py"),
+    ],
+)
+def test_apply_ar_stage_inputs_runs_declared_tokenizer_validator(
+    monkeypatch: pytest.MonkeyPatch, module_name: str, relpath: str
+) -> None:
+    """get_ar_tokenizer_validator's hook must run on a real tokenizer load,
+    and a validation failure must propagate -- not get swallowed by the
+    tokenizer-load try/except (which would silently fall back to the string
+    prompt instead of surfacing the drift)."""
+    from vllm_omni.model_extras import get_ar_input_builder, get_ar_tokenizer_validator
+
+    module = _load_module(module_name, relpath)
+    _patch_tokenizer_loader(monkeypatch, module)
+    ar_input_builder = get_ar_input_builder("HunyuanImage3ForCausalMM")
+    validator = get_ar_tokenizer_validator("HunyuanImage3ForCausalMM")
+    assert validator is not None
+
+    # The fake tokenizer's ids intentionally don't match
+    # HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS, so the real validator must reject it.
+    with pytest.raises(ValueError, match="no longer match"):
+        module._apply_ar_stage_inputs(
+            ar_input_builder,
+            model="tencent/HunyuanImage-3.0-Instruct",
+            prompt_text="a red panda",
+            extra_body={},
+            num_images=0,
+            height=1024,
+            width=1024,
+            prompt_dict={},
+            sampling_params_list=[_FakeARSamplingParams(), OmniDiffusionSamplingParams()],
+            trust_remote_code=False,
+            validate_tokenizer=validator,
+        )
+
+
+@pytest.mark.parametrize(
+    "module_name,relpath,required_argv",
+    [
+        ("_shared_text_to_image_cli", "examples/offline_inference/text_to_image/text_to_image.py", []),
+        # image_edit.py's parser declares --image/--prompt as required (no defaults);
+        # omitting them makes parse_args() raise SystemExit(2) before the assertion
+        # below is ever reached.
+        (
+            "_shared_image_edit_cli",
+            "examples/offline_inference/image_to_image/image_edit.py",
+            ["--image", "dummy.png", "--prompt", "x"],
+        ),
+    ],
+)
+@pytest.mark.parametrize("argv,expected", [([], False), (["--trust-remote-code"], True)])
+def test_trust_remote_code_flag_parses_from_real_cli(
+    monkeypatch: pytest.MonkeyPatch,
+    module_name: str,
+    relpath: str,
+    required_argv: list[str],
+    argv: list[str],
+    expected: bool,
+) -> None:
+    """The other tests in this file call _apply_ar_stage_inputs directly with
+    an already-resolved trust_remote_code bool, which never exercises
+    argparse itself. Closing that specific gap doesn't need a GPU or a model
+    load -- parse_args() only touches sys.argv -- so cover it here instead of
+    the (expensive, one-model-load-per-invocation) full CLI subprocess a
+    stricter GPU e2e test would need."""
+    module = _load_module(module_name, relpath)
+    monkeypatch.setattr(sys, "argv", ["prog", *required_argv, *argv])
+    args = module.parse_args()
+    assert args.trust_remote_code is expected
+
+
+@pytest.mark.parametrize(
+    "module_name,relpath",
+    [
+        ("_shared_text_to_image_failfast", "examples/offline_inference/text_to_image/text_to_image.py"),
+        ("_shared_image_edit_failfast", "examples/offline_inference/image_to_image/image_edit.py"),
+    ],
+)
+def test_apply_ar_stage_inputs_tokenizer_load_failure_raises_by_default(
+    monkeypatch: pytest.MonkeyPatch, module_name: str, relpath: str
+) -> None:
+    """A tokenizer load failure must surface as an error by default, not
+    silently degrade to the string-prompt form -- that degraded form can
+    complete "successfully" with subtly wrong stop tokens, masking the real
+    problem (e.g. a missing --trust-remote-code)."""
+    from vllm_omni.model_extras import get_ar_input_builder
+
+    module = _load_module(module_name, relpath)
+    _patch_failing_tokenizer_loader(monkeypatch)
+    ar_input_builder = get_ar_input_builder("HunyuanImage3ForCausalMM")
+
+    with pytest.raises(OSError, match="simulated tokenizer load failure"):
+        module._apply_ar_stage_inputs(
+            ar_input_builder,
+            model="tencent/HunyuanImage-3.0-Instruct",
+            prompt_text="a red panda",
+            extra_body={},
+            num_images=0,
+            height=1024,
+            width=1024,
+            prompt_dict={},
+            sampling_params_list=[_FakeARSamplingParams(), OmniDiffusionSamplingParams()],
+            trust_remote_code=False,
+        )
+
+
+@pytest.mark.parametrize(
+    "module_name,relpath",
+    [
+        ("_shared_text_to_image_fallback", "examples/offline_inference/text_to_image/text_to_image.py"),
+        ("_shared_image_edit_fallback", "examples/offline_inference/image_to_image/image_edit.py"),
+    ],
+)
+def test_apply_ar_stage_inputs_allow_tokenizer_fallback_option(
+    monkeypatch: pytest.MonkeyPatch, module_name: str, relpath: str
+) -> None:
+    """With allow_tokenizer_fallback=True (the CLI's --allow-tokenizer-fallback),
+    a tokenizer load failure degrades to the string-prompt form instead of
+    raising -- for a deliberate offline-compat run, not the default."""
+    from vllm_omni.model_extras import get_ar_input_builder
+
+    module = _load_module(module_name, relpath)
+    _patch_failing_tokenizer_loader(monkeypatch)
+    ar_input_builder = get_ar_input_builder("HunyuanImage3ForCausalMM")
+
+    prompt_dict: dict[str, Any] = {}
+    module._apply_ar_stage_inputs(
+        ar_input_builder,
+        model="tencent/HunyuanImage-3.0-Instruct",
+        prompt_text="a red panda",
+        extra_body={"bot_task": "recaption"},
+        num_images=0,
+        height=1024,
+        width=1024,
+        prompt_dict=prompt_dict,
+        sampling_params_list=[_FakeARSamplingParams(), OmniDiffusionSamplingParams()],
+        trust_remote_code=False,
+        allow_tokenizer_fallback=True,
+    )
+
+    # No tokenizer -> string-prompt form, not the byte-for-byte token-ids form.
+    assert "prompt_token_ids" not in prompt_dict
+    assert prompt_dict.get("prompt") and "a red panda" in prompt_dict["prompt"]
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/case_filtering.py b/tests/model_tests/diffusion/case_filtering.py
index da1aaa552..9f53edce0 100644
--- a/tests/model_tests/diffusion/case_filtering.py
+++ b/tests/model_tests/diffusion/case_filtering.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 """
 Analogous to: https://github.com/vllm-project/vllm/blob/v0.23.0/tests/models/multimodal/generation/vlm_utils/case_filtering.py
 
@@ -45,7 +48,6 @@ def get_test_group_marks(model_name: str, test_group: list[DiffusionAccs] | None
             f"but the max CI device count is {MAX_CI_DEVICES}. "
         )
 
-    marks.extend(hardware_marks(res={"cuda": "L4"}, num_cards=required_devices))
     # hardware_marks only adds skipif for num_cards > 1, so we currently handle the single-device case
     # directly here. This should probably be handled in a more common way later on.
     assert current_omni_platform is not None and current_omni_platform.device_count is not None
@@ -53,8 +55,10 @@ def get_test_group_marks(model_name: str, test_group: list[DiffusionAccs] | None
     if current_omni_platform.is_cuda() and device_count < required_devices:
         marks.append(pytest.mark.skip(reason=f"Need {required_devices} devices, got {device_count}"))
     if required_devices > 1:
+        marks.extend(hardware_marks(res={"cuda": ["L4", "B200"]}, num_cards=required_devices))
         marks.append(pytest.mark.full_model)
     else:
+        marks.extend(hardware_marks(res={"cuda": "L4"}, num_cards=1))
         marks.append(pytest.mark.core_model)
     return marks
 
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/task_runners.py b/tests/model_tests/diffusion/task_runners.py
index 010d73777..991c74603 100644
--- a/tests/model_tests/diffusion/task_runners.py
+++ b/tests/model_tests/diffusion/task_runners.py
@@ -15,6 +15,8 @@ import numpy as np
 import pytest
 from PIL import Image
 
+from benchmarks.accuracy.common import pil_to_png_bytes
+from tests.helpers.assertions import assert_images_generations_response
 from tests.helpers.runtime import DiffusionResponse, OmniServer, OnlineOmniClient, dummy_messages_from_mix_data
 from tests.model_tests.diffusion.config_types import DiffusionTasks
 from vllm_omni.entrypoints.omni import Omni
@@ -204,6 +206,25 @@ def _run_online_i2i(
     return client.send_diffusion_request(request_config)
 
 
+def _build_online_image_edits_request(model: str, num_images: int) -> dict[str, Any]:
+    """Build a multipart ``/v1/images/edits`` request with repeated image fields."""
+    files = [
+        ("image", (f"image_{index}.png", pil_to_png_bytes(INPUT_IMAGE), "image/png")) for index in range(num_images)
+    ]
+    return {
+        "data": {
+            "model": model,
+            "prompt": PROMPT,
+            "size": f"{WIDTH}x{HEIGHT}",
+            "n": 1,
+            "response_format": "b64_json",
+            "num_inference_steps": 2,
+            "seed": 42,
+        },
+        "files": files,
+    }
+
+
 ### Offline task runners
 def run_and_validate_text_to_image_request(omni: Omni):
     """Run and validate a text to image request."""
@@ -324,6 +345,35 @@ def run_and_validate_online_image_to_image_request(server: OmniServer, client: O
     _validate_images(_get_online_images(_run_online_i2i(server, client)))
 
 
+def run_and_validate_online_image_edits(
+    server: OmniServer,
+    client: OnlineOmniClient,
+    num_images: int,
+    max_multimodal_image_inputs: int,
+):
+    """Run and validate one request through ``/v1/images/edits``."""
+    request = _build_online_image_edits_request(server.model, num_images)
+    if num_images <= max_multimodal_image_inputs:
+        response = client.send_images_edits_http_request(request)[0]
+        assert response.success, response.error_message
+        assert isinstance(response.json_body, dict)
+        assert_images_generations_response(
+            response.json_body,
+            {"json": {"n": 1, "size": f"{WIDTH}x{HEIGHT}"}},
+        )
+    else:
+        err_message = (
+            "Only a single image is supported by this model."
+            if max_multimodal_image_inputs == 1
+            else f"At most {max_multimodal_image_inputs} images are supported"
+        )
+        client.send_images_edits_http_request(
+            request,
+            err_code=400,
+            err_message=err_message,
+        )
+
+
 def run_and_validate_online_determinism(server: OmniServer, client: OnlineOmniClient, task_type: DiffusionTasks):
     """Checks for determinism through the server, dispatching by task type.
 
diff --git a/tests/model_tests/diffusion/test_alignment.py b/tests/model_tests/diffusion/test_alignment.py
index 183ef8659..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,7 +85,12 @@ 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
+    # the real-checkpoint E2E test instead of a tiny model.
+    "AuKPipeline",
 ]
 
 
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 9c7ef8a0a..ef4449501 100644
--- a/tests/model_tests/diffusion/test_common_online.py
+++ b/tests/model_tests/diffusion/test_common_online.py
@@ -7,7 +7,10 @@ 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
 
 from tests.helpers.runtime import OmniServer, OnlineOmniClient
 from tests.model_tests.diffusion.case_filtering import get_parametrized_options
@@ -19,17 +22,36 @@ from tests.model_tests.diffusion.config_types import (
 from tests.model_tests.diffusion.model_settings import DIFFUSION_TEST_SETTINGS
 from tests.model_tests.diffusion.task_runners import (
     run_and_validate_online_determinism,
+    run_and_validate_online_image_edits,
     run_and_validate_online_image_to_image_request,
     run_and_validate_online_image_to_video_request,
     run_and_validate_online_multi_output,
     run_and_validate_online_text_to_image_request,
     run_and_validate_online_text_to_video_request,
 )
+from vllm_omni.diffusion.model_metadata import get_diffusion_model_metadata
 
 # NOTE : Hardware marks are added dynamically based on test requirements
 pytestmark = [pytest.mark.diffusion, pytest.mark.xdist]
 
 
+@pytest.fixture(autouse=True)
+def _disable_global_gpu_cleanup_for_parallel_workers(
+    request: pytest.FixtureRequest,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Do not wait on total GPU usage while sibling xdist workers are active.
+
+    ``cleanup_test_environment`` observes the whole device, not allocations
+    owned by the current worker.  Waiting for the device to fall below its
+    global threshold therefore turns server teardown into a cross-worker
+    barrier when online tests run with xdist.  ``OmniServer`` still tears down
+    its own subprocess tree; retain the broader cleanup for non-xdist runs.
+    """
+    if is_xdist_worker(request):
+        monkeypatch.setattr("tests.helpers.runtime.cleanup_test_environment", lambda: None)
+
+
 @pytest.mark.parametrize(
     "model_name,accelerations,supported_tasks,check_multioutput,check_determinism",
     get_parametrized_options(DIFFUSION_TEST_SETTINGS, online=True),
@@ -48,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,
@@ -66,6 +92,21 @@ def test_online_on_supported_tasks(
                     run_and_validate_online_text_to_image_request(server, client)
                 elif task_type == DiffusionTasks.IMAGE_TO_IMAGE:
                     run_and_validate_online_image_to_image_request(server, client)
+                    max_multimodal_image_inputs = (
+                        get_diffusion_model_metadata(model_name).max_multimodal_image_inputs or 1
+                    )
+                    image_counts = [1]
+                    if max_multimodal_image_inputs != 1:
+                        image_counts.append(max_multimodal_image_inputs)
+                    image_counts.append(max_multimodal_image_inputs + 1)
+                    for num_images in image_counts:
+                        with subtests.test(api="/v1/images/edits", num_images=num_images):
+                            run_and_validate_online_image_edits(
+                                server,
+                                client,
+                                num_images=num_images,
+                                max_multimodal_image_inputs=max_multimodal_image_inputs,
+                            )
                 elif task_type == DiffusionTasks.TEXT_TO_VIDEO:
                     run_and_validate_online_text_to_video_request(server, client)
                 elif task_type == DiffusionTasks.IMAGE_TO_VIDEO:
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_310p_patches.py b/tests/platforms/npu/test_310p_patches.py
index c19dcd997..0db4b9d41 100644
--- a/tests/platforms/npu/test_310p_patches.py
+++ b/tests/platforms/npu/test_310p_patches.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 310P patch wiring.
 
 The tests load patch modules from source with fake Qwen3-TTS dependencies, so
@@ -644,7 +644,11 @@ def test_qwen3_tts_tokenizer_npu_patch_dispatches_fused_ops(monkeypatch: pytest.
     torch.testing.assert_close(norm_out, torch.tensor([[2.0, 3.0]]))
 
 
-def test_qwen3_tts_code2wav_npu_patch_prepares_loaded_decoder(monkeypatch: pytest.MonkeyPatch) -> None:
+def _load_qwen3_tts_code2wav_npu_patch(
+    monkeypatch: pytest.MonkeyPatch,
+    *,
+    platform_dtype_override: bool = True,
+):
     linear_weights = []
     conv_weights = []
 
@@ -674,15 +678,22 @@ def test_qwen3_tts_code2wav_npu_patch_prepares_loaded_decoder(monkeypatch: pytes
             self.prefix = prefix
             self.decoder = FakeDecoder()
 
-        def _npu_decoder_runtime_dtype(self, _device):
-            return torch.float16
-
         def load_weights(self, weights):
             assert list(weights) == []
+            self.decoder.to(dtype=self.vllm_config.model_config.dtype)
+            self.decoder.precompute_snake_caches()
             return {"loaded"}
 
-    logger = SimpleNamespace(info=lambda *_: None, debug=lambda *_: None)
+    if platform_dtype_override:
+
+        def _npu_decoder_runtime_dtype(self, _device: torch.device) -> torch.dtype:
+            return torch.float16
+
+        FakeCode2Wav._npu_decoder_runtime_dtype = _npu_decoder_runtime_dtype  # type: ignore[attr-defined]
+
+    logger = SimpleNamespace(info=lambda *_: None, debug=lambda *_: None, warning=lambda *_: None)
     current_platform = SimpleNamespace(is_npu=lambda: False)
+
     target = _install_fake_module(
         monkeypatch,
         "vllm_omni.model_executor.models.qwen3_tts.qwen3_tts_code2wav",
@@ -702,11 +713,23 @@ def test_qwen3_tts_code2wav_npu_patch_prepares_loaded_decoder(monkeypatch: pytes
     path = _repo_root() / "vllm_omni" / "platforms" / "npu" / "models" / "qwen3_tts.py"
     module = _load_source_module("vllm_omni_test_qwen3_tts_code2wav_npu_patch", path)
     module.apply_qwen3_tts_code2wav_patch()
+    return module, target, linear_weights, conv_weights
 
-    model = target.Qwen3TTSCode2Wav(
-        vllm_config=SimpleNamespace(device_config=SimpleNamespace(device=torch.device("cpu"))),
+
+def _make_patched_code2wav(target, *, dtype=torch.bfloat16):
+    return target.Qwen3TTSCode2Wav(
+        vllm_config=SimpleNamespace(
+            device_config=SimpleNamespace(device=torch.device("cpu")),
+            model_config=SimpleNamespace(dtype=dtype),
+        ),
         prefix="stage1",
     )
+
+
+def test_qwen3_tts_code2wav_npu_patch_prepares_loaded_decoder(monkeypatch: pytest.MonkeyPatch) -> None:
+    module, target, linear_weights, conv_weights = _load_qwen3_tts_code2wav_npu_patch(monkeypatch)
+    model = _make_patched_code2wav(target, dtype=torch.bfloat16)
+
     assert model.load_weights(iter(())) == {"loaded"}
 
     assert model.prefix == "stage1"
@@ -717,4 +740,17 @@ def test_qwen3_tts_code2wav_npu_patch_prepares_loaded_decoder(monkeypatch: pytes
         model.decoder.deconv.weight.data_ptr(),
     }
     assert all(fmt == module._ACL_FORMAT_FRACTAL_Z for _, fmt in conv_weights)
+    assert model.decoder.cache_precompute_calls == 2
+
+
+@pytest.mark.parametrize("dtype", [torch.float32, torch.bfloat16, torch.float16])
+def test_qwen3_tts_code2wav_npu_patch_preserves_stage_dtype(
+    monkeypatch: pytest.MonkeyPatch,
+    dtype: torch.dtype,
+) -> None:
+    _, target, _, _ = _load_qwen3_tts_code2wav_npu_patch(monkeypatch, platform_dtype_override=False)
+    model = _make_patched_code2wav(target, dtype=dtype)
+
+    assert model.load_weights(iter(())) == {"loaded"}
+    assert all(parameter.dtype is dtype for parameter in model.decoder.parameters())
     assert model.decoder.cache_precompute_calls == 1
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/rl_rollout/__init__.py b/tests/rl_rollout/__init__.py
new file mode 100644
index 000000000..4244ce4b4
--- /dev/null
+++ b/tests/rl_rollout/__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/rl_rollout/test_rollout_routes.py b/tests/rl_rollout/test_rollout_routes.py
new file mode 100644
index 000000000..c6a9e2e56
--- /dev/null
+++ b/tests/rl_rollout/test_rollout_routes.py
@@ -0,0 +1,167 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Route-level tests for RL rollout serving endpoints."""
+
+from __future__ import annotations
+
+import pytest
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+from vllm_omni.entrypoints.openai.api_server import router
+from vllm_omni.entrypoints.openai.protocol.rollout import (
+    ErrorObject,
+    RolloutStepResponse,
+    SessionMetadata,
+)
+from vllm_omni.entrypoints.openai.rollout_session import (
+    RolloutSessionClosedError,
+    RolloutSessionNotFoundError,
+)
+
+
+class _FakeRolloutServing:
+    def __init__(self, close_error: Exception | None = None, step_error_code: str | None = None) -> None:
+        self.close_error = close_error
+        self.step_error_code = step_error_code
+        self.step_request = None
+
+    async def step(self, session_id, body):
+        self.step_request = body
+        error = None
+        if self.step_error_code is not None:
+            error = ErrorObject(
+                code=self.step_error_code,
+                message=f"{self.step_error_code}: {session_id}",
+                step_id=body.step_id,
+                committed_step_id=-1,
+            )
+        return RolloutStepResponse(
+            step_id=body.step_id,
+            next_observation=None,
+            model_metadata=SessionMetadata(
+                latency_ms=0.0,
+                steps_generated=0,
+                context_length=0,
+                committed_step_id=-1,
+            ),
+            error=error,
+        )
+
+    async def close_session(self, session_id):
+        if self.close_error is not None:
+            raise self.close_error
+
+
+def _client(serving: _FakeRolloutServing | None = None) -> TestClient:
+    app = FastAPI()
+    app.include_router(router)
+    if serving is not None:
+        app.state.rl_rollout_serving = serving
+    return TestClient(app)
+
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_step_route_rejects_base64_image_payload():
+    serving = _FakeRolloutServing()
+    client = _client(serving)
+
+    response = client.post(
+        "/v1/realtime/sessions/s1/step",
+        json={
+            "step_id": 0,
+            "observation": {"images": {"front": "base64-frames"}},
+            "action": {},
+        },
+    )
+
+    assert response.status_code == 422
+    assert serving.step_request is None
+
+
+def test_step_route_accepts_nested_image_payload():
+    serving = _FakeRolloutServing()
+    client = _client(serving)
+
+    response = client.post(
+        "/v1/realtime/sessions/s1/step",
+        json={
+            "step_id": 0,
+            "observation": {"images": {"observation/exterior_image_1_left": [[[0, 0, 0]]]}},
+            "action": {},
+        },
+    )
+
+    assert response.status_code == 200
+    assert serving.step_request.observation.images == {"observation/exterior_image_1_left": [[[0, 0, 0]]]}
+
+
+def test_step_route_requires_action():
+    client = _client(_FakeRolloutServing())
+
+    response = client.post(
+        "/v1/realtime/sessions/s1/step",
+        json={"step_id": 0, "observation": {}},
+    )
+
+    assert response.status_code == 422
+
+
+def test_step_route_maps_missing_session_to_404():
+    client = _client(_FakeRolloutServing(step_error_code="session_not_found"))
+
+    response = client.post(
+        "/v1/realtime/sessions/s1/step",
+        json={"step_id": 0, "observation": {}, "action": {}},
+    )
+
+    assert response.status_code == 404
+
+
+def test_step_route_maps_closed_session_to_410():
+    client = _client(_FakeRolloutServing(step_error_code="session_closed"))
+
+    response = client.post(
+        "/v1/realtime/sessions/s1/step",
+        json={"step_id": 0, "observation": {}, "action": {}},
+    )
+
+    assert response.status_code == 410
+
+
+def test_step_route_maps_invalid_request_to_400():
+    client = _client(_FakeRolloutServing(step_error_code="invalid_request"))
+
+    response = client.post(
+        "/v1/realtime/sessions/s1/step",
+        json={"step_id": 0, "observation": {}, "action": {}},
+    )
+
+    assert response.status_code == 400
+
+
+def test_close_route_maps_missing_session_to_404():
+    client = _client(_FakeRolloutServing(close_error=RolloutSessionNotFoundError("s1")))
+
+    response = client.post("/v1/realtime/sessions/s1/close")
+
+    assert response.status_code == 404
+
+
+def test_close_route_is_idempotent_for_closed_session():
+    client = _client(_FakeRolloutServing(close_error=RolloutSessionClosedError("s1")))
+
+    response = client.post("/v1/realtime/sessions/s1/close")
+
+    assert response.status_code == 200
+    assert response.json()["closed"] is True
+
+
+def test_rollout_routes_return_501_when_serving_is_unavailable():
+    client = _client()
+
+    response = client.post("/v1/realtime/sessions/s1/close")
+
+    assert response.status_code == 501
diff --git a/tests/rl_rollout/test_rollout_session.py b/tests/rl_rollout/test_rollout_session.py
new file mode 100644
index 000000000..2b3252a1a
--- /dev/null
+++ b/tests/rl_rollout/test_rollout_session.py
@@ -0,0 +1,157 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Unit tests for RolloutSessionStore (RFC #3747, P0)."""
+
+import asyncio
+
+import pytest
+
+from vllm_omni.entrypoints.openai.rollout_session import (
+    RolloutSession,
+    RolloutSessionClosedError,
+    RolloutSessionNotFoundError,
+    RolloutSessionStepError,
+    RolloutSessionStore,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+@pytest.fixture
+def store() -> RolloutSessionStore:
+    return RolloutSessionStore()
+
+
+@pytest.mark.asyncio
+async def test_create_returns_session(store):
+    s = await store.create("s1", model="dreamzero", mode="world_model_env")
+    assert isinstance(s, RolloutSession)
+    assert s.session_id == "s1"
+    assert s.committed_step_id == -1
+    assert s.context_length == 0
+    assert not s.closed
+
+
+@pytest.mark.asyncio
+async def test_get_existing(store):
+    await store.create("s1", model="dreamzero", mode="world_model_env")
+    s = await store.get("s1")
+    assert s.session_id == "s1"
+
+
+@pytest.mark.asyncio
+async def test_get_missing_raises(store):
+    with pytest.raises(RolloutSessionNotFoundError):
+        await store.get("does-not-exist")
+
+
+@pytest.mark.asyncio
+async def test_get_closed_raises(store):
+    await store.create("s1", model="dreamzero", mode="world_model_env")
+    await store.close("s1")
+    with pytest.raises(RolloutSessionClosedError):
+        await store.get("s1")
+
+
+@pytest.mark.asyncio
+async def test_close_missing_raises(store):
+    with pytest.raises(RolloutSessionNotFoundError):
+        await store.close("does-not-exist")
+
+
+@pytest.mark.asyncio
+async def test_close_is_idempotent(store):
+    await store.create("s1", model="dreamzero", mode="world_model_env")
+    await store.close("s1")
+    await store.close("s1")
+    s = await store.get("s1", include_closed=True)
+    assert s.closed
+
+
+@pytest.mark.asyncio
+async def test_advance_updates_committed_step_id(store):
+    await store.create("s1", model="dreamzero", mode="world_model_env")
+    await store.advance("s1", step_id=0)
+    s = await store.get("s1")
+    assert s.committed_step_id == 0
+    assert s.context_length == 1
+
+    await store.advance("s1", step_id=1)
+    s = await store.get("s1")
+    assert s.committed_step_id == 1
+    assert s.context_length == 2
+
+
+@pytest.mark.asyncio
+async def test_advance_rejects_duplicate_step_id(store):
+    await store.create("s1", model="dreamzero", mode="world_model_env")
+    await store.advance("s1", step_id=0)
+    with pytest.raises(RolloutSessionStepError):
+        await store.advance("s1", step_id=0)
+
+    s = await store.get("s1")
+    assert s.committed_step_id == 0
+    assert s.context_length == 1
+
+
+@pytest.mark.asyncio
+async def test_advance_rejects_out_of_order_step_id(store):
+    await store.create("s1", model="dreamzero", mode="world_model_env")
+    with pytest.raises(RolloutSessionStepError):
+        await store.advance("s1", step_id=2)
+
+    s = await store.get("s1")
+    assert s.committed_step_id == -1
+    assert s.context_length == 0
+
+
+@pytest.mark.asyncio
+async def test_reset_clears_state(store):
+    await store.create("s1", model="dreamzero", mode="world_model_env")
+    await store.advance("s1", step_id=0)
+    await store.advance("s1", step_id=1)
+    await store.advance("s1", step_id=2)
+    await store.advance("s1", step_id=3)
+    await store.reset("s1")
+    s = await store.get("s1")
+    assert s.committed_step_id == -1
+    assert s.context_length == 0
+
+
+@pytest.mark.asyncio
+async def test_reset_closed_raises(store):
+    await store.create("s1", model="dreamzero", mode="world_model_env")
+    await store.close("s1")
+    with pytest.raises(RolloutSessionClosedError):
+        await store.reset("s1")
+
+
+@pytest.mark.asyncio
+async def test_failed_step_does_not_advance(store):
+    """committed_step_id must not change when a step raises (RFC section 6.5 invariant)."""
+    await store.create("s1", model="dreamzero", mode="world_model_env")
+    await store.advance("s1", step_id=0)
+
+    # Simulate a failed step: advance is NOT called
+    s = await store.get("s1")
+    assert s.committed_step_id == 0  # unchanged
+
+
+@pytest.mark.asyncio
+async def test_concurrent_steps_are_serialised(store):
+    """Per-session lock must prevent concurrent context mutations."""
+    await store.create("s1", model="dreamzero", mode="world_model_env")
+    s = await store.get("s1")
+
+    results: list[int] = []
+
+    async def slow_advance(step_id: int, delay: float) -> None:
+        await asyncio.sleep(delay)
+        async with s.lock:
+            await asyncio.sleep(0.01)
+            await store.advance("s1", step_id=step_id)
+            results.append(step_id)
+
+    await asyncio.gather(slow_advance(0, 0.0), slow_advance(1, 0.01))
+    # Both steps ran under the per-session lock and committed in order.
+    assert sorted(results) == [0, 1]
diff --git a/tests/rl_rollout/test_serving_rl_rollout.py b/tests/rl_rollout/test_serving_rl_rollout.py
new file mode 100644
index 000000000..5474ebc20
--- /dev/null
+++ b/tests/rl_rollout/test_serving_rl_rollout.py
@@ -0,0 +1,371 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Unit tests for ServingRLRollout (RFC #3747, P0).
+
+The DreamZero engine is mocked. Tests verify session lifecycle, step_id
+semantics, committed_step_id invariants, and error paths without a GPU.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+from unittest.mock import MagicMock
+
+import numpy as np
+import pytest
+
+from vllm_omni.entrypoints.openai.protocol.rollout import (
+    Action,
+    CreateSessionRequest,
+    Observation,
+    RolloutStepRequest,
+)
+from vllm_omni.entrypoints.openai.serving_rl_rollout import ServingRLRollout
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _make_fake_result(video: Any = None, *, formatter_shaped: bool = True) -> MagicMock:
+    result = MagicMock()
+    if video is None:
+        video = np.zeros((1, 3, 64, 64), dtype=np.float32)
+    if formatter_shaped:
+        # Matches output_formatter: video is peeled into images; mm only has actions.
+        result.images = video
+        result.multimodal_output = {"actions": np.zeros((1, 8), dtype=np.float32)}
+    else:
+        result.images = None
+        result.multimodal_output = {"video": video}
+    return result
+
+
+def _make_openpi(video: Any = None, raises: Exception | None = None, *, formatter_shaped: bool = True):
+    openpi = MagicMock()
+    openpi.engine_client = MagicMock()
+    openpi.model_name = None
+
+    async def _generate(*_, **__):
+        if raises:
+            raise raises
+        yield _make_fake_result(video, formatter_shaped=formatter_shaped)
+
+    openpi.engine_client.generate = _generate
+    openpi.build_request = MagicMock(
+        return_value=MagicMock(
+            prompt="",
+            prompts=[""],
+            request_id="test-req",
+            sampling_params=MagicMock(),
+        )
+    )
+    return openpi
+
+
+@pytest.fixture
+def serving() -> ServingRLRollout:
+    return ServingRLRollout(_make_openpi())
+
+
+# ---------------------------------------------------------------------------
+# Session lifecycle
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_create_session(serving):
+    resp = await serving.create_session(CreateSessionRequest(model="dreamzero", mode="world_model_env"))
+    assert resp.session_id
+    assert resp.mode == "world_model_env"
+
+
+@pytest.mark.asyncio
+async def test_get_status_after_create(serving):
+    resp = await serving.create_session(CreateSessionRequest(model="dreamzero", mode="world_model_env"))
+    status = await serving.get_status(resp.session_id)
+    assert status.committed_step_id == -1
+    assert status.context_length == 0
+    assert not status.closed
+
+
+@pytest.mark.asyncio
+async def test_close_session(serving):
+    resp = await serving.create_session(CreateSessionRequest(model="dreamzero", mode="world_model_env"))
+    await serving.close_session(resp.session_id)
+    status = await serving.get_status(resp.session_id)
+    assert status.closed
+    assert status.committed_step_id == -1
+    serving._openpi.drop_session.assert_any_call(resp.session_id)
+    serving._openpi.drop_session.assert_any_call(f"{resp.session_id}:stateless")
+
+
+# ---------------------------------------------------------------------------
+# Step - success path
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_successful_step_advances_committed_step_id(serving):
+    sess = await serving.create_session(CreateSessionRequest(model="dreamzero", mode="world_model_env"))
+    req = RolloutStepRequest(
+        step_id=0,
+        observation=Observation(state=[0.1, 0.2]),
+        action=Action(joint_positions=[0.0] * 7),
+    )
+    resp = await serving.step(sess.session_id, req)
+    assert resp.error is None
+    assert resp.model_metadata.committed_step_id == 0
+
+    status = await serving.get_status(sess.session_id)
+    assert status.committed_step_id == 0
+    assert status.context_length == 1
+
+
+@pytest.mark.asyncio
+async def test_repeated_steps_advance_monotonically(serving):
+    sess = await serving.create_session(CreateSessionRequest(model="dreamzero", mode="world_model_env"))
+    for i in range(3):
+        req = RolloutStepRequest(
+            step_id=i,
+            observation=Observation(state=[float(i)]),
+            action=Action(joint_positions=[0.0] * 7),
+        )
+        resp = await serving.step(sess.session_id, req)
+        assert resp.error is None
+        assert resp.model_metadata.committed_step_id == i
+
+    status = await serving.get_status(sess.session_id)
+    assert status.committed_step_id == 2
+    assert status.context_length == 3
+
+
+@pytest.mark.asyncio
+async def test_next_observation_present_on_success(serving):
+    sess = await serving.create_session(CreateSessionRequest(model="dreamzero", mode="world_model_env"))
+    req = RolloutStepRequest(
+        step_id=0,
+        observation=Observation(),
+        action=Action(),
+    )
+    resp = await serving.step(sess.session_id, req)
+    assert resp.next_observation is not None
+    assert "video_latent" in resp.next_observation
+    assert resp.next_observation["dtype"] == "float32"
+
+
+@pytest.mark.asyncio
+async def test_duplicate_step_does_not_rerun_or_advance(serving):
+    sess = await serving.create_session(CreateSessionRequest(model="dreamzero", mode="world_model_env"))
+    req = RolloutStepRequest(step_id=0, observation=Observation(), action=Action())
+    assert (await serving.step(sess.session_id, req)).error is None
+
+    resp = await serving.step(sess.session_id, req)
+
+    assert resp.error is not None
+    assert resp.error.code == "step_already_committed"
+    assert resp.model_metadata.committed_step_id == 0
+    assert resp.model_metadata.context_length == 1
+    serving._openpi.build_request.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_out_of_order_step_does_not_rerun_or_advance(serving):
+    sess = await serving.create_session(CreateSessionRequest(model="dreamzero", mode="world_model_env"))
+    req = RolloutStepRequest(step_id=2, observation=Observation(), action=Action())
+
+    resp = await serving.step(sess.session_id, req)
+
+    assert resp.error is not None
+    assert resp.error.code == "step_out_of_order"
+    assert resp.model_metadata.committed_step_id == -1
+    assert resp.model_metadata.context_length == 0
+    serving._openpi.build_request.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_stateless_step_does_not_commit_context(serving):
+    sess = await serving.create_session(CreateSessionRequest(model="dreamzero", mode="world_model_env"))
+    req = RolloutStepRequest(
+        step_id=7,
+        observation=Observation(),
+        action=Action(),
+        use_session_context=False,
+    )
+
+    resp = await serving.step(sess.session_id, req)
+
+    assert resp.error is None
+    assert resp.model_metadata.committed_step_id == -1
+    assert resp.model_metadata.context_length == 0
+    serving._openpi.build_request.assert_called_once()
+    kwargs = serving._openpi.build_request.call_args.kwargs
+    assert kwargs["reset"] is True
+    assert kwargs["session_id"] == f"{sess.session_id}:stateless"
+
+
+# ---------------------------------------------------------------------------
+# Step - failure path: committed_step_id must NOT advance
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_failed_step_does_not_advance_committed_step_id():
+    serving = ServingRLRollout(_make_openpi(raises=RuntimeError("engine dead")))
+    sess = await serving.create_session(CreateSessionRequest(model="dreamzero", mode="world_model_env"))
+    req = RolloutStepRequest(step_id=0, observation=Observation(), action=Action())
+    resp = await serving.step(sess.session_id, req)
+
+    assert resp.error is not None
+    assert resp.error.code == "inference_error"
+    assert resp.model_metadata.committed_step_id == -1  # must not have advanced
+
+    status = await serving.get_status(sess.session_id)
+    assert status.committed_step_id == -1
+
+
+@pytest.mark.asyncio
+async def test_output_encoding_failure_does_not_advance_committed_step_id():
+    class BadVideo:
+        def detach(self):
+            return self
+
+        def float(self):
+            return self
+
+        def cpu(self):
+            return self
+
+        def numpy(self):
+            raise TypeError("cannot encode")
+
+    serving = ServingRLRollout(_make_openpi(video=BadVideo()))
+    sess = await serving.create_session(CreateSessionRequest(model="dreamzero", mode="world_model_env"))
+    req = RolloutStepRequest(step_id=0, observation=Observation(), action=Action())
+
+    resp = await serving.step(sess.session_id, req)
+
+    assert resp.error is not None
+    assert resp.error.code == "inference_error"
+    assert resp.model_metadata.committed_step_id == -1
+    status = await serving.get_status(sess.session_id)
+    assert status.committed_step_id == -1
+
+
+@pytest.mark.asyncio
+async def test_failed_step_after_success_preserves_last_committed():
+    good_serving = ServingRLRollout(_make_openpi())
+    sess = await good_serving.create_session(CreateSessionRequest(model="dreamzero", mode="world_model_env"))
+    # Step 0 succeeds
+    await good_serving.step(sess.session_id, RolloutStepRequest(step_id=0, observation=Observation(), action=Action()))
+
+    # Swap engine to failing one - reuse the same store via internal reference
+    good_serving._openpi = _make_openpi(raises=RuntimeError("oops"))
+    resp = await good_serving.step(
+        sess.session_id, RolloutStepRequest(step_id=1, observation=Observation(), action=Action())
+    )
+    assert resp.error is not None
+    assert resp.model_metadata.committed_step_id == 0  # still at last good step
+    assert resp.model_metadata.context_length == 1
+
+
+# ---------------------------------------------------------------------------
+# Step - unknown session
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_step_unknown_session_returns_error(serving):
+    req = RolloutStepRequest(step_id=0, observation=Observation(), action=Action())
+    resp = await serving.step("no-such-session", req)
+    assert resp.error is not None
+    assert resp.error.code == "session_not_found"
+
+
+# ---------------------------------------------------------------------------
+# Reset
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_reset_clears_committed_step_id(serving):
+    sess = await serving.create_session(CreateSessionRequest(model="dreamzero", mode="world_model_env"))
+    await serving.step(sess.session_id, RolloutStepRequest(step_id=0, observation=Observation(), action=Action()))
+    await serving.reset_session(sess.session_id)
+    status = await serving.get_status(sess.session_id)
+    assert status.committed_step_id == -1
+    assert status.context_length == 0
+    serving._openpi.drop_session.assert_called_with(sess.session_id)
+
+
+# ---------------------------------------------------------------------------
+# action -> obs folding (module assumption)
+# ---------------------------------------------------------------------------
+
+
+def test_merge_action_into_obs_emits_dreamzero_state_keys():
+    from vllm_omni.entrypoints.openai.serving_rl_rollout import _merge_action_into_obs
+
+    obs = Observation(state=[9.0] * 8, prompt="test")
+    action = Action(joint_positions=[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0], gripper_position=0.5)
+    result = _merge_action_into_obs(obs, action)
+
+    assert result["prompt"] == "test"
+    np.testing.assert_array_almost_equal(result["observation/joint_position"], [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0])
+    np.testing.assert_array_almost_equal(result["observation/gripper_position"], [0.5])
+
+
+def test_merge_action_none_splits_obs_state_for_dreamzero():
+    from vllm_omni.entrypoints.openai.serving_rl_rollout import _merge_action_into_obs
+
+    obs = Observation(state=[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 0.25])
+    result = _merge_action_into_obs(obs, None)
+    np.testing.assert_array_almost_equal(result["observation/joint_position"], [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0])
+    np.testing.assert_array_almost_equal(result["observation/gripper_position"], [0.25])
+
+
+def test_merge_no_state_no_action_omits_state_key():
+    from vllm_omni.entrypoints.openai.serving_rl_rollout import _merge_action_into_obs
+
+    obs = Observation()
+    result = _merge_action_into_obs(obs, None)
+    assert "observation/joint_position" not in result
+    assert "observation/gripper_position" not in result
+
+
+def test_merge_rejects_wrong_dreamzero_joint_dimension():
+    from vllm_omni.entrypoints.openai.serving_rl_rollout import _merge_action_into_obs
+
+    with pytest.raises(ValueError, match="joint_positions must have 7 values"):
+        _merge_action_into_obs(Observation(), Action(joint_positions=[1.0, 2.0]))
+
+
+@pytest.mark.asyncio
+async def test_step_reads_formatter_images_not_multimodal_video():
+    video = np.ones((1, 3, 8, 8), dtype=np.float32)
+    serving = ServingRLRollout(_make_openpi(video=video, formatter_shaped=True))
+    sess = await serving.create_session(CreateSessionRequest(model="dreamzero", mode="world_model_env"))
+    resp = await serving.step(
+        sess.session_id,
+        RolloutStepRequest(step_id=0, observation=Observation(), action=Action()),
+    )
+    assert resp.error is None
+    assert resp.next_observation is not None
+    assert "video_latent" in resp.next_observation
+    assert resp.next_observation["shape"] == [1, 3, 8, 8]
+
+
+@pytest.mark.asyncio
+async def test_step_falls_back_to_multimodal_video():
+    video = np.ones((2, 4, 4), dtype=np.float32)
+    serving = ServingRLRollout(_make_openpi(video=video, formatter_shaped=False))
+    sess = await serving.create_session(CreateSessionRequest(model="dreamzero", mode="world_model_env"))
+    resp = await serving.step(
+        sess.session_id,
+        RolloutStepRequest(step_id=0, observation=Observation(), action=Action()),
+    )
+    assert resp.error is None
+    assert resp.next_observation is not None
+    assert resp.next_observation["shape"] == [2, 4, 4]
diff --git a/tests/tools/test_check_tts_adapter.py b/tests/tools/test_check_tts_adapter.py
index 47c6ac89f..3107900c0 100644
--- a/tests/tools/test_check_tts_adapter.py
+++ b/tests/tools/test_check_tts_adapter.py
@@ -63,7 +63,15 @@ def test_gate_passes_on_current_tree():
     assert main([]) == 0
 
 
-def test_budgets_are_the_real_counts():
+def test_budgets_are_not_exceeded():
+    """Budgets are a ceiling, not a target.
+
+    This used to assert equality, which re-imposed through pytest exactly what
+    #6008 removed from the checker: a PR that deleted branches failed CI unless
+    it also hand-edited the constant. That is what broke `main` for 5h19m in
+    #5746. The checker reports an under-budget count as a passing notice
+    (check_tts_adapter.py:140); the test must agree.
+    """
     root = Path(__file__).resolve().parents[2]
     serving = root / "vllm_omni" / "entrypoints" / "openai" / "serving_speech.py"
-    assert len(_model_type_branches(ast.parse(serving.read_text()))) == MAX_MODEL_TYPE_BRANCHES
+    assert len(_model_type_branches(ast.parse(serving.read_text()))) <= MAX_MODEL_TYPE_BRANCHES
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 be282da81..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"),
@@ -231,6 +240,7 @@ def test_speech_extra_params_reach_model_sampler_as_sampling_metadata(monkeypatc
     serving._tts_model_type = "higgs_audio_v3"
     serving._get_tts_adapter = lambda: Adapter()
     serving._track_ref_audio_artifact_warmup = lambda *args, **kwargs: None
+    serving._speech_output_policies = {}
 
     _, stage_sampling_params, _ = asyncio.run(serving._prepare_speech_generation(request, request_id="speech-test"))
     stage0_params = stage_sampling_params[0]
@@ -264,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,
@@ -322,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)
 
@@ -376,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)
 
@@ -465,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,
@@ -641,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)
 
@@ -655,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,
@@ -698,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()}
 
@@ -744,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()}
 
@@ -789,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,
@@ -818,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),
@@ -845,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,
@@ -907,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)
@@ -945,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",
@@ -1094,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",
@@ -1171,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 c47802fbc..1b1bf4b7e 100644
--- a/tests/worker/test_native_duplex_hooks.py
+++ b/tests/worker/test_native_duplex_hooks.py
@@ -23,7 +23,7 @@ def _minicpmo_duplex_policy_case(
         MiniCPMO45OmniForConditionalGeneration,
     )
 
-    session_key = ("sid-policy", 1)
+    session_key = "sid-policy"
     model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
     model.model_stage = "llm"
     model._minicpmo45_native_duplex_token_ids_cache = {
@@ -35,8 +35,7 @@ def _minicpmo_duplex_policy_case(
     row = DuplexSamplingRow(
         row_idx=0,
         request_id="req-policy",
-        session_id=session_key[0],
-        incarnation=session_key[1],
+        session_id=session_key,
         seq=3,
         payload=payload,
         max_tokens=20,
@@ -63,13 +62,12 @@ def test_minicpmo_model_hook_owns_duplex_sampling_rows_and_force_listen():
         "tts_bos_token_id": 8,
         "turn_eos_token_id": 9,
     }
-    model._minicpmo45_duplex_data_plane_helper = SimpleNamespace(sessions={("sid-hook", 2): state})
+    model._minicpmo45_duplex_data_plane_helper = SimpleNamespace(sessions={"sid-hook": state})
     logits = torch.zeros((1, 16), dtype=torch.float32)
     row = DuplexSamplingRow(
         row_idx=0,
         request_id="req-hook",
         session_id="sid-hook",
-        incarnation=2,
         seq=3,
         payload={"force_listen": True, "is_speech": True},
         max_tokens=20,
@@ -78,7 +76,7 @@ def test_minicpmo_model_hook_owns_duplex_sampling_rows_and_force_listen():
     model.prepare_duplex_sampling(logits, SimpleNamespace(), (row,))
 
     assert model._minicpmo45_active_duplex_rows == [0]
-    assert model._minicpmo45_duplex_row_sessions == {0: ("sid-hook", 2)}
+    assert model._minicpmo45_duplex_row_sessions == {0: "sid-hook"}
     assert model._minicpmo45_duplex_row_payloads == {0: row.payload}
     assert model._minicpmo45_duplex_row_max_tokens == {0: 20}
     assert logits[0, listen_id].item() == 0.0
@@ -152,7 +150,7 @@ def test_minicpmo_model_hook_old_response_output_does_not_clear_pending_speech_c
         pending_speech_context=True,
     )
     model, row = _minicpmo_duplex_policy_case(state, {"is_speech": True})
-    model._minicpmo45_duplex_row_sessions = {0: (row.session_id, row.incarnation)}
+    model._minicpmo45_duplex_row_sessions = {0: row.session_id}
     model._minicpmo45_duplex_row_payloads = {0: row.payload}
 
     model._record_minicpmo45_duplex_terminator(
@@ -173,7 +171,7 @@ def test_minicpmo_model_hook_new_response_output_clears_pending_speech_context()
         pending_speech_context=True,
     )
     model, row = _minicpmo_duplex_policy_case(state, {"is_speech": False})
-    model._minicpmo45_duplex_row_sessions = {0: (row.session_id, row.incarnation)}
+    model._minicpmo45_duplex_row_sessions = {0: row.session_id}
     model._minicpmo45_duplex_row_payloads = {0: row.payload}
 
     model._record_minicpmo45_duplex_terminator(
@@ -195,7 +193,7 @@ def test_minicpmo_model_hook_empty_speak_envelope_preserves_pending_speech_conte
         pending_speech_response_open=False,
     )
     model, row = _minicpmo_duplex_policy_case(state, {"is_speech": False})
-    model._minicpmo45_duplex_row_sessions = {0: (row.session_id, row.incarnation)}
+    model._minicpmo45_duplex_row_sessions = {0: row.session_id}
     model._minicpmo45_duplex_row_payloads = {0: row.payload}
     token_ids = {
         "listen_token_id": 7,
@@ -236,7 +234,7 @@ def test_minicpmo_model_hook_second_new_response_step_is_not_forced_to_listen():
     original_logits = logits.clone()
 
     model.prepare_duplex_sampling(logits, SimpleNamespace(), (row,))
-    model._minicpmo45_duplex_row_sessions = {0: (row.session_id, row.incarnation)}
+    model._minicpmo45_duplex_row_sessions = {0: row.session_id}
     model._minicpmo45_duplex_row_payloads = {0: row.payload}
     model._record_minicpmo45_duplex_terminator(
         0,
@@ -269,7 +267,7 @@ def test_minicpmo_model_hook_same_speech_row_second_step_does_not_rearm_pending_
     logits[0, 10] = 20.0
 
     model.prepare_duplex_sampling(logits, SimpleNamespace(), (row,))
-    model._minicpmo45_duplex_row_sessions = {0: (row.session_id, row.incarnation)}
+    model._minicpmo45_duplex_row_sessions = {0: row.session_id}
     model._minicpmo45_duplex_row_payloads = {0: row.payload}
     model._record_minicpmo45_duplex_terminator(
         0,
@@ -339,7 +337,6 @@ def test_generic_ar_runner_builds_typed_duplex_sampling_rows():
             "duplex": {
                 "data_plane": True,
                 "session_id": "sid-runner-hook",
-                "incarnation": 4,
                 "seq": 4,
                 "payload": {"is_speech": True},
             }
@@ -359,7 +356,6 @@ def test_generic_ar_runner_builds_typed_duplex_sampling_rows():
     assert rows[0].row_idx == 0
     assert rows[0].request_id == "req-duplex"
     assert rows[0].session_id == "sid-runner-hook"
-    assert rows[0].incarnation == 4
     assert rows[0].seq == 4
     assert rows[0].payload == {"is_speech": True}
     assert rows[0].max_tokens == 32
@@ -458,13 +454,13 @@ def test_generic_ar_runner_has_no_minicpmo_sampler_state_or_typeerror_probe():
     assert 'if "duplex_rows" not in str(exc)' not in source
 
 
-def test_minicpmo_model_cleans_incarnation_state_when_request_finishes():
+def test_minicpmo_model_cleans_session_state_when_request_finishes():
     from vllm_omni.model_executor.models.minicpmo_4_5.minicpmo_4_5_omni import (
         MiniCPMO45OmniForConditionalGeneration,
     )
 
     request_id = "duplex-sid-cleanup-i3-e0-stage0"
-    session_key = ("sid-cleanup", 3)
+    session_key = "sid-cleanup"
     model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
     model.model = SimpleNamespace()
     model._minicpmo45_duplex_data_plane_helper = SimpleNamespace(sessions={session_key: object()})
@@ -1731,8 +1727,8 @@ def test_minicpmo_stage0_native_sampler_penalizes_text_from_prior_chunk():
     model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
     model.model_stage = "llm"
     model.thinker = SimpleNamespace(get_tokenizer=lambda: _Tokenizer())
-    session_key = ("sid-cross-chunk-repetition", 0)
-    state = _MiniCPMO45Stage0SessionState(session_id=session_key[0])
+    session_key = "sid-cross-chunk-repetition"
+    state = _MiniCPMO45Stage0SessionState(session_id=session_key)
     state.generated_tokens = [198] * 8
     model._minicpmo45_duplex_data_plane_helper = SimpleNamespace(sessions={session_key: state})
     model._minicpmo45_duplex_row_sessions = {0: session_key}
@@ -1791,8 +1787,8 @@ def test_minicpmo_stage0_native_sampler_matches_official_negative_logit_penalty(
     model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
     model.model_stage = "llm"
     model.thinker = SimpleNamespace(get_tokenizer=lambda: _Tokenizer())
-    session_key = ("sid-negative-logit-repetition", 0)
-    state = _MiniCPMO45Stage0SessionState(session_id=session_key[0])
+    session_key = "sid-negative-logit-repetition"
+    state = _MiniCPMO45Stage0SessionState(session_id=session_key)
     repeated = 198
     alternative = 1234
     state.generated_tokens = [repeated]
@@ -1827,8 +1823,8 @@ def test_minicpmo_stage0_records_bounded_model_policy_history():
         MiniCPMO45OmniForConditionalGeneration,
     )
 
-    session_key = ("sid-text-history", 0)
-    state = _MiniCPMO45Stage0SessionState(session_id=session_key[0])
+    session_key = "sid-text-history"
+    state = _MiniCPMO45Stage0SessionState(session_id=session_key)
     model = MiniCPMO45OmniForConditionalGeneration.__new__(MiniCPMO45OmniForConditionalGeneration)
     model._minicpmo45_duplex_data_plane_helper = SimpleNamespace(sessions={session_key: state})
     model._minicpmo45_duplex_row_sessions = {0: session_key}
@@ -2643,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 8366e177a..bdf9936a4 100644
--- a/tests/worker/test_omni_connector_mixin.py
+++ b/tests/worker/test_omni_connector_mixin.py
@@ -10,6 +10,7 @@ from __future__ import annotations
 
 import time
 import unittest
+from copy import deepcopy
 from types import SimpleNamespace
 from typing import Any
 from unittest.mock import MagicMock, patch
@@ -20,6 +21,10 @@ import torch
 from vllm_omni.distributed.omni_connectors.kv_transfer_manager import (
     OmniKVTransferManager,
 )
+from vllm_omni.distributed.omni_connectors.utils.config import ConnectorSpec
+from vllm_omni.distributed.omni_connectors.utils.initialization import (
+    resolve_connector_spec,
+)
 from vllm_omni.outputs import OmniConnectorOutput
 from vllm_omni.worker.omni_connector_model_runner_mixin import (
     OmniConnectorModelRunnerMixin,
@@ -392,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",
         ]
@@ -564,6 +569,55 @@ class TestChunkStreamCompletedGuard(unittest.TestCase):
 
         host.shutdown_omni_connectors()
 
+    def test_poll_uses_request_scoped_payload_sender_endpoint(self):
+        host = self._make_host(stage_id=1)
+        host._omni_connector.get = MagicMock(return_value=None)
+        req = _make_request("req-1", "ext-req-1")
+        req.payload_sender_info = {"host": "10.0.0.1", "zmq_port": 50051}
+
+        host.register_chunk_recv(req)
+        host._poll_single_request("req-1")
+
+        host._omni_connector.get.assert_called_once_with(
+            "0",
+            "1",
+            "ext-req-1_0_0",
+            {"source_host": "10.0.0.1", "source_port": 50051},
+        )
+        host.shutdown_omni_connectors()
+
+    def test_concurrent_requests_keep_distinct_payload_sender_endpoints(self):
+        host = self._make_host(stage_id=1)
+        host._omni_connector.get = MagicMock(return_value=None)
+        first = _make_request("req-1", "ext-req-1")
+        first.payload_sender_info = {"host": "10.0.0.1", "zmq_port": 50051}
+        second = _make_request("req-2", "ext-req-2")
+        second.payload_sender_info = {"host": "10.0.0.2", "zmq_port": 51051}
+
+        host.register_chunk_recv(first)
+        host.register_chunk_recv(second)
+        host._poll_single_request("req-2")
+        host._poll_single_request("req-1")
+
+        self.assertEqual(
+            host._omni_connector.get.call_args_list,
+            [
+                unittest.mock.call(
+                    "0",
+                    "1",
+                    "ext-req-2_0_0",
+                    {"source_host": "10.0.0.2", "source_port": 51051},
+                ),
+                unittest.mock.call(
+                    "0",
+                    "1",
+                    "ext-req-1_0_0",
+                    {"source_host": "10.0.0.1", "source_port": 50051},
+                ),
+            ],
+        )
+        host.shutdown_omni_connectors()
+
     def test_finish_sentinel_populates_completed_set(self):
         """Receiving is_finished=True adds to _chunk_stream_completed."""
         host = self._make_host(stage_id=1)
@@ -1381,6 +1435,144 @@ class TestConnectorConfigValidation(unittest.TestCase):
             host.init_omni_connectors(model_config=model_config)
 
 
+class TestRankAwareHandshakePort(unittest.TestCase):
+    """A sender must bind the port the orchestrator advertises for its rank."""
+
+    @staticmethod
+    def _resolve(name, extra, local_rank=0):
+        spec = resolve_connector_spec(
+            ConnectorSpec(name=name, extra=extra),
+            stage_id=int(extra.get("stage_id", 0)),
+            role=extra.get("role"),
+            local_rank=local_rank,
+        )
+        return spec.extra
+
+    def test_sender_port_matches_the_orchestrator_formula(self):
+        for local_rank in (0, 1, 3):
+            with self.subTest(local_rank=local_rank):
+                extra = {"zmq_port": 50071, "stage_id": 2, "role": "sender"}
+                resolved = self._resolve("NixlConnector", extra, local_rank=local_rank)
+                self.assertEqual(resolved["zmq_port"], 50071 + 2 + local_rank * 16)
+                self.assertEqual(extra["zmq_port"], 50071, "the source config must not be mutated")
+
+    def test_receiver_gets_sender_endpoint_without_a_bind_port(self):
+        receiver = self._resolve(
+            "NixlConnector",
+            {"zmq_port": 50071, "stage_id": 3, "from_stage": 2, "role": "receiver"},
+            local_rank=1,
+        )
+        self.assertNotIn("zmq_port", receiver)
+        self.assertEqual(receiver["sender_zmq_port"], 50071 + 2 + 16)
+
+    def test_handshake_less_connector_keeps_its_config(self):
+        shm = self._resolve("SharedMemoryConnector", {"zmq_port": 50071, "role": "sender"}, local_rank=1)
+        self.assertEqual(shm["zmq_port"], 50071)
+
+    def test_unresolvable_port_is_rejected(self):
+        extra = {"zmq_port": "${MISSING_PORT_VAR}", "stage_id": 0, "role": "sender"}
+        with self.assertRaises(ValueError):
+            self._resolve("NixlConnector", extra)
+
+
+@pytest.mark.parametrize(
+    ("extra", "expected"),
+    [
+        (
+            {"role": "sender", "from_stage": 2, "zmq_port": 50071},
+            {"zmq_port": 52153},
+        ),
+        (
+            {"role": "receiver", "from_stage": 1, "zmq_port": 50071, "host": "producer"},
+            {"sender_zmq_port": 52152, "sender_host": "producer"},
+        ),
+        (
+            {
+                "role": "receiver",
+                "from_stage": 1,
+                "zmq_port": 50071,
+                "sender_zmq_port": 49000,
+                "sender_host": "bound-producer",
+                "outgoing": {"from_stage": 2, "zmq_port": 51071, "host": "local-worker"},
+            },
+            {"sender_zmq_port": 49000, "sender_host": "bound-producer", "zmq_port": 53153, "host": "local-worker"},
+        ),
+    ],
+)
+def test_split_runtime_factory_resolves_nixl_endpoints(extra, expected):
+    """The runner must pass the resolved spec, not the raw config, to the factory."""
+    from vllm_omni.distributed.omni_connectors.model_runner import omni_connector_runtime as runtime
+
+    original = deepcopy(extra)
+    config = SimpleNamespace(stage_id=2, stage_connector_config={"name": "NixlConnector", "extra": extra})
+    with (
+        patch.object(runtime, "get_local_tp_rank", return_value=2, create=True),
+        patch.object(runtime, "get_omni_replica_id", return_value=2, create=True),
+        patch.object(runtime.OmniConnectorFactory, "create_connector") as factory,
+    ):
+        assert MixinHost._create_connector(config) is factory.return_value
+
+    spec = factory.call_args.args[0]
+    assert spec.name == "NixlConnector"
+    assert spec.extra["stage_id"] == 2
+    for key, value in expected.items():
+        assert spec.extra[key] == value
+    if extra["role"] == "receiver" and "outgoing" not in extra:
+        assert "zmq_port" not in spec.extra
+    assert extra == original
+
+
+@pytest.mark.parametrize("async_chunk", [False, True])
+def test_split_payload_endpoint_retry_cleanup_and_reuse(async_chunk):
+    host = MixinHost()
+    host.init_omni_connectors(_make_model_config(async_chunk=async_chunk))
+    host._stage_id = 1
+    host._omni_connector = MagicMock()
+    host._omni_connector.get.return_value = None
+    first = _make_request("req-1", "ext-req-1")
+    first.payload_sender_info = {"host": "producer-a", "zmq_port": "50051"}
+    second = _make_request("req-2", "ext-req-2")
+    second.payload_sender_info = {"host": "producer-b", "zmq_port": 51051}
+
+    try:
+        host.register_chunk_recv(first)
+        host.register_chunk_recv(second)
+        for req_id in ("req-1", "req-2", "req-1"):
+            assert not host._poll_single_request(req_id)
+        assert host._omni_connector.get.call_args_list == [
+            unittest.mock.call("0", "1", "ext-req-1_0_0", {"source_host": "producer-a", "source_port": 50051}),
+            unittest.mock.call("0", "1", "ext-req-2_0_0", {"source_host": "producer-b", "source_port": 51051}),
+            unittest.mock.call("0", "1", "ext-req-1_0_0", {"source_host": "producer-a", "source_port": 50051}),
+        ]
+        host.cleanup_finished_request("req-1")
+        assert "req-1" not in host._pending_load_reqs
+        assert host._pending_load_reqs["req-2"] is second
+        host.register_chunk_recv(_make_request("req-1", "reused"))
+        assert not host._poll_single_request("req-1")
+        host._omni_connector.get.assert_called_with("0", "1", "reused_0_0")
+    finally:
+        host.shutdown_omni_connectors()
+
+
+@pytest.mark.parametrize("method", ["_recv_full_payload_result", "_recv_async_chunk_result"])
+@pytest.mark.parametrize("rank", [0, 1])
+def test_split_payload_sender_metadata_respects_tp_leader(method, rank):
+    host = MixinHost()
+    connector = MagicMock()
+    metadata = {"source_host": "producer", "source_port": 50051}
+    with (
+        patch.object(host, "_get_local_tp_group", return_value=_FakeTPGroup(world_size=2, rank_in_group=rank)),
+        patch.object(host, "is_data_transfer_rank", return_value=rank == 0),
+    ):
+        result = getattr(host, method)(connector, "0", "1", "req_0_0", metadata)
+    if rank == 0:
+        connector.get.assert_called_once_with("0", "1", "req_0_0", metadata)
+        assert result is connector.get.return_value
+    else:
+        connector.get.assert_not_called()
+        assert result is None
+
+
 class _FailingConnector:
     """Connector whose put() fails a configurable number of times."""
 
@@ -1532,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_pp_async_token_broadcast.py b/tests/worker/test_pp_async_token_broadcast.py
new file mode 100644
index 000000000..d5e938681
--- /dev/null
+++ b/tests/worker/test_pp_async_token_broadcast.py
@@ -0,0 +1,321 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Async scheduling + pipeline parallelism: the last rank must send what earlier ranks wait for.
+
+vLLM's ``GPUModelRunner.sample_tokens`` pairs two collectives on the PP device group:
+a non-final rank posts an async broadcast *receive* of the newly sampled token ids
+(``_pp_receive_prev_sampled_token_ids_to_input_batch``) and the final rank performs
+the matching broadcast *send* (``_pp_broadcast_prev_sampled_token_ids``) right after
+``_update_states_after_model_execute``. ``GPUARModelRunner.sample_tokens`` overrides the
+upstream method and inherited the receive but not the send. With async scheduling and
+PP > 1 the first rank never returned from posting that receive: it is the first
+collective on the PP group's communicator, NCCL has to create the communicator with every
+rank, and the last rank never joined (observed live on 2x A100: rank 0 inside
+``torch.distributed.broadcast``, rank 1 waiting for the next intermediate tensors, engine
+dead after the RPC timeout). Had the communicator existed, the same missing send would
+have blocked the ``_pp_recv_work.wait()`` in ``_prepare_input_ids`` on the next step.
+
+These tests drive the real Omni override with a recorded ``torch.distributed.broadcast``
+ledger and, separately, a real two-process gloo group so the receive is proven to
+complete only because the Omni sampling path sent.
+"""
+
+from __future__ import annotations
+
+import os
+from datetime import timedelta
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+import torch
+from vllm.v1.worker import gpu_model_runner as upstream_runner_module
+
+from vllm_omni.worker import gpu_ar_model_runner as omni_runner_module
+from vllm_omni.worker.gpu_ar_model_runner import ExecuteModelState, GPUARModelRunner
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.parallel]
+
+
+class _StopAtBookkeepingError(Exception):
+    """Raised by the bookkeeping double: everything before it is what we assert on."""
+
+
+def _pp(rank: int, world_size: int, device_group: object = "pp-group") -> SimpleNamespace:
+    return SimpleNamespace(
+        rank=rank,
+        world_size=world_size,
+        last_rank=world_size - 1,
+        is_last_rank=rank == world_size - 1,
+        is_first_rank=rank == 0,
+        device_group=device_group,
+    )
+
+
+def _input_batch(num_reqs: int) -> SimpleNamespace:
+    return SimpleNamespace(
+        num_reqs=num_reqs,
+        req_ids=[f"req-{i}" for i in range(num_reqs)],
+        num_tokens_no_spec=np.ones(num_reqs, dtype=np.int64),
+        is_token_ids=np.zeros((num_reqs, 8), dtype=bool),
+        sampling_metadata=SimpleNamespace(no_penalties=True, logitsprocs=SimpleNamespace(non_argmax_invariant=[])),
+        vocab_size=32,
+        prev_sampled_token_ids=None,
+        prev_req_id_to_index=None,
+    )
+
+
+def _last_rank_runner(
+    *,
+    sampled: torch.Tensor,
+    async_scheduling: bool = True,
+    broadcast_pp_output: bool = False,
+    all_chunked_prefill: bool = False,
+    events: list[str],
+) -> GPUARModelRunner:
+    """A final-rank runner double that reaches the sampler and the state update."""
+    num_reqs = sampled.shape[0]
+    hidden = torch.ones(num_reqs, 8)
+    runner = object.__new__(GPUARModelRunner)
+    runner.use_async_scheduling = async_scheduling
+    runner.broadcast_pp_output = broadcast_pp_output
+    runner.speculative_config = None
+    runner.device = torch.device("cpu")
+    runner.input_batch = _input_batch(num_reqs)
+    runner.discard_request_mask = SimpleNamespace(np=np.full(num_reqs, all_chunked_prefill, dtype=bool))
+    runner.execute_model_state = ExecuteModelState(
+        scheduler_output=SimpleNamespace(total_num_scheduled_tokens=num_reqs),
+        logits=torch.zeros(num_reqs, 32),
+        spec_decode_metadata=None,
+        spec_decode_common_attn_metadata=None,
+        hidden_states=hidden,
+        hidden_states_cpu=None,
+        sample_hidden_states=hidden,
+        aux_hidden_states=None,
+        ec_connector_output=None,
+        cudagraph_stats=None,
+        multimodal_outputs={},
+        slot_mappings=None,
+    )
+    runner._sample = lambda logits, spec: SimpleNamespace(sampled_token_ids=sampled, logprobs_tensors=None)
+    runner._update_states_after_model_execute = lambda *args: events.append("state-update")
+
+    def stop(*args):
+        raise _StopAtBookkeepingError
+
+    runner._bookkeeping_sync = stop
+    return runner
+
+
+def _non_last_rank_runner(num_reqs: int) -> GPUARModelRunner:
+    runner = object.__new__(GPUARModelRunner)
+    runner.use_async_scheduling = True
+    runner.execute_model_state = None
+    runner.kv_connector_output = None
+    runner.device = torch.device("cpu")
+    runner._pp_recv_work = None  # as vLLM's __init__ leaves it before any receive is posted
+    runner.input_batch = _input_batch(num_reqs)
+    runner.discard_request_mask = SimpleNamespace(np=np.zeros(num_reqs, dtype=bool))
+    runner.requests = {rid: SimpleNamespace(output_token_ids=[]) for rid in runner.input_batch.req_ids}
+    runner.attach_omni_connector_output = lambda output: output
+    return runner
+
+
+class _Ledger(list):
+    """Every torch.distributed.broadcast, plus a shared timeline with the state update."""
+
+    def __init__(self):
+        super().__init__()
+        self.timeline: list[str] = []
+
+
+@pytest.fixture
+def ledger(monkeypatch):
+    calls = _Ledger()
+
+    class Pending:
+        def wait(self):
+            if not any(c["kind"] == "send" for c in calls):
+                raise RuntimeError("receive has no matching broadcast")
+
+    def broadcast(tensor, src, group, async_op=False):
+        kind = "receive" if async_op else "send"
+        calls.append(
+            dict(
+                kind=kind,
+                shape=tuple(tensor.shape),
+                dtype=tensor.dtype,
+                src=src,
+                group=group,
+                value=tensor.clone(),
+            )
+        )
+        calls.timeline.append(kind)
+        return Pending() if async_op else None
+
+    monkeypatch.setattr(torch.distributed, "broadcast", broadcast)
+    return calls
+
+
+def _use_pp(monkeypatch, pp):
+    # The guard lives in the Omni override; the sender/receiver bodies live in vLLM.
+    monkeypatch.setattr(omni_runner_module, "get_pp_group", lambda: pp)
+    monkeypatch.setattr(upstream_runner_module, "get_pp_group", lambda: pp)
+
+
+def test_non_last_rank_posts_the_receive_before_the_connector_only_return(monkeypatch, ledger):
+    _use_pp(monkeypatch, _pp(rank=0, world_size=2))
+    runner = _non_last_rank_runner(num_reqs=2)
+    output = runner.sample_tokens(None)
+    assert output is not None
+    assert [c["kind"] for c in ledger] == ["receive"]
+    assert ledger[0]["src"] == 1 and ledger[0]["group"] == "pp-group"
+    assert ledger[0]["shape"] == (2, 1) and ledger[0]["dtype"] == torch.int32
+    assert runner._pp_recv_work is not None
+    assert runner.input_batch.prev_sampled_token_ids.shape == (2, 1)
+    assert runner.input_batch.prev_req_id_to_index == {"req-0": 0, "req-1": 1}
+
+
+def test_last_rank_broadcasts_sampled_tokens_after_the_state_update(monkeypatch, ledger):
+    pp = _pp(rank=1, world_size=2)
+    _use_pp(monkeypatch, pp)
+    sampled = torch.tensor([[4], [7]], dtype=torch.int32)
+    runner = _last_rank_runner(sampled=sampled, events=ledger.timeline)
+    with pytest.raises(_StopAtBookkeepingError):
+        runner.sample_tokens(None)
+    assert ledger.timeline == ["state-update", "send"], "the send must follow the state update, not precede it"
+    sends = [c for c in ledger if c["kind"] == "send"]
+    assert len(sends) == 1
+    assert sends[0]["src"] == pp.rank == pp.last_rank
+    assert sends[0]["group"] == "pp-group"
+    assert sends[0]["shape"] == (2, 1) and sends[0]["dtype"] == torch.int32
+    assert torch.equal(sends[0]["value"], sampled)
+
+
+def test_receive_and_send_form_one_matched_pair(monkeypatch, ledger):
+    """The negative control from the handoff probe, now expected to complete."""
+    _use_pp(monkeypatch, _pp(rank=0, world_size=2))
+    first = _non_last_rank_runner(num_reqs=1)
+    first.sample_tokens(None)
+    _use_pp(monkeypatch, _pp(rank=1, world_size=2))
+    last = _last_rank_runner(sampled=torch.tensor([[4]], dtype=torch.int32), events=[])
+    with pytest.raises(_StopAtBookkeepingError):
+        last.sample_tokens(None)
+    first._pp_recv_work.wait()
+    assert [c["kind"] for c in ledger] == ["receive", "send"]
+    assert ledger[0]["shape"] == ledger[1]["shape"] and ledger[0]["dtype"] == ledger[1]["dtype"]
+    assert ledger[0]["src"] == ledger[1]["src"] and ledger[0]["group"] == ledger[1]["group"]
+
+
+@pytest.mark.parametrize(
+    ("async_scheduling", "broadcast_pp_output", "world_size", "reason"),
+    [
+        (False, False, 2, "synchronous scheduling feeds tokens through the scheduler"),
+        (True, True, 2, "external_launcher already broadcast the logits to every rank"),
+        (True, False, 1, "a single rank has nobody waiting"),
+    ],
+)
+def test_last_rank_does_not_send_outside_the_async_pp_case(
+    monkeypatch, ledger, async_scheduling, broadcast_pp_output, world_size, reason
+):
+    _use_pp(monkeypatch, _pp(rank=world_size - 1, world_size=world_size))
+    runner = _last_rank_runner(
+        sampled=torch.tensor([[4]], dtype=torch.int32),
+        async_scheduling=async_scheduling,
+        broadcast_pp_output=broadcast_pp_output,
+        events=[],
+    )
+    with pytest.raises(_StopAtBookkeepingError):
+        runner.sample_tokens(None)
+    assert ledger == [], reason
+
+
+def test_both_sides_skip_an_all_chunked_prefill_step(monkeypatch, ledger):
+    """Dummy tokens from unfinished prefill chunks are discarded, so neither side talks."""
+    _use_pp(monkeypatch, _pp(rank=0, world_size=2))
+    first = _non_last_rank_runner(num_reqs=1)
+    first.discard_request_mask = SimpleNamespace(np=np.ones(1, dtype=bool))
+    first.sample_tokens(None)
+    assert first._pp_recv_work is None
+    _use_pp(monkeypatch, _pp(rank=1, world_size=2))
+    last = _last_rank_runner(sampled=torch.tensor([[4]], dtype=torch.int32), all_chunked_prefill=True, events=[])
+    with pytest.raises(_StopAtBookkeepingError):
+        last.sample_tokens(None)
+    assert ledger == []
+
+
+def test_sender_rejects_multi_token_rows(monkeypatch, ledger):
+    """The receive buffer is [num_reqs, 1]; the upstream sender guards that contract."""
+    _use_pp(monkeypatch, _pp(rank=1, world_size=2))
+    runner = _last_rank_runner(sampled=torch.tensor([[4, 5]], dtype=torch.int32), events=[])
+    with pytest.raises(AssertionError, match="num_reqs, 1"):
+        runner.sample_tokens(None)
+    assert ledger == []
+
+
+# --- real collective -----------------------------------------------------------------
+
+
+def _gloo_rank(rank: int, world_size: int, rendezvous: str, result_path: str) -> None:
+    """Rank 0 runs the Omni receive branch; rank 1 runs the Omni sampling path.
+
+    Both use the real methods bound to doubles; the process group is a real gloo group,
+    so rank 0's wait can only return because rank 1's ``sample_tokens`` broadcast.
+    """
+    import torch.distributed as dist
+
+    dist.init_process_group(
+        backend="gloo",
+        init_method=f"file://{rendezvous}",
+        rank=rank,
+        world_size=world_size,
+        timeout=timedelta(seconds=60),
+    )
+    try:
+        pp = _pp(rank=rank, world_size=world_size, device_group=dist.group.WORLD)
+        omni_runner_module.get_pp_group = lambda: pp
+        upstream_runner_module.get_pp_group = lambda: pp
+        if rank == world_size - 1:
+            runner = _last_rank_runner(sampled=torch.tensor([[4], [7]], dtype=torch.int32), events=[])
+            try:
+                runner.sample_tokens(None)
+            except _StopAtBookkeepingError:
+                pass
+            received = None
+        else:
+            runner = _non_last_rank_runner(num_reqs=2)
+            runner.sample_tokens(None)
+            assert runner._pp_recv_work is not None
+            # A missing send surfaces here as a gloo timeout instead of a silent hang.
+            runner._pp_recv_work.wait(timeout=timedelta(seconds=30))
+            received = runner.input_batch.prev_sampled_token_ids.tolist()
+        with open(f"{result_path}.{rank}", "w") as handle:
+            handle.write(repr(received))
+    finally:
+        dist.destroy_process_group()
+
+
+def test_gloo_pp2_receive_completes_only_because_the_omni_sampling_path_sent(tmp_path):
+    import torch.multiprocessing as mp
+
+    rendezvous = str(tmp_path / "rendezvous")
+    result_path = str(tmp_path / "received")
+    context = mp.get_context("spawn")
+    processes = [
+        context.Process(target=_gloo_rank, args=(rank, 2, rendezvous, result_path), daemon=True) for rank in range(2)
+    ]
+    try:
+        for process in processes:
+            process.start()
+        for process in processes:
+            process.join(timeout=240)
+    finally:
+        for process in processes:
+            if process.is_alive():
+                process.kill()
+                process.join(timeout=30)
+    exit_codes = [process.exitcode for process in processes]
+    assert exit_codes == [0, 0], f"rank exit codes {exit_codes}: an unmatched receive times out on rank 0"
+    with open(f"{result_path}.0") as handle:
+        assert handle.read() == repr([[4], [7]])
+    assert os.path.exists(f"{result_path}.1")
diff --git a/tests/worker/test_pp_intermediate_output.py b/tests/worker/test_pp_intermediate_output.py
new file mode 100644
index 000000000..a9cf02bba
--- /dev/null
+++ b/tests/worker/test_pp_intermediate_output.py
@@ -0,0 +1,48 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Non-final pipeline outputs must reach vLLM's existing PP sender unchanged."""
+
+from types import SimpleNamespace
+
+import pytest
+import torch
+from vllm.sequence import IntermediateTensors
+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, pytest.mark.parallel]
+
+
+def test_nonfinal_forward_bypasses_final_output_conversion(monkeypatch):
+    intermediate = IntermediateTensors({"hidden_states": torch.ones(4, 8), "residual": torch.ones(4, 8)})
+    monkeypatch.setattr(GPUModelRunner, "_model_forward", lambda *args, **kwargs: intermediate)
+
+    def final_only_converter(*args, **kwargs):
+        pytest.fail("A non-final rank must not convert intermediate tensors to OmniOutput")
+
+    runner = object.__new__(OmniGPUModelRunner)
+    runner.model = SimpleNamespace(make_omni_output=final_only_converter, have_multimodal_outputs=True)
+    runner._build_model_kwargs_extra = lambda: {}
+    result = runner._model_forward()
+    assert result is intermediate
+    hidden, multimodal = runner.extract_multimodal_outputs(result)
+    assert hidden is intermediate
+    assert multimodal == {}
+
+
+def test_final_tensor_still_uses_model_converter(monkeypatch):
+    tensor = torch.ones(4, 8)
+    monkeypatch.setattr(GPUModelRunner, "_model_forward", lambda *args, **kwargs: tensor)
+    converted = object()
+    calls = []
+
+    def convert(value, **kwargs):
+        calls.append(value)
+        return converted
+
+    runner = object.__new__(OmniGPUModelRunner)
+    runner.model = SimpleNamespace(make_omni_output=convert)
+    runner._build_model_kwargs_extra = lambda: {}
+    assert runner._model_forward() is converted
+    assert calls == [tensor]
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/tests/worker/test_worker_base.py b/tests/worker/test_worker_base.py
index 18131a31c..a04cc35c2 100644
--- a/tests/worker/test_worker_base.py
+++ b/tests/worker/test_worker_base.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 tests for ``vllm_omni.worker.base.OmniGPUWorkerBase``.
 
 Pins the CURRENT behaviour of ``determine_available_memory`` (device-level
diff --git a/tests/worker_v2/__init__.py b/tests/worker_v2/__init__.py
new file mode 100644
index 000000000..e69de29bb
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/auk_parity_reference.py b/tools/auk_parity_reference.py
new file mode 100644
index 000000000..33b664232
--- /dev/null
+++ b/tools/auk_parity_reference.py
@@ -0,0 +1,227 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Generate the upstream AuK reference artifacts consumed by the parity tests.
+
+This runs the *upstream* implementation, so it must be executed in an
+environment where the upstream package is installed
+(``pip install -e /path/to/AuK``; it pins its own torch/transformers line and
+does not need vLLM-Omni). It writes:
+
+    <out>/parity_ref/<variant>/<case>.pt, <case>.wav, meta.json
+        Upstream generations for four cookbook cases (zero-shot TTS, instruct
+        TTS, content edit, denoise) with the reference latents, the generated
+        latents and the waveform. Point ``AUK_PARITY_REF`` at
+        ``<out>/parity_ref/<variant>`` for tests/diffusion/models/auk/test_pipeline_auk.py.
+    <out>/fusion_ref/zs_tts_audio.pt, instruct_text_only.pt
+        The fp32 layer-fused text condition from the HF thinker for the
+        zero-shot and text-only prompts (``AUK_FUSION_REF``).
+
+By default the VAE encode uses the posterior mean, matching the port's default
+and making the artifacts deterministic; ``--vae-sample`` reproduces the
+upstream stochastic draw (seeded through ``--global-seed``). The ODE noise is
+drawn from ``--seed`` on both sides.
+
+Usage:
+    python tools/auk_parity_reference.py \\
+        --auk-repo /path/to/AuK --ckpt-dir /path/to/AuK \\
+        --qwen-dir /path/to/Qwen2.5-Omni-3B --out /path/to/auk-parity \\
+        [--variant base|flash] [--vae-sample] [--fusion-device cpu|cuda] [--skip-fusion]
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import time
+from pathlib import Path
+from typing import Any
+
+import torch
+import torch.nn.functional as F
+
+WEIGHTS = {"base": "auk_base.safetensors", "flash": "auk_flash.safetensors"}
+
+# Cookbook cases; audio paths are relative to <auk-repo>/assets/demo-input-audio.
+CASES: dict[str, dict[str, Any]] = {
+    "zs_tts_en": {
+        "text": (
+            "Say the following with the same voice: 'Ladies and gentlemen, it's an honor to have the "
+            "opportunity to address such a distinguished audience'"
+        ),
+        "audio": "zero-shot-tts/ref.wav",
+        "gen_seconds": 6.0,
+    },
+    "instruct_en": {
+        "text": (
+            'Generate speech based on the following description: "A calm young woman speaking warmly and slowly.". '
+            'The content to speak is: "Welcome back, how was your day at work?".'
+        ),
+        "audio": None,
+        "gen_seconds": 3.5,
+    },
+    "content_edit": {
+        "text": "Replace 'but accepting what we cannot have' with 'and living well with dreams unmet'.",
+        "audio": "content-edit/content.wav",
+        "gen_seconds": 7.0,
+    },
+    "denoise": {
+        "text": "Keep pure speech voice, remove noise and reverberation.",
+        "audio": "vocal-extraction/vocal-1-input.wav",
+        "gen_seconds": None,
+    },
+}
+# The two prompts the fusion reference covers (they must match the cases above).
+FUSION_CASES = {"zs_tts_audio": "zs_tts_en", "instruct_text_only": "instruct_en"}
+NO_PROMPT_AUDIO = "|<no_prompt_audio>|"
+
+
+def _messages(case: dict[str, Any], assets: Path) -> list[dict[str, Any]]:
+    content: list[dict[str, Any]] = [{"type": "text", "text": case["text"]}]
+    if case["audio"]:
+        content.append({"type": "audio", "audio": str(assets / case["audio"])})
+    return [{"role": "user", "content": content}]
+
+
+def _mean_encode(vae):
+    """Posterior-mean version of the upstream ``encoding_and_normalization``."""
+
+    def encode(sample, sample_lengths=None):
+        latent_stats = vae.audio_encoder(sample)
+        if sample_lengths is None:
+            sample_lengths = torch.LongTensor([sample.size(-1)] * sample.size(0)).to(sample.device)
+        latent_lens = sample_lengths // vae.hop_size
+        mean, _log_std = latent_stats.chunk(2, 1)
+        latents = mean.transpose(1, 2).float()
+        latents = (latents - vae.global_mean.float()) / torch.sqrt(vae.global_log_std.float())
+        return latents, torch.clamp(latent_lens, max=latents.size(1))
+
+    return encode
+
+
+def generate_references(args: argparse.Namespace) -> None:
+    from auk.infer.infer_auk import AukInfer, save_audio
+
+    ckpt = Path(args.ckpt_dir)
+    out = Path(args.out) / "parity_ref" / args.variant
+    out.mkdir(parents=True, exist_ok=True)
+    assets = Path(args.auk_repo) / "assets" / "demo-input-audio"
+
+    engine = AukInfer(str(ckpt / "config.yaml"), str(ckpt / WEIGHTS[args.variant]), qwen_path=args.qwen_dir)
+    encode = engine.vae_model.encoding_and_normalization if args.vae_sample else _mean_encode(engine.vae_model)
+    recorded: dict[str, torch.Tensor] = {}
+
+    def encode_hook(sample, sample_lengths=None):
+        latents, lens = encode(sample, sample_lengths)
+        recorded["ref_latents"] = latents.detach().float().cpu()
+        recorded["ref_latent_lens"] = lens.detach().cpu()
+        return latents, lens
+
+    engine.vae_model.encoding_and_normalization = encode_hook
+    upstream_sample = engine.model.sample
+
+    def sample_hook(*a, **k):
+        latents, trajectory = upstream_sample(*a, **k)
+        recorded["generated"] = latents.detach().float().cpu()
+        return latents, trajectory
+
+    engine.model.sample = sample_hook
+
+    meta: dict[str, Any] = {}
+    for name, case in CASES.items():
+        messages = _messages(case, assets)
+        recorded.clear()
+        torch.manual_seed(args.global_seed)
+        started = time.perf_counter()
+        audio, sr = engine.generate(messages, gen_seconds=case["gen_seconds"], seed=args.seed)
+        wall = time.perf_counter() - started
+        save_audio(audio, sr, str(out / f"{name}.wav"))
+        torch.save(
+            {
+                "messages": messages,
+                "gen_seconds": case["gen_seconds"],
+                "seed": args.seed,
+                "global_seed": args.global_seed,
+                "vae_sample": bool(args.vae_sample),
+                "audio": audio.float().cpu(),
+                "sr": sr,
+                **recorded,
+            },
+            out / f"{name}.pt",
+        )
+        ref_frames = int(recorded["ref_latent_lens"][0]) if "ref_latent_lens" in recorded else 0
+        meta[name] = {
+            "wall_s": wall,
+            "out_s": audio.shape[-1] / sr,
+            "sr": sr,
+            "ref_frames": ref_frames,
+            "gen_frames": int(recorded["generated"].shape[1]) - ref_frames,
+        }
+        print(name, meta[name], flush=True)
+    (out / "meta.json").write_text(json.dumps(meta, indent=1) + "\n")
+
+
+def generate_fusion(args: argparse.Namespace) -> None:
+    from auk.model.cfm_edit import CFMEdit
+    from safetensors import safe_open
+    from transformers import Qwen2_5OmniProcessor, Qwen2_5OmniThinkerForConditionalGeneration
+
+    out = Path(args.out) / "fusion_ref"
+    out.mkdir(parents=True, exist_ok=True)
+    assets = Path(args.auk_repo) / "assets" / "demo-input-audio"
+    with safe_open(str(Path(args.ckpt_dir) / WEIGHTS[args.variant]), "pt") as f:
+        layer_weights = f.get_tensor("layer_weights").float()
+        layer_scale = f.get_tensor("layer_scale").float()
+
+    processor = Qwen2_5OmniProcessor.from_pretrained(args.qwen_dir)
+    thinker = Qwen2_5OmniThinkerForConditionalGeneration.from_pretrained(args.qwen_dir, torch_dtype=torch.float32)
+    thinker.visual = None
+    thinker = thinker.to(args.fusion_device).eval()
+
+    for out_name, case_name in FUSION_CASES.items():
+        case = dict(CASES[case_name])
+        if not case["audio"] and not case["text"].endswith(NO_PROMPT_AUDIO):
+            case["text"] = case["text"] + NO_PROMPT_AUDIO
+        cond = CFMEdit.build_cond_inputs([_messages(case, assets)], processor).to(args.fusion_device)
+        with torch.no_grad():
+            hidden_states = thinker(**cond, output_hidden_states=True).hidden_states
+        width = hidden_states[0].shape[-1]
+        stacked = torch.stack([F.layer_norm(h.float(), [width]) for h in hidden_states[1:]], 0)
+        weights = F.softmax(layer_weights.to(stacked.device), 0)
+        fused = (stacked * weights[:, None, None, None]).sum(0) * layer_scale.to(stacked.device)
+        torch.save(
+            {
+                "input_ids": cond["input_ids"].cpu(),
+                "attention_mask": cond["attention_mask"].cpu(),
+                "fused": fused[0].float().cpu(),
+                "final_normed": hidden_states[-1][0].float().cpu(),
+                "text": case["text"],
+            },
+            out / f"{out_name}.pt",
+        )
+        print(out_name, {"tokens": int(cond["input_ids"].shape[1]), "fused_norm": float(fused.norm())}, flush=True)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--auk-repo", required=True, help="checkout of the upstream AuK repository (for demo clips)")
+    parser.add_argument("--ckpt-dir", required=True, help="tencent/AuK or tencent/AuK-Flash snapshot")
+    parser.add_argument("--qwen-dir", required=True, help="Qwen/Qwen2.5-Omni-3B snapshot")
+    parser.add_argument("--out", required=True, help="output root; writes parity_ref/<variant> and fusion_ref")
+    parser.add_argument("--variant", choices=sorted(WEIGHTS), default="base")
+    parser.add_argument("--seed", type=int, default=0, help="ODE noise seed passed to the upstream sampler")
+    parser.add_argument("--global-seed", type=int, default=1234, help="global RNG seed set before each generate()")
+    parser.add_argument("--vae-sample", action="store_true", help="draw the VAE posterior sample as upstream does")
+    parser.add_argument("--fusion-device", default="cpu", help="device for the fp32 HF thinker forward")
+    parser.add_argument("--skip-fusion", action="store_true", help="only write the generation references")
+    args = parser.parse_args()
+
+    generate_references(args)
+    if not args.skip_fusion:
+        generate_fusion(args)
+    print(f"reference artifacts written under {args.out}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/tools/breeze_tts_2_compare_golden.py b/tools/breeze_tts_2_compare_golden.py
new file mode 100644
index 000000000..23306896e
--- /dev/null
+++ b/tools/breeze_tts_2_compare_golden.py
@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Compare upstream and vLLM-Omni Breeze-TTS-2 golden artifacts."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+from pathlib import Path
+
+import soundfile as sf
+import torch
+
+TEMPLATES = {
+    "plain": "tts_plain",
+    "instruction": "tts_instruction",
+    "reference_edit": "ref_edit_tata",
+}
+
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def _audio_metrics(path: Path) -> dict[str, object]:
+    data, sample_rate = sf.read(path, dtype="float32")
+    return {
+        "path": str(path),
+        "bytes": path.stat().st_size,
+        "sha256": _sha256(path),
+        "samples": int(data.shape[0]),
+        "sample_rate": int(sample_rate),
+        "channels": int(1 if data.ndim == 1 else data.shape[1]),
+        "duration_s": round(float(data.shape[0]) / sample_rate, 6),
+        "finite": bool(torch.isfinite(torch.from_numpy(data)).all().item()),
+        "peak": round(float(abs(data).max()), 6),
+        "rms": round(float((data**2).mean() ** 0.5), 6),
+    }
+
+
+def _vector_metrics(upstream: torch.Tensor, actual: torch.Tensor) -> dict[str, float]:
+    difference = upstream.double() - actual.double()
+    return {
+        "mae": round(float(difference.abs().mean()), 8),
+        "rmse": round(float(difference.pow(2).mean().sqrt()), 8),
+        "max_abs_error": round(float(difference.abs().max()), 8),
+        "relative_l2": round(float(difference.norm() / upstream.norm()), 8),
+        "cosine": round(
+            float(torch.dot(upstream.double(), actual.double()) / (upstream.norm() * actual.norm())),
+            8,
+        ),
+    }
+
+
+def _load_vllm_payload(vllm_dir: Path, template: str) -> dict[str, object]:
+    matches = []
+    for path in vllm_dir.glob("breeze_*.pt"):
+        payload = torch.load(path, weights_only=False)
+        if payload.get("template") == template:
+            matches.append(payload)
+    if len(matches) != 1:
+        raise ValueError(f"expected one vLLM dump for {template!r}, found {len(matches)}")
+    return matches[0]
+
+
+def _longest_exact_frame_prefix(upstream: torch.Tensor, actual: torch.Tensor) -> int:
+    count = min(int(upstream.shape[0]), int(actual.shape[0]))
+    equal = (upstream[:count] == actual[:count]).all(dim=-1)
+    prefix = 0
+    for is_equal in equal.tolist():
+        if not is_equal:
+            break
+        prefix += 1
+    return prefix
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--upstream-dir", type=Path, required=True)
+    parser.add_argument("--vllm-dir", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--plain-audio", type=Path)
+    parser.add_argument("--instruction-audio", type=Path)
+    parser.add_argument("--reference-audio", type=Path)
+    args = parser.parse_args()
+
+    audio_paths = {
+        "plain": args.plain_audio,
+        "instruction": args.instruction_audio,
+        "reference_edit": args.reference_audio,
+    }
+    report: dict[str, object] = {
+        "upstream_dir": str(args.upstream_dir.resolve()),
+        "vllm_dir": str(args.vllm_dir.resolve()),
+        "cases": [],
+    }
+    for name, template in TEMPLATES.items():
+        upstream_codes = torch.load(args.upstream_dir / name / "codes.pt", weights_only=False)
+        upstream_prompt = torch.load(args.upstream_dir / name / "prompt_ids.pt", weights_only=False)
+        actual_payload = _load_vllm_payload(args.vllm_dir, template)
+        actual_codes = actual_payload["codes"]
+        actual_prompt = actual_payload["prompt_ids"]
+        common_frames = min(int(upstream_codes.shape[0]), int(actual_codes.shape[0]))
+        code_equal = upstream_codes[:common_frames] == actual_codes[:common_frames]
+        frame_equal = code_equal.all(dim=-1)
+        prefill_metrics = None
+        upstream_hidden_path = args.upstream_dir / name / "prefill_hidden.pt"
+        if upstream_hidden_path.exists():
+            prefill_files = [
+                path
+                for path in args.vllm_dir.glob("prefill_*.pt")
+                if torch.load(path, weights_only=False).get("template") == template
+            ]
+            if len(prefill_files) == 1:
+                actual_hidden = torch.load(prefill_files[0], weights_only=False)["hidden"]
+                prefill_metrics = _vector_metrics(
+                    torch.load(upstream_hidden_path, weights_only=False),
+                    actual_hidden,
+                )
+        entry: dict[str, object] = {
+            "name": name,
+            "template": template,
+            "prompt": {
+                "upstream_tokens": int(upstream_prompt.numel()),
+                "vllm_tokens": int(actual_prompt.numel()),
+                "exact": bool(torch.equal(upstream_prompt, actual_prompt)),
+            },
+            "frames": {
+                "upstream": int(upstream_codes.shape[0]),
+                "vllm": int(actual_codes.shape[0]),
+                "codebooks": int(upstream_codes.shape[-1]),
+                "exact_sequence": bool(torch.equal(upstream_codes, actual_codes)),
+                "common_frames": common_frames,
+                "exact_common_frames": int(frame_equal.sum()),
+                "longest_exact_prefix": _longest_exact_frame_prefix(upstream_codes, actual_codes),
+                "exact_codes": int(code_equal.sum()),
+                "total_common_codes": int(code_equal.numel()),
+                "code_accuracy": round(float(code_equal.float().mean()), 8),
+                "codebook0_accuracy": round(
+                    float((upstream_codes[:common_frames, 0] == actual_codes[:common_frames, 0]).float().mean()),
+                    8,
+                ),
+                "range_valid": bool(
+                    upstream_codes.min() >= 0
+                    and upstream_codes.max() < 2048
+                    and actual_codes.min() >= 0
+                    and actual_codes.max() < 2048
+                ),
+            },
+            "prefill_hidden": prefill_metrics,
+        }
+        if audio_paths[name] is not None and Path(audio_paths[name]).exists():  # type: ignore[arg-type]
+            entry["audio"] = _audio_metrics(Path(audio_paths[name]))  # type: ignore[arg-type]
+        report["cases"].append(entry)
+
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps(report, indent=2))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/breeze_tts_2_upstream_golden.py b/tools/breeze_tts_2_upstream_golden.py
new file mode 100644
index 000000000..337a0444f
--- /dev/null
+++ b/tools/breeze_tts_2_upstream_golden.py
@@ -0,0 +1,200 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Generate deterministic Breeze-TTS-2 golden frames with the upstream runtime.
+
+This tool is intentionally separate from vLLM-Omni: it imports the unmodified
+``breezeblue-ai/breeze-tts`` reference implementation, fixes greedy decoding,
+and writes both generated codec frames and decoded audio for offline parity
+checks. It is a diagnostic tool, not a serving path.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+
+import soundfile as sf
+import torch
+
+
+def _plain_template(upstream_templates):
+    """The upstream CLI does not register tts_plain; reuse its segment builder."""
+    return SimpleNamespace(
+        name="tts_plain",
+        required_fields=("text",),
+        build_segments=upstream_templates._tts_plain_segments,
+        build_negative_segments=None,
+        build_dual_branches=None,
+    )
+
+
+def _greedy(model) -> None:
+    model.generation_config.do_sample = False
+    model.generation_config.temperature = None
+    model.generation_config.top_p = None
+    model.generation_config.top_k = None
+    depth = model.depth_decoder.generation_config
+    depth.depth_decoder_do_sample = False
+    depth.do_sample = False
+    depth.temperature = None
+    depth.top_p = None
+    depth.top_k = None
+
+
+def _valid_frames(sequences: torch.Tensor, pad_token_id: int) -> torch.Tensor:
+    frames = sequences[0].detach().cpu().to(torch.long)
+    if frames.ndim == 1:
+        frames = frames.unsqueeze(0)
+    is_pad = (frames == pad_token_id).all(dim=-1)
+    if bool(is_pad.any()):
+        frames = frames[: int(torch.argmax(is_pad.int()).item())]
+    return frames.contiguous()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model", type=Path, required=True)
+    parser.add_argument("--upstream", type=Path, required=True)
+    parser.add_argument("--output-dir", type=Path, required=True)
+    parser.add_argument("--reference-audio", type=Path)
+    parser.add_argument("--max-new-tokens", type=int, default=32)
+    args = parser.parse_args()
+
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    upstream_posix = str(args.upstream.resolve())
+    if upstream_posix not in sys.path:
+        sys.path.insert(0, upstream_posix)
+
+    from breeze_infer.runtime import load_runtime, resolve_device
+    from breeze_infer.templates import get_template, prepare_inputs
+
+    device = resolve_device()
+    # ``torch.manual_seed`` seeds CUDA RNGs as well, so no device-specific
+    # seeding call is needed here.
+    torch.manual_seed(0)
+    tokenizer, model, audio_tokenizer = load_runtime(
+        args.model,
+        device=device,
+        attn_implementation="eager",
+    )
+    # Do not enable Transformers 4.x's ``fix_mistral_regex`` compatibility
+    # path: vLLM-Omni runs with Transformers 5.x, and direct tokenization checks
+    # showed both runtimes produce the same token IDs without that patch.
+    _greedy(model)
+    model.eval()
+    first_backbone_hidden: list[torch.Tensor] = []
+
+    def _capture_first_backbone_hidden(_module, _inputs, output):
+        if first_backbone_hidden:
+            return
+        hidden = getattr(output, "last_hidden_state", None)
+        if isinstance(hidden, torch.Tensor):
+            first_backbone_hidden.append(hidden[0, -1].detach().cpu().to(torch.float32).contiguous())
+
+    model.backbone_model.register_forward_hook(_capture_first_backbone_hidden)
+
+    cases = [
+        {
+            "name": "plain",
+            "template": _plain_template(sys.modules["breeze_infer.templates"]),
+            "request": {
+                "id": "golden-plain",
+                "text": "Golden plain alignment check.",
+                "speaker": "S0",
+            },
+        },
+        {
+            "name": "instruction",
+            "template": get_template("tts_instruction"),
+            "request": {
+                "id": "golden-instruction",
+                "text": "Golden instruction alignment check.",
+                "instruction": "Speak calmly, warmly, and clearly.",
+                "speaker": "S0",
+            },
+        },
+    ]
+    if args.reference_audio is not None:
+        cases.append(
+            {
+                "name": "reference_edit",
+                "template": get_template("ref_edit_tata"),
+                "request": {
+                    "id": "golden-reference-edit",
+                    "text": "Golden reference alignment check.",
+                    "instruction": "Speak calmly and clearly.",
+                    "ref_audio_path": str(args.reference_audio),
+                    "ref_text": "Hello from Breeze.",
+                    "speaker": "S0",
+                },
+            }
+        )
+
+    manifest = {
+        "runtime": "upstream breezeblue-ai/breeze-tts",
+        "model": str(args.model.resolve()),
+        "upstream": upstream_posix,
+        "device": device,
+        "seed": 0,
+        "max_new_tokens": args.max_new_tokens,
+        "decoding": "greedy",
+        "cfg_scale": 1.0,
+        "cases": [],
+    }
+    for case in cases:
+        first_backbone_hidden.clear()
+        inputs = prepare_inputs(
+            tokenizer,
+            audio_tokenizer,
+            model,
+            [case["request"]],
+            case["template"],
+            guidance_scale=1.0,
+            guidance_scale_ref=None,
+            guidance_scale_ins=None,
+        )
+        output = model.generate(
+            **inputs,
+            max_new_tokens=args.max_new_tokens,
+            do_sample=False,
+            return_dict_in_generate=True,
+            output_audio=True,
+            audio_tokenizer=audio_tokenizer,
+        )
+        frames = _valid_frames(output.sequences, model.config.codebook_pad_token_id)
+        audio = output.audio[0].detach().cpu().to(torch.float32).reshape(-1)
+        case_dir = args.output_dir / case["name"]
+        case_dir.mkdir(parents=True, exist_ok=True)
+        torch.save(frames, case_dir / "codes.pt")
+        prompt_ids = inputs["input_ids"].detach().cpu().to(torch.long).reshape(-1)
+        torch.save(prompt_ids, case_dir / "prompt_ids.pt")
+        if first_backbone_hidden:
+            torch.save(first_backbone_hidden[0], case_dir / "prefill_hidden.pt")
+        sf.write(case_dir / "upstream.wav", audio.numpy(), 24_000, subtype="PCM_16")
+        entry = {
+            "name": case["name"],
+            "request": case["request"],
+            "prompt_tokens": int(prompt_ids.numel()),
+            "frames": int(frames.shape[0]),
+            "codebooks": int(frames.shape[-1]) if frames.ndim == 2 else 0,
+            "min_code": int(frames.min().item()) if frames.numel() else None,
+            "max_code": int(frames.max().item()) if frames.numel() else None,
+            "audio_samples": int(audio.numel()),
+            "audio_sha256": __import__("hashlib").sha256((case_dir / "upstream.wav").read_bytes()).hexdigest(),
+        }
+        manifest["cases"].append(entry)
+        print(json.dumps(entry), flush=True)
+
+    (args.output_dir / "manifest.json").write_text(
+        json.dumps(manifest, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/pre_commit/check_buildkite.py b/tools/pre_commit/check_buildkite.py
index 362253494..f470f09f9 100644
--- a/tools/pre_commit/check_buildkite.py
+++ b/tools/pre_commit/check_buildkite.py
@@ -27,6 +27,7 @@ from upload_pipeline import _render_test_pipeline  # noqa: E402
 
 SKIP_FILES = {
     ".buildkite/common/ci_mirror_hardwares.yml",
+    ".buildkite/common/ci_source_file_dependencies.yml",
     ".buildkite/npu/pipeline-npu-a3.yml",
 }
 
diff --git a/tools/pre_commit/check_forbidden_imports.py b/tools/pre_commit/check_forbidden_imports.py
index c5a96148e..3a8f89121 100644
--- a/tools/pre_commit/check_forbidden_imports.py
+++ b/tools/pre_commit/check_forbidden_imports.py
@@ -79,16 +79,16 @@ 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/commands.py",
             "vllm_omni/engine/duplex/contracts.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/adapter.py",
             "vllm_omni/model_executor/models/minicpmo_4_5/duplex/input.py",
-            "vllm_omni/model_executor/models/minicpmo_4_5/duplex/runtime.py",
+            "vllm_omni/model_executor/models/minicpmo_4_5/duplex/plugin.py",
             "vllm_omni/model_executor/models/minicpmo_4_5/duplex/stage0.py",
-            "vllm_omni/entrypoints/duplex/audio.py",
-            "vllm_omni/entrypoints/duplex/realtime_input.py",
-            "vllm_omni/entrypoints/duplex/runtime_bridge.py",
-            "vllm_omni/entrypoints/duplex/serving.py",
             "vllm_omni/model_executor/models/personaplex/duplex/input.py",
             "vllm_omni/model_executor/models/personaplex/duplex/runtime_extension.py",
             "vllm_omni/model_executor/models/personaplex/duplex/stage0.py",
@@ -108,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/tools/prepare_auk_checkpoint.py b/tools/prepare_auk_checkpoint.py
new file mode 100755
index 000000000..7f55dab8a
--- /dev/null
+++ b/tools/prepare_auk_checkpoint.py
@@ -0,0 +1,369 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Assemble an AuK checkpoint directory that ``--model <path>`` can load.
+
+The released AuK repos ship ``config.yaml`` plus loose safetensors and depend
+on a separate Qwen2.5-Omni-3B snapshot for the frozen text encoder. This tool
+writes the ``config.json`` the vLLM-Omni pipeline expects and links every
+artifact both stages need into one flat directory:
+
+    <out>/
+      config.json          the Qwen2.5-Omni-3B config with model_type "auk",
+                           AuK's architecture, and the dit / vae / variant /
+                           flash_t_grid / defaults sections added at the top
+                           level (see transformers_utils/configs/auk.py)
+      auk.safetensors      -> auk_base.safetensors or auk_flash.safetensors
+      vae.safetensors      -> the AuK VAE weights
+      thinker/             -> the Qwen2.5-Omni-3B snapshot, for reference only
+      model-0000*.safetensors, model.safetensors.index.json,
+      tokenizer*, vocab.json, merges.txt, added_tokens.json,
+      special_tokens_map.json, chat_template.json,
+      preprocessor_config.json, generation_config.json, spk_dict.pt
+                           -> the same snapshot's entries
+
+The Qwen entries are linked at the top level rather than left under
+``thinker/`` because both stages load from this one directory: the encoder
+reads the thinker shards, the tokenizer and the audio processor from here,
+and takes the layer-fusion tensors out of ``auk.safetensors``. The weight
+index keeps ``auk.safetensors`` and ``vae.safetensors`` out of the thinker's
+own weight load, and the DiT and VAE weights are read by model code directly.
+
+Usage:
+    python tools/prepare_auk_checkpoint.py \
+        --auk-dir  /path/to/AuK \
+        --qwen-dir /path/to/Qwen2.5-Omni-3B \
+        --out      /path/to/auk-omni-base
+
+Re-running against an existing directory is safe: config.json is rewritten
+and the links are repointed. Pass ``--copy`` on filesystems without symlinks.
+"""
+
+from __future__ import annotations
+
+import argparse
+import ast
+import json
+import re
+import shutil
+import sys
+from pathlib import Path
+from typing import Any
+
+# The distilled student's 4-step grid. Duplicated from
+# vllm_omni/transformers_utils/configs/auk.py so this tool stays runnable
+# without importing the package (and its torch dependency).
+FLASH_T_GRID = [
+    0.0,
+    0.07612049579620361,
+    0.2928932309150696,
+    0.6173166036605835,
+    1.0,
+]
+
+# Names the assembled directory owns; everything else in it is a Qwen entry.
+WEIGHTS_LINK = "auk.safetensors"
+VAE_LINK = "vae.safetensors"
+THINKER_LINK = "thinker"
+CONFIG_NAME = "config.json"
+
+# Snapshot entries that are not reused: the config is rewritten, and the repo
+# paperwork would misdescribe the assembled directory.
+_SKIP_QWEN_ENTRIES = frozenset({CONFIG_NAME, "README.md", "LICENSE"})
+
+DIT_KEYS = ("dim", "heads", "ff_mult", "text_hidden_dim", "num_layers", "num_single_layers")
+VAE_KEYS = ("latent_dim", "downsample_rate", "target_sample_rate", "model_init_kwargs")
+
+_INTERPOLATION = re.compile(r"^\$\{([A-Za-z0-9_.]+)\}$")
+
+
+def _strip_comment(line: str) -> str:
+    """Drop a trailing ``#`` comment that is not inside a quoted scalar."""
+    out: list[str] = []
+    quote: str | None = None
+    for ch in line:
+        if quote is not None:
+            if ch == quote:
+                quote = None
+            out.append(ch)
+            continue
+        if ch in "\"'":
+            quote = ch
+            out.append(ch)
+            continue
+        if ch == "#":
+            break
+        out.append(ch)
+    return "".join(out).rstrip()
+
+
+def _parse_scalar(text: str) -> Any:
+    """Parse one YAML scalar or inline sequence."""
+    text = text.strip()
+    if not text:
+        return None
+    lowered = text.lower()
+    if lowered in ("true", "yes"):
+        return True
+    if lowered in ("false", "no"):
+        return False
+    if lowered in ("null", "~"):
+        return None
+    if text[0] in "[{":
+        normalized = re.sub(r"\b(True|true|yes)\b", "True", text)
+        normalized = re.sub(r"\b(False|false|no)\b", "False", normalized)
+        normalized = re.sub(r"\b(null|~)\b", "None", normalized)
+        try:
+            return ast.literal_eval(normalized)
+        except (SyntaxError, ValueError):
+            return text
+    try:
+        return ast.literal_eval(text)
+    except (SyntaxError, ValueError):
+        return text.strip("\"'")
+
+
+def _parse_yaml_minimal(text: str) -> dict[str, Any]:
+    """Parse the small subset of YAML the AuK configs use.
+
+    Nested mappings by indentation, scalars, and inline sequences. Used only
+    when PyYAML is unavailable.
+    """
+    root: dict[str, Any] = {}
+    stack: list[tuple[int, dict[str, Any]]] = [(-1, root)]
+    for raw in text.splitlines():
+        line = _strip_comment(raw)
+        if not line.strip():
+            continue
+        indent = len(line) - len(line.lstrip(" "))
+        body = line.strip()
+        if ":" not in body:
+            raise ValueError(f"unsupported YAML line (no key): {raw!r}")
+        key, _, rest = body.partition(":")
+        key = key.strip()
+        while stack and indent <= stack[-1][0]:
+            stack.pop()
+        if not stack:
+            raise ValueError(f"unsupported YAML indentation at: {raw!r}")
+        parent = stack[-1][1]
+        if rest.strip():
+            parent[key] = _parse_scalar(rest)
+        else:
+            child: dict[str, Any] = {}
+            parent[key] = child
+            stack.append((indent, child))
+    return root
+
+
+def _resolve_interpolations(node: Any, root: dict[str, Any]) -> Any:
+    """Replace ``${a.b.c}`` scalars with the value at that dotted path."""
+    if isinstance(node, dict):
+        return {k: _resolve_interpolations(v, root) for k, v in node.items()}
+    if isinstance(node, list):
+        return [_resolve_interpolations(v, root) for v in node]
+    if isinstance(node, str):
+        match = _INTERPOLATION.match(node.strip())
+        if match is None:
+            return node
+        target: Any = root
+        for part in match.group(1).split("."):
+            if not isinstance(target, dict) or part not in target:
+                raise ValueError(f"cannot resolve interpolation ${{{match.group(1)}}}")
+            target = target[part]
+        return target
+    return node
+
+
+def load_auk_yaml(path: Path) -> dict[str, Any]:
+    """Load the AuK ``config.yaml`` with interpolations resolved."""
+    text = path.read_text()
+    try:
+        import yaml
+
+        parsed = yaml.safe_load(text)
+    except ImportError:
+        parsed = _parse_yaml_minimal(text)
+    if not isinstance(parsed, dict) or "model" not in parsed:
+        raise ValueError(f"{path} has no top-level 'model' section")
+    return _resolve_interpolations(parsed, parsed)
+
+
+def detect_variant(auk_dir: Path, model_section: dict[str, Any]) -> str:
+    """Infer base vs flash from the weight filename, then the model name."""
+    if (auk_dir / "auk_flash.safetensors").exists():
+        return "flash"
+    if (auk_dir / "auk_base.safetensors").exists():
+        return "base"
+    name = str(model_section.get("name", "")).lower()
+    return "flash" if "flash" in name else "base"
+
+
+def weights_name(variant: str) -> str:
+    return "auk_flash.safetensors" if variant == "flash" else "auk_base.safetensors"
+
+
+def build_config(
+    auk_yaml: dict[str, Any],
+    qwen_config: dict[str, Any],
+    variant: str,
+) -> dict[str, Any]:
+    """Assemble the ``config.json`` body for the output directory.
+
+    The Qwen config is kept whole, including ``talker_config`` and
+    ``token2wav_config``: ``AuKConfig`` subclasses ``Qwen2_5OmniConfig`` and
+    the encoder stage reuses the in-tree thinker processor, which asserts that
+    type. AuK's own sections are added at the top level.
+    """
+    model = auk_yaml["model"]
+    arch = model.get("arch", {})
+    vae = model.get("vae", {})
+
+    missing = [key for key in DIT_KEYS if key not in arch]
+    if missing:
+        raise ValueError(f"AuK config.yaml arch section is missing {missing}")
+    missing = [key for key in VAE_KEYS if key not in vae]
+    if missing:
+        raise ValueError(f"AuK config.yaml vae section is missing {missing}")
+    if not isinstance(qwen_config.get("thinker_config"), dict):
+        raise ValueError("Qwen snapshot config.json has no 'thinker_config' mapping")
+
+    dit = {key: arch[key] for key in DIT_KEYS}
+    # dim_head is implicit upstream (dim // heads) but the port takes it
+    # explicitly, so it is recorded rather than recomputed at load time.
+    dit["dim_head"] = int(arch["dim"]) // int(arch["heads"])
+    # Carried from the released config: the DiT builds an attention mask over
+    # the padded [audio | text] sequence and parity depends on it.
+    dit["attn_mask_enabled"] = bool(arch.get("attn_mask_enabled", True))
+
+    config = dict(qwen_config)
+    config["model_type"] = "auk"
+    config["architectures"] = ["AuKForConditionalGeneration"]
+    config["dit"] = dit
+    config["vae"] = {key: vae[key] for key in VAE_KEYS}
+    config["variant"] = variant
+    config["flash_t_grid"] = FLASH_T_GRID
+    config["defaults"] = {"nfe": 32, "cfg": 2.0, "sway": -1.0}
+    return config
+
+
+def _replace_path(target: Path) -> None:
+    """Remove an existing file, directory, or link at ``target``."""
+    if target.is_symlink() or target.is_file():
+        target.unlink()
+    elif target.is_dir():
+        shutil.rmtree(target)
+
+
+def link_or_copy(source: Path, target: Path, *, copy: bool) -> None:
+    """Point ``target`` at ``source``, replacing whatever is already there."""
+    if not source.exists():
+        raise FileNotFoundError(f"missing source artifact: {source}")
+    if target.is_symlink() and not copy and target.readlink() == source.resolve():
+        return
+    _replace_path(target)
+    if copy:
+        if source.is_dir():
+            shutil.copytree(source, target)
+        else:
+            shutil.copy2(source, target)
+        return
+    target.symlink_to(source.resolve(), target_is_directory=source.is_dir())
+
+
+MANIFEST_NAME = ".auk-assembled.json"
+
+
+def _reject_overlap(out: Path, *inputs: Path) -> None:
+    """Refuse an output directory that is, contains, or lives inside an input."""
+    out_r = out.resolve()
+    for src in inputs:
+        src_r = src.resolve()
+        if out_r == src_r or out_r in src_r.parents or src_r in out_r.parents:
+            raise ValueError(f"--out {out} overlaps input directory {src}; choose a separate directory")
+
+
+def assemble(auk_dir: Path, qwen_dir: Path, out: Path, variant: str, *, copy: bool) -> None:
+    """Link the AuK weights and the Qwen snapshot entries into ``out``."""
+    _reject_overlap(out, auk_dir, qwen_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    manifest_path = out / MANIFEST_NAME
+    previous: set[str] = set()
+    if manifest_path.is_file():
+        previous = set(json.loads(manifest_path.read_text()).get("entries", []))
+    weights = auk_dir / weights_name(variant)
+
+    entries: dict[str, Path] = {
+        WEIGHTS_LINK: weights,
+        VAE_LINK: auk_dir / VAE_LINK,
+        THINKER_LINK: qwen_dir,
+    }
+    # The assembled config replaces the Qwen one; every other entry is reused.
+    for entry in qwen_dir.iterdir():
+        if entry.name.startswith(".") or entry.name in _SKIP_QWEN_ENTRIES:
+            continue
+        entries[entry.name] = entry
+
+    for name, source in entries.items():
+        link_or_copy(source, out / name, copy=copy)
+
+    # Drop only entries this tool created in an earlier run and no longer needs;
+    # anything else in the directory belongs to the user.
+    for name in previous - set(entries) - {CONFIG_NAME}:
+        stale = out / name
+        if stale.exists() or stale.is_symlink():
+            _replace_path(stale)
+    manifest_path.write_text(json.dumps({"entries": sorted(entries)}, indent=1) + "\n")
+
+
+def print_tree(out: Path) -> None:
+    """Print the assembled directory, one entry per line."""
+    print(f"\n{out}/")
+    for entry in sorted(out.iterdir()):
+        if entry.is_symlink():
+            print(f"  {entry.name} -> {entry.readlink()}")
+        elif entry.is_dir():
+            print(f"  {entry.name}/")
+        else:
+            print(f"  {entry.name}  ({entry.stat().st_size / 1e9:.2f} GB)")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("--auk-dir", required=True, help="HF snapshot of the AuK or AuK-Flash repo")
+    parser.add_argument("--qwen-dir", required=True, help="HF snapshot of Qwen2.5-Omni-3B")
+    parser.add_argument("--out", required=True, help="Directory to assemble (created if absent)")
+    parser.add_argument(
+        "--variant",
+        choices=("base", "flash"),
+        help="Override the variant; detected from the AuK snapshot by default",
+    )
+    parser.add_argument(
+        "--copy",
+        action="store_true",
+        help="Copy the weights and the snapshot entries instead of symlinking",
+    )
+    args = parser.parse_args()
+
+    auk_dir = Path(args.auk_dir).expanduser().resolve()
+    qwen_dir = Path(args.qwen_dir).expanduser().resolve()
+    out = Path(args.out).expanduser().resolve()
+    _reject_overlap(out, auk_dir, qwen_dir)
+
+    auk_yaml = load_auk_yaml(auk_dir / "config.yaml")
+    variant = args.variant or detect_variant(auk_dir, auk_yaml["model"])
+    qwen_config = json.loads((qwen_dir / CONFIG_NAME).read_text())
+
+    config = build_config(auk_yaml, qwen_config, variant)
+    assemble(auk_dir, qwen_dir, out, variant, copy=args.copy)
+    (out / CONFIG_NAME).write_text(json.dumps(config, indent=2) + "\n")
+
+    print(f"variant: {variant}  (weights {weights_name(variant)})")
+    print_tree(out)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
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_clock.py b/vllm_omni/benchmarks/duplex/omni_duplex_eval_clock.py
index 03997fc8e..494f9a856 100644
--- a/vllm_omni/benchmarks/duplex/omni_duplex_eval_clock.py
+++ b/vllm_omni/benchmarks/duplex/omni_duplex_eval_clock.py
@@ -49,7 +49,11 @@ def extract_timed_sentences(events: Iterable[dict[str, Any]], *, clock: str = "m
     last: float | None = None
     for event in events:
         event_type = event.get("type")
-        if event_type not in {"response.output_text.delta", "response.audio_transcript.delta", "response.text.delta"}:
+        if event_type not in {
+            "response.output_text.delta",
+            "response.output_audio_transcript.delta",
+            "response.text.delta",
+        }:
             continue
         delta = event.get("delta")
         if not isinstance(delta, str) or not delta.strip():
diff --git a/vllm_omni/benchmarks/duplex/omni_duplex_eval_dataset.py b/vllm_omni/benchmarks/duplex/omni_duplex_eval_dataset.py
index 9d6013e80..349d80fc3 100644
--- a/vllm_omni/benchmarks/duplex/omni_duplex_eval_dataset.py
+++ b/vllm_omni/benchmarks/duplex/omni_duplex_eval_dataset.py
@@ -3,15 +3,36 @@
 
 """Dataset and split normalization for Omni-DuplexEval.
 
-The loader accepts a Hugging Face dataset id, a JSON/JSONL manifest, or an
+The loader accepts a Hugging Face dataset id, a local Hugging Face dataset
+layout (a directory or a ``.parquet`` file), a JSON/JSONL manifest, or an
 already materialized iterable.  Media is deliberately resolved at use time so
 the benchmark remains usable in air-gapped environments.
+
+Local directory mirrors are expected to use a *single* Hugging Face
+configuration whose data files are named after the benchmark splits
+(``data/<SPLIT>-00000-of-00001.parquet``, with ``<SPLIT>`` one of the RTD_*/PR_*
+names), so ``datasets.load_dataset`` exposes one physical split per benchmark
+split.  A single ``.parquet`` file and a mirror that Hugging Face collapses into
+a generic ``train`` split are also accepted, but then the requested ``split`` is
+applied as a filter on each row's preserved ``split``/``subset``/``config``
+identity instead of as a physical split name.  Rows that identify neither their
+split nor their family/task raise a clear error that explains the required
+layout.
+
+A requested ``split`` that matches zero rows (for example a mistyped name) is
+reported loudly: :func:`load_samples` raises a ``ValueError`` that lists the
+split identities actually observed in the loaded rows instead of silently
+returning an empty selection.  Rows coming from a JSON/JSONL manifest or an
+already materialized iterable that carry no split/subset/config identity keep
+the base override behavior: ``--split`` is stamped onto them so they are kept
+rather than rejected.
 """
 
 from __future__ import annotations
 
+import importlib
 import json
-from collections.abc import Iterable
+from collections.abc import Callable, Iterable
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
@@ -68,6 +89,23 @@ def family_for_split(split: str, task_type: str | None = None) -> str:
     raise ValueError(f"cannot infer benchmark family from split {split!r}")
 
 
+def _identity_error(split: str, sample_id: str, *, family: bool) -> str:
+    """Build an actionable error for a row whose family/task cannot be derived."""
+    subject = "family" if family else "proactive-reminder task type"
+    label = f" for sample {sample_id!r}" if sample_id else ""
+    detail = (
+        "the split is not an RTD_*/PR_* name and no per-row 'task_type' is present"
+        if family
+        else "no per-row 'task_type' is present"
+    )
+    return (
+        f"cannot infer the Omni-DuplexEval {subject}{label} from split {split!r}: {detail}. "
+        "Load a local Omni-DuplexEval mirror whose data files are named after the "
+        "Hugging Face splits (RTD_*/PR_*) or add per-row "
+        "'family'/'task_type'/'split' columns."
+    )
+
+
 def _value(row: dict[str, Any], *keys: str, default: Any = None) -> Any:
     for key in keys:
         if key in row and row[key] is not None:
@@ -100,14 +138,27 @@ class DuplexSample:
     raw: dict[str, Any] | None = None
 
     @classmethod
-    def from_row(cls, row: dict[str, Any], *, split: str | None = None, media_root: Path | None = None) -> DuplexSample:
-        chosen_split = str(split or _value(row, "split", "subset", "config", default=""))
+    def from_row(cls, row: dict[str, Any], *, media_root: Path | None = None) -> DuplexSample:
+        chosen_split = str(_value(row, "split", "subset", "config", default=""))
+        sample_id = str(_value(row, "id", "sample_id", "uid", "name", default=""))
         task_value = _value(row, "task_type", "task", "type")
-        family = str(_value(row, "family", default="") or family_for_split(chosen_split, task_value))
+        family_value = _value(row, "family", default="")
+        if family_value:
+            family = str(family_value)
+        else:
+            try:
+                family = family_for_split(chosen_split, task_value)
+            except ValueError as exc:
+                raise ValueError(_identity_error(chosen_split, sample_id, family=True)) from exc
         task = None
         if family == "pr":
-            task = canonical_task_type(str(task_value)) if task_value else task_type_for_split(chosen_split)
-        sample_id = str(_value(row, "id", "sample_id", "uid", "name", default=""))
+            if task_value:
+                task = canonical_task_type(str(task_value))
+            else:
+                try:
+                    task = task_type_for_split(chosen_split)
+                except ValueError as exc:
+                    raise ValueError(_identity_error(chosen_split, sample_id, family=False)) from exc
         video = _value(row, "video", "video_path", "video_file")
         audio = _value(row, "question_audio", "audio", "question_wav")
         if media_root:
@@ -148,6 +199,150 @@ def _read_manifest(path: Path) -> list[dict[str, Any]]:
     return payload
 
 
+def _has_split_identity(row: dict[str, Any]) -> bool:
+    """Whether a row already identifies the benchmark split it belongs to."""
+    return any(row.get(key) for key in ("split", "subset", "config"))
+
+
+def _stamp_split(rows: Iterable[dict[str, Any]], name: str) -> list[dict[str, Any]]:
+    """Stamp a physical Hugging Face split name onto rows that lack identity.
+
+    Hugging Face collapses a config-less local mirror (a bare ``data/``
+    directory) or a single ``.parquet`` file into a single generic split
+    (``train``).  A row's own split identity (``split``/``subset``/``config``)
+    must win so family inference is not poisoned by that generic name; the
+    physical split name is only stamped when the row does not identify itself.
+    """
+    stamped: list[dict[str, Any]] = []
+    for row in rows:
+        item = dict(row)
+        if name and not _has_split_identity(item):
+            item["split"] = name
+        stamped.append(item)
+    return stamped
+
+
+def _override_split(rows: list[dict[str, Any]], split: str | None) -> list[dict[str, Any]]:
+    """Apply the base split-override semantics to manifest/iterable rows.
+
+    Rows that lack split/subset/config identity are stamped with the requested
+    split so they are kept, matching the pre-override behavior; rows that
+    already carry identity are left untouched so the requested split stays a
+    filter. Copies are returned, never mutating the caller's original dicts.
+    """
+    if not split or split == "all":
+        return rows
+    return [row if _has_split_identity(row) else {**row, "split": split} for row in rows]
+
+
+def _recast_media_features(loaded: Any) -> Any:
+    """Recast Audio/Video features to decode=False so rows carry {bytes, path}.
+
+    Hugging Face ``Audio``/``Video`` features default to ``decode=True``,
+    producing ``{"array", "path", "sampling_rate"}`` dicts without the
+    ``bytes`` key that :func:`materialize_media` needs. ``decode=False`` keeps
+    the raw parquet struct instead. Must run before row iteration
+    (``cast_column`` is lazy; decoding happens at row access).
+    """
+    try:
+        features_mod = importlib.import_module("datasets.features")
+    except ImportError:
+        return loaded
+    audio_cls = getattr(features_mod, "Audio", None)
+    video_cls = getattr(features_mod, "Video", None)
+    if audio_cls is None:
+        return loaded
+
+    if isinstance(loaded, dict):
+        # A DatasetDict -- or a plain dict returned by a fake loader whose
+        # values are lists -- recurses one level and is returned untouched by
+        # the features guard below.
+        return {name: _recast_media_features(table) for name, table in loaded.items()}
+
+    feats = getattr(loaded, "features", None)
+    if feats is None:
+        return loaded
+    for column, feature in feats.items():
+        if isinstance(feature, audio_cls):
+            loaded = loaded.cast_column(column, audio_cls(decode=False))
+        elif video_cls is not None and isinstance(feature, video_cls):
+            loaded = loaded.cast_column(column, video_cls(decode=False))
+    return loaded
+
+
+def _read_hf(load_dataset: Callable[..., Any], dataset: str, want: str | None) -> Any:
+    """Call ``datasets.load_dataset`` for a local layout or a remote id.
+
+    The physical split is only requested when one was asked for; ``datasets``
+    then returns a single ``Dataset`` (an iterable of rows) instead of a
+    ``DatasetDict`` (a mapping of split name to such an iterable). The result is
+    normalized by :func:`_rows_from_hf`.
+    """
+    if Path(dataset).suffix.lower() == ".parquet":
+        # A single parquet file is always exposed as one generic ``train``
+        # split; the logical benchmark split is filtered from row identity
+        # afterwards. The ``want`` branch was unreachable (the only call site
+        # passes ``None``) and implied physical split support that does not
+        # exist, so it was removed.
+        return load_dataset("parquet", data_files=dataset)
+    if want:
+        return load_dataset(dataset, split=want)
+    return load_dataset(dataset)
+
+
+def _rows_from_hf(dataset: str, *, split: str | None) -> list[dict[str, Any]]:
+    """Load rows from a Hugging Face dataset id or a local dataset layout.
+
+    ``datasets.load_dataset`` accepts a remote id, a local dataset directory
+    (``data/<SPLIT>-00000-of-00001.parquet``) and, via the ``parquet`` builder,
+    a single ``.parquet`` file, which keeps the benchmark usable offline with a
+    locally mirrored copy of the dataset.
+
+    The logical benchmark split (``RTD_OCR``, ``PR_correction``, ...) is not
+    forwarded blindly as a physical Hugging Face split: a single ``.parquet``
+    file and a collapsed local mirror only expose a generic ``train`` split, so
+    passing the logical name there raises ``Unknown split``.  The physical
+    dataset is loaded instead and the requested split is applied later, on the
+    preserved per-row identity (see :func:`load_samples`).
+    """
+    try:
+        from datasets import load_dataset
+    except ImportError as exc:
+        raise RuntimeError(
+            "datasets is required to load a Hugging Face dataset id or a local "
+            "dataset directory/parquet file; use a local JSON/JSONL manifest instead"
+        ) from exc
+
+    requested = split if split and split != "all" else None
+    is_local = Path(dataset).exists()
+    if Path(dataset).suffix.lower() == ".parquet":
+        # A single parquet file is always exposed as one generic ``train``
+        # split; the logical benchmark split is filtered from row identity
+        # afterwards rather than forwarded as a physical split name.
+        loaded = _read_hf(load_dataset, dataset, None)
+    else:
+        try:
+            loaded = _read_hf(load_dataset, dataset, requested)
+        except ValueError as exc:
+            # A collapsed *local* mirror (bare ``data/`` directory) does not
+            # expose the logical split as a physical Hugging Face split; fall
+            # back to the whole physical dataset and filter by row identity.
+            # A remote id keeps the original error so a mistyped split still
+            # fails loudly instead of silently selecting nothing.
+            if not is_local or requested is None or "Unknown split" not in str(exc):
+                raise
+            loaded = _read_hf(load_dataset, dataset, None)
+            requested = None
+
+    loaded = _recast_media_features(loaded)
+    if isinstance(loaded, dict):
+        rows: list[dict[str, Any]] = []
+        for name, table in loaded.items():
+            rows.extend(_stamp_split((dict(row) for row in table), name))
+        return rows
+    return _stamp_split((dict(row) for row in loaded), requested or "")
+
+
 def load_samples(
     dataset: str | Path | Iterable[dict[str, Any]] = DEFAULT_DATASET,
     *,
@@ -157,37 +352,54 @@ def load_samples(
     limit: int | None = None,
     ids: Iterable[str] | None = None,
 ) -> list[DuplexSample]:
-    if isinstance(dataset, (str, Path)) and Path(str(dataset)).exists():
-        rows = _read_manifest(Path(str(dataset)))
-    elif not isinstance(dataset, (str, Path)):
-        rows = list(dataset)
-    else:
-        try:
-            from datasets import load_dataset
-        except ImportError as exc:
-            raise RuntimeError("datasets is required for Hugging Face loading; use a local manifest instead") from exc
-        kwargs: dict[str, Any] = {}
-        if split and split != "all":
-            kwargs["split"] = split
-        loaded = load_dataset(str(dataset), **kwargs)
-        if isinstance(loaded, dict):
-            rows = []
-            for name, table in loaded.items():
-                rows.extend({**dict(row), "split": name} for row in table)
+    if isinstance(dataset, str | Path):
+        path = Path(str(dataset))
+        if path.exists():
+            # A directory or a ``.parquet`` file is a Hugging Face dataset
+            # layout (e.g. a locally mirrored Omni-DuplexEval snapshot); only
+            # single JSON/JSONL files are parsed as manifests.  Routing by path
+            # shape instead of mere existence lets local Hugging Face datasets
+            # load through ``datasets.load_dataset``.
+            if path.is_dir() or path.suffix.lower() == ".parquet":
+                rows = _rows_from_hf(str(path), split=split)
+            else:
+                try:
+                    rows = _override_split(_read_manifest(path), split)
+                except (json.JSONDecodeError, UnicodeDecodeError) as exc:
+                    raise ValueError(
+                        f"cannot load dataset from {str(path)!r}: expected a "
+                        "JSON/JSONL manifest file, a local Hugging Face dataset "
+                        "directory, or a single .parquet file"
+                    ) from exc
         else:
-            rows = [dict(row) for row in loaded]
+            rows = _rows_from_hf(str(dataset), split=split)
+    else:
+        rows = _override_split(list(dataset), split)
     wanted = set(str(item) for item in ids) if ids else None
     root = Path(media_root).expanduser() if media_root else None
     result = []
+    split_matched = 0
     for row in rows:
-        sample = DuplexSample.from_row(row, split=None if split in (None, "all") else split, media_root=root)
+        # The requested split is a *filter* over each row's own split identity;
+        # never pass it as an override, which would relabel every row as the
+        # requested split (turning a collapsed local dataset into a full match
+        # instead of a filter).
+        sample = DuplexSample.from_row(row, media_root=root)
         if split and split != "all" and sample.split != split:
             continue
+        split_matched += 1
         if family != "all" and sample.family != family:
             continue
         if wanted is not None and sample.id not in wanted:
             continue
         result.append(sample)
+    if split and split != "all" and split_matched == 0 and rows:
+        observed = sorted({str(_value(row, "split", "subset", "config", default="")) or "<none>" for row in rows})
+        raise ValueError(
+            f"--split {split!r} matched zero samples. "
+            f"Split identities observed in the loaded rows: {observed}. "
+            "Check the split name for a typo."
+        )
     if limit is not None:
         result = result[: max(0, limit)]
     return result
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 629d8e877..ae198902a 100644
--- a/vllm_omni/benchmarks/duplex/omni_duplex_eval_media.py
+++ b/vllm_omni/benchmarks/duplex/omni_duplex_eval_media.py
@@ -1,11 +1,19 @@
 # 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 subprocess
+import io
+import logging
+import os
+import tempfile
 import wave
 from collections.abc import Iterator
 from pathlib import Path
@@ -13,56 +21,132 @@ 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:
-    """Resolve common Hugging Face media values to a local file."""
+    """Resolve common Hugging Face media values to a local file.
+
+    ``str``/``Path`` values are returned as-is. Inline byte payloads (a
+    ``bytes``/``bytearray`` or a Hugging Face ``Audio``/``Video``/``Image``
+    feature mapping ``{"bytes": ..., "path": ...}``) are written to a real file
+    under ``output_dir`` and that existing path is returned. For such mappings
+    the ``path`` key is the original artifact name inside the dataset, which is
+    usually *not* present on the local disk, so it is only used to pick a
+    content extension and never treated as an existing file. A mapping or
+    object carrying only a ``path`` (no inline ``bytes``) is returned as an
+    already-materialized file reference.
+    """
     if isinstance(value, str | Path):
         return Path(value)
     path = value.get("path") if isinstance(value, dict) else getattr(value, "path", None)
-    if path:
-        return Path(path)
-    payload = value.get("bytes") if isinstance(value, dict) else None
+    payload = value.get("bytes") if isinstance(value, dict) else getattr(value, "bytes", None)
     if payload is None and isinstance(value, bytes | bytearray):
         payload = value
-    if payload is None:
-        raise ValueError(f"cannot materialize media value for {stem!r}")
-    destination = Path(output_dir) / f"{stem}{suffix}"
-    destination.parent.mkdir(parents=True, exist_ok=True)
-    destination.write_bytes(bytes(payload))
+    if payload is not None:
+        return _write_media_bytes(payload, output_dir, stem, _media_extension(path, suffix))
+    if path:
+        return Path(path)
+    raise ValueError(f"cannot materialize media value for {stem!r}")
+
+
+def _media_extension(path: str | Path | None, fallback: str) -> str:
+    """Pick a safe lower-case file extension from ``path`` when available."""
+    extension = Path(str(path)).suffix.lower() if path else ""
+    if extension.startswith(".") and len(extension) <= 8 and extension[1:].isalnum():
+        return extension
+    return fallback
+
+
+def _write_media_bytes(payload: bytes | bytearray, output_dir: str | Path, stem: str, extension: str) -> Path:
+    data = bytes(payload)
+    root = Path(output_dir)
+    root.mkdir(parents=True, exist_ok=True)
+    destination = root / f"{stem}{extension}"
+    if destination.exists() and destination.stat().st_size == len(data) and destination.read_bytes() == data:
+        return destination
+    fd, temporary = tempfile.mkstemp(dir=root, prefix=f".{destination.name}.", suffix=".part")
+    try:
+        with os.fdopen(fd, "wb") as handle:
+            handle.write(data)
+        os.replace(temporary, destination)
+    except OSError:
+        try:
+            os.unlink(temporary)
+        except OSError:
+            pass
+        raise
     return destination
 
 
 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(
@@ -74,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
@@ -93,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(
@@ -111,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/duplex/omni_duplex_eval_runner.py b/vllm_omni/benchmarks/duplex/omni_duplex_eval_runner.py
index d5a28aa06..db500ebf0 100644
--- a/vllm_omni/benchmarks/duplex/omni_duplex_eval_runner.py
+++ b/vllm_omni/benchmarks/duplex/omni_duplex_eval_runner.py
@@ -8,24 +8,58 @@ from __future__ import annotations
 import asyncio
 import hashlib
 import json
+import time
+from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any
+from typing import TYPE_CHECKING
 
 import pybase64 as base64
 
-from vllm_omni.experimental.fullduplex.client import RealtimeDuplexClient, build_realtime_url, wait_for
+from vllm_omni.benchmarks.duplex.omni_duplex_eval_dataset import DuplexSample
+from vllm_omni.experimental.fullduplex.client import (
+    RealtimeDuplexClient,
+    RealtimeEventCollector,
+    build_realtime_url,
+    wait_for,
+)
+
+if TYPE_CHECKING:
+    from vllm_omni.clients.duplex import EventCollector
 
 from .omni_duplex_eval_clock import extract_timed_sentences
 from .omni_duplex_eval_media import iter_av_units, iter_jpegs, materialize_media, read_audio_pcm16, video_duration
 
 
+@dataclass(frozen=True)
+class GenerateSampleResult:
+    """Timed-sentence path plus duplex metrics for one generate sample."""
+
+    output: Path
+    request_metrics: list[dict[str, object]] = field(default_factory=list)
+    session_metrics: dict[str, object] = field(default_factory=dict)
+
+
 def _ref_audio(path: str | Path) -> str:
     value = Path(path).expanduser().read_bytes()
     return "data:audio/wav;base64," + base64.b64encode(value).decode("ascii")
 
 
+def _event_collector_from_realtime(source: RealtimeEventCollector) -> EventCollector:
+    """Replay experimental collector events onto the public EventCollector."""
+    from vllm_omni.clients.duplex import EventCollector
+
+    collector = EventCollector()
+    for event, received_at_s in zip(source.events, source.event_received_at_s, strict=True):
+        collector.add(event, received_at_s=received_at_s)
+    return collector
+
+
+def _with_sample_identity(payload: dict[str, object], sample: DuplexSample) -> dict[str, object]:
+    return {"sample_id": sample.id, "split": sample.split, **payload}
+
+
 async def generate_sample(
-    sample: Any,
+    sample: DuplexSample,
     *,
     url: str,
     model: str,
@@ -37,11 +71,17 @@ async def generate_sample(
     clock: str = "media",
     overwrite: bool = False,
     unit_ms: int = 1000,
-) -> Path:
+) -> GenerateSampleResult:
+    """Generate one sample's timed sentences and collect duplex session metrics.
+
+    Timed sentences and ``*.meta.json`` stay the quality-eval artifacts. Duplex
+    request/session metrics are returned for the CLI to write
+    ``duplex_metrics.json``; they are not written into meta.
+    """
     output = Path(output_root) / sample.split / f"{sample.id}.json"
     meta_path = output.with_name(output.stem + ".meta.json")
     if output.exists() and not overwrite:
-        return output
+        return GenerateSampleResult(output=output)
     if mix != "question":
         raise NotImplementedError("v1 supports mix=question; soundtrack mixing is reserved for P1")
     media_dir = output.parent / ".media"
@@ -57,10 +97,12 @@ async def generate_sample(
     response_done = False
     drain_timeout = None
     close_timeout = None
+    stream_start: float | None = None
     async with client:
         await client.configure(model, ref_audio=_ref_audio(ref_audio), instructions="Streaming Omni Conversation.")
         ack_task = asyncio.create_task(_ack_playback(client))
         try:
+            stream_start = time.monotonic()
             await client.stream_av_units(iter_av_units(pcm, frames, unit_ms=unit_ms), realtime=realtime)
             await client.commit()
             try:
@@ -84,6 +126,7 @@ async def generate_sample(
         except TimeoutError as exc:
             close_timeout = str(exc)
         events = list(client.events.events)
+        collector = _event_collector_from_realtime(client.events)
     timed = [sentence.as_dict() for sentence in extract_timed_sentences(events, clock=clock)]
     output.parent.mkdir(parents=True, exist_ok=True)
     output.write_text(json.dumps(timed, ensure_ascii=False, indent=2), encoding="utf-8")
@@ -102,7 +145,18 @@ async def generate_sample(
         "ref_audio_sha256": hashlib.sha256(Path(ref_audio).read_bytes()).hexdigest(),
     }
     meta_path.write_text(json.dumps(meta, indent=2), encoding="utf-8")
-    return output
+    from vllm_omni.benchmarks.duplex_session_metrics import collect_duplex_session_metrics
+
+    bundle = collect_duplex_session_metrics(
+        collector,
+        stream_start=stream_start if stream_start is not None else 0.0,
+        session_id=sample.id,
+    )
+    return GenerateSampleResult(
+        output=output,
+        request_metrics=[_with_sample_identity(metric, sample) for metric in bundle.request_metrics],
+        session_metrics=_with_sample_identity(bundle.session_metrics, sample),
+    )
 
 
 async def _ack_playback(client: RealtimeDuplexClient) -> None:
diff --git a/vllm_omni/benchmarks/duplex_session_metrics.py b/vllm_omni/benchmarks/duplex_session_metrics.py
new file mode 100644
index 000000000..ba3bab5ac
--- /dev/null
+++ b/vllm_omni/benchmarks/duplex_session_metrics.py
@@ -0,0 +1,229 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Assemble duplex serve metrics from a public EventCollector.
+
+This module does not instrument the server. It reads the same
+``EventCollector.timing_summary`` / ``global_timing_summary`` surfaces that
+OmniInteract already uses, derives RTF with ``compute_audio_rtf``, and folds
+per-session ``stream_*`` values into a run-level report.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from vllm_omni.metrics.definitions import compute_audio_rtf
+
+if TYPE_CHECKING:
+    from vllm_omni.clients.duplex import EventCollector
+
+DUPLEX_METRICS_FILENAME = "duplex_metrics.json"
+
+_REQUEST_MEASUREMENT_ORIGIN = {
+    "tpot": "Stage-0 engine mean time per output token",
+    "rtf": "response.created client receive to last audio packet divided by emitted audio duration",
+}
+_STREAM_MEASUREMENT_ORIGIN = {
+    "ttft": "input stream start to first non-empty text delta",
+    "ttfp": "input stream start to first audio packet",
+    "rtf": (
+        "input stream start-to-last-audio receive time divided by total emitted audio duration; "
+        "includes concurrent realtime input"
+    ),
+}
+
+
+@dataclass(frozen=True)
+class DuplexSessionMetricBundle:
+    """One session's request rows plus the session/stream summary."""
+
+    request_metrics: list[dict[str, object]]
+    session_metrics: dict[str, object]
+    output_tokens: int
+
+
+def audio_rtf_from_raw_metric(raw_metric: Mapping[str, object]) -> float | None:
+    """Derive audio RTF from client-reported generation and duration milliseconds."""
+    generation_ms = raw_metric.get("audio_generation_ms")
+    duration_ms = raw_metric.get("audio_duration_ms")
+    if not isinstance(generation_ms, int | float) or not isinstance(duration_ms, int | float) or duration_ms <= 0:
+        return None
+    return round(compute_audio_rtf(float(generation_ms) / 1000.0, float(duration_ms) / 1000.0), 6)
+
+
+def collect_duplex_session_metrics(
+    collector: EventCollector,
+    *,
+    stream_start: float,
+    session_id: str | None,
+) -> DuplexSessionMetricBundle:
+    """Build per-response and session/stream metrics for one duplex session.
+
+    ``stream_start`` is the client monotonic time just before input media is
+    pushed. Per-response TTFT/TTFP prefer server ``response_request_metrics``
+    when present; RTF and the session ``stream_*`` window stay client-receive.
+    """
+    from vllm_omni.clients.duplex import summarize_session_request_metrics
+
+    request_metrics: list[dict[str, object]] = []
+    output_tokens = 0
+    for request_index, response_id in enumerate(collector.response_ids):
+        timing = collector.timing_summary(
+            after_s=stream_start,
+            input_committed_at_s=None,
+            response_id=response_id,
+            measurement_origin=_REQUEST_MEASUREMENT_ORIGIN,
+        )
+        raw_metric = timing.get("request_metrics")
+        stage0 = timing.get("stage0_tokens")
+        metric: dict[str, object] = {
+            "session_id": session_id,
+            "request_index": request_index,
+            "response_id": response_id,
+        }
+        if isinstance(raw_metric, dict):
+            metric.update(raw_metric)
+            metric["rtf"] = audio_rtf_from_raw_metric(raw_metric)
+        if isinstance(stage0, dict):
+            metric["stage0_tokens"] = dict(stage0)
+            output_tokens += int(stage0.get("output_token_count") or 0)
+        if isinstance(raw_metric, dict) or isinstance(stage0, dict):
+            request_metrics.append(metric)
+    session_metrics = summarize_session_request_metrics(
+        request_metrics,
+        session_id=session_id,
+    )
+    stream_metrics = collector.global_timing_summary(
+        after_s=stream_start,
+        window_started_at_s=stream_start,
+        response_ids=list(collector.response_ids),
+        measurement_origin=_STREAM_MEASUREMENT_ORIGIN,
+    )
+    if stream_metrics:
+        session_metrics.update(
+            {
+                "stream_ttft_ms": stream_metrics.get("ttft_ms"),
+                "stream_ttfp_ms": stream_metrics.get("ttfp_ms"),
+                "stream_rtf": audio_rtf_from_raw_metric(stream_metrics),
+                "stream_audio_generation_ms": stream_metrics.get("audio_generation_ms"),
+                "stream_audio_duration_ms": stream_metrics.get("audio_duration_ms"),
+                "stream_measurement_origin": stream_metrics.get("measurement_origin"),
+            }
+        )
+    return DuplexSessionMetricBundle(
+        request_metrics=request_metrics,
+        session_metrics=session_metrics,
+        output_tokens=output_tokens,
+    )
+
+
+def duplex_stream_metrics(session_metrics: Sequence[Mapping[str, object]]) -> dict[str, object]:
+    """Summarize finite, non-negative per-session ``stream_*`` values."""
+    from vllm_omni.clients.duplex import distribution_summary
+
+    result: dict[str, object] = {}
+    for session_key, result_key, digits in (
+        ("stream_ttft_ms", "duplex_stream_ttft_ms", 3),
+        ("stream_ttfp_ms", "duplex_stream_ttfp_ms", 3),
+        ("stream_rtf", "duplex_stream_rtf", 6),
+    ):
+        values = [
+            float(value)
+            for metric in session_metrics
+            if isinstance((value := metric.get(session_key)), int | float)
+            and not isinstance(value, bool)
+            and math.isfinite(value)
+            and value >= 0
+        ]
+        summary = distribution_summary(values, digits=digits)
+        if summary is not None:
+            result[result_key] = summary
+    return result
+
+
+def build_duplex_metrics_report(
+    *,
+    request_metrics: Sequence[Mapping[str, object]],
+    session_metrics: Sequence[Mapping[str, object]],
+) -> dict[str, object]:
+    """Flatten this generate run into the ``duplex_metrics.json`` payload."""
+    report: dict[str, object] = {
+        "duplex_request_metrics": [dict(metric) for metric in request_metrics],
+        "duplex_session_metrics": [dict(metric) for metric in session_metrics],
+    }
+    report.update(duplex_stream_metrics(session_metrics))
+    return report
+
+
+def sample_metric_key(metric: Mapping[str, object]) -> tuple[str, str] | None:
+    """Identity used to merge resume rows: ``(split, sample_id)``."""
+    split = metric.get("split")
+    sample_id = metric.get("sample_id")
+    if isinstance(split, str) and split and isinstance(sample_id, str) and sample_id:
+        return (split, sample_id)
+    return None
+
+
+def merge_metric_rows(
+    existing: Sequence[Mapping[str, object]],
+    incoming: Sequence[Mapping[str, object]],
+) -> list[dict[str, object]]:
+    """Replace existing rows that share an incoming ``(split, sample_id)``.
+
+    Incoming rows without a key are appended. Existing rows without a key are
+    kept because they cannot be matched.
+    """
+    incoming_keys = {key for metric in incoming if (key := sample_metric_key(metric)) is not None}
+    merged = [dict(metric) for metric in existing if (key := sample_metric_key(metric)) not in incoming_keys]
+    merged.extend(dict(metric) for metric in incoming)
+    return merged
+
+
+def read_duplex_metrics_report(path: Path) -> dict[str, object] | None:
+    """Load an on-disk report. Missing files return ``None``; corrupt JSON raises."""
+    if not path.is_file():
+        return None
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(payload, dict):
+        raise ValueError(f"{path} must contain a JSON object")
+    return payload
+
+
+def _metric_rows(value: object, *, field_name: str) -> list[Mapping[str, object]]:
+    if value is None:
+        return []
+    if not isinstance(value, list):
+        raise ValueError(f"{field_name} must be a JSON list")
+    rows: list[Mapping[str, object]] = []
+    for item in value:
+        if not isinstance(item, dict):
+            raise ValueError(f"{field_name} entries must be JSON objects")
+        rows.append(item)
+    return rows
+
+
+def merge_duplex_metrics_report(
+    existing: Mapping[str, object] | None,
+    *,
+    request_metrics: Sequence[Mapping[str, object]],
+    session_metrics: Sequence[Mapping[str, object]],
+) -> dict[str, object]:
+    """Merge this run into a previous ``duplex_metrics.json`` payload."""
+    previous_requests = _metric_rows(
+        None if existing is None else existing.get("duplex_request_metrics"),
+        field_name="duplex_request_metrics",
+    )
+    previous_sessions = _metric_rows(
+        None if existing is None else existing.get("duplex_session_metrics"),
+        field_name="duplex_session_metrics",
+    )
+    return build_duplex_metrics_report(
+        request_metrics=merge_metric_rows(previous_requests, request_metrics),
+        session_metrics=merge_metric_rows(previous_sessions, session_metrics),
+    )
diff --git a/vllm_omni/benchmarks/metrics/metrics.py b/vllm_omni/benchmarks/metrics/metrics.py
index 52eec86b9..759e60667 100644
--- a/vllm_omni/benchmarks/metrics/metrics.py
+++ b/vllm_omni/benchmarks/metrics/metrics.py
@@ -916,11 +916,9 @@ def calculate_metrics(
             all_tpots.append(tpot)
             itls += outputs[i].itl
             session_metrics = getattr(outputs[i], "duplex_session_metrics", None)
-            ttft_measured = not isinstance(session_metrics, dict) or session_metrics.get("mean_ttft_ms") is not None
-            audio_ttfp_measured = (
-                not isinstance(session_metrics, dict) or session_metrics.get("mean_ttfp_ms") is not None
-            )
-            audio_rtf_measured = not isinstance(session_metrics, dict) or session_metrics.get("mean_rtf") is not None
+            ttft_measured = not isinstance(session_metrics, dict) or session_metrics.get("ttft_ms") is not None
+            audio_ttfp_measured = not isinstance(session_metrics, dict) or session_metrics.get("ttfp_ms") is not None
+            audio_rtf_measured = not isinstance(session_metrics, dict) or session_metrics.get("rtf") is not None
             if ttft_measured:
                 ttfts.append(outputs[i].ttft)
             if audio_ttfp_measured:
diff --git a/vllm_omni/benchmarks/omniinteract.py b/vllm_omni/benchmarks/omniinteract.py
index b821d0235..e566ac12b 100644
--- a/vllm_omni/benchmarks/omniinteract.py
+++ b/vllm_omni/benchmarks/omniinteract.py
@@ -233,7 +233,7 @@ class _Playback:
                 if response_id:
                     self.completed.add(response_id)
                 continue
-            if event.get("type") != "response.audio.delta":
+            if event.get("type") != "response.output_audio.delta":
                 continue
             encoded = event.get("delta") or event.get("audio")
             if not response_id:
@@ -241,13 +241,13 @@ class _Playback:
             if not isinstance(encoded, str):
                 raise ValueError("response audio payload is missing")
             if event.get("format") is None:
-                self._warn_once("response.audio.delta omitted format; assumed pcm16")
+                self._warn_once("response.output_audio.delta omitted format; assumed pcm16")
             elif event.get("format") != "pcm16":
                 raise ValueError("OmniInteract output must be pcm16")
             rate = event.get("sample_rate_hz")
             if rate is None:
                 rate = events.output_sample_rate_hz or OUTPUT_SAMPLE_RATE
-                self._warn_once(f"response.audio.delta omitted sample_rate_hz; assumed {rate}")
+                self._warn_once(f"response.output_audio.delta omitted sample_rate_hz; assumed {rate}")
             if rate != OUTPUT_SAMPLE_RATE:
                 raise ValueError(f"OmniInteract output must use {OUTPUT_SAMPLE_RATE} Hz audio")
             try:
@@ -417,6 +417,13 @@ def _has_post_commit_decision(
 # refusal is harmless — record it instead of failing the case.
 _TOLERATED_ERROR_CODES = frozenset({"playback_ack_too_late"})
 
+# ``session.close`` carries no reason of its own, so the server stamps the
+# terminal event with the reason it inferred for it. Anything else on a
+# ``session.closed`` after our own close request means the session ended for a
+# reason we did not ask for (a disconnect, a lease timeout, a shutdown), which
+# is what this guard is looking for.
+_CLIENT_CLOSE_REASONS = frozenset({"client_close"})
+
 
 def _error_code(event: dict[str, object]) -> str | None:
     error = event.get("error")
@@ -452,7 +459,7 @@ def _raise_if_session_terminated(
             event_type == "session.closed"
             and explicit_close_from is not None
             and index >= explicit_close_from
-            and reason is None
+            and (reason is None or reason in _CLIENT_CLOSE_REASONS)
         )
         if expected:
             continue
@@ -683,7 +690,7 @@ def _collect_output(
         timing = response_times.setdefault(response_id, [start_s, end_s])
         timing[0], timing[1] = min(timing[0], start_s), max(timing[1], end_s)
 
-    text_event_types = {"response.audio_transcript.delta", "response.output_text.delta", "response.text.delta"}
+    text_event_types = {"response.output_audio_transcript.delta", "response.output_text.delta", "response.text.delta"}
     text_ids = {collector.response_id(event) for event in collector.events if event.get("type") in text_event_types}
     if None in text_ids or not text_ids <= created:
         raise ValueError("response transcript has no matching response.created")
@@ -726,7 +733,7 @@ def _collect_output(
                 **{key: value for key, value in event.items() if key not in {"delta", "audio"}},
                 "audio_bytes": audio_sizes[index],
             }
-            if event.get("type") == "response.audio.delta"
+            if event.get("type") == "response.output_audio.delta"
             else dict(event)
             for index, event in enumerate(collector.events)
         ]
@@ -826,7 +833,7 @@ def write_batch_artifacts(
     )
 
 
-def _websocket_url(config: OmniInteractBenchmarkConfig, session_id: str) -> str:
+def _websocket_url(config: OmniInteractBenchmarkConfig) -> str:
     endpoint = (
         config.endpoint
         if urlsplit(config.endpoint).scheme
@@ -834,13 +841,7 @@ def _websocket_url(config: OmniInteractBenchmarkConfig, session_id: str) -> str:
     )
     from vllm_omni.clients.duplex import build_realtime_url
 
-    return build_realtime_url(
-        endpoint,
-        config.model,
-        autostart=False,
-        native_duplex=True,
-        session_id=session_id,
-    )
+    return build_realtime_url(endpoint, config.model, autostart=False)
 
 
 class _RealtimeSession:
@@ -855,7 +856,7 @@ class _RealtimeSession:
 
     _MAX_FRAME_BYTES = 64 * 1024 * 1024
 
-    def __init__(self, config: OmniInteractBenchmarkConfig, session_id: str, reference_audio: str) -> None:
+    def __init__(self, config: OmniInteractBenchmarkConfig, reference_audio: str) -> None:
         from vllm_omni.clients.duplex import DuplexClient, EventCollector, SessionConfig
 
         self.session_config = SessionConfig(
@@ -864,12 +865,11 @@ class _RealtimeSession:
             playback_commit_policy="ack_only",
             idle_timeout_s=float(config.timeout_s),
             extra_body={
-                "native_duplex": True,
                 "force_listen_count": 0,
                 **(config.extra_body or {}),
             },
         )
-        self.url = _websocket_url(config, session_id)
+        self.url = _websocket_url(config)
         headers = dict(config.extra_headers or {})
 
         async def connect(url: str) -> WebSocketTransport:
@@ -886,7 +886,6 @@ class _RealtimeSession:
             self.url,
             model=config.model,
             config=self.session_config,
-            session_id=session_id,
             reconnect=None,
             heartbeat_interval_s=None,
             handshake_timeout_s=min(config.timeout_s, 20.0),
@@ -946,13 +945,9 @@ class _RealtimeSession:
 
 def _audio_rtf_from_raw_metric(raw_metric: dict[str, object]) -> float | None:
     """Derive the audio RTF from a client-reported raw request metric."""
-    from vllm_omni.metrics.definitions import compute_audio_rtf
+    from vllm_omni.benchmarks.duplex_session_metrics import audio_rtf_from_raw_metric
 
-    generation_ms = raw_metric.get("audio_generation_ms")
-    duration_ms = raw_metric.get("audio_duration_ms")
-    if not isinstance(generation_ms, int | float) or not isinstance(duration_ms, int | float) or duration_ms <= 0:
-        return None
-    return round(compute_audio_rtf(float(generation_ms) / 1000.0, float(duration_ms) / 1000.0), 6)
+    return audio_rtf_from_raw_metric(raw_metric)
 
 
 def _populate_response_metrics(
@@ -961,45 +956,16 @@ def _populate_response_metrics(
     *,
     stream_start: float,
 ) -> None:
-    measurement_origin = {
-        "ttft": "response.created client receive to first non-empty text delta",
-        "ttfp": "response.created client receive to first audio packet",
-        "rtf": "response.created client receive to last audio packet divided by emitted audio duration",
-    }
-    request_metrics: list[dict[str, object]] = []
-    output_tokens = 0
-    for request_index, response_id in enumerate(collector.response_ids):
-        timing = collector.timing_summary(
-            after_s=stream_start,
-            input_committed_at_s=None,
-            response_id=response_id,
-            measurement_origin=measurement_origin,
-        )
-        raw_metric = timing.get("request_metrics")
-        stage0 = timing.get("stage0_tokens")
-        metric = {
-            "session_id": result.session_id,
-            "request_index": request_index,
-            "response_id": response_id,
-            **(raw_metric if isinstance(raw_metric, dict) else {}),
-        }
-        if isinstance(raw_metric, dict):
-            # The client reports raw data only; the RTF is derived here with
-            # the canonical server-side metric definition.
-            metric["rtf"] = _audio_rtf_from_raw_metric(raw_metric)
-        if isinstance(stage0, dict):
-            metric["stage0_tokens"] = dict(stage0)
-            output_tokens += int(stage0.get("output_token_count") or 0)
-        if isinstance(raw_metric, dict) or isinstance(stage0, dict):
-            request_metrics.append(metric)
-    result.output_tokens = output_tokens
-    result.duplex_request_metrics = request_metrics
-    from vllm_omni.clients.duplex import summarize_session_request_metrics
+    from vllm_omni.benchmarks.duplex_session_metrics import collect_duplex_session_metrics
 
-    result.duplex_session_metrics = summarize_session_request_metrics(
-        request_metrics,
+    bundle = collect_duplex_session_metrics(
+        collector,
+        stream_start=stream_start,
         session_id=result.session_id,
     )
+    result.output_tokens = bundle.output_tokens
+    result.duplex_request_metrics = bundle.request_metrics
+    result.duplex_session_metrics = bundle.session_metrics
 
 
 async def run_omniinteract_case(
@@ -1046,7 +1012,7 @@ async def run_omniinteract_case(
             frames = prepared_input.video_frames
         if not any(frames):
             raise ValueError(f"No video frames were decoded from {case.video_path}")
-        async with _RealtimeSession(config, session_id, reference_audio) as client:
+        async with _RealtimeSession(config, reference_audio) as client:
             session_from = 0  # the collector holds only this session's events
             pcm = _ensure_final_commit_tail(pcm, client.events.events)
             playback = _Playback()
diff --git a/vllm_omni/benchmarks/patch/patch.py b/vllm_omni/benchmarks/patch/patch.py
index 3313e691f..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 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
@@ -2153,10 +2278,68 @@ async def async_request_openai_audio_speech(
     return output
 
 
+#: Silence budget per Seed-TTS turn: a model-native duplex session generates
+#: per audio unit, and the target text rides the session context, so the
+#: silence only advances the clock. It stops at the turn's response.done --
+#: a native model that keeps hearing silence after its turn may decide to
+#: speak again, and the benchmark measures one response per utterance -- so
+#: the budget is only spent on a turn the model is slow to take: it may
+#: choose to listen on a few units first, and a turn that has not settled
+#: when the budget runs out is reported with what the model did.
+_SEED_TTS_SILENCE_SECONDS = 30.0
+#: A native model normally answers the seeded text within this much silence;
+#: a turn that needs more is logged so a slow-to-speak model shows in the run.
+_SEED_TTS_PROMPT_RESPONSE_S = 12.0
+#: MiniCPM-o emits 24 kHz mono; used to report audio_frames after the session closed.
+_SEED_TTS_OUTPUT_SAMPLE_RATE_HZ = 24_000
+
+
+def _seed_tts_turn_stall_report(events: object, response_offset: int, request_index: int, silence_s: float) -> str:
+    """Explain a Seed-TTS turn that never settled: what the model did with the silence."""
+    response_ids = list(getattr(events, "response_ids")[response_offset:])
+    if not response_ids:
+        return (
+            f"Seed-TTS Realtime TTS turn {request_index} never started a response: the model listened "
+            f"through {silence_s:.1f}s of silence and the wait that followed"
+        )
+    audio_bytes = getattr(events, "audio_bytes")
+    response_text = getattr(events, "response_text")
+    started = ", ".join(
+        f"{response_id} ({len(audio_bytes(response_id))} audio bytes, text {response_text(response_id)!r})"
+        for response_id in response_ids
+    )
+    return (
+        f"Seed-TTS Realtime TTS turn {request_index} started {len(response_ids)} response(s) after "
+        f"{silence_s:.1f}s of silence but none reached response.done: {started}"
+    )
+
+
+def _seed_tts_turn_response_id(events: object, response_offset: int, request_index: int) -> str:
+    """The response id the Seed-TTS turn is measured on: the first one with audio.
+
+    A model-native session answers the seeded text once, but nothing in the
+    protocol stops it from speaking again on silence it hears afterwards, so
+    a later audio response is the model's own and not a failed turn.
+    """
+    response_ids = getattr(events, "response_ids")
+    audio_bytes = getattr(events, "audio_bytes")
+    audio_response_ids = [response_id for response_id in response_ids[response_offset:] if audio_bytes(response_id)]
+    if not audio_response_ids:
+        raise RuntimeError(f"Seed-TTS Realtime TTS turn {request_index} produced no audio response")
+    if len(audio_response_ids) > 1:
+        logger.warning(
+            "Seed-TTS Realtime TTS turn %d: model spoke again after its response (%d audio responses); "
+            "measuring the first",
+            request_index,
+            len(audio_response_ids),
+        )
+    return audio_response_ids[0]
+
+
 def _realtime_websocket_url(api_url: str) -> str:
     from vllm_omni.clients.duplex import build_realtime_url
 
-    return build_realtime_url(api_url, None, native_duplex=None)
+    return build_realtime_url(api_url, None)
 
 
 def _nonnegative_number(value: object) -> bool:
@@ -2272,9 +2455,11 @@ async def _async_request_omniinteract(
         output.audio_duration = case_result.audio_bytes / (24_000 * 2)
         output.audio_frames = case_result.audio_bytes // 2
         session_metrics = case_result.duplex_session_metrics
-        output.ttft = float(session_metrics.get("mean_ttft_ms") or 0.0) / 1000.0
-        output.audio_ttfp = float(session_metrics.get("mean_ttfp_ms") or 0.0) / 1000.0
-        output.audio_rtf = float(session_metrics.get("mean_rtf") or 0.0)
+        from vllm_omni.clients.duplex import metric_mean
+
+        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
         token_timing_measured = _apply_stage0_token_timings(
             output,
             [request_metric.get("stage0_tokens") for request_metric in case_result.duplex_request_metrics],
@@ -2319,6 +2504,13 @@ class _RealtimeTTSProbe:
     request time.
     """
 
+    #: How long ``configure`` waits for a free duplex session. Every Seed-TTS
+    #: utterance is one session and the deploy config admits ``max_sessions``
+    #: of them, so a benchmark run above that concurrency queues for a slot
+    #: rather than counting the server's (retryable) refusal as a failed
+    #: request.
+    _SESSION_SLOT_WAIT_S = 120.0
+
     def __init__(self, url: str) -> None:
         from vllm_omni.clients.duplex import EventCollector
 
@@ -2345,16 +2537,13 @@ class _RealtimeTTSProbe:
         *,
         output_audio_format: str = "pcm16",
         instructions: str | None = None,
-        native_duplex: bool = False,
         auto_response: bool = False,
         extra_body: dict[str, object] | None = None,
-        session_id: str | None = None,
         timeout_s: float = 120.0,
     ) -> None:
-        from vllm_omni.clients.duplex import AudioFormat, DuplexClient, SessionConfig
+        from vllm_omni.clients.duplex import AudioFormat, DuplexClient, DuplexProtocolError, SessionConfig
 
         session_extra_body: dict[str, object] = dict(extra_body or {})
-        session_extra_body["native_duplex"] = bool(native_duplex)
         config = SessionConfig(
             output_audio=AudioFormat(output_audio_format, 24_000),
             instructions=instructions,
@@ -2363,16 +2552,33 @@ class _RealtimeTTSProbe:
             playback_commit_policy="ack_only",
             extra_body=session_extra_body,
         )
-        self._client = DuplexClient(
-            self._url,
-            model=model,
-            config=config,
-            session_id=session_id,
-            reconnect=None,
-            heartbeat_interval_s=None,
-            handshake_timeout_s=timeout_s,
-        )
-        await self._client.__aenter__()
+        deadline = time.monotonic() + self._SESSION_SLOT_WAIT_S
+        delay_s = 0.25
+        waited = False
+        while True:
+            # A failed handshake closes the socket on the client's side, so
+            # a refused attempt leaves nothing behind to clean up.
+            client = DuplexClient(
+                self._url,
+                model=model,
+                config=config,
+                reconnect=None,
+                heartbeat_interval_s=None,
+                handshake_timeout_s=timeout_s,
+            )
+            try:
+                await client.__aenter__()
+            except DuplexProtocolError as exc:
+                if exc.code != "resource_exhausted" or time.monotonic() >= deadline:
+                    raise
+                if not waited:
+                    logger.info("Seed-TTS Realtime TTS: no free duplex session (%s); waiting for a slot", exc)
+                    waited = True
+                await asyncio.sleep(delay_s)
+                delay_s = min(delay_s * 2.0, 2.0)
+                continue
+            self._client = client
+            break
         self._consume_task = asyncio.create_task(self.events.consume(self._client))
 
     async def send(self, event: dict[str, object]) -> None:
@@ -2385,6 +2591,32 @@ class _RealtimeTTSProbe:
         assert self._client is not None
         await acknowledge_collected_playback(self._client, self.events)
 
+    async def stream_silence(
+        self,
+        *,
+        seconds: float,
+        chunk_ms: int = 200,
+        until: Callable[[], bool] | None = None,
+    ) -> float:
+        """Append silent PCM16 units so a model-native session has units to speak on.
+
+        A duplex model generates per audio unit. The target text rides the
+        session context (``duplex_initial_user_text``), so the audio only has
+        to advance the clock; silence keeps it from adding content of its own.
+        Streams in real time for at most ``seconds``, stopping as soon as
+        ``until`` holds, and returns the seconds actually appended.
+        """
+        assert self._client is not None
+        input_format = self._client.config.input_audio
+        chunk = bytes(max(input_format.byte_count(chunk_ms), input_format.bytes_per_sample))
+        chunk_s = input_format.duration_ms(len(chunk)) / 1000.0
+        streamed_s = 0.0
+        while streamed_s < seconds and not (until is not None and until()):
+            await self._client.append_audio(chunk, is_speech=False)
+            streamed_s += chunk_s
+            await asyncio.sleep(chunk_s)
+        return streamed_s
+
     async def close_session(self, *, timeout_s: float = 20.0) -> None:
         assert self._client is not None
         await self._client.close(timeout_s=timeout_s)
@@ -2421,69 +2653,70 @@ async def async_request_openai_realtime_duplex(
     if not turn_prompts:
         turn_prompts = [("", request_func_input.prompt)]
     session_id = f"seed-tts-{request_func_input.request_id or uuid.uuid4().hex}"
+    silence_seconds = float(getattr(request_func_input, "seed_tts_silence_seconds", 0.0) or _SEED_TTS_SILENCE_SECONDS)
+    turn_metrics: list[dict[str, object]] = []
+    turn_timings: list[dict[str, object]] = []
+    turn_pcm_bytes: list[bytes] = []
+    turn_transcripts: list[str] = []
+    measurement_origin = {
+        "ttft": "first silence append client send to first non-empty text delta",
+        "ttfp": "first silence append client send to first audio packet",
+        "rtf": "request-start-to-last-audio receive time divided by emitted audio duration",
+    }
     try:
-        async with _RealtimeTTSProbe(_realtime_websocket_url(request_func_input.api_url)) as client:
-            await client.configure(
-                request_func_input.model_name or request_func_input.model,
-                output_audio_format="pcm16",
-                instructions=getattr(
-                    request_func_input,
-                    "seed_tts_system_prompt",
-                    SEED_TTS_DEFAULT_OMNI_SYSTEM_PROMPT,
-                ),
-                native_duplex=False,
-                auto_response=False,
-                extra_body=speech_extra,
-                session_id=session_id,
-                timeout_s=120.0,
-            )
-            turn_metrics: list[dict[str, object]] = []
-            turn_timings: list[dict[str, object]] = []
-            turn_pcm_bytes: list[bytes] = []
-            turn_transcripts: list[str] = []
-            measurement_origin = {
-                "ttft": "conversation.item.create client send to first non-empty text delta",
-                "ttfp": "conversation.item.create client send to first audio packet",
-                "rtf": "request-start-to-last-audio receive time divided by emitted audio duration",
-            }
-            for request_index, (utterance_id, target_text) in enumerate(turn_prompts):
+        # One session per utterance. A model-native duplex session takes its
+        # text once, in the session context (``duplex_initial_user_text``), so
+        # a session cannot be re-seeded for a second target text.
+        for request_index, (utterance_id, target_text) in enumerate(turn_prompts):
+            async with _RealtimeTTSProbe(_realtime_websocket_url(request_func_input.api_url)) as client:
+                await client.configure(
+                    request_func_input.model_name or request_func_input.model,
+                    output_audio_format="pcm16",
+                    instructions=getattr(
+                        request_func_input,
+                        "seed_tts_system_prompt",
+                        SEED_TTS_DEFAULT_OMNI_SYSTEM_PROMPT,
+                    ),
+                    auto_response=True,
+                    extra_body={
+                        **speech_extra,
+                        "duplex_initial_user_text": target_text,
+                        "force_listen_count": 0,
+                    },
+                    timeout_s=120.0,
+                )
                 response_offset = len(client.events.response_ids)
                 done_before = client.events.count("response.done")
                 errors_before = len(client.events.errors())
-                turn_started_at_s = time.monotonic()
-                await client.send(
-                    {
-                        "type": "conversation.item.create",
-                        "item": {
-                            "type": "message",
-                            "role": "user",
-                            "content": [{"type": "input_text", "text": target_text}],
-                        },
-                    }
-                )
-                await client.send({"type": "response.create"})
-                await wait_for_condition(
-                    lambda: (
+
+                def turn_settled() -> bool:
+                    return (
                         client.events.count("response.done") > done_before
                         or len(client.events.errors()) > errors_before
-                    ),
-                    timeout_s=180.0,
-                    label=f"Seed-TTS Realtime TTS turn {request_index} response.done",
-                )
+                    )
+
+                turn_started_at_s = time.monotonic()
+                silence_s = await client.stream_silence(seconds=silence_seconds, until=turn_settled)
+                if silence_s > _SEED_TTS_PROMPT_RESPONSE_S:
+                    logger.warning(
+                        "Seed-TTS Realtime TTS turn %d: the model took %.1fs of silence to settle its response",
+                        request_index,
+                        silence_s,
+                    )
+                try:
+                    await wait_for_condition(
+                        turn_settled,
+                        timeout_s=180.0,
+                        label=f"Seed-TTS Realtime TTS turn {request_index} response.done",
+                    )
+                except TimeoutError as exc:
+                    raise RuntimeError(
+                        _seed_tts_turn_stall_report(client.events, response_offset, request_index, silence_s)
+                    ) from exc
                 errors = client.events.errors()
                 if len(errors) > errors_before:
                     raise RuntimeError(f"Seed-TTS Realtime TTS server error: {errors[-1]}")
-                new_audio_response_ids = [
-                    response_id
-                    for response_id in client.events.response_ids[response_offset:]
-                    if client.events.audio_bytes(response_id)
-                ]
-                if len(new_audio_response_ids) != 1:
-                    raise RuntimeError(
-                        f"Seed-TTS Realtime TTS turn {request_index} expected one audio response, "
-                        f"got {len(new_audio_response_ids)}"
-                    )
-                response_id = new_audio_response_ids[0]
+                response_id = _seed_tts_turn_response_id(client.events, response_offset, request_index)
                 timing = client.events.timing_summary(
                     after_s=turn_started_at_s,
                     input_committed_at_s=turn_started_at_s,
@@ -2516,43 +2749,45 @@ async def async_request_openai_realtime_duplex(
                 )
                 turn_transcripts.append(client.events.response_text(response_id))
                 await client.acknowledge_playback()
-            request_finished_at = time.perf_counter()
-            session_metrics = summarize_session_request_metrics(
-                turn_metrics,
-                session_id=session_id,
-            )
-            await client.close_session(timeout_s=30.0)
+                await client.close_session(timeout_s=30.0)
+        request_finished_at = time.perf_counter()
+        session_metrics = summarize_session_request_metrics(
+            turn_metrics,
+            session_id=session_id,
+        )
 
-            output.generated_text = " ".join(filter(None, turn_transcripts))
-            output.ttft = float(session_metrics.get("mean_ttft_ms") or 0.0) / 1000.0
-            output.audio_ttfp = float(session_metrics.get("mean_ttfp_ms") or 0.0) / 1000.0
-            output.audio_rtf = float(session_metrics.get("mean_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.generated_text = " ".join(filter(None, turn_transcripts))
+        from vllm_omni.clients.duplex import metric_mean
+
+        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((_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
+        output.tts_output_pcm_bytes = b"".join(turn_pcm_bytes)
+        if bool((request_func_input.extra_body or {}).get("save_duplex_request_metrics")):
+            output.duplex_request_metrics = turn_metrics
+            output.duplex_session_metrics = session_metrics
+        output.output_tokens = sum(
+            int(stage0.get("output_token_count") or 0)
+            for timing in turn_timings
+            if isinstance((stage0 := timing.get("stage0_tokens")), dict)
+        )
+        token_timing_measured = _apply_stage0_token_timings(
+            output,
+            [timing.get("stage0_tokens") for timing in turn_timings],
+            expected_output_tokens=output.output_tokens,
+        )
+        if not token_timing_measured and output.output_tokens > 1:
+            logger.warning(
+                "Realtime TTS session %s omitted complete engine token timing; standard TPOT/ITL are unavailable",
+                session_id,
             )
-            output.audio_frames = int(output.audio_duration * client.events.output_sample_rate_hz)
-            output.latency = request_finished_at - output.start_time
-            output.tts_turn_pcm_bytes = turn_pcm_bytes
-            output.tts_output_pcm_bytes = b"".join(turn_pcm_bytes)
-            if bool((request_func_input.extra_body or {}).get("save_duplex_request_metrics")):
-                output.duplex_request_metrics = turn_metrics
-                output.duplex_session_metrics = session_metrics
-            output.output_tokens = sum(
-                int(stage0.get("output_token_count") or 0)
-                for timing in turn_timings
-                if isinstance((stage0 := timing.get("stage0_tokens")), dict)
-            )
-            token_timing_measured = _apply_stage0_token_timings(
-                output,
-                [timing.get("stage0_tokens") for timing in turn_timings],
-                expected_output_tokens=output.output_tokens,
-            )
-            if not token_timing_measured and output.output_tokens > 1:
-                logger.warning(
-                    "Realtime TTS session %s omitted complete engine token timing; standard TPOT/ITL are unavailable",
-                    session_id,
-                )
-            output.success = True
+        output.success = True
     except Exception:
         output.success = False
         output.error = traceback.format_exc()
@@ -2703,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)
 
@@ -2728,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():
@@ -2746,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...")
@@ -2769,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:
@@ -2790,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:
@@ -2861,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(
@@ -2880,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(
@@ -2899,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,
@@ -2923,42 +3161,46 @@ 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)
-            if isinstance(session_metrics, dict) and session_metrics.get("mean_ttft_ms") is None:
+            if isinstance(session_metrics, dict) and session_metrics.get("ttft_ms") is None:
                 return None
             return output.ttft
 
         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,
@@ -2966,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,
@@ -2998,6 +3248,24 @@ async def benchmark(
     ]
     if duplex_session_metrics:
         result["duplex_session_metrics"] = duplex_session_metrics
+        from vllm_omni.clients.duplex import distribution_summary
+
+        for session_key, result_key, digits in (
+            ("stream_ttft_ms", "duplex_stream_ttft_ms", 3),
+            ("stream_ttfp_ms", "duplex_stream_ttfp_ms", 3),
+            ("stream_rtf", "duplex_stream_rtf", 6),
+        ):
+            values = [
+                float(value)
+                for metric in duplex_session_metrics
+                if isinstance((value := metric.get(session_key)), int | float)
+                and not isinstance(value, bool)
+                and np.isfinite(value)
+                and value >= 0
+            ]
+            summary = distribution_summary(values, digits=digits)
+            if summary is not None:
+                result[result_key] = summary
     if omniinteract_summary is not None:
         result["omniinteract"] = omniinteract_summary
 
@@ -3016,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/__init__.py b/vllm_omni/clients/__init__.py
index 924582bf4..35f904778 100644
--- a/vllm_omni/clients/__init__.py
+++ b/vllm_omni/clients/__init__.py
@@ -2,8 +2,10 @@
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Client-side libraries for vLLM-Omni serving APIs.
 
-Modules under this package speak to a running vLLM-Omni server over the
-network. They are for applications and tests; server runtime code
+``vllm_omni.clients.duplex`` speaks to a running vLLM-Omni server over the
+network; ``vllm_omni.clients.inline_duplex`` drives an in-process
+``DuplexOmni`` handed in by the caller with the same client API. Modules here
+import no server runtime code at module load, and server runtime code
 (``vllm_omni.engine``, ``vllm_omni.entrypoints``, ``vllm_omni.model_executor``)
 must never import from here.
 """
diff --git a/vllm_omni/clients/duplex.py b/vllm_omni/clients/duplex.py
index eb8a6ded0..17358906f 100644
--- a/vllm_omni/clients/duplex.py
+++ b/vllm_omni/clients/duplex.py
@@ -2,9 +2,13 @@
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Public asynchronous client for the vLLM-Omni full-duplex Realtime API.
 
-Connects to ``/v1/realtime?duplex=1`` (the normative duplex contract) and
-provides typed events, response demultiplexing, incremental playback
-acking, and transparent session resume on transport drops.
+:class:`DuplexClientBase` holds the transport-agnostic session client (typed
+events, response demultiplexing, incremental playback acking, the session
+handshake). :class:`DuplexClient` connects it to ``/v1/realtime?duplex=1``
+(the normative duplex contract) over WebSocket with transparent session
+resume on transport drops; :class:`vllm_omni.clients.inline_duplex.InlineDuplexClient`
+drives an in-process :class:`~vllm_omni.entrypoints.duplex_omni.DuplexOmni`
+with exactly the same usage.
 
 Example::
 
@@ -35,10 +39,10 @@ import math
 import random
 import time
 import wave
-from collections.abc import AsyncIterator, Awaitable, Callable, Iterator, Sequence
+from abc import ABC, abstractmethod
+from collections.abc import AsyncIterator, Awaitable, Callable, Iterator, Mapping, Sequence
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Protocol
 from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
 from uuid import uuid4
 
@@ -53,6 +57,7 @@ __all__ = [
     "AudioDelta",
     "ConnectionResumed",
     "DuplexClient",
+    "DuplexClientBase",
     "DuplexClientError",
     "DuplexConnectionError",
     "DuplexEvent",
@@ -80,6 +85,8 @@ __all__ = [
     "image_data_url",
     "read_pcm16_wav",
     "reference_audio_data_url",
+    "distribution_summary",
+    "metric_mean",
     "summarize_session_request_metrics",
     "wait_for_condition",
     "write_pcm16_wav",
@@ -227,7 +234,7 @@ class SessionConfig:
     idle_timeout_s: float | None = None
     extra_body: dict[str, object] = field(default_factory=dict)
 
-    def to_session_payload(self, *, model: str, session_id: str | None = None) -> dict[str, object]:
+    def to_session_payload(self, *, model: str) -> dict[str, object]:
         payload: dict[str, object] = {
             "model": model,
             "modalities": list(self.modalities),
@@ -244,8 +251,6 @@ class SessionConfig:
             },
             "turn_detection": self.turn_detection,
         }
-        if session_id:
-            payload["session_id"] = session_id
         if self.instructions is not None:
             payload["instructions"] = self.instructions
         if self.ref_audio is not None:
@@ -366,11 +371,6 @@ class SessionCreated(DuplexEvent):
         value = self.raw.get("resume_token")
         return value if isinstance(value, str) else None
 
-    @property
-    def incarnation(self) -> int:
-        value = self.raw.get("incarnation")
-        return value if isinstance(value, int) else 0
-
 
 class SessionResumed(SessionCreated):
     pass
@@ -460,9 +460,7 @@ _EVENT_TYPES: dict[str, type[DuplexEvent]] = {
     "session.expired": SessionExpired,
     "response.created": ResponseCreated,
     "response.done": ResponseDone,
-    "response.audio.delta": AudioDelta,
     "response.output_audio.delta": AudioDelta,
-    "response.audio_transcript.delta": TranscriptDelta,
     "response.output_audio_transcript.delta": TranscriptDelta,
     "response.text.delta": TextDelta,
     "response.output_text.delta": TextDelta,
@@ -598,79 +596,85 @@ class ResponseHandle:
 # Client
 
 
-class WebSocketTransport(Protocol):
+class WebSocketTransport(ABC):
     """Minimal WebSocket surface the client needs (satisfied by ``websockets``)."""
 
+    @abstractmethod
     async def send(self, data: str) -> None: ...
 
+    @abstractmethod
     async def recv(self) -> str | bytes: ...
 
+    @abstractmethod
     async def close(self) -> None: ...
 
 
 ConnectFn = Callable[[str], Awaitable["WebSocketTransport"]]
 
 
-class DuplexClient:
-    """Async client for one duplex session over ``/v1/realtime?duplex=1``.
+class DuplexClientBase(ABC):
+    """Transport-agnostic duplex session client.
 
-    ``session_id`` only names the session this client creates: entering the
-    client always performs the ``session.update`` handshake. Resuming an
-    existing session is supported only as automatic reconnect within the same
-    client instance (see ``ReconnectPolicy``); taking over a session from a
-    new client requires the wire-level ``session.resume`` handshake
-    (``resume_token``, ``incarnation``, ``last_received_server_event_seq``),
-    which this client does not expose.
+    Everything a caller touches (typed events, response demux, input helpers,
+    playback acks, the ``session.update`` handshake) lives here. A subclass
+    only supplies the transport: :meth:`_open` establishes it and must deliver
+    the server's ``session.created`` payload through :meth:`_dispatch`,
+    :meth:`_send_command` delivers one client event, :meth:`_teardown`
+    releases the transport.
     """
 
     def __init__(
         self,
-        url: str,
         *,
         model: str,
         config: SessionConfig | None = None,
-        session_id: str | None = None,
-        reconnect: ReconnectPolicy | None = ReconnectPolicy(),
-        heartbeat_interval_s: float | None = 30.0,
         handshake_timeout_s: float = 30.0,
-        connect: ConnectFn | None = None,
     ) -> None:
-        self.url = url
         self.model = model
         self.config = config or SessionConfig()
-        self.session_id = session_id
+        #: Allocated by the server; ``None`` until ``session.created`` arrives.
+        self.session_id: str | None = None
         self.session_info: dict[str, object] = {}
-        self.incarnation = 0
-        self.resume_token: str | None = None
-        self._reconnect = reconnect
-        self._heartbeat_interval_s = heartbeat_interval_s
         self._handshake_timeout_s = handshake_timeout_s
-        self._connect_fn: ConnectFn = connect or self._default_connect
-        self._ws: WebSocketTransport | None = None
-        self._reader_task: asyncio.Task[None] | None = None
-        self._heartbeat_task: asyncio.Task[None] | None = None
         self._subscribers: list[asyncio.Queue[DuplexEvent | _ClosedMarker]] = []
         self._response_queue: asyncio.Queue[ResponseHandle | _ClosedMarker | _ErrorMarker] = asyncio.Queue(
             maxsize=_MAX_BUFFERED_EVENTS
         )
         self._responses: dict[str, ResponseHandle] = {}
-        self._last_server_event_seq: int | None = None
         self._input_audio_end_ms = 0.0
         self._closing = False
         self._closed = asyncio.Event()
         self._closed_marker: _ClosedMarker | None = None
+        self._last_error_reason: str | None = None
+
+    # -- transport hooks ------------------------------------------------------
+
+    @abstractmethod
+    async def _open(self) -> None:
+        """Establish the transport and start delivering server events via ``_dispatch``.
+
+        Called once from :meth:`__aenter__`; the base then sends the
+        ``session.update`` handshake and waits for ``session.created``.
+        """
+
+    @abstractmethod
+    async def _send_command(self, payload: dict[str, object]) -> None:
+        """Deliver one client event (already stamped with ``event_id``)."""
+
+    @abstractmethod
+    async def _teardown(self) -> None:
+        """Release the transport; must be idempotent."""
 
     # -- lifecycle ----------------------------------------------------------
 
-    async def __aenter__(self) -> DuplexClient:
-        self._ws = await self._connect_fn(self._target_url())
+    async def __aenter__(self) -> DuplexClientBase:
         handshake_queue = self._add_subscriber()
         try:
-            self._reader_task = asyncio.create_task(self._read_loop(), name="duplex-client-reader")
+            await self._open()
             await self.send(
                 {
                     "type": "session.update",
-                    "session": self.config.to_session_payload(model=self.model, session_id=self.session_id),
+                    "session": self.config.to_session_payload(model=self.model),
                 }
             )
             created = await self._wait_on_queue(
@@ -679,14 +683,12 @@ class DuplexClient:
                 timeout_s=self._handshake_timeout_s,
             )
         except BaseException:
-            await self._teardown()
+            await self._teardown_quietly()
             raise
         finally:
             self._remove_subscriber(handshake_queue)
         assert isinstance(created, SessionCreated)
         self._adopt_session(created)
-        if self._heartbeat_interval_s is not None:
-            self._heartbeat_task = asyncio.create_task(self._heartbeat_loop(), name="duplex-client-heartbeat")
         return self
 
     async def __aexit__(self, exc_type, exc, traceback) -> None:
@@ -706,7 +708,7 @@ class DuplexClient:
                 except DuplexClientError:
                     pass
         finally:
-            await self._teardown()
+            await self._teardown_quietly()
 
     async def close(self, *, timeout_s: float = 20.0) -> None:
         """Send ``session.close`` and wait for the server to confirm."""
@@ -723,6 +725,12 @@ class DuplexClient:
         except asyncio.TimeoutError:
             self._finalize("close timed out", expected=True)
 
+    async def _teardown_quietly(self) -> None:
+        self._closing = True
+        if not self._closed.is_set():
+            self._finalize("closed", expected=True)
+        await self._teardown()
+
     # -- input ----------------------------------------------------------------
 
     async def append_audio(
@@ -925,53 +933,25 @@ class DuplexClient:
         payload = dict(event)
         payload.setdefault("event_id", f"evt_{uuid4().hex}")
         try:
-            await self._ws.send(json.dumps(payload))
+            await self._send_command(payload)
         except asyncio.CancelledError:
             raise
+        except DuplexClientError:
+            raise
         except Exception as exc:
             raise DuplexConnectionError(f"send failed: {exc}") from exc
         return payload["event_id"]
 
     # -- internals ---------------------------------------------------------------
 
-    def _target_url(self) -> str:
-        parts = urlsplit(self.url)
-        path = parts.path if parts.path not in ("", "/") else "/v1/realtime"
-        query = dict(parse_qsl(parts.query, keep_blank_values=True))
-        query.setdefault("duplex", "1")
-        query.setdefault("model", self.model)
-        # The client always opens with an explicit session.update (and resumes
-        # with an explicit session.resume). Autostart would race that handshake:
-        # with a model query param, the server creates a bare default session
-        # before reading the first client event, silently dropping ref_audio
-        # and the model-specific extra_body. Force it off even when the caller's
-        # URL carries autostart=1 — this client cannot operate over it.
-        query["autostart"] = "0"
-        return urlunsplit((parts.scheme or "ws", parts.netloc, path, urlencode(query), parts.fragment))
-
-    async def _default_connect(self, url: str) -> WebSocketTransport:
-        try:
-            import websockets
-        except ImportError as exc:  # pragma: no cover - websockets is a pinned dep
-            raise DuplexConnectionError("The duplex client requires the 'websockets' package") from exc
-        try:
-            return await websockets.connect(url, max_size=_MAX_FRAME_BYTES)
-        except asyncio.CancelledError:
-            raise
-        except Exception as exc:
-            raise DuplexConnectionError(f"connect to {url} failed: {exc}") from exc
-
     def _adopt_session(self, event: SessionCreated) -> None:
-        # A resume activation carries no nested session object; keep the
-        # session_info captured at the original handshake in that case.
+        # session.created and session.resumed both carry the engine's current
+        # session object; keep the last one seen.
         if event.session:
             self.session_info = event.session
         session_id = event.session.get("session_id") or event.session.get("id") or event.session_id
         if isinstance(session_id, str) and session_id:
             self.session_id = session_id
-        self.incarnation = event.incarnation
-        if event.resume_token:
-            self.resume_token = event.resume_token
 
     def _announce(self, handle: ResponseHandle) -> None:
         """Deliver a handle to responses() exactly once, decision known."""
@@ -1013,36 +993,18 @@ class DuplexClient:
             if item.type in types:
                 return item
 
-    async def _read_loop(self) -> None:
-        while True:
-            try:
-                while True:
-                    raw = await self._ws.recv()
-                    if isinstance(raw, (bytes, bytearray)):
-                        continue
-                    try:
-                        data = json.loads(raw)
-                    except json.JSONDecodeError:
-                        continue
-                    if isinstance(data, dict):
-                        await self._dispatch(data)
-            except asyncio.CancelledError:
-                raise
-            except Exception as exc:
-                if self._closing or self._closed.is_set():
-                    self._finalize("closed", expected=True)
-                    return
-                if await self._attempt_resume():
-                    continue
-                self._finalize(f"connection lost: {exc}", expected=False)
-                return
+    def _accept_event(self, data: dict[str, object]) -> bool:
+        """Transport hook: return False to drop ``data`` before dispatch (duplicates)."""
+        del data
+        return True
+
+    async def _after_dispatch(self, event: DuplexEvent, data: dict[str, object]) -> None:
+        """Transport hook run after an event was delivered to subscribers."""
+        del event, data
 
     async def _dispatch(self, data: dict[str, object]) -> None:
-        seq = data.get("server_event_seq")
-        if isinstance(seq, int):
-            if self._last_server_event_seq is not None and seq <= self._last_server_event_seq:
-                return  # duplicate delivered by resume replay
-            self._last_server_event_seq = seq
+        if not self._accept_event(data):
+            return
         event = wrap_event(data)
 
         if isinstance(event, SessionResumed):
@@ -1100,23 +1062,143 @@ class DuplexClient:
             # on the response path too so a consumer waiting in responses()
             # is not left waiting forever (see the responses() docstring).
             _put_drop_oldest(self._response_queue, _ErrorMarker(event))
+            # Keep the text for the close that usually follows: a client that
+            # is streaming input is inside send(), not draining responses(),
+            # and would otherwise only ever see "closed".
+            self._last_error_reason = f"{event.code}: {event.message}" if event.code else event.message
 
         for queue in list(self._subscribers):
             _put_drop_oldest(queue, event)
 
         if isinstance(event, SessionClosed):
-            self._finalize("closed", expected=True)
+            self._finalize(self._last_error_reason or "closed", expected=True)
         elif isinstance(event, SessionExpired):
             reason = data.get("reason")
             self._finalize(f"expired: {reason}" if reason else "expired", expected=False)
-        elif event.type == "session.resync_required":
+
+        await self._after_dispatch(event, data)
+
+    def _finalize(self, reason: str, *, expected: bool) -> None:
+        if self._closed.is_set():
+            return
+        marker = _ClosedMarker(reason=reason, expected=expected)
+        self._closed_marker = marker
+        self._closed.set()
+        for handle in self._responses.values():
+            handle._finish(None)
+        self._responses.clear()
+        for queue in (*self._subscribers, self._response_queue):
+            _put_drop_oldest(queue, marker)
+
+
+class DuplexClient(DuplexClientBase):
+    """Async client for one duplex session over ``/v1/realtime?duplex=1``."""
+
+    def __init__(
+        self,
+        url: str,
+        *,
+        model: str,
+        config: SessionConfig | None = None,
+        reconnect: ReconnectPolicy | None = ReconnectPolicy(),
+        heartbeat_interval_s: float | None = 30.0,
+        handshake_timeout_s: float = 30.0,
+        connect: ConnectFn | None = None,
+    ) -> None:
+        super().__init__(model=model, config=config, handshake_timeout_s=handshake_timeout_s)
+        self.url = url
+        self.resume_token: str | None = None
+        self._reconnect = reconnect
+        self._heartbeat_interval_s = heartbeat_interval_s
+        self._connect_fn: ConnectFn = connect or self._default_connect
+        self._ws: WebSocketTransport | None = None
+        self._reader_task: asyncio.Task[None] | None = None
+        self._heartbeat_task: asyncio.Task[None] | None = None
+        self._last_server_event_seq: int | None = None
+
+    # -- transport hooks ------------------------------------------------------
+
+    async def _open(self) -> None:
+        self._ws = await self._connect_fn(self._target_url())
+        self._reader_task = asyncio.create_task(self._read_loop(), name="duplex-client-reader")
+
+    async def __aenter__(self) -> DuplexClient:
+        await super().__aenter__()
+        if self._heartbeat_interval_s is not None:
+            self._heartbeat_task = asyncio.create_task(self._heartbeat_loop(), name="duplex-client-heartbeat")
+        return self
+
+    async def _send_command(self, payload: dict[str, object]) -> None:
+        if self._ws is None:
+            raise DuplexConnectionError("send failed: transport is not connected")
+        await self._ws.send(json.dumps(payload))
+
+    async def _teardown(self) -> None:
+        for task in (self._heartbeat_task, self._reader_task):
+            if task is not None and not task.done():
+                task.cancel()
+                try:
+                    await task
+                except (asyncio.CancelledError, Exception):  # noqa: BLE001
+                    pass
+        if self._ws is not None:
+            try:
+                await self._ws.close()
+            except Exception:  # noqa: BLE001
+                pass
+
+    # -- internals ---------------------------------------------------------------
+
+    def _target_url(self) -> str:
+        parts = urlsplit(self.url)
+        path = parts.path if parts.path not in ("", "/") else "/v1/realtime"
+        query = dict(parse_qsl(parts.query, keep_blank_values=True))
+        query.setdefault("duplex", "1")
+        query.setdefault("model", self.model)
+        # The client always opens with an explicit session.update (and resumes
+        # with an explicit session.resume). Autostart would race that handshake:
+        # with a model query param, the server creates a bare default session
+        # before reading the first client event, silently dropping ref_audio
+        # and the model-specific extra_body. Force it off even when the caller's
+        # URL carries autostart=1 — this client cannot operate over it.
+        query["autostart"] = "0"
+        return urlunsplit((parts.scheme or "ws", parts.netloc, path, urlencode(query), parts.fragment))
+
+    async def _default_connect(self, url: str) -> WebSocketTransport:
+        try:
+            import websockets
+        except ImportError as exc:  # pragma: no cover - websockets is a pinned dep
+            raise DuplexConnectionError("The duplex client requires the 'websockets' package") from exc
+        try:
+            return await websockets.connect(url, max_size=_MAX_FRAME_BYTES)
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:
+            raise DuplexConnectionError(f"connect to {url} failed: {exc}") from exc
+
+    def _adopt_session(self, event: SessionCreated) -> None:
+        super()._adopt_session(event)
+        if event.resume_token:
+            self.resume_token = event.resume_token
+
+    def _accept_event(self, data: dict[str, object]) -> bool:
+        seq = data.get("server_event_seq")
+        if isinstance(seq, int):
+            if self._last_server_event_seq is not None and seq <= self._last_server_event_seq:
+                return False  # duplicate delivered by resume replay
+            self._last_server_event_seq = seq
+        return True
+
+    async def _after_dispatch(self, event: DuplexEvent, data: dict[str, object]) -> None:
+        if event.type == "session.resync_required":
             # The server stopped journaling this session's events, so any
             # retained resume credential will be refused on the next
             # session.resume. Drop it now: a later transport failure then
             # finalizes immediately instead of burning reconnect attempts.
             self.resume_token = None
 
-        if isinstance(seq, int) and not self._closed.is_set():
+        seq = data.get("server_event_seq")
+        if isinstance(seq, int) and not self._closed.is_set() and self._ws is not None:
             try:
                 await self._ws.send(json.dumps({"type": "session.event_ack", "server_event_seq": seq}))
             except asyncio.CancelledError:
@@ -1124,6 +1206,30 @@ class DuplexClient:
             except Exception:
                 pass  # the reader will observe the transport failure itself
 
+    async def _read_loop(self) -> None:
+        while True:
+            try:
+                while True:
+                    raw = await self._ws.recv()
+                    if isinstance(raw, (bytes, bytearray)):
+                        continue
+                    try:
+                        data = json.loads(raw)
+                    except json.JSONDecodeError:
+                        continue
+                    if isinstance(data, dict):
+                        await self._dispatch(data)
+            except asyncio.CancelledError:
+                raise
+            except Exception as exc:
+                if self._closing or self._closed.is_set():
+                    self._finalize("closed", expected=True)
+                    return
+                if await self._attempt_resume():
+                    continue
+                self._finalize(f"connection lost: {exc}", expected=False)
+                return
+
     async def _attempt_resume(self) -> bool:
         policy = self._reconnect
         if policy is None or not self.resume_token or not self.session_id:
@@ -1142,7 +1248,6 @@ class DuplexClient:
                         {
                             "type": "session.resume",
                             "session_id": self.session_id,
-                            "incarnation": self.incarnation,
                             "resume_token": self.resume_token,
                             "last_received_server_event_seq": self._last_server_event_seq or 0,
                         }
@@ -1162,7 +1267,10 @@ class DuplexClient:
                         continue
                     event_type = data.get("type")
                     if event_type == "session.resumed":
+                        previous = self._ws
                         self._ws = ws
+                        if previous is not None and previous is not ws:
+                            await self._close_quietly(previous)
                         await self._dispatch({"type": "connection.resumed", "attempt": attempt})
                         await self._dispatch(data)
                         for entry in pending:
@@ -1212,35 +1320,6 @@ class DuplexClient:
             except DuplexClientError:
                 return
 
-    def _finalize(self, reason: str, *, expected: bool) -> None:
-        if self._closed.is_set():
-            return
-        marker = _ClosedMarker(reason=reason, expected=expected)
-        self._closed_marker = marker
-        self._closed.set()
-        for handle in self._responses.values():
-            handle._finish(None)
-        self._responses.clear()
-        for queue in (*self._subscribers, self._response_queue):
-            _put_drop_oldest(queue, marker)
-
-    async def _teardown(self) -> None:
-        self._closing = True
-        if not self._closed.is_set():
-            self._finalize("closed", expected=True)
-        for task in (self._heartbeat_task, self._reader_task):
-            if task is not None and not task.done():
-                task.cancel()
-                try:
-                    await task
-                except (asyncio.CancelledError, Exception):  # noqa: BLE001
-                    pass
-        if self._ws is not None:
-            try:
-                await self._ws.close()
-            except Exception:  # noqa: BLE001
-                pass
-
 
 # ---------------------------------------------------------------------------
 # Test/benchmark collector
@@ -1250,6 +1329,15 @@ def _rounded_ms(value: float) -> float:
     return round(float(value), 3)
 
 
+def _finite_number(value: object, *, nonnegative: bool = False) -> float | None:
+    if not isinstance(value, int | float) or isinstance(value, bool) or not math.isfinite(float(value)):
+        return None
+    number = float(value)
+    if nonnegative and number < 0:
+        return None
+    return number
+
+
 def _interval_summary(values: list[float]) -> dict[str, float | int]:
     clean = sorted(_rounded_ms(value) for value in values if math.isfinite(value) and value >= 0)
     if not clean:
@@ -1268,6 +1356,36 @@ def _interval_summary(values: list[float]) -> dict[str, float | int]:
     }
 
 
+def distribution_summary(values: Sequence[float], *, digits: int = 3) -> dict[str, float | int] | None:
+    """Summarize values as ``{count, mean, p50, p99}`` for duplex report fields."""
+    clean = sorted(float(value) for value in values if math.isfinite(float(value)))
+    if not clean:
+        return None
+
+    def nearest_rank(percentile: float) -> float:
+        index = max(0, math.ceil(percentile * len(clean)) - 1)
+        return clean[min(index, len(clean) - 1)]
+
+    return {
+        "count": len(clean),
+        "mean": round(sum(clean) / len(clean), digits),
+        "p50": round(nearest_rank(0.50), digits),
+        "p99": round(nearest_rank(0.99), digits),
+    }
+
+
+def metric_mean(value: object) -> float | None:
+    """Read a scalar mean, or the ``mean`` field of a distribution summary."""
+    if isinstance(value, Mapping):
+        nested = value.get("mean")
+        if isinstance(nested, int | float) and not isinstance(nested, bool) and math.isfinite(float(nested)):
+            return float(nested)
+        return None
+    if isinstance(value, int | float) and not isinstance(value, bool) and math.isfinite(float(value)):
+        return float(value)
+    return None
+
+
 def _event_stage_metrics(event: dict[str, object]) -> dict[str, object] | None:
     candidates: list[object] = [event.get("vllm_omni")]
     metadata = event.get("metadata")
@@ -1287,6 +1405,34 @@ def _event_stage_metrics(event: dict[str, object]) -> dict[str, object] | None:
     return None
 
 
+def _event_response_request_metrics(event: dict[str, object]) -> dict[str, object] | None:
+    direct_metrics = event.get("response_request_metrics")
+    if isinstance(direct_metrics, dict):
+        return direct_metrics
+    candidates: list[object] = [event.get("vllm_omni")]
+    metadata = event.get("metadata")
+    if isinstance(metadata, dict):
+        candidates.extend((metadata, metadata.get("vllm_omni"), metadata.get("duplex_event")))
+    response = event.get("response")
+    if isinstance(response, dict):
+        response_metadata = response.get("metadata")
+        if isinstance(response_metadata, dict):
+            candidates.extend(
+                (
+                    response_metadata,
+                    response_metadata.get("vllm_omni"),
+                    response_metadata.get("duplex_event"),
+                )
+            )
+    for candidate in candidates:
+        if not isinstance(candidate, dict):
+            continue
+        request_metrics = candidate.get("response_request_metrics")
+        if isinstance(request_metrics, dict):
+            return request_metrics
+    return None
+
+
 class EventCollector:
     """Accumulate events for assertions and latency summaries (tests/benchmarks).
 
@@ -1301,7 +1447,7 @@ class EventCollector:
         self.response_ids: list[str] = []
         self.output_sample_rate_hz = 24_000
 
-    async def consume(self, client: DuplexClient) -> None:
+    async def consume(self, client: DuplexClientBase) -> None:
         """Subscribe to ``client`` and collect until the session ends."""
         try:
             async for event in client.events():
@@ -1359,7 +1505,7 @@ class EventCollector:
             if self.response_id(event) == response_id
             and event.get("type")
             in {
-                "response.audio_transcript.delta",
+                "response.output_audio_transcript.delta",
                 "response.output_text.delta",
                 "response.text.delta",
             }
@@ -1381,6 +1527,85 @@ class EventCollector:
                 return received_at_s
         return None
 
+    def global_timing_summary(
+        self,
+        *,
+        after_s: float,
+        window_started_at_s: float,
+        response_ids: list[str],
+        measurement_origin: dict[str, str],
+    ) -> dict[str, object]:
+        """Summarize one client-observed timing window across responses.
+
+        Returns raw measurements only. Derived metrics such as RTF are computed
+        by the caller — e.g. with ``vllm_omni.metrics.definitions.compute_audio_rtf``.
+        """
+        selected_response_ids = set(response_ids)
+        first_text_received_at_s: float | None = None
+        audio_received_at_s: list[float] = []
+        response_audio_duration_ms: dict[str, float] = {}
+
+        for event, received_at_s in zip(self.events, self.event_received_at_s, strict=True):
+            if received_at_s < after_s:
+                continue
+            response_id = self.response_id(event)
+            if response_id is None or response_id not in selected_response_ids:
+                continue
+            if (
+                event.get("type")
+                in {
+                    "response.output_audio_transcript.delta",
+                    "response.output_text.delta",
+                    "response.text.delta",
+                }
+                and isinstance(event.get("delta"), str)
+                and bool(event["delta"])
+                and first_text_received_at_s is None
+            ):
+                first_text_received_at_s = received_at_s
+            if event.get("type") not in _AUDIO_DELTA_TYPES:
+                continue
+            delta = event.get("delta") or event.get("audio")
+            if not isinstance(delta, str) or not delta:
+                continue
+            audio_received_at_s.append(received_at_s)
+            metadata = event.get("metadata")
+            duration_ms = metadata.get("audio_duration_ms") if isinstance(metadata, dict) else None
+            parsed_duration_ms = _finite_number(duration_ms, nonnegative=True)
+            if parsed_duration_ms is not None:
+                response_audio_duration_ms[response_id] = max(
+                    response_audio_duration_ms.get(response_id, 0.0),
+                    parsed_duration_ms,
+                )
+
+        if not audio_received_at_s:
+            return {}
+
+        audio_duration_ms = sum(
+            response_audio_duration_ms.get(
+                response_id,
+                self._format_for_bytes().duration_ms(len(self.audio_bytes(response_id))),
+            )
+            for response_id in response_ids
+        )
+        audio_generation_ms = max(
+            0.0,
+            (audio_received_at_s[-1] - window_started_at_s) * 1000.0,
+        )
+        return {
+            "source": "client_monotonic_receive",
+            "response_ids": list(response_ids),
+            "measurement_origin": dict(measurement_origin),
+            "ttft_ms": (
+                _rounded_ms((first_text_received_at_s - window_started_at_s) * 1000.0)
+                if first_text_received_at_s is not None
+                else None
+            ),
+            "ttfp_ms": _rounded_ms((audio_received_at_s[0] - window_started_at_s) * 1000.0),
+            "audio_generation_ms": _rounded_ms(audio_generation_ms),
+            "audio_duration_ms": _rounded_ms(audio_duration_ms),
+        }
+
     def timing_summary(
         self,
         *,
@@ -1391,6 +1616,7 @@ class EventCollector:
     ) -> dict[str, object]:
         """Summarize engine token metrics and client-observed audio cadence."""
         stage0_metrics: dict[str, object] | None = None
+        response_request_metrics: dict[str, object] = {}
         response_created_at_s: float | None = None
         first_text_received_at_s: float | None = None
         audio_received_at_s: list[float] = []
@@ -1406,7 +1632,7 @@ class EventCollector:
             if (
                 event.get("type")
                 in {
-                    "response.audio_transcript.delta",
+                    "response.output_audio_transcript.delta",
                     "response.output_text.delta",
                     "response.text.delta",
                 }
@@ -1421,6 +1647,10 @@ class EventCollector:
             if isinstance(stage0, dict):
                 stage0_metrics = stage0
 
+            event_request_metrics = _event_response_request_metrics(event)
+            if event_request_metrics is not None:
+                response_request_metrics.update(event_request_metrics)
+
             if event.get("type") not in _AUDIO_DELTA_TYPES:
                 continue
             delta = event.get("delta") or event.get("audio")
@@ -1480,6 +1710,31 @@ class EventCollector:
             }
             request_started_at_s = input_committed_at_s if input_committed_at_s is not None else response_created_at_s
             if request_started_at_s is not None:
+                default_measurement_origin = (
+                    {
+                        "ttft": "input_audio_buffer.commit client send to first non-empty text delta",
+                        "ttfp": "input_audio_buffer.commit client send to first audio packet",
+                    }
+                    if input_committed_at_s is not None
+                    else {
+                        "ttft": "response.created client receive to first non-empty text delta",
+                        "ttfp": "response.created client receive to first audio packet",
+                    }
+                )
+                resolved_measurement_origin = {
+                    **default_measurement_origin,
+                    **(measurement_origin or {}),
+                }
+                if stage0_metrics is not None:
+                    resolved_measurement_origin["tpot"] = "Stage-0 engine mean time per output token"
+                server_ttft_ms = _finite_number(response_request_metrics.get("ttft_ms"), nonnegative=True)
+                server_ttfp_ms = _finite_number(response_request_metrics.get("ttfp_ms"), nonnegative=True)
+                server_origins = response_request_metrics.get("measurement_origin")
+                if isinstance(server_origins, dict):
+                    if server_ttft_ms is not None and isinstance(server_origins.get("ttft"), str):
+                        resolved_measurement_origin["ttft"] = server_origins["ttft"]
+                    if server_ttfp_ms is not None and isinstance(server_origins.get("ttfp"), str):
+                        resolved_measurement_origin["ttfp"] = server_origins["ttfp"]
                 audio_duration_ms = (
                     max(cumulative_audio_ms)
                     if cumulative_audio_ms
@@ -1495,21 +1750,49 @@ class EventCollector:
                 # compute_audio_rtf — so metric definitions stay out of this
                 # dependency-free client module.
                 result["request_metrics"] = {
-                    "source": "client_monotonic_receive",
-                    "measurement_origin": measurement_origin
-                    or {
-                        "ttft": "input_audio_buffer.commit client send to first non-empty text delta",
-                        "ttfp": "input_audio_buffer.commit client send to first audio packet",
-                    },
+                    "source": (
+                        "server_request_start_and_client_receive"
+                        if server_ttft_ms is not None or server_ttfp_ms is not None
+                        else "client_monotonic_receive"
+                    ),
+                    "measurement_origin": resolved_measurement_origin,
                     "ttft_ms": (
-                        _rounded_ms((first_text_received_at_s - request_started_at_s) * 1000.0)
-                        if first_text_received_at_s is not None
-                        else None
+                        server_ttft_ms
+                        if server_ttft_ms is not None
+                        else (
+                            _rounded_ms((first_text_received_at_s - request_started_at_s) * 1000.0)
+                            if first_text_received_at_s is not None
+                            else None
+                        )
+                    ),
+                    "ttfp_ms": (
+                        server_ttfp_ms
+                        if server_ttfp_ms is not None
+                        else _rounded_ms((audio_received_at_s[0] - request_started_at_s) * 1000.0)
                     ),
-                    "ttfp_ms": _rounded_ms((audio_received_at_s[0] - request_started_at_s) * 1000.0),
                     "audio_generation_ms": _rounded_ms(audio_generation_ms),
                     "audio_duration_ms": _rounded_ms(audio_duration_ms),
                 }
+                if server_ttft_ms is not None or server_ttfp_ms is not None:
+                    request_metrics = result["request_metrics"]
+                    assert isinstance(request_metrics, dict)
+                    request_metrics["response_created_to_first_text_ms"] = (
+                        _rounded_ms((first_text_received_at_s - response_created_at_s) * 1000.0)
+                        if first_text_received_at_s is not None and response_created_at_s is not None
+                        else None
+                    )
+                    request_metrics["response_created_to_first_audio_ms"] = (
+                        _rounded_ms((audio_received_at_s[0] - response_created_at_s) * 1000.0)
+                        if response_created_at_s is not None
+                        else None
+                    )
+                if stage0_metrics is not None:
+                    request_metrics = result["request_metrics"]
+                    assert isinstance(request_metrics, dict)
+                    request_metrics["tpot_ms"] = _finite_number(
+                        stage0_metrics.get("vllm_tpot_ms"),
+                        nonnegative=True,
+                    )
         return result
 
     def _format_for_bytes(self) -> AudioFormat:
@@ -1591,15 +1874,12 @@ def build_realtime_url(
     model: str | None,
     *,
     autostart: bool | None = None,
-    native_duplex: bool | None = None,
-    session_id: str | None = None,
     extra_query: dict[str, str] | None = None,
 ) -> str:
     """Add explicit duplex query parameters to a Realtime URL.
 
     :class:`DuplexClient` builds its own URL; this helper is for drivers that
-    speak the wire protocol directly. ``native_duplex`` sets the per-session
-    model-native opt-in query flag; other model-specific query flags ride in
+    speak the wire protocol directly. Model-specific query flags ride in
     ``extra_query``. ``http(s)`` URLs are rewritten to ``ws(s)``.
     """
     parts = urlsplit(url)
@@ -1611,14 +1891,10 @@ def build_realtime_url(
     query.setdefault("duplex", "1")
     if model:
         query.setdefault("model", model)
-    if native_duplex is not None:
-        query["native_duplex"] = "1" if native_duplex else "0"
     for key, value in (extra_query or {}).items():
         query.setdefault(key, value)
     if autostart is not None:
         query.setdefault("autostart", "1" if autostart else "0")
-    if session_id:
-        query.setdefault("session_id", session_id)
     return urlunsplit((parts.scheme, parts.netloc, parts.path, urlencode(query), parts.fragment))
 
 
@@ -1642,33 +1918,41 @@ def summarize_session_request_metrics(
     *,
     session_id: str | None,
 ) -> dict[str, object]:
-    """Average client-observed metrics across turns that emitted audio.
+    """Summarize client- and engine-observed metrics across audio responses.
 
     ``request_metrics`` entries are caller-assembled dicts; keys that are
     absent or non-numeric in an entry are simply skipped. ``rtf`` is not
     produced by :meth:`EventCollector.timing_summary` (which reports raw data
-    only) — callers that want ``mean_rtf`` add an ``rtf`` value per turn,
-    e.g. via ``vllm_omni.metrics.definitions.compute_audio_rtf``.
+    only) — callers that want session ``rtf`` add an ``rtf`` value per turn,
+    e.g. via ``vllm_omni.metrics.definitions.compute_audio_rtf``. Zero or
+    missing ``tpot_ms`` values are omitted from session ``tpot_ms``.
+
+    Aggregatable fields are nested as ``{count, mean, p50, p99}``.
     """
 
-    def mean(metric: str, *, digits: int = 3) -> float | None:
-        values = [
+    def values(metric: str, *, positive: bool = False) -> list[float]:
+        return [
             float(request[metric])
             for request in request_metrics
-            if isinstance(request.get(metric), int | float) and math.isfinite(float(request[metric]))
+            if isinstance(request.get(metric), int | float)
+            and not isinstance(request.get(metric), bool)
+            and math.isfinite(float(request[metric]))
+            and (not positive or float(request[metric]) > 0)
         ]
-        return round(sum(values) / len(values), digits) if values else None
 
-    return {
+    summary: dict[str, object] = {
         "session_id": session_id,
         "audio_turn_count": len(request_metrics),
-        "mean_ttft_ms": mean("ttft_ms"),
-        "mean_ttfp_ms": mean("ttfp_ms"),
-        "mean_rtf": mean("rtf", digits=6),
+        "ttft_ms": distribution_summary(values("ttft_ms")),
+        "ttfp_ms": distribution_summary(values("ttfp_ms")),
+        "rtf": distribution_summary(values("rtf"), digits=6),
     }
+    if (tpot := distribution_summary(values("tpot_ms", positive=True))) is not None:
+        summary["tpot_ms"] = tpot
+    return summary
 
 
-async def acknowledge_collected_playback(client: DuplexClient, collector: EventCollector) -> None:
+async def acknowledge_collected_playback(client: DuplexClientBase, collector: EventCollector) -> None:
     """Ack playback of every collected response's audio (probe shorthand).
 
     A response that has produced no audio yet is still acked (0 ms) unless it
diff --git a/vllm_omni/clients/inline_duplex.py b/vllm_omni/clients/inline_duplex.py
new file mode 100644
index 000000000..5af8efc5f
--- /dev/null
+++ b/vllm_omni/clients/inline_duplex.py
@@ -0,0 +1,136 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""In-process duplex client: the :class:`DuplexClient` usage over a ``DuplexOmni``.
+
+Example::
+
+    from vllm_omni.clients.inline_duplex import InlineDuplexClient
+    from vllm_omni.clients.minicpmo_4_5 import create_duplex_session_config
+    from vllm_omni.entrypoints.duplex_omni import DuplexOmni
+
+    omni = DuplexOmni(model="openbmb/MiniCPM-o-4_5", trust_remote_code=True)
+    cfg = create_duplex_session_config(ref_audio=audio_data_url(wav_bytes))
+    async with InlineDuplexClient(omni, model="openbmb/MiniCPM-o-4_5", config=cfg) as client:
+        await client.stream_pcm(pcm16)
+        await client.commit()
+        async for response in client.responses():
+            async for chunk in response.audio():
+                play(chunk)
+            break
+
+There is no transport to drop, so this client has no reconnect, resume,
+heartbeat or event-acknowledgement machinery. The ``DuplexOmni`` instance is
+passed in by the caller; this module never imports server runtime code at
+import time.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING
+
+from vllm_omni.clients.duplex import DuplexClientBase, DuplexConnectionError, SessionConfig
+
+if TYPE_CHECKING:
+    from vllm_omni.entrypoints.duplex_omni import DuplexOmni, DuplexSessionHandle
+    from vllm_omni.protocol.duplex import RealtimeInputDefaults
+
+__all__ = ["InlineDuplexClient"]
+
+#: Acknowledgements are a websocket-journal concern; heartbeats are lease touches and go through.
+_TRANSPORT_ONLY_EVENTS = frozenset({"session.event_ack"})
+
+
+class InlineDuplexClient(DuplexClientBase):
+    """Async client for one duplex session on an in-process :class:`DuplexOmni`."""
+
+    def __init__(
+        self,
+        omni: DuplexOmni,
+        *,
+        model: str,
+        config: SessionConfig | None = None,
+        handshake_timeout_s: float = 30.0,
+    ) -> None:
+        super().__init__(model=model, config=config, handshake_timeout_s=handshake_timeout_s)
+        self.omni = omni
+        self._handle: DuplexSessionHandle | None = None
+        self._pump_task: asyncio.Task[None] | None = None
+        self._handshake_pending = False
+
+    # -- transport hooks ------------------------------------------------------
+
+    async def _open(self) -> None:
+        # The handle's first event is ``session.created``; the pump delivers
+        # it through ``_dispatch`` where the base handshake is waiting.
+        self._handle = await self.omni.open_session(self.config.to_session_payload(model=self.model))
+        # The base class follows up with the ``session.update`` handshake; the
+        # open above already carried that session object, so it is not resent.
+        self._handshake_pending = True
+        self._pump_task = asyncio.create_task(self._pump_events(), name="inline-duplex-client-pump")
+
+    def _input_defaults(self) -> RealtimeInputDefaults:
+        """Audio format / sample-rate / VAD defaults declared by this session's object."""
+        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)
+
+    async def _send_command(self, payload: dict[str, object]) -> None:
+        handle = self._handle
+        if handle is None or handle.closed:
+            raise DuplexConnectionError("send failed: session is not open")
+        event_type = payload.get("type")
+        if event_type == "session.update" and self._handshake_pending:
+            self._handshake_pending = False
+            return
+        if event_type == "session.close":
+            await handle.close()
+            return
+        if event_type in _TRANSPORT_ONLY_EVENTS:
+            return
+        # Lazy import keeps ``vllm_omni.clients`` free of runtime imports at
+        # module load; the caller already holds a live DuplexOmni.
+        from vllm_omni.engine.duplex.commands import DuplexCommandError, command_from_realtime
+        from vllm_omni.engine.duplex.events import error_event
+
+        try:
+            command = command_from_realtime(payload, defaults=self._input_defaults())
+        except DuplexCommandError as exc:
+            await self._dispatch(
+                error_event(exc.code, str(exc), event_id=exc.event_id or payload.get("event_id")).to_realtime()
+            )
+            return
+        await handle.submit(command)
+
+    async def _teardown(self) -> None:
+        pump = self._pump_task
+        if pump is not None and not pump.done():
+            pump.cancel()
+            try:
+                await pump
+            except (asyncio.CancelledError, Exception):  # noqa: BLE001
+                pass
+        handle = self._handle
+        if handle is not None and not handle.closed:
+            try:
+                await handle.close()
+            except Exception:  # noqa: BLE001
+                pass
+
+    # -- internals ---------------------------------------------------------------
+
+    async def _pump_events(self) -> None:
+        handle = self._handle
+        assert handle is not None
+        reason = "closed"
+        try:
+            async for event in handle.events():
+                await self._dispatch(event.to_realtime())
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:  # noqa: BLE001
+            reason = f"session failed: {exc}"
+            self._finalize(reason, expected=False)
+            return
+        self._finalize(reason, expected=True)
diff --git a/vllm_omni/clients/minicpmo_4_5.py b/vllm_omni/clients/minicpmo_4_5.py
index 4b25346d4..b43346324 100644
--- a/vllm_omni/clients/minicpmo_4_5.py
+++ b/vllm_omni/clients/minicpmo_4_5.py
@@ -13,7 +13,7 @@ __all__ = ["create_duplex_session_config"]
 
 def create_duplex_session_config(*, ref_audio: str | None = None, **overrides: object) -> SessionConfig:
     """Session preset matching the MiniCPM-o 4.5 native duplex deployment."""
-    extra_body: dict[str, object] = {"native_duplex": True, "force_listen_count": 0}
+    extra_body: dict[str, object] = {"force_listen_count": 0}
     extra_body.update(overrides.pop("extra_body", {}))
     config = SessionConfig(
         ref_audio=ref_audio,
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 c1e380a22..f04bf8358 100644
--- a/vllm_omni/config/environment_variable_inventory.py
+++ b/vllm_omni/config/environment_variable_inventory.py
@@ -63,9 +63,14 @@ _PUBLIC_OMNI = (
     "OMNI_DIFFUSION_SESSION_STATE_MANAGER_MAX_SESSIONS",
     "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",
     "VLLM_OMNI_INPUT_WAIT_TIMEOUT_S",
+    "VLLM_OMNI_NIXL_LEASE_S",
+    "VLLM_OMNI_NIXL_XFER_TIMEOUT_S",
     "VLLM_OMNI_ORCH_MONITOR_PATH",
     "VLLM_OMNI_SERVER_STORAGE__FILE_CONCURRENCY",
     "VLLM_OMNI_SERVER_STORAGE__FILE_TTL",
@@ -137,16 +142,10 @@ _MODEL_PROMOTE = (
     "AR_DIFFUSION_KV_SCRATCH_BLOCKS_PER_BRANCH",
     "COSMOS3_SOUND_TOKENIZER_CONFIG_PATH",
     "COSMOS3_SOUND_TOKENIZER_PATH",
+    "COSYVOICE3_BATCH_FLOW",
     "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",
@@ -174,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",
@@ -188,14 +186,15 @@ _MODEL_REQUEST_SCOPE = (
 _MODEL_EXTERNAL: tuple[str, ...] = ()
 
 _MODEL_INTERNALIZE = (
-    "DOTS_TTS_BETA_TRACE",
-    "DYNIN_S2U_VENDOR_ROOT",
+    "COSYVOICE3_BATCH_FLOW_DEBUG",
     "DZ_PHASE_TIMING",
     "MAGI2_ALLOW_UNSUPPORTED_TOPOLOGY",
     "MAGI2_ROUTER_BIAS_SOURCE",
     "MING_TTS_STAGE1_FINAL_LOG",
     "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",
@@ -206,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",
@@ -228,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 81eb76f0b..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,17 +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"),
@@ -64,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",
     }
 )
@@ -85,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
@@ -153,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
@@ -165,8 +185,27 @@ class _ModelEngineOverrides(TypedDict, total=False):
     max_cudagraph_capture_size: int
     enable_flashinfer_autotune: bool
     enable_multithread_weight_load: bool
+    enable_broadcast_weight_load: bool
     num_weight_load_threads: int
     disable_autocast: bool
+    # Upstream ModelConfig inputs that users pass as global CLI flags.
+    served_model_name: str | list[str]
+    allowed_local_media_path: str
+    allowed_media_domains: list[str]
+    max_logprobs: int
+    logprobs_mode: str
+    mm_processor_kwargs: dict[str, Any]
+    mm_processor_cache_type: str
+    hf_token: bool | str
+    hf_config_path: str
+    generation_config: str
+    override_generation_config: dict[str, Any]
+    enable_prompt_embeds: bool
+
+
+class _PoolingEngineOverrides(TypedDict, total=False):
+    runner: str
+    pooling_output_decoder: str
 
 
 class _LoadEngineOverrides(TypedDict, total=False):
@@ -235,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)
@@ -244,6 +284,7 @@ class _StageEngineValues:
     quantization: _QuantizationEngineOverrides
     model: _ModelEngineOverrides
     load: _LoadEngineOverrides
+    pooling: _PoolingEngineOverrides
     cache: _CacheEngineOverrides
     scheduler: _SchedulerEngineOverrides
     connector: _ConnectorEngineOverrides
@@ -260,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()}
 
@@ -299,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
@@ -329,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)
 
@@ -342,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
 
 
@@ -357,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(
@@ -420,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
@@ -435,6 +514,7 @@ class OmniStageModelConfig(_TrackExplicitConfigFields):
     max_cudagraph_capture_size: int | None = Field(default=None, ge=0)
     enable_flashinfer_autotune: bool | None = None
     enable_multithread_weight_load: bool = True
+    enable_broadcast_weight_load: bool = False
     num_weight_load_threads: int = Field(default=4, ge=1)
     disable_autocast: bool = False
     # Per-stage checkpoint/tokenizer subdirectories under the model root
@@ -443,6 +523,28 @@ class OmniStageModelConfig(_TrackExplicitConfigFields):
     model_subdir: str | None = None
     tokenizer_subdir: str | None = None
     requires_full_payload_input: bool = False
+    # Upstream ModelConfig inputs that users pass as global CLI flags.
+    served_model_name: str | list[str] | None = None
+    allowed_local_media_path: str | None = None
+    allowed_media_domains: list[str] | None = None
+    max_logprobs: int | None = None
+    logprobs_mode: str | None = None
+    mm_processor_kwargs: dict[str, Any] | None = None
+    mm_processor_cache_type: str | None = None
+    hf_token: bool | str | None = None
+    hf_config_path: str | None = None
+    generation_config: str | None = None
+    override_generation_config: dict[str, Any] | None = None
+    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
@@ -512,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",
@@ -683,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.
 
@@ -718,6 +821,7 @@ class _DiffusionConfigProjection:
     cache_strategy: str = "none"
     cache_backend: str = "none"
     cache_config: Any = field(default_factory=dict)
+    video_output_transport: object = field(default_factory=dict)
     enable_cache_dit_summary: bool = False
     diffusion_kv_mode: DiffusionKVCacheMode = DiffusionKVCacheMode.DENSE_LEGACY
     diffusion_kv_max_rows_per_request: int | None = Field(default=None, ge=1, strict=True)
@@ -774,6 +878,7 @@ class _DiffusionConfigProjection:
             "transformer": True,
             "vae": True,
             "text_encoder": True,
+            "vae_encoder": True,
         }
     )
     override_transformer_cls_name: str | None = None
@@ -784,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")
@@ -795,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
@@ -812,6 +923,7 @@ class _DiffusionConfigProjection:
             AttentionConfig,
             DiffusionCacheConfig,
             TransformerConfig,
+            VideoOutputTransportConfig,
             build_attention_config,
             parse_kv_cache_skip_selector,
             validate_dlo_host_registration_options,
@@ -854,6 +966,13 @@ class _DiffusionConfigProjection:
         elif not isinstance(self.cache_config, DiffusionCacheConfig):
             self.cache_config = DiffusionCacheConfig()
 
+        if self.video_output_transport is None:
+            self.video_output_transport = VideoOutputTransportConfig()
+        elif isinstance(self.video_output_transport, Mapping):
+            self.video_output_transport = VideoOutputTransportConfig(**dict(self.video_output_transport))
+        elif not isinstance(self.video_output_transport, VideoOutputTransportConfig):
+            raise TypeError("video_output_transport must be a VideoOutputTransportConfig or mapping")
+
         self._propagate_quantization_from_tf_config(self.tf_model_config)
         if self.quantization_config is not None:
             if isinstance(self.quantization_config, QuantizationConfig):
@@ -923,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)
@@ -1019,6 +1140,7 @@ _DIFFUSION_MOVED_SHARED_FIELDS = frozenset(
         "enable_sleep_mode",
         "enforce_eager",
         "enable_multithread_weight_load",
+        "enable_broadcast_weight_load",
         "num_weight_load_threads",
         "disable_autocast",
     }
@@ -1027,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(
@@ -1099,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"})
@@ -1129,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 = (
@@ -1178,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]
@@ -1186,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
@@ -1203,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.
@@ -1215,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)
     )
@@ -1259,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,
@@ -1288,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,
@@ -1299,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")),
     )
@@ -1309,10 +1580,10 @@ def _stage_sampling_params(
     stage_deploy: StageDeployConfig | None,
     topology: StagePipelineConfig,
 ) -> dict[str, Any] | None:
-    sampling: dict[str, Any] = {}
-    if stage_deploy is not None and stage_deploy.default_sampling_params:
-        sampling.update(_copy_value(stage_deploy.default_sampling_params))
-    sampling.update(_copy_value(topology.sampling_constraints))
+    sampling = merge_sampling_constraints(
+        _copy_value(stage_deploy.default_sampling_params) if stage_deploy is not None else None,
+        _copy_value(topology.sampling_constraints),
+    )
     return sampling or None
 
 
@@ -1360,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
@@ -1444,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
@@ -1480,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)
 
@@ -1497,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,
@@ -1694,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:
@@ -1710,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,
@@ -1795,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,
     )
@@ -1888,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:
@@ -1903,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:
@@ -1926,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")
 
@@ -1948,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,
@@ -1957,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 b711f0cfb..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,
@@ -40,17 +41,18 @@ from vllm_omni.model_executor.models.audex.pipeline import (
     AUDEX_TTS_PIPELINE,
 )
 from vllm_omni.model_executor.models.audio8_tts.pipeline import AUDIO8_TTS_PIPELINE
+from vllm_omni.model_executor.models.auk.pipeline import AUK_PIPELINE
 from vllm_omni.model_executor.models.aura_omni.pipeline import AURA_OMNI_PIPELINE
 from vllm_omni.model_executor.models.bagel.pipeline import (
     BAGEL_PIPELINE,
     BAGEL_SINGLE_STAGE_PIPELINE,
     BAGEL_THINK_PIPELINE,
 )
+from vllm_omni.model_executor.models.breeze_tts_2.pipeline import BREEZE_TTS_2_PIPELINE
+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
@@ -126,6 +128,7 @@ PipelineResolverFunc: TypeAlias = Callable[[PretrainedConfig | None], PipelineCo
 # --- Multi-stage omni pipelines (LLM-centric; audio / video I/O) ---
 OMNI_PIPELINES: dict[str, PipelineConfig | PipelineResolverFunc] = {
     "aura_omni": AURA_OMNI_PIPELINE,
+    "breeze": BREEZE_TTS_2_PIPELINE,
     "joyai_vl_interaction": JOYAI_VL_INTERACTION_PIPELINE,
     "qwen2_5_omni": QWEN2_5_OMNI_PIPELINE,
     "qwen2_5_omni_thinker_only": QWEN2_5_OMNI_THINKER_ONLY_PIPELINE,
@@ -149,6 +152,12 @@ 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
+    # (see deploy/cosmos3_policy_droid.yaml).
+    "cosmos3_policy": COSMOS3_POLICY_PIPELINE,
     "gepard": GEPARD_PIPELINE,
     "glm_image": GLM_IMAGE_PIPELINE,
     "hunyuan_image_3_moe": HUNYUAN_IMAGE3_PIPELINE,
@@ -157,7 +166,7 @@ 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,
     "audex_tta": AUDEX_TTA_PIPELINE,
@@ -190,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 2ac1f99dd..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,14 +310,17 @@ class PipelineConfig:
     diffusers_class_name: str | None = None
     diffusers_class_aliases: tuple[str, ...] = ()
     endpoint_restrictions: tuple[EndpointRestriction, ...] = ()
-    # Optional model-owned duplex planner loaded by the stable engine runtime.
+    # 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
+    # away with the follow-up PR that ports its model to ``duplex_plugin``.
     duplex_runtime_extension: str | None = None
-    # Optional model-owned Serving adapter loaded only when the Realtime duplex
-    # endpoint is enabled. Generic OpenAI modules must not select a model.
     duplex_serving_adapter: str | None = None
-    # Explicitly enable the stable duplex control mechanism. This is separate
-    # from the optional model extension because turn-commit-only deployments
-    # do not require a model planner.
     duplex_control_enabled: bool = False
     # Bundled deploy defaults for this concrete pipeline topology. The file is
     # loaded from vllm_omni/deploy; None uses DeployConfig defaults.
@@ -387,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
@@ -458,6 +465,7 @@ class StageDeployConfig:
     fa_deterministic: bool | None = None
     cache_backend: str | None = None
     cache_config: dict[str, Any] | None = None
+    video_output_transport: dict[str, Any] | None = None
     enable_cache_dit_summary: bool | None = None
     step_execution: bool | None = None
     vae_use_slicing: bool | None = None
@@ -471,6 +479,7 @@ class StageDeployConfig:
 
     # Runtime optimizations used by diffusion loading/execution.
     enable_multithread_weight_load: bool | None = None
+    enable_broadcast_weight_load: bool | None = None
     num_weight_load_threads: int | None = None
     diffusion_offload_config: dict[str, Any] | None = None
     # Compatibility aliases for existing callers and model-specific stage
@@ -508,6 +517,12 @@ class DuplexSessionRuntimeConfig:
     max_pending_input_bytes_per_session: int = 16 * 1024 * 1024
     max_pending_turns_per_session: int = 4
     max_sessions: int = 1
+    # Unread by the plugin framework. It used to bound the per-session
+    # completed-append table that made a retried append RPC submit once; the
+    # framework carries appends as one-way commands on the runner's ordered
+    # mailbox, so there is no client-visible retry to deduplicate. The field
+    # stays so the deploy configs of the models that are not ported yet still
+    # parse, and goes away with the PR that ports the last of them.
     completed_append_cache_size: int = 256
     server_vad_model_path: str | None = None
     # Startup warmup: run this many silent 80 ms-style frames through a
@@ -552,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)
@@ -576,6 +592,7 @@ class DeployConfig:
 
 _STAGE_RESERVED_KEYS = frozenset(
     {
+        "async_chunk",
         "stage_id",
         "devices",
         "num_replicas",
@@ -634,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")
@@ -720,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))
@@ -732,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:
@@ -757,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),
@@ -812,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
 
@@ -877,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,
@@ -953,31 +1021,64 @@ 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
     return engine_args
 
 
+def merge_sampling_constraints(
+    sampling_params: Mapping[str, Any] | None,
+    constraints: Mapping[str, Any],
+) -> dict[str, Any]:
+    """Apply scalar constraints and extend stop tokens without mutating inputs."""
+    resolved_constraints = dict(constraints)
+    if "stop_token_ids" in resolved_constraints:
+        caller_stop_ids = (sampling_params or {}).get("stop_token_ids") or []
+        required_stop_ids = resolved_constraints["stop_token_ids"] or []
+        resolved_constraints["stop_token_ids"] = list(dict.fromkeys([*caller_stop_ids, *required_stop_ids]))
+    return {**(sampling_params or {}), **resolved_constraints}
+
+
 def _build_extras(
     ps: StagePipelineConfig,
     ds: StageDeployConfig | None,
 ) -> dict[str, Any]:
     """Assemble ``yaml_extras`` (sampling + connectors + pipeline extras)."""
     extras: dict[str, Any] = {}
-    sampling: dict[str, Any] = {}
-    if ds is not None and ds.default_sampling_params:
-        sampling.update(ds.default_sampling_params)
-    sampling.update(ps.sampling_constraints)
+    sampling = merge_sampling_constraints(
+        ds.default_sampling_params if ds is not None else None,
+        ps.sampling_constraints,
+    )
     if sampling:
         extras["default_sampling_params"] = sampling
     if ds is not None and ds.default_pooling_params:
@@ -1036,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.
@@ -1129,10 +1231,25 @@ class StageConfig:
             _apply_diffusion_parallel_runtime_overrides(engine_args, runtime_overrides)
             reconcile_diffusion_attention_overrides(engine_args, runtime_overrides)
 
-        # CLI overrides take precedence over YAML defaults
+        # CLI overrides take precedence over YAML defaults. Most dict-valued
+        # overrides are deep-merged so a partial CLI dict (e.g. --no-guardrails
+        # riding on ``model_config``) layers onto the deploy YAML instead of
+        # clobbering sibling keys such as ``policy_server_config`` — the same
+        # rationale as the platform-overlay deep-merge. Legacy atomic mappings
+        # are handled explicitly below.
         for key, value in runtime_overrides.items():
             if value is not None and key not in ("devices", "max_batch_size", "num_replicas"):
-                engine_args[key] = value
+                existing = engine_args.get(key)
+                # ``omni_kv_config`` is an atomic legacy override: callers use
+                # a partial mapping to replace the topology-provided transfer
+                # role, rather than to add fields to it.
+                if key != "omni_kv_config" and isinstance(existing, dict) and isinstance(value, dict):
+                    engine_args[key] = _get_recursively_merged_dict(existing, value)
+                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)
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 329e8ad81..4d55c55f8 100644
--- a/vllm_omni/core/sched/omni_ar_scheduler.py
+++ b/vllm_omni/core/sched/omni_ar_scheduler.py
@@ -16,20 +16,38 @@ from vllm.v1.core.sched.async_scheduler import AsyncScheduler as AsyncVLLMSchedu
 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.engine import EngineCoreEventType, EngineCoreOutput, EngineCoreOutputs
+from vllm.v1.engine import EngineCoreEventType, EngineCoreOutput, EngineCoreOutputs, FinishReason
 from vllm.v1.metrics.perf import PerfStats
 from vllm.v1.outputs import ModelRunnerOutput
 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
@@ -116,12 +136,37 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
         self._init_omni_io_scheduling_state()
         # Snapshot prompt length for each streaming input update
         self._new_prompt_len_snapshot: dict[str, int] = {}
+        # Streaming sessions finished because their next prompt extension
+        # would exceed max_model_len: request_id -> (client_index, reason).
+        # Drained into an explicit FinishReason.ERROR output on the next
+        # update_from_output so the client learns why the session ended.
+        self._streaming_context_overflow: dict[str, tuple[int, str]] = {}
 
     def _get_confirmed_num_computed_tokens(self, request: Request) -> int:
         """num_computed_tokens minus async placeholders (KV actually on GPU)."""
         # 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")
@@ -172,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
@@ -301,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:
@@ -413,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
@@ -581,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)
@@ -599,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:
@@ -655,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,
@@ -674,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.
@@ -704,6 +776,7 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
             failed_kv_load_req_ids,
             outputs,
         )
+        self._emit_streaming_context_overflow_outputs(outputs)
         if self.chunk_transfer_adapter is not None:
             for request in failed_requests:
                 self.chunk_transfer_adapter.cleanup_receiver(request.request_id)
@@ -749,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)
@@ -850,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:
@@ -883,11 +955,143 @@ class OmniARScheduler(OmniSchedulerMixin, VLLMScheduler):
             self._release_replaced_streaming_prompt_cache(session)
             self._replace_streaming_session(session, update)
             return
+        if self._streaming_update_overflows(session, update):
+            return
         session._omni_segment_generation = int(getattr(session, "_omni_segment_generation", 0) or 0) + 1
         super()._update_request_as_session(session, update)
         if hasattr(update, "model_intermediate_buffer"):
             session.model_intermediate_buffer = update.model_intermediate_buffer
 
+    # Prefix of the stop_reason carried by the FinishReason.ERROR output, so the
+    # serving side can map it to a stable error code.
+    STREAMING_CONTEXT_OVERFLOW_STOP_REASON = "context_length_exceeded"
+
+    def _streaming_update_overflows(self, session: Request, update: StreamingUpdate) -> bool:
+        """Finish a streaming session whose next extension cannot fit the model.
+
+        Upstream ``_update_request_as_session`` appends the update to the
+        session prompt without checking ``max_model_len``. The worker's input
+        batch then fails to copy the prompt (``could not broadcast input array
+        from shape (N,) into shape (max_model_len,)``) and the EngineCore dies,
+        taking every session on the replica with it. A native duplex session
+        grows by tens to hundreds of tokens per second of input, so long
+        sessions reach this point in normal use.
+
+        A prompt that fills the model exactly is over the line as well: the
+        session samples at least one listen/speak token after every append,
+        and upstream's running-request budget
+        ``max_model_len - num_computed_tokens - num_sampled_tokens_per_step``
+        then goes negative, which the ``num_new_tokens == 0`` guard in
+        ``schedule()`` does not catch (``allocate_slots`` dies, or the worker
+        asserts ``max_model_len + 1`` sampled positions). So the extended
+        prompt must leave room for the tokens sampled in one step.
+
+        The update is dropped and only this request is finished, right here:
+        a parked session does not make the engine schedule, so deferring the
+        finish to the next ``schedule()`` would leave the client waiting. The
+        reason is emitted with the terminal output (see
+        :meth:`_emit_streaming_context_overflow_outputs`).
+        """
+        max_model_len = getattr(self, "max_model_len", None)
+        if max_model_len is None:
+            model_config = getattr(getattr(self, "vllm_config", None), "model_config", None)
+            max_model_len = getattr(model_config, "max_model_len", None)
+        if not max_model_len:
+            return False
+        new_tokens = len(update.prompt_token_ids or ())
+        # The extended prompt is the current prompt plus the computed output
+        # tokens upstream keeps, then the update: num_computed_tokens covers
+        # both when the prompt was fully computed.
+        projected = max(int(session.num_prompt_tokens), int(session.num_computed_tokens)) + new_tokens
+        # Room for the tokens one step samples on top of the prompt (1 without
+        # speculative decoding). __new__-built test schedulers carry no
+        # num_sampled_tokens_per_step.
+        sample_room = max(1, int(getattr(self, "num_sampled_tokens_per_step", 1) or 1))
+        if projected + sample_room <= int(max_model_len):
+            return False
+        reason = (
+            f"{self.STREAMING_CONTEXT_OVERFLOW_STOP_REASON}: streaming session prompt would grow to "
+            f"{projected} tokens, leaving no room to sample within max_model_len {int(max_model_len)}"
+        )
+        logger.error(
+            "[Omni] %s: %s; finishing the request instead of extending it",
+            session.request_id,
+            reason,
+        )
+        overflow = getattr(self, "_streaming_context_overflow", None)
+        if overflow is None:
+            overflow = self._streaming_context_overflow = {}
+        overflow[session.request_id] = (int(getattr(session, "client_index", 0) or 0), reason)
+        if session.is_finished():
+            # Reached from ``_handle_stopped_request`` with a queued update.
+            # ``update_from_output`` frees every request that call reports as
+            # finished, so finishing the session here too would free it twice.
+            # ``_handle_stopped_request`` below takes it out of admission and
+            # leaves the single free to the caller.
+            return True
+        self.finish_requests((session.request_id,), RequestStatus.FINISHED_ERROR)
+        return True
+
+    def _handle_stopped_request(self, request: Request) -> bool:
+        """Do not resume a session whose queued update overflowed the model.
+
+        Upstream pops one queued ``StreamingUpdate``, applies it through
+        ``_update_request_as_session`` and then re-enqueues the request
+        unconditionally. When that update overflows, the request must not go
+        back into the waiting queue: it is terminal, and admission raises
+        ``RuntimeError: Invalid request status`` on anything that is neither
+        WAITING nor PREEMPTED, which would kill the EngineCore this guard
+        exists to keep alive. The same holds for a session whose overflow was
+        recorded before this call and that upstream still reports as resumed.
+        """
+        finished = super()._handle_stopped_request(request)
+        if finished:
+            return True
+        overflow = getattr(self, "_streaming_context_overflow", None)
+        if not overflow or request.request_id not in overflow:
+            return False
+        # Whether the overflow was recorded by this call's queued update or
+        # earlier makes no difference: a session in the overflow map is
+        # terminal, and upstream has just put it back into admission.
+        self._finish_overflowed_streaming_session(request)
+        return True
+
+    def _finish_overflowed_streaming_session(self, request: Request) -> None:
+        """Take a terminal session back out of admission.
+
+        Queues and status only. ``update_from_output`` frees every request
+        ``_handle_stopped_request`` reports as finished, so freeing here as
+        well deletes it from ``self.requests`` twice (``KeyError`` in
+        ``_free_blocks``) and skips the caller's input-coordinator cleanup.
+        """
+        self.waiting.remove_requests((request,))
+        self.skipped_waiting.remove_requests((request,))
+        if request.status == RequestStatus.WAITING_FOR_STREAMING_REQ:
+            self.num_waiting_for_streaming_input -= 1
+        request.status = RequestStatus.FINISHED_ERROR
+        request.resumable = False
+
+    def _emit_streaming_context_overflow_outputs(self, outputs: dict[int, list[EngineCoreOutput]]) -> None:
+        """Turn recorded context overflows into explicit error outputs.
+
+        Without this the finished session would only get the synthesized
+        ``FinishReason.ABORT`` output, which a client cannot tell apart from
+        its own cancel.
+        """
+        overflow = getattr(self, "_streaming_context_overflow", None)
+        if not overflow:
+            return
+        for request_id, (client_index, reason) in list(overflow.items()):
+            outputs.setdefault(client_index, []).append(
+                OmniEngineCoreOutput(
+                    request_id=request_id,
+                    new_token_ids=[],
+                    finish_reason=FinishReason.ERROR,
+                    stop_reason=reason,
+                )
+            )
+        overflow.clear()
+
     def _free_request(
         self, request: Request, delay_free_blocks: bool = False
     ) -> tuple[dict[str, Any] | None, dict[str, Any] | None]:
@@ -903,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 9123b794d..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(
@@ -688,6 +817,68 @@ class OmniSchedulerMixin:
             engine_core_outputs[0] = output = EngineCoreOutputs()
         output.scheduler_stats = stats
 
+    def add_request(self, request: Request) -> None:
+        """Route a terminal streaming update that lands on a parked session.
+
+        Upstream ``Scheduler.add_request`` turns "final update (``resumable``
+        is False) arrives while the session sits in
+        ``WAITING_FOR_STREAMING_REQ``" into a local
+        ``finish_requests(FINISHED_ABORTED)``. That is fine for a stage whose
+        output the orchestrator forwards, but an async-chunk *sender* also
+        owes its downstream stage a terminal chunk: the receiver learns that a
+        stream ended only from a connector payload carrying ``finished``, and
+        an abort emits none. The downstream stage then parks in
+        ``WAITING_FOR_CHUNK`` until ``VLLM_OMNI_INPUT_WAIT_TIMEOUT_S`` (600s by
+        default), long after the client's own deadline -- the realtime
+        async-chunk hang in vllm-project/vllm-omni#6670.
+
+        Whether this races is timing, not configuration: the stage parks only
+        when its own stop beats both the upstream terminal chunk and the
+        orchestrator's terminal update, a window of tens of milliseconds at
+        the end of the last segment. Emit the terminal chunk here so the
+        downstream stage terminates on the payload path either way.
+        """
+        existing = self.requests.get(request.request_id)
+        if existing is not None and existing.status == RequestStatus.WAITING_FOR_STREAMING_REQ:
+            adapter = None if getattr(request, "resumable", False) else self._adapter_owing_terminal(existing)
+            if adapter is not None:
+                self._finish_parked_streaming_session(existing, adapter)
+                return
+        super().add_request(request)
+
+    def _adapter_owing_terminal(self, request: Request) -> OmniChunkTransferAdapter | None:
+        """The adapter that owes *request*'s downstream stage a terminal chunk.
+
+        Sender ownership starts when the first chunk is queued, before the
+        background thread initializes its chunk counter. A prewarmed receiver
+        needs a terminal even if that first chunk has not been sent yet.
+        Final stages never queue sends, so they never match.
+        """
+        adapter = getattr(self, "chunk_transfer_adapter", None)
+        if adapter is None:
+            return None
+        external_req_id = getattr(request, "external_req_id", None) or request.request_id
+        return adapter if adapter.has_active_sender(external_req_id) else None
+
+    def _finish_parked_streaming_session(self, request: Request, adapter: OmniChunkTransferAdapter) -> None:
+        """End a parked async-chunk session with a downstream terminal chunk."""
+        request.resumable = False
+        # A segment stop already advanced the adapter's dedup watermark to
+        # ``generation + 1`` for the segment that never arrived. Claim that
+        # generation, exactly as ``_update_request_as_session`` would have,
+        # or ``save_async`` drops this chunk as a late duplicate.
+        request._omni_segment_generation = int(getattr(request, "_omni_segment_generation", 0) or 0) + 1
+        # ``force_request_finished``: the terminal must be enqueued *before*
+        # ``finish_requests``, which skips requests that already report
+        # ``is_finished()``.
+        adapter.save_async(
+            None,
+            request,
+            is_segment_finished=False,
+            force_request_finished=True,
+        )
+        self.finish_requests(request.request_id, RequestStatus.FINISHED_STOPPED)
+
     def finish_requests(
         self,
         request_ids: str | Iterable[str] | None,
@@ -891,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 93f40daa0..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,
@@ -121,6 +188,7 @@ class OmniSchedulingCoordinator:
                     OmniChunkRecvHandle(
                         request_id=request.request_id,
                         external_req_id=getattr(request, "external_req_id", None),
+                        payload_sender_info=getattr(request, "payload_sender_info", None),
                     )
                 )
             elif request.status == RequestStatus.WAITING_FOR_INPUT:
@@ -134,6 +202,7 @@ class OmniSchedulingCoordinator:
                         OmniChunkRecvHandle(
                             request_id=request.request_id,
                             external_req_id=getattr(request, "external_req_id", None),
+                            payload_sender_info=getattr(request, "payload_sender_info", None),
                         )
                     )
         if to_remove:
@@ -142,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,
@@ -176,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)
@@ -196,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()
@@ -245,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
@@ -253,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",
@@ -282,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)
@@ -289,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 b73fbd6aa..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
@@ -105,6 +108,7 @@ class OmniChunkRecvHandle:
 
     request_id: str
     external_req_id: str | None = None
+    payload_sender_info: dict[str, object] | None = None
 
 
 @dataclass
@@ -113,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/auk.yaml b/vllm_omni/deploy/auk.yaml
new file mode 100644
index 000000000..bbe544919
--- /dev/null
+++ b/vllm_omni/deploy/auk.yaml
@@ -0,0 +1,51 @@
+# AuK deploy: thinker encoder (stage 0) + rectified-flow DiT (stage 1).
+# Topology declared in vllm_omni/model_executor/models/auk/pipeline.py.
+#
+# Fields omitted from a stage fall back to StageDeployConfig dataclass
+# defaults (see vllm_omni/config/stage_config.py). trust_remote_code,
+# enable_prefix_caching and enable_chunked_prefill are pipeline-wide
+# DeployConfig fields and apply to both stages.
+#
+# The ODE runs over the whole target segment, so there is nothing to stream
+# between the stages: async_chunk stays off.
+async_chunk: false
+trust_remote_code: true
+# Prefix caching must stay off: a cache hit skips the prefix positions, and
+# the fused [tokens, 2048] condition needs every position of the prompt.
+# Chunked prefill works (the runner concatenates the per-chunk hidden states)
+# but measured no wall-time gain, since the encoder is a few percent of a
+# request, and it costs bit-exact reproducibility across scheduling.
+enable_prefix_caching: false
+enable_chunked_prefill: false
+
+stages:
+  # Stage 0: Qwen2.5-Omni thinker as a frozen text encoder.
+  # Prefill only — one sampled token, discarded downstream. eager because the
+  # fused-hidden forward walks the decoder layers itself and so bypasses the
+  # compiled graph.
+  - stage_id: 0
+    devices: "0"
+    max_num_seqs: 1
+    gpu_memory_utilization: 0.45
+    enforce_eager: true
+    max_num_batched_tokens: 32768
+    # AuK takes text plus at most one clip; no image or video tower is built.
+    limit_mm_per_prompt: {audio: 1}
+    default_sampling_params:
+      temperature: 0.0
+      max_tokens: 1
+      detokenize: false
+      seed: 0
+
+  # Stage 1: AuKPipeline (DiT + BigVGAN-flow VAE encoder and decoder).
+  # Shares GPU 0 with the encoder; 32 Euler steps at CFG 2.0 is the Base
+  # recipe, and AuK-Flash overrides both with its distilled 4-step grid.
+  - stage_id: 1
+    devices: "0"
+    max_num_seqs: 1
+    gpu_memory_utilization: 0.35
+    enforce_eager: true
+    default_sampling_params:
+      seed: 0
+      num_inference_steps: 32
+      guidance_scale: 2.0
diff --git a/vllm_omni/deploy/breeze_tts_2.yaml b/vllm_omni/deploy/breeze_tts_2.yaml
new file mode 100644
index 000000000..fd75dd69e
--- /dev/null
+++ b/vllm_omni/deploy/breeze_tts_2.yaml
@@ -0,0 +1,55 @@
+# Breeze-TTS-2: talker -> stateful Qwen3-TTS codec decoder.
+# Stage 0 batches codec frames and sends incremental codebook-major chunks.
+async_chunk: true
+trust_remote_code: true
+
+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
+      breeze_codec_chunk_frames: 8
+
+stages:
+  - stage_id: 0
+    max_num_seqs: 8
+    gpu_memory_utilization: 0.80
+    enable_prefix_caching: false
+    # The talker derives one codec frame from the last hidden row of every
+    # scheduled request. A partially scheduled prompt would yield a frame from
+    # a mid-prompt hidden state, so keep each prefill in a single step.
+    enable_chunked_prefill: false
+    async_scheduling: true
+    max_num_batched_tokens: 4096
+    max_model_len: 4096
+    devices: "0"
+    output_connectors:
+      to_stage_1: connector_of_shared_memory
+    default_sampling_params:
+      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 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
+    gpu_memory_utilization: 0.15
+    enforce_eager: true
+    enable_prefix_caching: false
+    async_scheduling: true
+    max_num_batched_tokens: 65536
+    max_model_len: 65536
+    devices: "0"
+    default_sampling_params:
+      temperature: 0.0
+      top_p: 1.0
+      top_k: -1
+      max_tokens: 65536
diff --git a/vllm_omni/deploy/cosmos3_policy_droid.yaml b/vllm_omni/deploy/cosmos3_policy_droid.yaml
new file mode 100644
index 000000000..cbcbcb42c
--- /dev/null
+++ b/vllm_omni/deploy/cosmos3_policy_droid.yaml
@@ -0,0 +1,49 @@
+# Cosmos3 policy (DROID) deploy: single diffusion stage serving the OpenPI
+# realtime API (/v1/realtime/robot/openpi).
+#
+# Topology (COSMOS3_POLICY_PIPELINE) is declared in
+# vllm_omni/model_executor/models/cosmos3/pipeline.py. Policy checkpoints share
+# their HF metadata (model_type=cosmos3_omni, model_index.json _class_name=
+# Cosmos3OmniDiffusersPipeline) with the T2I/video Cosmos3 checkpoints, which
+# must keep using the default single-stage diffusion fallback — so this
+# pipeline cannot be auto-detected and must be selected explicitly:
+#
+#   vllm serve nvidia/Cosmos3-Nano-Policy-DROID --omni \
+#     --deploy-config /absolute/path/to/vllm-omni/vllm_omni/deploy/cosmos3_policy_droid.yaml
+#
+# Per-checkpoint model_config tweaks (e.g. policy_server_config values) can
+# still be layered on top with --stage-overrides; dict overrides deep-merge
+# with this file.
+
+pipeline: cosmos3_policy
+# async_chunk defaults to True, which the deploy validator rejects for a
+# single-stage pipeline (no next-stage processor). Must be false here.
+async_chunk: false
+distributed_executor_backend: mp
+
+stages:
+  - stage_id: 0
+    devices: "0"
+    # OpenPI policy serving is one observation -> one action reply.
+    max_num_seqs: 1
+    model_class_name: Cosmos3OmniDiffusersPipeline
+    # JSON prompt formatting is a property of this DROID checkpoint's training
+    # recipe, not a generic server default.
+    default_sampling_params:
+      extra_args:
+        format_prompt_as_json: true
+    model_config:
+      # Policy serving emits robot actions, not text/video; the Cosmos3
+      # guardrail stack (gated nvidia/Cosmos-1.0-Guardrail repo) is not part
+      # of it. Equivalent to launching with --no-guardrails.
+      guardrails: false
+      # OpenPI handshake metadata advertised to the robot client. Sent verbatim
+      # (the pipeline never reads these); they describe the camera inputs and
+      # action space the client must produce for this checkpoint.
+      policy_server_config:
+        image_resolution: [540, 640]
+        n_external_cameras: 2
+        needs_wrist_camera: true
+        needs_stereo_camera: false
+        needs_session_id: true
+        action_space: joint_position
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/mammoth_moda2_fp8_kv.yaml b/vllm_omni/deploy/mammoth_moda2_fp8_kv.yaml
new file mode 100644
index 000000000..8d99226b5
--- /dev/null
+++ b/vllm_omni/deploy/mammoth_moda2_fp8_kv.yaml
@@ -0,0 +1,7 @@
+# MammothModa2 AR→DiT text-to-image with opt-in FP8 KV cache for the AR stage.
+
+base_config: mammoth_moda2.yaml
+
+stages:
+  - stage_id: 0
+    kv_cache_dtype: fp8_e4m3
diff --git a/vllm_omni/deploy/minicpmo_4_5.yaml b/vllm_omni/deploy/minicpmo_4_5.yaml
index 4e9fd5a77..07090660b 100644
--- a/vllm_omni/deploy/minicpmo_4_5.yaml
+++ b/vllm_omni/deploy/minicpmo_4_5.yaml
@@ -1,12 +1,10 @@
 # MiniCPM-o 4.5 three-stage deploy on one large-memory GPU.
 pipeline: minicpmo_4_5
 async_chunk: true
-# Native full-duplex shares this profile with /v1/chat/completions. 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.
-active_stream_window: 4
 duplex_session:
   # Matches Stage 0/1 max_num_seqs below.
   max_sessions: 4
@@ -30,6 +28,7 @@ connectors:
       enable_hift_graph: true
       enable_cfm_graph: true
       cfm_max_graphs: 32
+      cfm_graph_bucket_frames: 16
 
 stages:
   - stage_id: 0
@@ -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_2gpu.yaml b/vllm_omni/deploy/minicpmo_4_5_2gpu.yaml
index 9c3818813..136dace7e 100644
--- a/vllm_omni/deploy/minicpmo_4_5_2gpu.yaml
+++ b/vllm_omni/deploy/minicpmo_4_5_2gpu.yaml
@@ -4,12 +4,11 @@
 # isolated from codec/vocoder contention while preserving stage-2 batching.
 pipeline: minicpmo_4_5
 async_chunk: true
-# Native full-duplex shares this profile with /v1/chat/completions. Every other
-# duplex_session knob keeps its runtime default.
+# 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.
 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.
-active_stream_window: 4
 duplex_session:
   # Matches Stage 0/1 max_num_seqs below.
   max_sessions: 4
@@ -33,6 +32,7 @@ connectors:
       enable_hift_graph: true
       enable_cfm_graph: true
       cfm_max_graphs: 32
+      cfm_graph_bucket_frames: 16
 
 stages:
   - stage_id: 0
diff --git a/vllm_omni/deploy/minicpmo_4_5_3gpu.yaml b/vllm_omni/deploy/minicpmo_4_5_3gpu.yaml
index 5eddbb6f4..9669a2768 100644
--- a/vllm_omni/deploy/minicpmo_4_5_3gpu.yaml
+++ b/vllm_omni/deploy/minicpmo_4_5_3gpu.yaml
@@ -4,12 +4,11 @@
 # Code2Wav run independently on GPUs 0, 1, and 2.
 pipeline: minicpmo_4_5
 async_chunk: true
-# Native full-duplex shares this profile with /v1/chat/completions. Every other
-# duplex_session knob keeps its runtime default.
+# 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.
 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.
-active_stream_window: 4
 duplex_session:
   # Matches Stage 0/1 max_num_seqs below.
   max_sessions: 4
@@ -33,6 +32,7 @@ connectors:
       enable_hift_graph: true
       enable_cfm_graph: true
       cfm_max_graphs: 32
+      cfm_graph_bucket_frames: 16
 
 stages:
   - stage_id: 0
diff --git a/vllm_omni/deploy/minicpmo_4_5_8x4090.yaml b/vllm_omni/deploy/minicpmo_4_5_8x4090.yaml
index eacc069d1..92065dd4f 100644
--- a/vllm_omni/deploy/minicpmo_4_5_8x4090.yaml
+++ b/vllm_omni/deploy/minicpmo_4_5_8x4090.yaml
@@ -15,10 +15,10 @@
 # so 4096 is the empirically-verified safe ceiling.
 pipeline: minicpmo_4_5
 async_chunk: true
-# Native full-duplex shares this profile with /v1/chat/completions. The default
-# duplex_session caps sessions at 1, matching Stage 0/1 max_num_seqs below.
+# session_mode: duplex makes vllm-omni serve run this model duplex-only
+# (/v1/realtime?duplex=1). The default duplex_session caps sessions at 1,
+# matching Stage 0/1 max_num_seqs below.
 session_mode: duplex
-active_stream_window: 1
 
 trust_remote_code: true
 enable_prefix_caching: false
@@ -39,6 +39,7 @@ connectors:
       enable_hift_graph: true
       enable_cfm_graph: true
       cfm_max_graphs: 32
+      cfm_graph_bucket_frames: 16
 
 stages:
   - stage_id: 0
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_h3_disaggregated.yaml b/vllm_omni/deploy/minimax_h3_disaggregated.yaml
index 1c1ee6c40..25a561c27 100644
--- a/vllm_omni/deploy/minimax_h3_disaggregated.yaml
+++ b/vllm_omni/deploy/minimax_h3_disaggregated.yaml
@@ -1,4 +1,4 @@
-# MiniMax H3: vLLM Qwen3-VL text encoder + diffusion video/audio generation.
+# MiniMax H3: unified text/video/audio encoder stage + diffusion generation stage.
 pipeline: minimax_h3_disaggregated
 async_chunk: false
 trust_remote_code: true
@@ -8,7 +8,16 @@ stages:
   - stage_id: 0
     devices: "0,1"
     max_num_seqs: 1
+    gpu_memory_utilization: 0.6
     tensor_parallel_size: 2
+    hf_overrides:
+      minimax_h3_encoder_components:
+        text_encoder:
+          parallel_mode: tp
+        video_vae:
+          parallel_mode: patch
+        audio_vae:
+          parallel_mode: leader
     default_sampling_params:
       max_tokens: 1
       temperature: 0.0
@@ -19,6 +28,7 @@ stages:
     max_num_seqs: 1
     model_loaded:
       text_encoder: false
+      vae_encoder: false
     parallel_config:
       tensor_parallel_size: 1
       ulysses_degree: 4
diff --git a/vllm_omni/deploy/minimax_h3_disaggregated_turbo.yaml b/vllm_omni/deploy/minimax_h3_disaggregated_turbo.yaml
index d7e84db42..ec11796b6 100644
--- a/vllm_omni/deploy/minimax_h3_disaggregated_turbo.yaml
+++ b/vllm_omni/deploy/minimax_h3_disaggregated_turbo.yaml
@@ -8,7 +8,16 @@ stages:
   - stage_id: 0
     devices: "0,1"
     max_num_seqs: 1
+    gpu_memory_utilization: 0.6
     tensor_parallel_size: 2
+    hf_overrides:
+      minimax_h3_encoder_components:
+        text_encoder:
+          parallel_mode: tp
+        video_vae:
+          parallel_mode: patch
+        audio_vae:
+          parallel_mode: leader
     default_sampling_params:
       max_tokens: 1
       temperature: 0.0
@@ -19,6 +28,7 @@ stages:
     max_num_seqs: 1
     model_loaded:
       text_encoder: false
+      vae_encoder: false
     parallel_config:
       tensor_parallel_size: 1
       ulysses_degree: 4
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/moss_tts_nano.yaml b/vllm_omni/deploy/moss_tts_nano.yaml
index e9eab184b..9a7e3fa0b 100644
--- a/vllm_omni/deploy/moss_tts_nano.yaml
+++ b/vllm_omni/deploy/moss_tts_nano.yaml
@@ -6,8 +6,9 @@
 #   * enforce_eager=true — the model uses upstream inference_stream() with
 #     trust_remote_code; CUDA graph capture is not wired up.
 #   * gpu_memory_utilization=0.3 — the AR LM + codec fit in ~2 GiB.
-#   * max_num_seqs=4 — supports per-request streaming generators stored in
-#     self._stream_gens.
+#   * max_num_seqs=1 — the remote model and audio tokenizer keep process-wide
+#     RNG and streaming decode state. HTTP requests may arrive concurrently,
+#     but generation must remain serial to avoid cross-request audio corruption.
 #
 # MOSS-TTS-Nano has no multimodal input preprocessing, so skip_mm_profiling
 # bypasses the dummy-MM pass at profile time.
@@ -16,7 +17,7 @@ trust_remote_code: true
 
 stages:
   - stage_id: 0
-    max_num_seqs: 4
+    max_num_seqs: 1
     gpu_memory_utilization: 0.3
     enforce_eager: true
     enable_prefix_caching: false
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 747b68852..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
@@ -95,6 +96,8 @@ stages:
       top_p: 1.0
 
   - stage_id: 1
+    # Decoder compute dtype on GPU/NPU; 310P requires FP16 and overrides this.
+    dtype: bfloat16
     # Tuned for Base voice clone; CustomVoice / VoiceDesign are TTFA-optimal at 1.
     max_num_seqs: 64
     gpu_memory_utilization: 0.3
diff --git a/vllm_omni/deploy/qwen3_tts_high_concurrency.yaml b/vllm_omni/deploy/qwen3_tts_high_concurrency.yaml
index 7a73dd50a..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:
@@ -85,6 +94,8 @@ stages:
       top_p: 1.0
 
   - stage_id: 1
+    # Decoder compute dtype on GPU/NPU; 310P requires FP16 and overrides this.
+    dtype: bfloat16
     max_num_seqs: 10
     gpu_memory_utilization: 0.3
     enforce_eager: true
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/abstract.py b/vllm_omni/diffusion/attention/backends/abstract.py
index e903960d6..592f5ba9b 100644
--- a/vllm_omni/diffusion/attention/backends/abstract.py
+++ b/vllm_omni/diffusion/attention/backends/abstract.py
@@ -215,8 +215,9 @@ class AttentionMetadata:
     #     variable-length query/key sequences for FlashAttention.
     #   "max_seqlen_q" / "max_seqlen_k": maximum sequence lengths paired with
     #     the packed cu_seqlens tensors.
-    #   "valid_kv_length": int — contiguous valid K/V prefix length for a
-    #     backend that advertises supports_prefix_kv_slicing.
+    #   "valid_kv_length": int — contiguous valid K/V prefix length. Local
+    #     backends may slice it directly; ring backends trim each circulated
+    #     K/V block from the same global prefix.
     #   "npu_attn_varlen": bool — model opt-in for the NPU packed varlen path
     #     (TND npu_fusion_attention driven by cu_seqlens, mask never read).
     #     Requires the [real, pad] two-document packing contract; see
diff --git a/vllm_omni/diffusion/attention/backends/fastvideo_vsa.py b/vllm_omni/diffusion/attention/backends/fastvideo_vsa.py
index 465912d39..cbab82c9a 100644
--- a/vllm_omni/diffusion/attention/backends/fastvideo_vsa.py
+++ b/vllm_omni/diffusion/attention/backends/fastvideo_vsa.py
@@ -6,7 +6,6 @@ from __future__ import annotations
 import functools
 import importlib.util
 import math
-import os
 from collections.abc import Mapping
 from typing import Any
 
@@ -88,77 +87,6 @@ if not hasattr(torch.ops.vllm_omni, "fastvideo_vsa_bshd"):
 _fastvideo_vsa_bshd_op = torch.ops.vllm_omni.fastvideo_vsa_bshd
 
 
-# H3 needs an explicit per-query block map: prefix queries are dense, while
-# video queries select prefix + top-k video tiles. The generic
-# video_sparse_attn() entry point cannot express that contract.
-if not hasattr(torch.ops.vllm_omni, "fastvideo_h3_vsa_bhsd"):
-
-    @torch.library.custom_op("vllm_omni::fastvideo_h3_vsa_bhsd", mutates_args=())
-    def _fastvideo_h3_vsa_bhsd_op(
-        query: torch.Tensor,
-        key: torch.Tensor,
-        value: torch.Tensor,
-        block_map: torch.Tensor,
-        variable_block_sizes: torch.Tensor,
-        logical_blocks: int,
-    ) -> torch.Tensor:
-        q = query.transpose(1, 2).contiguous()
-        k = key.transpose(1, 2).contiguous()
-        v = value.transpose(1, 2).contiguous()
-
-        # Official FastVideo's measured FastH3 route opts into this native
-        # Blackwell forward. Wheels without the extension (including SM103
-        # builds today) retain the corrected explicit-mask Triton route.
-        if os.environ.get("FASTVIDEO_VSA_SM100A", "0") == "1":
-            try:
-                from fastvideo_kernel import block_sparse_attn_sm100a
-                from fastvideo_kernel.triton_kernels.index import map_to_index
-
-                if block_sparse_attn_sm100a.is_supported(q, variable_block_sizes):
-                    q2k_idx, q2k_num = map_to_index(block_map)
-                    out, _ = block_sparse_attn_sm100a.block_sparse_attn_sm100a(
-                        q,
-                        k,
-                        v,
-                        q2k_idx.to(torch.int32).contiguous(),
-                        q2k_num.to(torch.int32).contiguous(),
-                        variable_block_sizes.to(torch.int32).contiguous(),
-                        need_lse=False,
-                    )
-                    return out.transpose(1, 2).contiguous()
-            except (ImportError, RuntimeError) as exc:
-                # Opting in explicitly and then silently getting a different
-                # numeric path is worse than the slower route it lands on.
-                logger.warning_once(
-                    "FASTVIDEO_VSA_SM100A=1 requested but the native Blackwell forward is "
-                    "unavailable (%s); using the Triton block-sparse route instead.",
-                    exc,
-                )
-
-        from fastvideo_kernel.block_sparse_attn import block_sparse_attn
-
-        logical_len = logical_blocks * 64
-        out, _ = block_sparse_attn(
-            q[:, :, :logical_len].contiguous(),
-            k[:, :, :logical_len].contiguous(),
-            v[:, :, :logical_len].contiguous(),
-            block_map[..., :logical_blocks, :logical_blocks].contiguous(),
-            variable_block_sizes[:logical_blocks].to(torch.int32).contiguous(),
-        )
-        out = out.transpose(1, 2).contiguous()
-        if out.shape[1] != query.shape[1]:
-            out = torch.nn.functional.pad(out, (0, 0, 0, 0, 0, query.shape[1] - out.shape[1]))
-        return out
-
-    @_fastvideo_h3_vsa_bhsd_op.register_fake
-    def _(query, key, value, block_map, variable_block_sizes, logical_blocks):
-        del key, value, block_map, variable_block_sizes, logical_blocks
-        return torch.empty_like(query)
-
-
-_fastvideo_h3_vsa_bhsd_op = torch.ops.vllm_omni.fastvideo_h3_vsa_bhsd
-
-
 @functools.lru_cache(maxsize=32)
 def _get_tile_partition_indices(
     dit_seq_shape: tuple[int, int, int],
@@ -226,81 +154,6 @@ def _get_tile_metadata(
     return tile_partition_indices, variable_block_sizes, non_pad_index, untile_combined_index
 
 
-@functools.lru_cache(maxsize=32)
-def _get_h3_tile_metadata(
-    prefix_segments: tuple[int, ...],
-    video_shape: tuple[int, int, int],
-    device: torch.device,
-) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, int, int]:
-    """Official FastVideo H3 geometry: pure prefix chunks + 3-D video tiles."""
-    block_size = (4, 4, 4)
-    block_elements = 64
-    prefix_len = sum(prefix_segments)
-    prefix_sizes: list[int] = []
-    for segment in prefix_segments:
-        full, remainder = divmod(segment, block_elements)
-        prefix_sizes.extend([block_elements] * full)
-        if remainder:
-            prefix_sizes.append(remainder)
-
-    video_indices = _get_tile_partition_indices(video_shape, block_size, device) + prefix_len
-    video_sizes = _construct_variable_block_sizes(video_shape, block_size, device)
-    partition = torch.cat([torch.arange(prefix_len, device=device, dtype=torch.long), video_indices])
-    sizes = torch.cat([torch.tensor(prefix_sizes, device=device, dtype=torch.int32), video_sizes.to(torch.int32)])
-    non_pad = _get_non_pad_index(sizes, block_elements)
-    untile = non_pad[torch.argsort(partition)]
-    total = prefix_len + math.prod(video_shape)
-    if int(sizes.sum()) != total or untile.numel() != total:
-        raise ValueError(
-            f"invalid H3 VSA geometry: prefix={prefix_segments}, video={video_shape}, "
-            f"sizes_sum={int(sizes.sum())}, total={total}"
-        )
-    return partition, sizes, non_pad, untile, len(prefix_sizes), int(video_sizes.numel())
-
-
-def _get_h3_layout(
-    attn_metadata: AttentionMetadata | None,
-) -> tuple[tuple[int, ...], tuple[int, int, int], int] | None:
-    if attn_metadata is None or attn_metadata.video_layout is None:
-        return None
-    prefix = attn_metadata.extra.get("vsa_h3_prefix_segments")
-    if not isinstance(prefix, (tuple, list)):
-        return None
-    target = next(
-        (span for span in reversed(attn_metadata.video_layout.video_spans) if span.role == "target"),
-        None,
-    )
-    if target is None:
-        return None
-    return tuple(int(x) for x in prefix if int(x) > 0), target.latent_grid, target.start
-
-
-def _pool_h3_tiles(x: torch.Tensor, sizes: torch.Tensor) -> torch.Tensor:
-    batch, seq_len, heads, dim = x.shape
-    blocks = seq_len // 64
-    pooled = x.view(batch, blocks, 64, heads, dim).sum(dim=2, dtype=torch.float32)
-    pooled = pooled / sizes.view(1, -1, 1, 1).clamp_min(1)
-    return pooled.permute(0, 2, 1, 3)
-
-
-def _build_h3_block_map(
-    scores: torch.Tensor,
-    num_prefix_blocks: int,
-    num_video_blocks: int,
-    topk: int,
-) -> torch.Tensor:
-    """Prefix K/V are exempt and prefix queries stay dense, as in FastVideo."""
-    keep_video = min(topk, num_video_blocks)
-    if keep_video == num_video_blocks:
-        return torch.ones_like(scores, dtype=torch.bool)
-    block_map = torch.zeros_like(scores, dtype=torch.bool)
-    indices = scores[..., num_prefix_blocks:].topk(keep_video, dim=-1).indices + num_prefix_blocks
-    block_map.scatter_(-1, indices, True)
-    block_map[..., :num_prefix_blocks] = True
-    block_map[:, :, :num_prefix_blocks, :] = True
-    return block_map
-
-
 def _get_vsa_dit_seq_shape(attn_metadata: AttentionMetadata | None) -> tuple[int, int, int] | None:
     if attn_metadata is None:
         return None
@@ -343,7 +196,9 @@ class FastVideoVSABackend(AttentionBackend):
         if importlib.util.find_spec("fastvideo_kernel") is None:
             raise ImportError(
                 "FASTVIDEO_VSA requires the optional fastvideo-kernel package "
-                "(the installation must provide the 'fastvideo_kernel' Python module)."
+                "included in vllm-omni[vsa]. Install with `uv pip install 'vllm-omni[vsa]'` "
+                "(from source: `uv pip install -e '.[vsa]'`). "
+                "Prebuilt kernels require Linux, Python 3.12 and glibc >= 2.34."
             )
 
     @staticmethod
@@ -504,93 +359,6 @@ class FastVideoVSAImpl(AttentionImpl):
                 return "sequence parallel context is active"
         return None
 
-    def _forward_h3(
-        self,
-        query: torch.Tensor,
-        key: torch.Tensor,
-        value: torch.Tensor,
-        attn_metadata: AttentionMetadata,
-    ) -> torch.Tensor:
-        layout = _get_h3_layout(attn_metadata)
-        if layout is None:
-            raise ValueError("incomplete VSA-H3 layout metadata")
-        prefix_segments, video_shape, target_start = layout
-        if sum(prefix_segments) != target_start:
-            raise ValueError(f"VSA-H3 prefix segments sum to {sum(prefix_segments)}, target starts at {target_start}")
-        expected = target_start + math.prod(video_shape)
-        if query.shape[1] != expected:
-            raise ValueError(f"VSA-H3 layout has {expected} rows but attention received {query.shape[1]}")
-        if query.dtype not in (torch.float16, torch.bfloat16):
-            raise ValueError(f"VSA-H3 requires fp16/bf16 tensors, got {query.dtype}")
-        gate = _get_gate_compress(attn_metadata)
-        if gate is not None:
-            # H3 pads the packed document to 64 rows, while VSA operates on
-            # the valid prefix. Validate/slice before launching attention so a
-            # metadata error can never trigger an unsafe dense fallback after
-            # an asynchronous custom kernel.
-            if gate.shape[0] != query.shape[0] or gate.shape[2:] != query.shape[2:] or gate.shape[1] < query.shape[1]:
-                raise ValueError(f"gate_compress shape {gate.shape} cannot cover query shape {query.shape}")
-            gate = gate[:, : query.shape[1]]
-
-        partition, sizes, non_pad, untile, prefix_blocks, video_blocks = _get_h3_tile_metadata(
-            prefix_segments, video_shape, query.device
-        )
-        logical_blocks = int(sizes.numel())
-        # The native sm100a kernel assigns pairs of query blocks to CTAs. Its
-        # contract requires an even block count; the synthetic partner is
-        # transport-only and is removed before returning.
-        pair_pad = logical_blocks % 2
-        kernel_blocks = logical_blocks + pair_pad
-        target_shape = (query.shape[0], kernel_blocks * 64, query.shape[2], query.shape[3])
-        q_tiled = torch.zeros(target_shape, device=query.device, dtype=query.dtype)
-        k_tiled = torch.zeros_like(q_tiled)
-        v_tiled = torch.zeros_like(q_tiled)
-        q_tiled[:, non_pad] = query[:, partition]
-        k_tiled[:, non_pad] = key[:, partition]
-        v_tiled[:, non_pad] = value[:, partition]
-
-        q_pool = _pool_h3_tiles(q_tiled[:, : logical_blocks * 64], sizes)
-        k_pool = _pool_h3_tiles(k_tiled[:, : logical_blocks * 64], sizes)
-        scores = torch.matmul(q_pool, k_pool.transpose(-2, -1)) * self.softmax_scale
-        block_map = _build_h3_block_map(scores, prefix_blocks, video_blocks, self.topk)
-        kernel_sizes = sizes
-        if pair_pad:
-            block_map = torch.nn.functional.pad(block_map, (0, 1, 0, 1), value=False)
-            kernel_sizes = torch.nn.functional.pad(sizes, (0, 1), value=0)
-
-        logger.info_once(
-            "FASTVIDEO_VSA H3 routing: seq_len=%d, prefix_segments=%s, video_shape=%s, "
-            "prefix_blocks=%d, video_blocks=%d, topk=%d, kernel_blocks=%d",
-            query.shape[1],
-            prefix_segments,
-            video_shape,
-            prefix_blocks,
-            video_blocks,
-            min(self.topk, video_blocks),
-            kernel_blocks,
-        )
-        output = _fastvideo_h3_vsa_bhsd_op(
-            q_tiled.contiguous(),
-            k_tiled.contiguous(),
-            v_tiled.contiguous(),
-            block_map.contiguous(),
-            kernel_sizes.contiguous(),
-            logical_blocks,
-        )[:, : logical_blocks * 64]
-
-        if gate is not None:
-            gate_tiled = torch.zeros_like(q_tiled[:, : logical_blocks * 64])
-            gate_tiled[:, non_pad] = gate[:, partition]
-            v_pool = _pool_h3_tiles(v_tiled[:, : logical_blocks * 64], sizes)
-            compressed = torch.matmul(torch.softmax(scores, dim=-1), v_pool)
-            compressed = compressed.permute(0, 2, 1, 3).to(output.dtype)
-            output = (
-                output.view(output.shape[0], logical_blocks, 64, output.shape[2], output.shape[3])
-                + compressed.unsqueeze(2)
-                * gate_tiled.view(gate_tiled.shape[0], logical_blocks, 64, gate_tiled.shape[2], gate_tiled.shape[3])
-            ).view_as(output)
-        return output[:, untile].contiguous()
-
     def forward_cuda(
         self,
         query: torch.Tensor,
@@ -611,26 +379,6 @@ class FastVideoVSAImpl(AttentionImpl):
             key = key[:, :valid_seq_len]
             value = value[:, :valid_seq_len]
 
-        if attn_metadata is not None and _get_h3_layout(attn_metadata) is not None:
-            try:
-                output = self._forward_h3(query, key, value, attn_metadata)
-                if valid_seq_len == original_seq_len:
-                    return output
-                restored = torch.zeros_like(original_query)
-                restored[:, :valid_seq_len] = output
-                return restored
-            except Exception as exc:
-                # A CUDA fault poisons the process context; attempting SDPA
-                # afterwards obscures the original kernel failure and cannot
-                # recover the request.
-                if isinstance(exc, torch.AcceleratorError):
-                    raise
-                if not self.fallback_on_error:
-                    raise
-                return self._fallback(
-                    original_query, original_key, original_value, attn_metadata, f"VSA-H3 kernel failed: {exc}"
-                )
-
         reason = self._fallback_reason(query, key, value, attn_metadata)
         if reason is not None:
             return self._fallback(original_query, original_key, original_value, attn_metadata, reason)
diff --git a/vllm_omni/diffusion/attention/backends/flash_attn.py b/vllm_omni/diffusion/attention/backends/flash_attn.py
index cef6a97f5..679bf4955 100644
--- a/vllm_omni/diffusion/attention/backends/flash_attn.py
+++ b/vllm_omni/diffusion/attention/backends/flash_attn.py
@@ -2,7 +2,8 @@
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
 import os
-from functools import partial
+from collections.abc import Callable
+from functools import cache, partial
 
 import torch
 from vllm.logger import init_logger
@@ -19,6 +20,15 @@ from vllm_omni.platforms import current_omni_platform
 logger = init_logger(__name__)
 
 
+@cache
+def _get_npu_compressed_causal_mask(device: torch.device) -> torch.Tensor:
+    """Return the shared block mask used by NPU right-down causal attention."""
+    return torch.triu(
+        torch.ones((2048, 2048), dtype=torch.bool, device=device),
+        diagonal=1,
+    ).contiguous()
+
+
 class FlashAttentionBackend(AttentionBackend):
     accept_output_buffer: bool = True
     supports_piecewise_spans: bool = True
@@ -66,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__(
@@ -301,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(
@@ -343,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(
@@ -517,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,
@@ -529,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,
@@ -549,6 +609,53 @@ class FlashAttentionImpl(AttentionImpl[AttentionMetadata]):
         value: torch.Tensor,
         attn_metadata: AttentionMetadata | None = None,
     ) -> torch.Tensor:
+        attention_mask = attn_metadata.attn_mask if attn_metadata else None
+        if self.causal:
+            import torch_npu
+
+            if attention_mask is None:
+                # The compressed upper-triangular mask with sparse_mode=3
+                # applies FlashAttention's bottom-right causal alignment when
+                # Sq != Skv without materializing the full attention matrix.
+                npu_attention_mask = _get_npu_compressed_causal_mask(query.device)
+                sparse_mode = 3
+                # Explicitly enable invalid-row handling for Sq > Skv. Equal
+                # and shorter query sequences have no fully causal-masked rows.
+                inner_precise = 2 if query.shape[1] > key.shape[1] else 0
+            else:
+                # A custom keep-mask cannot be combined with the compressed
+                # sparse_mode=3 mask. Materialize the composed block-mask and
+                # use allMask mode instead. The explicit mask follows the
+                # framework convention (True=keep), while npu_fusion_attention
+                # uses True=block.
+                explicit_keep_mask = _maybe_reshape_attn_mask(
+                    query,
+                    key,
+                    attention_mask,
+                    mask_mode="full_qk",
+                ).to(device=query.device, dtype=torch.bool)
+                query_positions = torch.arange(query.shape[1], device=query.device).unsqueeze(1)
+                key_positions = torch.arange(key.shape[1], device=query.device).unsqueeze(0)
+                causal_block_mask = key_positions > query_positions + (key.shape[1] - query.shape[1])
+                npu_attention_mask = (causal_block_mask | ~explicit_keep_mask).contiguous()
+                sparse_mode = 1
+                # An explicit mask can create fully masked rows regardless of
+                # the Sq/Skv relationship.
+                inner_precise = 2
+
+            return torch_npu.npu_fusion_attention(
+                query.contiguous(),
+                key.contiguous(),
+                value.contiguous(),
+                head_num=query.shape[2],
+                input_layout="BSND",
+                atten_mask=npu_attention_mask,
+                scale=float(self.softmax_scale),
+                keep_prob=1.0,
+                inner_precise=inner_precise,
+                sparse_mode=sparse_mode,
+            )[0]
+
         from mindiesd import attention_forward
 
         # Opt-in mask-free paths (mirror the CUDA cu_seqlens behavior): the
@@ -567,7 +674,6 @@ class FlashAttentionImpl(AttentionImpl[AttentionMetadata]):
                 out = self._forward_varlen_packed_npu(query, key, value, extra)
             if out is not None:
                 return out
-        attention_mask = attn_metadata.attn_mask if attn_metadata else None
         if attention_mask is None and extra.get("npu_attn_varlen", False):
             # Models skip mask construction when this opt-in is set
             # (FlashAttentionBackend.supports_packed_mask_free). The packed
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/backends/ring/ring_utils.py b/vllm_omni/diffusion/attention/backends/ring/ring_utils.py
index b8743fe13..a898c7729 100644
--- a/vllm_omni/diffusion/attention/backends/ring/ring_utils.py
+++ b/vllm_omni/diffusion/attention/backends/ring/ring_utils.py
@@ -1,4 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 # Copyright (c) 2024, Jiarui Fang.
 # Adapted from https://github.com/feifeibear/long-context-attention
 
@@ -9,7 +10,33 @@ import torch.nn.functional as F
 
 LseLayout = Literal["bhs", "bsh"]
 
-__all__ = ["update_out_and_lse", "flatten_varlen_lse", "unflatten_varlen_lse"]
+__all__ = [
+    "ring_kv_block_valid_length",
+    "update_out_and_lse",
+    "flatten_varlen_lse",
+    "unflatten_varlen_lse",
+]
+
+
+def ring_kv_block_valid_length(
+    valid_kv_length: int | None,
+    block_size: int,
+    block_rank: int,
+    world_size: int,
+) -> int:
+    """Return the valid prefix length in one globally ordered ring K/V block."""
+    if valid_kv_length is None:
+        return block_size
+    if isinstance(valid_kv_length, bool) or not isinstance(valid_kv_length, int):
+        raise ValueError("valid_kv_length must be a Python integer")
+    total_length = block_size * world_size
+    if not 0 < valid_kv_length <= total_length:
+        raise ValueError(
+            "valid_kv_length must be within the global ring K/V sequence, "
+            f"got {valid_kv_length} for length {total_length}"
+        )
+    block_start = block_rank * block_size
+    return max(0, min(block_size, valid_kv_length - block_start))
 
 
 def _normalize_lse(block_lse: torch.Tensor, block_out: torch.Tensor, lse_layout: LseLayout) -> torch.Tensor:
diff --git a/vllm_omni/diffusion/attention/backends/ring_flash_attn.py b/vllm_omni/diffusion/attention/backends/ring_flash_attn.py
index 1fce4f1b4..87c3b9e3d 100644
--- a/vllm_omni/diffusion/attention/backends/ring_flash_attn.py
+++ b/vllm_omni/diffusion/attention/backends/ring_flash_attn.py
@@ -1,4 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 # Copyright (c) 2024, Jiarui Fang.
 # Adapted from https://github.com/feifeibear/long-context-attention
 
@@ -6,7 +7,10 @@
 import torch
 
 from vllm_omni.diffusion.attention.backends.ring.ring_selector import AttnType, select_flash_attn_impl
-from vllm_omni.diffusion.attention.backends.ring.ring_utils import update_out_and_lse
+from vllm_omni.diffusion.attention.backends.ring.ring_utils import (
+    ring_kv_block_valid_length,
+    update_out_and_lse,
+)
 from vllm_omni.diffusion.distributed.comm import RingComm
 
 
@@ -27,6 +31,7 @@ def ring_flash_attn_forward(
     joint_tensor_key=None,
     joint_tensor_value=None,
     joint_strategy="front",
+    valid_kv_length: int | None = None,
 ):
     # Validate causal + joint_strategy combination
     # When causal=True and joint_strategy="rear", the causal mask would incorrectly
@@ -42,6 +47,21 @@ def ring_flash_attn_forward(
             "from seeing the joint tokens."
         )
 
+    # Trimming the circulated K/V blocks changes their length while the query
+    # block keeps the full padded length. Flash-Attention aligns a causal mask
+    # to the bottom-right of a rectangular (seqlen_q, seqlen_k) tile, so a
+    # trimmed block would shift the diagonal and let queries attend to the
+    # wrong key positions -- silently, with no shape error. The two are
+    # therefore an unsupported combination rather than a slow path: the caller
+    # must either drop the padding before the ring or run non-causal.
+    if causal and valid_kv_length is not None:
+        raise ValueError(
+            "valid_kv_length is not supported with causal=True in Ring Attention. "
+            "Trimming a circulated K/V block shortens seqlen_k while seqlen_q keeps "
+            "the padded length, and the causal diagonal is bottom-right aligned, so "
+            "the mask would silently shift. Unpad before the ring, or use causal=False."
+        )
+
     comm = RingComm(process_group)
 
     out = None
@@ -66,8 +86,15 @@ def ring_flash_attn_forward(
             comm.commit()
 
         if not causal or step <= comm.rank:
-            step_k = k
-            step_v = v
+            block_rank = (comm.rank - step) % comm.world_size
+            block_valid_length = ring_kv_block_valid_length(
+                valid_kv_length,
+                k.shape[1],
+                block_rank,
+                comm.world_size,
+            )
+            step_k = k[:, :block_valid_length]
+            step_v = v[:, :block_valid_length]
             if step == 0 and joint_tensor_key is not None:
                 if joint_strategy == "front":
                     step_k = torch.cat([joint_tensor_key, step_k], dim=1)
@@ -76,27 +103,28 @@ def ring_flash_attn_forward(
                     step_k = torch.cat([step_k, joint_tensor_key], dim=1)
                     step_v = torch.cat([step_v, joint_tensor_value], dim=1)
 
-            fn = select_flash_attn_impl(attn_type, stage="fwd-only", attn_processor=attn_processor)
-            block_out, block_lse = fn(
-                q,
-                step_k,
-                step_v,
-                dropout_p=dropout_p,
-                softmax_scale=softmax_scale,
-                causal=causal and step == 0,
-                window_size=window_size,
-                softcap=softcap,
-                alibi_slopes=alibi_slopes,
-                return_softmax=True and dropout_p > 0,
-            )
+            if step_k.shape[1] > 0:
+                fn = select_flash_attn_impl(attn_type, stage="fwd-only", attn_processor=attn_processor)
+                block_out, block_lse = fn(
+                    q,
+                    step_k,
+                    step_v,
+                    dropout_p=dropout_p,
+                    softmax_scale=softmax_scale,
+                    causal=causal and step == 0,
+                    window_size=window_size,
+                    softcap=softcap,
+                    alibi_slopes=alibi_slopes,
+                    return_softmax=True and dropout_p > 0,
+                )
 
-            # Ensure block_out is contiguous if needed, though usually it is from FA
+                # Ensure block_out is contiguous if needed, though usually it is from FA
 
-            if attn_type == AttnType.SPARSE_SAGE:
-                out, lse = block_out, block_lse
-            else:
-                # Ring kernel wrappers canonicalize LSE to (B, H, S).
-                out, lse = update_out_and_lse(out, lse, block_out, block_lse, lse_layout="bhs")
+                if attn_type == AttnType.SPARSE_SAGE:
+                    out, lse = block_out, block_lse
+                else:
+                    # Ring kernel wrappers canonicalize LSE to (B, H, S).
+                    out, lse = update_out_and_lse(out, lse, block_out, block_lse, lse_layout="bhs")
 
         if step + 1 != comm.world_size:
             comm.wait()
@@ -132,6 +160,7 @@ class RingFlashAttnFunc(torch.autograd.Function):
         joint_tensor_key=None,
         joint_tensor_value=None,
         joint_strategy="front",
+        valid_kv_length: int | None = None,
     ):
         if softmax_scale is None:
             softmax_scale = q.shape[-1] ** (-0.5)
@@ -158,6 +187,7 @@ class RingFlashAttnFunc(torch.autograd.Function):
             joint_tensor_key=joint_tensor_key,
             joint_tensor_value=joint_tensor_value,
             joint_strategy=joint_strategy,
+            valid_kv_length=valid_kv_length,
         )
         return out if not return_softmax else (out, softmax_lse, None)
 
@@ -193,6 +223,7 @@ def ring_flash_attn_qkvpacked_func(
         None,  # joint_tensor_key
         None,  # joint_tensor_value
         "front",  # joint_strategy
+        None,  # valid_kv_length
     )
 
 
@@ -228,6 +259,7 @@ def ring_flash_attn_kvpacked_func(
         None,  # joint_tensor_key
         None,  # joint_tensor_value
         "front",  # joint_strategy
+        None,  # valid_kv_length
     )
 
 
@@ -249,6 +281,7 @@ def ring_flash_attn_func(
     joint_tensor_key=None,
     joint_tensor_value=None,
     joint_strategy="front",
+    valid_kv_length: int | None = None,
 ) -> torch.Tensor | tuple[torch.Tensor, torch.Tensor, None]:
     """Ring Attention forward pass using Flash Attention backend.
 
@@ -290,6 +323,8 @@ def ring_flash_attn_func(
             Defaults to None.
         joint_strategy (str): Concatenation strategy ("front" or "back").
             Defaults to "front".
+        valid_kv_length (int | None): Length of the contiguous valid prefix in
+            the global ring K/V sequence. Defaults to the full sequence.
 
     Returns:
         Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor, None]]:
@@ -314,4 +349,5 @@ def ring_flash_attn_func(
         joint_tensor_key,
         joint_tensor_value,
         joint_strategy,
+        valid_kv_length,
     )
diff --git a/vllm_omni/diffusion/attention/backends/ring_pytorch_attn.py b/vllm_omni/diffusion/attention/backends/ring_pytorch_attn.py
index 7ab60b784..65f5d8ad7 100644
--- a/vllm_omni/diffusion/attention/backends/ring_pytorch_attn.py
+++ b/vllm_omni/diffusion/attention/backends/ring_pytorch_attn.py
@@ -1,4 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 # Copyright (c) 2024, Jiarui Fang.
 # Adapted from https://github.com/feifeibear/long-context-attention
 
@@ -10,7 +11,10 @@ import torch
 from vllm.logger import init_logger
 
 from vllm_omni.diffusion.attention.backends.ring.ring_kernels import pytorch_attn_forward
-from vllm_omni.diffusion.attention.backends.ring.ring_utils import update_out_and_lse
+from vllm_omni.diffusion.attention.backends.ring.ring_utils import (
+    ring_kv_block_valid_length,
+    update_out_and_lse,
+)
 from vllm_omni.diffusion.distributed.comm import RingComm
 
 logger = init_logger(__name__)
@@ -33,6 +37,7 @@ def ring_pytorch_attn_func(
     joint_tensor_key=None,
     joint_tensor_value=None,
     joint_strategy="front",
+    valid_kv_length: int | None = None,
 ):
     return RingAttentionFunc.apply(
         group,
@@ -45,6 +50,7 @@ def ring_pytorch_attn_func(
         joint_tensor_key,
         joint_tensor_value,
         joint_strategy,
+        valid_kv_length,
     )
 
 
@@ -64,6 +70,7 @@ class RingAttentionFunc(torch.autograd.Function):
         joint_tensor_key=None,
         joint_tensor_value=None,
         joint_strategy="front",
+        valid_kv_length: int | None = None,
     ):
         # Validate causal + joint_strategy combination
         # When causal=True and joint_strategy="rear", the causal mask would incorrectly
@@ -79,6 +86,22 @@ class RingAttentionFunc(torch.autograd.Function):
                 "from seeing the joint tokens."
             )
 
+        # Trimming the circulated K/V blocks changes their length while the
+        # query block keeps the full padded length. A causal SDPA mask over a
+        # rectangular (seqlen_q, seqlen_k) tile is aligned to the bottom right,
+        # so a trimmed block would shift the diagonal and let queries attend to
+        # the wrong key positions -- silently, with no shape error. The two are
+        # therefore an unsupported combination rather than a slow path: the
+        # caller must either drop the padding before the ring or run
+        # non-causal.
+        if is_causal and valid_kv_length is not None:
+            raise ValueError(
+                "valid_kv_length is not supported with causal=True in Ring Attention. "
+                "Trimming a circulated K/V block shortens seqlen_k while seqlen_q keeps "
+                "the padded length, and the causal diagonal is bottom-right aligned, so "
+                "the mask would silently shift. Unpad before the ring, or use causal=False."
+            )
+
         comm = RingComm(group)
         # Ensure tensors are contiguous for P2P communication
         q = q.contiguous()
@@ -98,8 +121,15 @@ class RingAttentionFunc(torch.autograd.Function):
                 comm.commit()
 
             if not is_causal or step <= comm.rank:
-                step_k = k
-                step_v = v
+                block_rank = (comm.rank - step) % comm.world_size
+                block_valid_length = ring_kv_block_valid_length(
+                    valid_kv_length,
+                    k.shape[1],
+                    block_rank,
+                    comm.world_size,
+                )
+                step_k = k[:, :block_valid_length]
+                step_v = v[:, :block_valid_length]
                 if step == 0 and joint_tensor_key is not None:
                     if joint_strategy == "front":
                         step_k = torch.cat([joint_tensor_key, step_k], dim=1)
@@ -108,15 +138,16 @@ class RingAttentionFunc(torch.autograd.Function):
                         step_k = torch.cat([step_k, joint_tensor_key], dim=1)
                         step_v = torch.cat([step_v, joint_tensor_value], dim=1)
 
-                block_out, block_lse = pytorch_attn_forward(
-                    q,
-                    step_k,
-                    step_v,
-                    softmax_scale=sm_scale,
-                    causal=is_causal and step == 0,
-                    op_type=op_type,
-                )
-                out, lse = update_out_and_lse(out, lse, block_out, block_lse, lse_layout="bhs")
+                if step_k.shape[1] > 0:
+                    block_out, block_lse = pytorch_attn_forward(
+                        q,
+                        step_k,
+                        step_v,
+                        softmax_scale=sm_scale,
+                        causal=is_causal and step == 0,
+                        op_type=op_type,
+                    )
+                    out, lse = update_out_and_lse(out, lse, block_out, block_lse, lse_layout="bhs")
 
             if step + 1 != comm.world_size:
                 comm.wait()
diff --git a/vllm_omni/diffusion/attention/layer.py b/vllm_omni/diffusion/attention/layer.py
index 4b8ca8f49..0ad41e80f 100644
--- a/vllm_omni/diffusion/attention/layer.py
+++ b/vllm_omni/diffusion/attention/layer.py
@@ -7,7 +7,9 @@
 # https://github.com/feifeibear/long-context-attention/blob/main/yunchang/attention/layer.py
 
 
+from collections.abc import Mapping
 from dataclasses import replace
+from typing import cast
 
 import torch
 import torch.nn as nn
@@ -16,7 +18,7 @@ from vllm.logger import init_logger
 from vllm.model_executor.models.utils import extract_layer_index
 from vllm.v1.kv_cache_interface import FullAttentionSpec, KVCacheSpec
 
-from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata
+from vllm_omni.diffusion.attention.backends.abstract import AttentionBackend, AttentionImpl, AttentionMetadata
 from vllm_omni.diffusion.attention.backends.sdpa import SDPABackend
 from vllm_omni.diffusion.attention.parallel import build_parallel_attention_strategy
 from vllm_omni.diffusion.attention.parallel.base import NoParallelAttention
@@ -81,6 +83,12 @@ class Attention(nn.Module):
         # varlen attention with learned sink logits). The shared Attention
         # layer still owns parallel dispatch and compile boundaries.
         custom_attention: nn.Module | None = None,
+        # Preserve dense FP32 inference for models opting into CUDA auto fallback.
+        allow_fp32_fallback: bool = False,
+        # Model-owned implementation subclasses, keyed by backend name.
+        # Keep the platform-selected backend and its capabilities unchanged.
+        # Each override must preserve the selected implementation's contract.
+        impl_overrides: Mapping[str, type[AttentionImpl]] | None = None,
     ):
         super().__init__()
 
@@ -179,8 +187,18 @@ class Attention(nn.Module):
                 self.backend_pref = attn_backend_cls.get_name()
                 logger.debug("Attention(role=%s) → platform default (%s)", role, self.backend_pref)
 
-            self.attn_backend = attn_backend_cls
+            self.attn_backend: type[AttentionBackend] | None = attn_backend_cls
             self.attn_impl_cls = self.attn_backend.get_impl_cls()
+            if impl_overrides is not None:
+                override = impl_overrides.get(attn_backend_cls.get_name())
+                if override is not None:
+                    if not issubclass(override, self.attn_impl_cls):
+                        raise TypeError(
+                            f"Attention implementation override {override.__qualname__} must subclass "
+                            f"the selected implementation {self.attn_impl_cls.__qualname__} "
+                            f"for backend {attn_backend_cls.__qualname__}"
+                        )
+                    self.attn_impl_cls = override
             self.attention = self.attn_impl_cls(
                 num_heads=num_heads,
                 head_size=head_size,
@@ -193,9 +211,9 @@ class Attention(nn.Module):
                 role=role,
                 backend_explicit=self.backend_explicit,
             )
-            # Some model-specific paths call this helper directly. The main backend
-            # dispatch below never switches to it implicitly.
-            self.sdpa_fallback = SDPABackend.get_impl_cls()(
+            # Compatibility kernels run inside shared dispatch, between the
+            # parallel strategy's input preparation and output restoration.
+            self.sdpa_fallback: AttentionImpl | None = SDPABackend.get_impl_cls()(
                 num_heads=num_heads,
                 head_size=head_size,
                 softmax_scale=softmax_scale,
@@ -221,6 +239,7 @@ class Attention(nn.Module):
         self.use_sync = use_sync
         self.causal = causal
         self.skip_sequence_parallel = skip_sequence_parallel
+        self.allow_fp32_fallback = allow_fp32_fallback
 
         self.use_ring = False
         self.ring_pg = None
@@ -296,12 +315,13 @@ class Attention(nn.Module):
     def _init_kv_cache_quantization(self, config) -> None:
         if config is None or self._has_custom_attention:
             return
+        assert self.attn_backend is not None
         dtype = getattr(config, "diffusion_kv_cache_dtype", None)
         if dtype == "auto":
             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 "
@@ -318,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:
@@ -332,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(
@@ -397,6 +422,7 @@ class Attention(nn.Module):
             )
         use_paged_attention = paged_adapter is not None and self.paged_kv_cache_role is not None
         if use_paged_attention and not getattr(self.attn_backend, "supports_paged_kv", False):
+            assert self.attn_backend is not None
             raise NotImplementedError(
                 f"Diffusion paged KV requires an Omni backend with paged support; "
                 f"selected {self.attn_backend.get_name()}"
@@ -493,29 +519,49 @@ class Attention(nn.Module):
 
     def _run_local_attention(self, query, key, value, attn_metadata):
         if self._has_custom_attention:
-            return self.attention(query, key, value, attn_metadata)
+            return cast(nn.Module, self.attention)(query, key, value, attn_metadata)
 
         self._assert_metadata_compatible(attn_metadata)
 
+        if (
+            self.allow_fp32_fallback
+            and query.is_cuda
+            and query.dtype == torch.float32
+            and query.ndim == 4
+            and not self.backend_explicit
+            and cast(type[AttentionBackend], self.attn_backend).get_name() == "FLASH_ATTN"
+            and (
+                attn_metadata is None
+                or (
+                    attn_metadata.full_attn_spans is None
+                    and attn_metadata.query_ranges is None
+                    and attn_metadata.video_layout is None
+                    and attn_metadata.packed_padding is None
+                    and not attn_metadata.extra
+                )
+            )
+        ):
+            logger.warning_once("Using SDPA for this layer's FP32 input with automatic CUDA FlashAttention selection.")
+            return cast(AttentionImpl, self.sdpa_fallback).forward(query, key, value, attn_metadata)
+
         in_kv_memory_profile = is_forward_context_available() and get_forward_context().in_diffusion_kv_memory_profile
         # The startup KV-capacity profile needs tensor shapes, not a paged
         # attention result. If dense FLASH_ATTN deps are absent (NPU MindIE-SD
         # or CUDA CuTe FA4), SDPA provides that profile forward. Formal paged
         # requests never use this branch because their Worker adapter is active.
-        # Do not silently remap float32 (or other dtypes) to SDPA: a
-        # user-explicit backend must run or raise.
+        # A user-explicit backend must run or raise.
         if (
             self._scheduler_paged_kv
             and self.paged_kv_cache_role is not None
             and in_kv_memory_profile
-            and self.attn_backend.get_name() == "FLASH_ATTN"
+            and cast(type[AttentionBackend], self.attn_backend).get_name() == "FLASH_ATTN"
             and not current_omni_platform.supports_diffusion_dense_flash_attention()
         ):
             logger.warning_once(
                 "The startup KV memory profile is using SDPA because dense FLASH_ATTN is unavailable. "
                 "Formal paged requests still use the platform-native paged attention backend."
             )
-            return self.sdpa_fallback.forward(query, key, value, attn_metadata)
+            return cast(AttentionImpl, self.sdpa_fallback).forward(query, key, value, attn_metadata)
 
         return self.attention.forward(query, key, value, attn_metadata)
 
diff --git a/vllm_omni/diffusion/attention/ops/block_sparse.py b/vllm_omni/diffusion/attention/ops/block_sparse.py
new file mode 100644
index 000000000..aeec14699
--- /dev/null
+++ b/vllm_omni/diffusion/attention/ops/block_sparse.py
@@ -0,0 +1,115 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Shared pooling, routing and provider calls for explicit block-sparse attention."""
+
+import os
+
+import torch
+from vllm.logger import init_logger
+
+logger = init_logger(__name__)
+
+
+if not hasattr(torch.ops.vllm_omni, "fastvideo_block_sparse_attn_bshd"):
+
+    @torch.library.custom_op("vllm_omni::fastvideo_block_sparse_attn_bshd", mutates_args=())
+    def fastvideo_block_sparse_attn_bshd(
+        query: torch.Tensor,
+        key: torch.Tensor,
+        value: torch.Tensor,
+        block_map: torch.Tensor,
+        variable_block_sizes: torch.Tensor,
+        logical_blocks: int,
+    ) -> torch.Tensor:
+        """Run explicit block-sparse attention on BSHD tensors in 64-row blocks.
+
+        Inputs and the block map may include transport-only blocks after
+        ``logical_blocks``. The Triton provider sees only logical blocks and
+        the wrapper restores the original row count. Native provider selection
+        and its supported-input checks remain owned by FastVideo.
+        """
+        q = query.transpose(1, 2).contiguous()
+        k = key.transpose(1, 2).contiguous()
+        v = value.transpose(1, 2).contiguous()
+
+        # Prefer the explicitly selected native provider when it supports
+        # these tensors; retain the existing Triton provider otherwise.
+        if os.environ.get("FASTVIDEO_VSA_SM100A", "0") == "1":
+            try:
+                from fastvideo_kernel import block_sparse_attn_sm100a
+                from fastvideo_kernel.triton_kernels.index import map_to_index
+
+                if block_sparse_attn_sm100a.is_supported(q, variable_block_sizes):
+                    q2k_idx, q2k_num = map_to_index(block_map)
+                    out, _ = block_sparse_attn_sm100a.block_sparse_attn_sm100a(
+                        q,
+                        k,
+                        v,
+                        q2k_idx.to(torch.int32).contiguous(),
+                        q2k_num.to(torch.int32).contiguous(),
+                        variable_block_sizes.to(torch.int32).contiguous(),
+                        need_lse=False,
+                    )
+                    return out.transpose(1, 2).contiguous()
+            except torch.AcceleratorError:
+                # A device fault can poison the context; do not launch another kernel.
+                raise
+            except (ImportError, RuntimeError) as exc:
+                logger.warning_once(
+                    "FASTVIDEO_VSA_SM100A=1 requested but the native Blackwell forward is "
+                    "unavailable (%s); using the Triton block-sparse route instead.",
+                    exc,
+                )
+
+        from fastvideo_kernel.block_sparse_attn import block_sparse_attn
+
+        logical_len = logical_blocks * 64
+        out, _ = block_sparse_attn(
+            q[:, :, :logical_len].contiguous(),
+            k[:, :, :logical_len].contiguous(),
+            v[:, :, :logical_len].contiguous(),
+            block_map[..., :logical_blocks, :logical_blocks].contiguous(),
+            variable_block_sizes[:logical_blocks].to(torch.int32).contiguous(),
+        )
+        out = out.transpose(1, 2).contiguous()
+        if out.shape[1] != query.shape[1]:
+            out = torch.nn.functional.pad(out, (0, 0, 0, 0, 0, query.shape[1] - out.shape[1]))
+        return out
+
+    @fastvideo_block_sparse_attn_bshd.register_fake
+    def _(query, key, value, block_map, variable_block_sizes, logical_blocks):
+        del key, value, block_map, variable_block_sizes, logical_blocks
+        return torch.empty_like(query)
+
+
+fastvideo_block_sparse_attn_bshd = torch.ops.vllm_omni.fastvideo_block_sparse_attn_bshd
+
+
+def mean_pool_tiles(x: torch.Tensor, sizes: torch.Tensor, block_size: int) -> torch.Tensor:
+    """Mean-pool zero-padded BSHD tiles with FP32 accumulation.
+
+    ``sizes`` gives the number of valid rows in each tile.
+    """
+    batch, seq_len, heads, dim = x.shape
+    blocks = seq_len // block_size
+    pooled = x.view(batch, blocks, block_size, heads, dim).sum(dim=2, dtype=torch.float32)
+    pooled = pooled / sizes.view(1, -1, 1, 1).clamp_min(1)
+    return pooled.permute(0, 2, 1, 3)
+
+
+def build_prefix_dense_block_map(
+    scores: torch.Tensor,
+    num_prefix_blocks: int,
+    num_sparse_blocks: int,
+    topk: int,
+) -> torch.Tensor:
+    """Keep prefix queries/keys dense and select top-k non-prefix keys per row."""
+    keep_sparse = min(topk, num_sparse_blocks)
+    if keep_sparse == num_sparse_blocks:
+        return torch.ones_like(scores, dtype=torch.bool)
+    block_map = torch.zeros_like(scores, dtype=torch.bool)
+    indices = scores[..., num_prefix_blocks:].topk(keep_sparse, dim=-1).indices + num_prefix_blocks
+    block_map.scatter_(-1, indices, True)
+    block_map[..., :num_prefix_blocks] = True
+    block_map[:, :, :num_prefix_blocks, :] = True
+    return block_map
diff --git a/vllm_omni/diffusion/attention/parallel/ring.py b/vllm_omni/diffusion/attention/parallel/ring.py
index d71359ae7..1eb811636 100644
--- a/vllm_omni/diffusion/attention/parallel/ring.py
+++ b/vllm_omni/diffusion/attention/parallel/ring.py
@@ -156,9 +156,11 @@ class RingParallelAttention:
         # Extract joint tensors
         joint_key, joint_value = None, None
         joint_strategy = "front"
+        valid_kv_length = None
         if attn_metadata is not None:
             joint_key = attn_metadata.joint_key
             joint_value = attn_metadata.joint_value
+            valid_kv_length = attn_metadata.extra.get("valid_kv_length")
             if attn_metadata.joint_strategy is not None:
                 joint_strategy = attn_metadata.joint_strategy
 
@@ -176,6 +178,7 @@ class RingParallelAttention:
                 joint_tensor_key=joint_key,
                 joint_tensor_value=joint_value,
                 joint_strategy=joint_strategy,
+                valid_kv_length=valid_kv_length,
             )
 
         # Ring only implements local Flash/AITER and SDPA kernels. HuggingFace
@@ -261,4 +264,5 @@ class RingParallelAttention:
             joint_tensor_key=joint_key,
             joint_tensor_value=joint_value,
             joint_strategy=joint_strategy,
+            valid_kv_length=valid_kv_length,
         )
diff --git a/vllm_omni/diffusion/cache/seacache/__init__.py b/vllm_omni/diffusion/cache/seacache/__init__.py
new file mode 100644
index 000000000..2821c4de0
--- /dev/null
+++ b/vllm_omni/diffusion/cache/seacache/__init__.py
@@ -0,0 +1,18 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from vllm_omni.diffusion.cache.seacache.backend import SeaCacheBackend
+from vllm_omni.diffusion.cache.seacache.config import SeaCacheConfig
+from vllm_omni.diffusion.cache.seacache.hook import (
+    SeaCacheRootHook,
+    apply_sea_cache_hook,
+)
+from vllm_omni.diffusion.cache.seacache.state import SeaCacheState
+
+__all__ = [
+    "SeaCacheBackend",
+    "SeaCacheConfig",
+    "SeaCacheRootHook",
+    "SeaCacheState",
+    "apply_sea_cache_hook",
+]
diff --git a/vllm_omni/diffusion/cache/seacache/backend.py b/vllm_omni/diffusion/cache/seacache/backend.py
new file mode 100644
index 000000000..e5e513a73
--- /dev/null
+++ b/vllm_omni/diffusion/cache/seacache/backend.py
@@ -0,0 +1,100 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from __future__ import annotations
+
+from typing import Any
+
+from vllm.logger import init_logger
+
+from vllm_omni.diffusion.cache.base import CacheBackend
+from vllm_omni.diffusion.cache.seacache.config import SeaCacheConfig
+from vllm_omni.diffusion.cache.seacache.hook import (
+    SeaCacheRootHook,
+    apply_sea_cache_hook,
+)
+from vllm_omni.diffusion.data import DiffusionCacheConfig
+
+logger = init_logger(__name__)
+
+
+def enable_cosmos3_seacache(
+    pipeline: Any,
+    config: DiffusionCacheConfig,
+) -> SeaCacheRootHook:
+    transformer = getattr(pipeline, "transformer", None)
+    if transformer is None:
+        raise ValueError("SeaCache requires a pipeline with a transformer")
+
+    sea_config = SeaCacheConfig(
+        threshold=config.sea_threshold,
+        residual_order=config.sea_residual_order,
+        max_consecutive_cached=config.sea_max_consecutive_cached,
+        power_exp=config.sea_power_exp,
+    )
+    hook = apply_sea_cache_hook(
+        transformer,
+        sea_config,
+        current_step_callback=lambda: getattr(pipeline, "current_step_index", None),
+        current_sigma_callback=lambda: getattr(pipeline, "current_sigma", None),
+        num_inference_steps_callback=lambda: getattr(
+            pipeline,
+            "num_timesteps",
+            None,
+        ),
+    )
+    logger.info(
+        "SeaCache enabled for %s (threshold=%s, residual_order=%d, max_consecutive_cached=%d, power_exp=%s)",
+        pipeline.__class__.__name__,
+        sea_config.threshold,
+        sea_config.residual_order,
+        sea_config.max_consecutive_cached,
+        sea_config.power_exp,
+    )
+    return hook
+
+
+CUSTOM_SEACACHE_ENABLERS = {
+    "Cosmos3OmniDiffusersPipeline": enable_cosmos3_seacache,
+    "Cosmos3OmniPipeline": enable_cosmos3_seacache,
+}
+
+
+class SeaCacheBackend(CacheBackend):
+    """Backend for spectral-evolution-aware diffusion caching."""
+
+    def __init__(self, config: DiffusionCacheConfig):
+        super().__init__(config)
+        self._transformer_id: int | None = None
+
+    def enable(self, pipeline: Any) -> None:
+        pipeline_type = pipeline.__class__.__name__
+        enabler = CUSTOM_SEACACHE_ENABLERS.get(pipeline_type)
+        if enabler is None:
+            raise ValueError(f"SeaCache does not support pipeline type {pipeline_type}")
+        hook = enabler(pipeline, self.config)
+        self._transformer_id = id(pipeline.transformer)
+        self.enabled = True
+        pipeline._cache_context_factory = hook.cache_context
+
+    def refresh(
+        self,
+        pipeline: Any,
+        num_inference_steps: int,
+        verbose: bool = True,
+    ) -> None:
+        del num_inference_steps
+        transformer = getattr(pipeline, "transformer", None)
+        if transformer is None:
+            raise ValueError("SeaCache requires a pipeline with a transformer")
+        if not self.enabled or self._transformer_id != id(transformer):
+            self.enable(pipeline)
+
+        registry = getattr(transformer, "_hook_registry", None)
+        hook = registry.get_hook(SeaCacheRootHook._HOOK_NAME) if registry is not None else None
+        if not isinstance(hook, SeaCacheRootHook):
+            raise RuntimeError("SeaCache hook is not installed on the pipeline transformer")
+        hook.refresh(transformer)
+        pipeline._cache_context_factory = hook.cache_context
+        if verbose:
+            logger.debug("SeaCache state refreshed")
diff --git a/vllm_omni/diffusion/cache/seacache/config.py b/vllm_omni/diffusion/cache/seacache/config.py
new file mode 100644
index 000000000..501d4653e
--- /dev/null
+++ b/vllm_omni/diffusion/cache/seacache/config.py
@@ -0,0 +1,36 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class SeaCacheConfig:
+    """Configuration for SeaCache.
+
+    Defaults are tuned for Cosmos3 and may require adjustment for other models.
+    """
+
+    threshold: float = 0.25
+    residual_order: int = 1
+    max_consecutive_cached: int = 2
+    power_exp: float = 3.0
+
+    def __post_init__(self) -> None:
+        if not math.isfinite(self.threshold) or self.threshold < 0:
+            raise ValueError(f"threshold must be finite and non-negative, got {self.threshold}")
+        if isinstance(self.residual_order, bool) or not isinstance(self.residual_order, int) or self.residual_order < 0:
+            raise ValueError(f"residual_order must be a non-negative integer, got {self.residual_order!r}")
+        if (
+            isinstance(self.max_consecutive_cached, bool)
+            or not isinstance(self.max_consecutive_cached, int)
+            or self.max_consecutive_cached < 0
+        ):
+            raise ValueError(
+                f"max_consecutive_cached must be a non-negative integer, got {self.max_consecutive_cached!r}"
+            )
+        if not math.isfinite(self.power_exp) or self.power_exp <= 0:
+            raise ValueError(f"power_exp must be finite and positive, got {self.power_exp}")
diff --git a/vllm_omni/diffusion/cache/seacache/hook.py b/vllm_omni/diffusion/cache/seacache/hook.py
new file mode 100644
index 000000000..3fac58c09
--- /dev/null
+++ b/vllm_omni/diffusion/cache/seacache/hook.py
@@ -0,0 +1,397 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from __future__ import annotations
+
+import math
+from collections.abc import Callable, Iterator
+from contextlib import contextmanager
+from typing import Any
+
+import torch
+from vllm.logger import init_logger
+
+from vllm_omni.diffusion.cache.seacache.config import SeaCacheConfig
+from vllm_omni.diffusion.cache.seacache.sea_filter import (
+    apply_sea_filter,
+    extrapolate_residual,
+    indicator_distance,
+)
+from vllm_omni.diffusion.cache.seacache.state import SeaCacheState
+from vllm_omni.diffusion.cache.teacache.extractors import CacheContext, get_extractor
+from vllm_omni.diffusion.hooks import HookRegistry, ModelHook, StateManager
+
+logger = init_logger(__name__)
+
+
+def _is_parameter_sharded(module: torch.nn.Module) -> bool:
+    """Detect parameter-sharding runtimes whose collectives cannot be skipped."""
+    for submodule in module.modules():
+        module_type = type(submodule)
+        if callable(getattr(submodule, "_get_fsdp_state", None)):
+            return True
+        if module_type.__name__ == "FullyShardedDataParallel" and module_type.__module__.startswith(
+            "torch.distributed.fsdp"
+        ):
+            return True
+        for parameter in submodule.parameters(recurse=False):
+            parameter_type = type(parameter)
+            if (
+                parameter_type.__name__ == "FlatParameter"
+                and parameter_type.__module__.startswith("torch.distributed.fsdp")
+            ) or (
+                parameter_type.__name__ == "DTensor"
+                and parameter_type.__module__.startswith("torch.distributed.tensor")
+            ):
+                return True
+    return False
+
+
+class SeaCacheRootHook(ModelHook):
+    """Drive SeaCache gating and transformer forward control."""
+
+    _HOOK_NAME = "sea_cache"
+
+    def __init__(
+        self,
+        config: SeaCacheConfig,
+        *,
+        current_step_callback: Callable[[], int | torch.Tensor | None] | None = None,
+        current_sigma_callback: Callable[[], float | torch.Tensor | None] | None = None,
+        num_inference_steps_callback: Callable[[], int | torch.Tensor | None] | None = None,
+        extractor_fn: Callable[..., CacheContext] | None = None,
+    ) -> None:
+        super().__init__()
+        self.config = config
+        self.current_step_callback = current_step_callback
+        self.current_sigma_callback = current_sigma_callback
+        self.num_inference_steps_callback = num_inference_steps_callback
+        self.state_manager = StateManager(SeaCacheState)
+        self._warned_messages: set[str] = set()
+        self.full_count = 0
+        self.skip_count = 0
+        self.extractor_fn = extractor_fn
+        self._parameter_sharded = False
+        self._collective_skip_groups: list[torch.distributed.ProcessGroup] = []
+
+    def initialize_hook(self, module: torch.nn.Module) -> torch.nn.Module:
+        if self.extractor_fn is None:
+            self.extractor_fn = get_extractor(type(module))
+        self._parameter_sharded = _is_parameter_sharded(module)
+        seen_groups: set[int] = set()
+        for block in getattr(module, "gen_layers", ()):
+            registry = getattr(block, "_hook_registry", None)
+            dlo_hook = registry.get_hook("distributed_layerwise_offload") if registry is not None else None
+            group = getattr(dlo_hook, "dp_group", None)
+            if group is not None and int(getattr(dlo_hook, "dp_size", 1)) > 1 and id(group) not in seen_groups:
+                seen_groups.add(id(group))
+                self._collective_skip_groups.append(group)
+        return module
+
+    def _warn_once(self, message: str) -> None:
+        if message not in self._warned_messages:
+            logger.warning(message)
+            self._warned_messages.add(message)
+
+    @contextmanager
+    def cache_context(self, name: str) -> Iterator[None]:
+        previous_context = self.state_manager._context
+        self.state_manager.set_context(name)
+        try:
+            yield
+        finally:
+            self.state_manager.set_context(previous_context)
+
+    def _build_indicator(
+        self,
+        vision_items: list[torch.Tensor] | None,
+        sigma: float,
+    ) -> list[torch.Tensor] | None:
+        if not vision_items:
+            return None
+        hidden_states = vision_items[-1]
+        if not isinstance(hidden_states, torch.Tensor) or hidden_states.ndim != 5:
+            return None
+
+        # Controls precede the denoised target in packed vision-token order,
+        # and each vision item is filtered independently.
+        if any(
+            not isinstance(item, torch.Tensor)
+            or item.ndim != 5
+            or item.shape[0] != hidden_states.shape[0]
+            or item.shape[1:] != hidden_states.shape[1:]
+            for item in vision_items
+        ):
+            return None
+
+        indicator = []
+        for batch_index in range(hidden_states.shape[0]):
+            for latent in vision_items:
+                thwc = latent[batch_index].movedim(0, -1)
+                indicator.append(
+                    apply_sea_filter(
+                        thwc,
+                        sigma=sigma,
+                        power_exp=self.config.power_exp,
+                    ).detach()
+                )
+        return indicator or None
+
+    def _resolve_gate(
+        self,
+        state: SeaCacheState,
+        indicator: list[torch.Tensor] | None,
+        step: int,
+        num_inference_steps: int,
+    ) -> bool:
+        if state.last_step is not None and step != state.last_step + 1:
+            state.reset()
+        state.last_step = step
+        max_consecutive = bool(
+            self.config.max_consecutive_cached and state.consecutive_cached >= self.config.max_consecutive_cached
+        )
+        forced_compute = (
+            step < 1
+            or step >= num_inference_steps - 1
+            or max_consecutive
+            or not state.history
+            or indicator is None
+            or state.previous_indicator is None
+        )
+        if forced_compute:
+            state.accumulated_distance = 0.0
+            state.previous_indicator = None if indicator is None else [value.detach() for value in indicator]
+            return True
+
+        assert indicator is not None
+        assert state.previous_indicator is not None
+        distance = indicator_distance(indicator, state.previous_indicator)
+        state.previous_indicator = [value.detach() for value in indicator]
+        if not math.isfinite(distance):
+            state.accumulated_distance = 0.0
+            self._warn_once("SeaCache indicator history changed shape, device, or dtype; running full.")
+            return True
+
+        state.accumulated_distance += distance
+        if state.accumulated_distance < self.config.threshold:
+            return False
+        state.accumulated_distance = 0.0
+        return True
+
+    def _synchronize_compute(self, compute: bool, device: torch.device) -> bool:
+        if not torch.distributed.is_available() or not torch.distributed.is_initialized():
+            return True if self._parameter_sharded else compute
+        decision = torch.tensor(int(compute), dtype=torch.int32, device=device)
+        if self._parameter_sharded:
+            from vllm_omni.diffusion.distributed.parallel_state import (
+                get_fs_group,
+                get_sequence_parallel_world_size,
+                get_sp_group,
+            )
+
+            fs_group = get_fs_group()
+            if fs_group.world_size > 1:
+                torch.distributed.all_reduce(
+                    decision,
+                    op=torch.distributed.ReduceOp.MAX,
+                    group=fs_group.device_group,
+                )
+            if get_sequence_parallel_world_size() > 1:
+                torch.distributed.all_reduce(
+                    decision,
+                    op=torch.distributed.ReduceOp.MAX,
+                    group=get_sp_group().device_group,
+                )
+            return bool(decision.item())
+
+        for group in self._collective_skip_groups:
+            torch.distributed.all_reduce(
+                decision,
+                op=torch.distributed.ReduceOp.MAX,
+                group=group,
+            )
+        from vllm_omni.diffusion.distributed.parallel_state import (
+            get_sequence_parallel_world_size,
+            get_sp_group,
+        )
+
+        if get_sequence_parallel_world_size() > 1:
+            torch.distributed.all_reduce(
+                decision,
+                op=torch.distributed.ReduceOp.MAX,
+                group=get_sp_group().device_group,
+            )
+        return bool(decision.item())
+
+    @torch.compiler.disable
+    def new_forward(
+        self,
+        module: torch.nn.Module,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Any:
+        if self.extractor_fn is None:
+            raise RuntimeError("SeaCache extractor was not initialized")
+        ctx = self.extractor_fn(module, *args, **kwargs)
+
+        if torch.is_grad_enabled():
+            self._warn_once("SeaCache is inference-only; autograd-enabled calls run in full.")
+            return self._run_uncached(ctx)
+        if self.state_manager._current_context is None:
+            self._warn_once("SeaCache requires an explicit cache context; running full.")
+            return self._run_uncached(ctx)
+        callbacks = (
+            self.current_step_callback,
+            self.current_sigma_callback,
+            self.num_inference_steps_callback,
+        )
+        if any(callback is None for callback in callbacks):
+            self._warn_once("SeaCache requires scheduler step, sigma, and step-count callbacks; running full.")
+            return self._run_uncached(ctx)
+        assert self.current_step_callback is not None
+        assert self.current_sigma_callback is not None
+        assert self.num_inference_steps_callback is not None
+
+        try:
+            extra_states = ctx.extra_states or {}
+            vision_items = extra_states.get("sea_cache_latents")
+            if not isinstance(vision_items, list):
+                raise ValueError("extractor did not provide SeaCache vision inputs")
+            noisy_frame_mask = extra_states.get("sea_cache_noisy_frame_mask")
+            conditioning_only = isinstance(noisy_frame_mask, torch.Tensor) and not bool(
+                torch.any(noisy_frame_mask != 0).item()
+            )
+
+            step = self.current_step_callback()
+            sigma = self.current_sigma_callback()
+            num_inference_steps = self.num_inference_steps_callback()
+            if isinstance(step, torch.Tensor):
+                step = step.item()
+            if isinstance(sigma, torch.Tensor):
+                sigma = sigma.item()
+            if isinstance(num_inference_steps, torch.Tensor):
+                num_inference_steps = num_inference_steps.item()
+            if step is None or sigma is None or num_inference_steps is None:
+                raise ValueError("scheduler metadata is unavailable")
+            step = int(step)
+            sigma = float(sigma)
+            num_inference_steps = int(num_inference_steps)
+            if (
+                step < 0
+                or num_inference_steps <= 0
+                or step >= num_inference_steps
+                or not math.isfinite(sigma)
+                or not 0.0 <= sigma <= 1.0
+            ):
+                raise ValueError("expected a valid step index and exact sigma in [0, 1]")
+        except (IndexError, TypeError, ValueError, RuntimeError) as error:
+            self._warn_once(f"SeaCache metadata is invalid; running full: {error}")
+            return self._run_uncached(ctx)
+
+        if conditioning_only:
+            self._warn_once("SeaCache requires noisy vision; conditioning-only calls run in full.")
+            return self._run_uncached(ctx)
+
+        state: SeaCacheState = self.state_manager.get_state()
+        try:
+            indicator = self._build_indicator(vision_items, sigma)
+        except (TypeError, ValueError, RuntimeError) as error:
+            self._warn_once(f"SeaCache could not construct its vision indicator; running full: {error}")
+            indicator = None
+
+        local_compute = self._resolve_gate(state, indicator, step, num_inference_steps)
+        should_compute = self._synchronize_compute(local_compute, ctx.hidden_states.device)
+        if should_compute and not local_compute:
+            state.accumulated_distance = 0.0
+
+        if should_compute:
+            self.full_count += 1
+            output = self._run_full_stack(ctx)
+            result = ctx.postprocess(output)
+            self._record_execution(state, step, ctx.hidden_states, output)
+            return result
+
+        residual = extrapolate_residual(
+            state.history,
+            step,
+            self.config.residual_order,
+        )
+        if residual.device != ctx.hidden_states.device:
+            residual = residual.to(ctx.hidden_states.device)
+        state.consecutive_cached += 1
+        self.skip_count += 1
+
+        can_reuse = (
+            residual.shape == ctx.hidden_states.shape
+            and residual.device == ctx.hidden_states.device
+            and residual.dtype == ctx.hidden_states.dtype
+        )
+        if can_reuse:
+            return ctx.postprocess(ctx.hidden_states + residual)
+
+        output = self._run_full_stack(ctx)
+        result = ctx.postprocess(output)
+        self._record_execution(state, step, ctx.hidden_states, output)
+        return result
+
+    @staticmethod
+    def _run_full_stack(ctx: CacheContext) -> torch.Tensor:
+        outputs = ctx.run_transformer_blocks()
+        if not outputs:
+            raise RuntimeError("Cache extractor returned no transformer outputs")
+        return outputs[0]
+
+    @staticmethod
+    def _run_uncached(ctx: CacheContext) -> Any:
+        return ctx.postprocess(SeaCacheRootHook._run_full_stack(ctx))
+
+    def _record_execution(
+        self,
+        state: SeaCacheState,
+        step: int,
+        execution_input: torch.Tensor,
+        output: torch.Tensor,
+    ) -> None:
+        if (
+            output.shape == execution_input.shape
+            and output.device == execution_input.device
+            and output.dtype == execution_input.dtype
+        ):
+            state.history.append((step, (output - execution_input).detach().clone()))
+            state.history = state.history[-(self.config.residual_order + 1) :]
+            state.consecutive_cached = 0
+            return
+
+        state.history.clear()
+        state.accumulated_distance = 0.0
+        self._warn_once("SeaCache execution boundary returned an incompatible tensor; clearing cache history.")
+
+    def reset_state(self, module: torch.nn.Module) -> torch.nn.Module:
+        self.state_manager.reset()
+        self.full_count = 0
+        self.skip_count = 0
+        return module
+
+    def refresh(self, module: torch.nn.Module) -> None:
+        self.reset_state(module)
+
+
+def apply_sea_cache_hook(
+    module: torch.nn.Module,
+    config: SeaCacheConfig,
+    *,
+    current_step_callback: Callable[[], int | torch.Tensor | None] | None = None,
+    current_sigma_callback: Callable[[], float | torch.Tensor | None] | None = None,
+    num_inference_steps_callback: Callable[[], int | torch.Tensor | None] | None = None,
+    extractor_fn: Callable[..., CacheContext] | None = None,
+) -> SeaCacheRootHook:
+    registry = HookRegistry.get_or_create(module)
+    hook = SeaCacheRootHook(
+        config,
+        current_step_callback=current_step_callback,
+        current_sigma_callback=current_sigma_callback,
+        num_inference_steps_callback=num_inference_steps_callback,
+        extractor_fn=extractor_fn,
+    )
+    registry.register_hook(SeaCacheRootHook._HOOK_NAME, hook)
+    return hook
diff --git a/vllm_omni/diffusion/cache/seacache/sea_filter.py b/vllm_omni/diffusion/cache/seacache/sea_filter.py
new file mode 100644
index 000000000..f68b5c288
--- /dev/null
+++ b/vllm_omni/diffusion/cache/seacache/sea_filter.py
@@ -0,0 +1,93 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from __future__ import annotations
+
+import math
+
+import torch
+
+
+# SeaCache paper: "Spectral-Evolution-Aware Cache for Accelerating Diffusion Models"
+# https://arxiv.org/abs/2602.18993
+def apply_sea_filter(hidden_states: torch.Tensor, sigma: float, power_exp: float = 3.0) -> torch.Tensor:
+    """Apply the separable SEA Wiener filter over ``(T, H, W)``."""
+    original_dtype = hidden_states.dtype
+    hidden_states = hidden_states.contiguous().float()
+    dimensions = (0, 1, 2)
+    spectrum = torch.fft.fftn(hidden_states, dim=dimensions)
+
+    sigma = max(1e-6, min(1.0 - 1e-6, float(sigma)))
+    signal_scale = 1.0 - sigma
+    noise_scale = sigma
+    gain: torch.Tensor | None = None
+    for axis in dimensions:
+        frequencies = torch.fft.fftfreq(
+            hidden_states.shape[axis],
+            device=hidden_states.device,
+            dtype=torch.float32,
+        )
+        clean_power = 1.0 / (frequencies.abs().pow(power_exp) + 1e-16)
+        axis_gain = signal_scale * clean_power / (signal_scale**2 * clean_power + noise_scale**2 + 1e-16)
+        axis_shape = [1] * hidden_states.ndim
+        axis_shape[axis] = axis_gain.shape[0]
+        reshaped_gain = axis_gain.reshape(axis_shape)
+        gain = reshaped_gain if gain is None else gain * reshaped_gain
+
+    assert gain is not None
+    gain = gain / gain.mean()
+    return torch.fft.ifftn(spectrum * gain, dim=dimensions).real.to(original_dtype)
+
+
+def relative_l1_distance(current: torch.Tensor, previous: torch.Tensor, eps: float = 1e-16) -> float:
+    numerator = (current.float() - previous.float()).abs().mean()
+    denominator = previous.float().abs().mean() + eps
+    return float((numerator / denominator).detach().cpu())
+
+
+def indicator_distance(
+    current: list[torch.Tensor] | None,
+    previous: list[torch.Tensor] | None,
+) -> float:
+    """Mean relative-L1 distance, or infinity for incompatible indicators."""
+    if current is None or previous is None or not current or len(current) != len(previous):
+        return float("inf")
+
+    total = 0.0
+    for current_value, previous_value in zip(current, previous, strict=True):
+        if (
+            current_value.shape != previous_value.shape
+            or current_value.device != previous_value.device
+            or current_value.dtype != previous_value.dtype
+        ):
+            return float("inf")
+        total += relative_l1_distance(current_value, previous_value)
+    distance = total / len(current)
+    return distance if math.isfinite(distance) else float("inf")
+
+
+def extrapolate_residual(
+    history: list[tuple[int, torch.Tensor]],
+    step: int,
+    order: int,
+) -> torch.Tensor:
+    """Evaluate a Newton residual polynomial at ``step``."""
+    if not history:
+        raise ValueError("SeaCache residual extrapolation requires non-empty history")
+
+    polynomial_order = max(0, min(order, len(history) - 1))
+    window = history[-(polynomial_order + 1) :]
+    steps = [history_step for history_step, _ in window]
+    coefficients = [residual.clone() for _, residual in window]
+
+    for level in range(1, polynomial_order + 1):
+        for index in range(polynomial_order, level - 1, -1):
+            denominator = steps[index] - steps[index - level]
+            if denominator == 0:
+                return window[-1][1].clone()
+            coefficients[index] = (coefficients[index] - coefficients[index - 1]) / float(denominator)
+
+    result = coefficients[polynomial_order]
+    for index in range(polynomial_order - 1, -1, -1):
+        result = result * float(step - steps[index]) + coefficients[index]
+    return result
diff --git a/vllm_omni/diffusion/cache/seacache/state.py b/vllm_omni/diffusion/cache/seacache/state.py
new file mode 100644
index 000000000..bdf21c1f4
--- /dev/null
+++ b/vllm_omni/diffusion/cache/seacache/state.py
@@ -0,0 +1,26 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+import torch
+
+
+@dataclass(slots=True)
+class SeaCacheState:
+    """Per-cache-context trajectory state."""
+
+    last_step: int | None = None
+    accumulated_distance: float = 0.0
+    previous_indicator: list[torch.Tensor] | None = None
+    history: list[tuple[int, torch.Tensor]] = field(default_factory=list)
+    consecutive_cached: int = 0
+
+    def reset(self) -> None:
+        self.last_step = None
+        self.accumulated_distance = 0.0
+        self.previous_indicator = None
+        self.history.clear()
+        self.consecutive_cached = 0
diff --git a/vllm_omni/diffusion/cache/selector.py b/vllm_omni/diffusion/cache/selector.py
index d58bada6c..79bb86a4c 100644
--- a/vllm_omni/diffusion/cache/selector.py
+++ b/vllm_omni/diffusion/cache/selector.py
@@ -1,8 +1,12 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 from typing import Any
 
 from vllm_omni.diffusion.cache.base import CacheBackend
 from vllm_omni.diffusion.cache.cachedit import CacheDiTBackend
 from vllm_omni.diffusion.cache.magcache import MagCacheBackend
+from vllm_omni.diffusion.cache.seacache import SeaCacheBackend
 from vllm_omni.diffusion.cache.stepcache import StepCacheBackend
 from vllm_omni.diffusion.cache.teacache import TeaCacheBackend
 from vllm_omni.diffusion.data import DiffusionCacheConfig
@@ -15,11 +19,12 @@ def get_cache_backend(cache_backend: str | None, cache_config: Any) -> CacheBack
     - cache_dit: Uses CacheDiTBackend with enable()/refresh() interface
     - tea_cache: Uses TeaCacheBackend with enable()/refresh() interface
     - mag_cache: Uses MagCacheBackend with enable()/refresh() interface
+    - sea_cache: Uses SeaCacheBackend for spectral residual caching
     - step_cache: Uses StepCacheBackend for DreamZero velocity step skip
 
     Args:
         cache_backend: Cache backend name ("cache_dit", "tea_cache",
-            "mag_cache", "step_cache", or None).
+            "mag_cache", "sea_cache", "step_cache", or None).
         cache_config: Cache configuration (dict or DiffusionCacheConfig instance).
 
     Returns:
@@ -40,10 +45,12 @@ def get_cache_backend(cache_backend: str | None, cache_config: Any) -> CacheBack
         return TeaCacheBackend(cache_config)
     elif cache_backend == "mag_cache":
         return MagCacheBackend(cache_config)
+    elif cache_backend == "sea_cache":
+        return SeaCacheBackend(cache_config)
     elif cache_backend in ("step_cache", "stepcache", "step_cache_dit"):
         return StepCacheBackend(cache_config)
     else:
         raise ValueError(
             f"Unsupported cache backend: {cache_backend}. "
-            "Supported: 'cache_dit', 'tea_cache', 'mag_cache', 'step_cache'"
+            "Supported: 'cache_dit', 'tea_cache', 'mag_cache', 'sea_cache', 'step_cache'"
         )
diff --git a/vllm_omni/diffusion/cache/teacache/extractors.py b/vllm_omni/diffusion/cache/teacache/extractors.py
index 7f0242d57..a7539b34a 100644
--- a/vllm_omni/diffusion/cache/teacache/extractors.py
+++ b/vllm_omni/diffusion/cache/teacache/extractors.py
@@ -199,7 +199,7 @@ def extract_qwen_context(
     hidden_states, vid_freqs, txt_freqs = module.image_rope_prepare(hidden_states, img_shapes, txt_seq_lens)
     image_rotary_emb = (vid_freqs, txt_freqs)
 
-    timestep = timestep.to(device=hidden_states.device, dtype=hidden_states.dtype)
+    timestep = torch.as_tensor(timestep, device=hidden_states.device, dtype=hidden_states.dtype)
 
     # Call modulate_index_prepare instead of handling timestep directly.
     # For zero_cond_t=False: timestep unchanged, modulate_index=None.
@@ -618,6 +618,8 @@ def extract_flux2_klein_context(
     # ============================================================================
     dtype = hidden_states.dtype
 
+    if encoder_hidden_states is None:
+        raise ValueError("Flux2Klein requires encoder_hidden_states")
     num_txt_tokens = encoder_hidden_states.shape[1]
 
     timestep = timestep.to(dtype=dtype) * 1000
@@ -1260,7 +1262,7 @@ def extract_minimax_h3_context(
     preprocessing via ``_embed``, cacheable ``blocks`` loop, and
     ``final_layer`` postprocessing with row selection and update masks.
     """
-    from vllm_omni.diffusion.attention.ops.minimax_h3_modulation import indexed_scale_shift_
+    from vllm_omni.diffusion.layers.indexed_modulation import indexed_scale_shift_
     from vllm_omni.diffusion.models.minimax_h3.minimax_h3_transformer import (
         _FORWARD_SUPPORTED_KWARGS,
         MINIMAX_H3_ADALN_MODALITY_NUM,
@@ -1466,6 +1468,77 @@ def extract_minimax_h3_context(
     )
 
 
+def extract_cosmos3_context(
+    module: nn.Module,
+    hidden_states: torch.Tensor,
+    timestep: torch.Tensor,
+    text_ids: torch.Tensor,
+    text_mask: torch.Tensor,
+    video_shape: tuple[int, int, int],
+    fps: float | None = None,
+    action_latents: torch.Tensor | None = None,
+    action_domain_ids: torch.Tensor | None = None,
+    action_noisy_mask: torch.Tensor | None = None,
+    action_start_frame_offset: int = 1,
+    action_fps: float | None = None,
+    sound_latents: torch.Tensor | None = None,
+    noisy_frame_mask: torch.Tensor | None = None,
+    control_latents: list[torch.Tensor] | tuple[torch.Tensor, ...] | torch.Tensor | None = None,
+    control_weights: list[float] | tuple[float, ...] | torch.Tensor | None = None,
+    transfer_share_vision_temporal_positions: bool = True,
+    **kwargs: Any,
+) -> CacheContext:
+    """Build the shared cache execution context for Cosmos3's GEN pathway."""
+    if kwargs:
+        raise TypeError(f"Unexpected Cosmos3 transformer kwargs: {sorted(kwargs)}")
+
+    prep = module._gen_preprocess(
+        hidden_states,
+        timestep,
+        text_ids,
+        text_mask,
+        video_shape,
+        fps=fps,
+        action_latents=action_latents,
+        action_domain_ids=action_domain_ids,
+        action_noisy_mask=action_noisy_mask,
+        action_start_frame_offset=action_start_frame_offset,
+        action_fps=action_fps,
+        sound_latents=sound_latents,
+        noisy_frame_mask=noisy_frame_mask,
+        control_latents=control_latents,
+        control_weights=control_weights,
+        transfer_share_vision_temporal_positions=transfer_share_vision_temporal_positions,
+    )
+
+    def run_transformer_blocks() -> tuple[torch.Tensor, ...]:
+        return (module._run_gen_stack(prep),)
+
+    def postprocess(hidden: torch.Tensor) -> Any:
+        return module._gen_postprocess(hidden, prep)
+
+    if control_latents is None:
+        controls: list[torch.Tensor] = []
+    elif isinstance(control_latents, torch.Tensor):
+        controls = [control_latents]
+    else:
+        controls = list(control_latents)
+
+    return CacheContext(
+        # SeaCache uses the separate inputs in extra_states for its decision.
+        modulated_input=prep.hidden_gen,
+        hidden_states=prep.hidden_gen,
+        encoder_hidden_states=None,
+        temb=prep.time_embed,
+        run_transformer_blocks=run_transformer_blocks,
+        postprocess=postprocess,
+        extra_states={
+            "sea_cache_latents": [*controls, hidden_states],
+            "sea_cache_noisy_frame_mask": noisy_frame_mask,
+        },
+    )
+
+
 # Registry for model-specific extractors
 # Key: Transformer class name
 # Value: extractor function with signature (module, *args, **kwargs) -> CacheContext
@@ -1475,6 +1548,8 @@ def extract_minimax_h3_context(
 EXTRACTOR_REGISTRY: dict[str, Callable] = {
     "QwenImageTransformer2DModel": extract_qwen_context,
     "Bagel": extract_bagel_context,
+    "Cosmos3EdgeVFMTransformer": extract_cosmos3_context,
+    "Cosmos3VFMTransformer": extract_cosmos3_context,
     "ZImageTransformer2DModel": extract_zimage_context,
     "Flux2Klein": extract_flux2_klein_context,
     "StableAudioDiTModel": extract_stable_audio_context,
@@ -1521,16 +1596,15 @@ def register_extractor(transformer_cls_name: str, extractor_fn: Callable) -> Non
     EXTRACTOR_REGISTRY[transformer_cls_name] = extractor_fn
 
 
-def get_extractor(transformer_cls_name: str) -> Callable:
+def get_extractor(transformer_type: str | type) -> Callable:
     """
     Get extractor function for given transformer class.
 
-    This function looks up the extractor based on the exact transformer_cls_name string,
-    which should match the transformer type in the pipeline (i.e., pipeline.transformer.__class__.__name__).
+    String lookups match an exact registered name. Type lookups also check base
+    classes so runtime wrappers such as FSDP retain the underlying model extractor.
 
     Args:
-        transformer_cls_name: Transformer class name (e.g., "QwenImageTransformer2DModel")
-                                Must exactly match a key in EXTRACTOR_REGISTRY.
+        transformer_type: Transformer class name or runtime type.
 
     Returns:
         Extractor function with signature (module, *args, **kwargs) -> CacheContext
@@ -1543,14 +1617,18 @@ def get_extractor(transformer_cls_name: str) -> Callable:
         >>> extractor = get_extractor("QwenImageTransformer2DModel")
         >>> ctx = extractor(transformer, hidden_states, encoder_hidden_states, timestep, ...)
     """
-    # Direct lookup - no substring matching
-    if transformer_cls_name in EXTRACTOR_REGISTRY:
-        return EXTRACTOR_REGISTRY[transformer_cls_name]
+    candidate_names: tuple[str, ...]
+    if isinstance(transformer_type, str):
+        candidate_names = (transformer_type,)
+    else:
+        candidate_names = tuple(candidate.__name__ for candidate in transformer_type.__mro__)
+    for candidate_name in candidate_names:
+        if candidate_name in EXTRACTOR_REGISTRY:
+            return EXTRACTOR_REGISTRY[candidate_name]
 
-    # No match found
     available_types = list(EXTRACTOR_REGISTRY.keys())
     raise ValueError(
-        f"Unknown model type: '{transformer_cls_name}'. "
+        f"Unknown model type: '{transformer_type}'. "
         f"Available types: {available_types}\n"
         f"To add support for a new model, use register_extractor() or add to EXTRACTOR_REGISTRY."
     )
diff --git a/vllm_omni/diffusion/data.py b/vllm_omni/diffusion/data.py
index ddf55d151..c643f5ff8 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
@@ -29,6 +30,7 @@ from vllm_omni.diffusion.diffusion_kv.config import (
     parse_diffusion_kv_cache_mode,
 )
 from vllm_omni.diffusion.lora.manager import LoRABackend
+from vllm_omni.diffusion.media import DiffusionMediaOutput
 from vllm_omni.diffusion.model_metadata import get_diffusion_model_metadata
 from vllm_omni.diffusion.utils.network_utils import is_port_available
 from vllm_omni.errors import client_error_metadata
@@ -43,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,
@@ -99,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.
@@ -161,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:
@@ -540,6 +575,8 @@ class DiffusionCacheConfig:
                     scm_steps_mask_policy, scm_steps_policy
         - MagCache: mag_threshold, mag_max_skip_steps, mag_retention_ratio,
                     mag_ratios, mag_calibrate
+        - SeaCache: sea_threshold, sea_residual_order,
+                    sea_max_consecutive_cached, sea_power_exp
         - step_cache: step_cache_dit_enabled, velocity_sim_thresholds,
                           velocity_skip_countdowns, step_cache_dit_min_history
 
@@ -559,6 +596,12 @@ class DiffusionCacheConfig:
     rel_l1_thresh: float | None = None
     coefficients: list[float] | None = None  # Uses model-specific defaults if None
 
+    # SeaCache parameters [sea_cache only]
+    sea_threshold: float = 0.25
+    sea_residual_order: int = 1
+    sea_max_consecutive_cached: int = 2
+    sea_power_exp: float = 3.0
+
     # MagCache parameters [mag_cache only]
     # Default: 0.24 threshold for accumulated magnitude error
     mag_threshold: float = 0.24
@@ -758,6 +801,15 @@ def uses_diffusers_adapter(od_config: object) -> bool:
     )
 
 
+@dataclass
+class VideoOutputTransportConfig:
+    enable_device_postprocess: bool = False
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.enable_device_postprocess, bool):
+            raise TypeError("enable_device_postprocess must be a bool")
+
+
 @dataclass
 class OmniDiffusionConfig:
     # Model and path configuration (for convenience)
@@ -793,6 +845,7 @@ class OmniDiffusionConfig:
     # Cache backend configuration (NEW)
     cache_backend: str = "none"  # "tea_cache", "deep_cache", etc.
     cache_config: DiffusionCacheConfig | dict[str, Any] = field(default_factory=dict)
+    video_output_transport: VideoOutputTransportConfig = field(default_factory=VideoOutputTransportConfig)
     enable_cache_dit_summary: bool = False
 
     # Prompt-embedding cache. When enabled, ``DiffusionModelRunner`` wraps the
@@ -909,6 +962,7 @@ class OmniDiffusionConfig:
 
     # Parallel weight loading (for faster diffusion model startup)
     enable_multithread_weight_load: bool = True
+    enable_broadcast_weight_load: bool = False
     num_weight_load_threads: int = 4
 
     # Enable sleep mode
@@ -964,6 +1018,7 @@ class OmniDiffusionConfig:
             "transformer": True,
             "vae": True,
             "text_encoder": True,
+            "vae_encoder": True,
         }
     )
     override_transformer_cls_name: str | None = None
@@ -1000,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.
@@ -1171,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)
@@ -1258,6 +1314,13 @@ class OmniDiffusionConfig:
             # If it's neither dict nor DiffusionCacheConfig, convert to empty config
             self.cache_config = DiffusionCacheConfig()
 
+        if self.video_output_transport is None:
+            self.video_output_transport = VideoOutputTransportConfig()
+        elif isinstance(self.video_output_transport, Mapping):
+            self.video_output_transport = VideoOutputTransportConfig(**dict(self.video_output_transport))
+        elif not isinstance(self.video_output_transport, VideoOutputTransportConfig):
+            raise TypeError("video_output_transport must be a VideoOutputTransportConfig or mapping")
+
         # Auto-detect quantization from TransformerConfig if not explicitly set.
         # This covers the case where tf_model_config is passed at construction
         # time. For late (post-construction) assignment, callers should use
@@ -1318,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
@@ -1330,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",
@@ -1420,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,
@@ -1583,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
@@ -1597,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
@@ -1610,6 +1695,18 @@ class OmniDiffusionConfig:
         return cls(**cls.normalize_init_kwargs(kwargs))
 
 
+DIFFUSION_REQUEST_LIFECYCLE_KEY = "_diffusion_request_lifecycle"
+DIFFUSION_REQUEST_STARTED = "started"
+
+
+def is_diffusion_request_started_output(output: Any) -> bool:
+    custom_output = getattr(output, "custom_output", None)
+    return (
+        isinstance(custom_output, dict)
+        and custom_output.get(DIFFUSION_REQUEST_LIFECYCLE_KEY) == DIFFUSION_REQUEST_STARTED
+    )
+
+
 @dataclass
 class DiffusionOutput:
     """
@@ -1618,8 +1715,8 @@ class DiffusionOutput:
 
     output: torch.Tensor | tuple[Any, ...] | dict[str, Any] | None = None
 
-    # Legacy compatibility fields. New pipeline-specific payloads should be
-    # carried by output["payload"] instead.
+    # Legacy compatibility fields. Decoded video uses ``media``; other new
+    # payloads should be carried by output["payload"] instead.
     trajectory_timesteps: torch.Tensor | dict[str, Any] | None = None
     trajectory_latents: torch.Tensor | dict[str, Any] | None = None
     trajectory_log_probs: torch.Tensor | dict[str, Any] | None = None
@@ -1658,7 +1755,21 @@ class DiffusionOutput:
     # mode) and the receiving side must not initialise a stray CUDA context.
     to_cpu: bool = False
 
+    # Internal control-plane event emitted on first scheduler admission.
+    request_started: bool = False
+
+    # Typed video-media contract. Declared last so the pre-existing positional
+    # constructor order (output, trajectory_timesteps, ...) that out-of-tree
+    # pipelines rely on is preserved. Mutually exclusive with ``output``.
+    media: DiffusionMediaOutput | None = None
+
     def __post_init__(self) -> None:
+        if self.media is not None and not isinstance(self.media, DiffusionMediaOutput):
+            raise TypeError(f"media must be DiffusionMediaOutput, got {type(self.media).__name__}")
+        if self.media is not None and self.output is not None:
+            raise ValueError("DiffusionOutput cannot contain both media and legacy output")
+        if self.media is not None and self.post_process_func is not None:
+            raise ValueError("Typed diffusion media cannot carry a model-specific post_process_func")
         if not self.to_cpu:
             return
 
@@ -1674,6 +1785,10 @@ class DiffusionOutput:
             return value
 
         self.output = _maybe_to_cpu(self.output)
+        if self.media is not None:
+            if not self.media.prepared_for_transport:
+                raise ValueError("Diffusion media must be prepared before to_cpu=True")
+            self.media = self.media.to_cpu()
         self.trajectory_timesteps = _maybe_to_cpu(self.trajectory_timesteps)
         self.trajectory_latents = _maybe_to_cpu(self.trajectory_latents)
         self.trajectory_log_probs = _maybe_to_cpu(self.trajectory_log_probs)
diff --git a/vllm_omni/diffusion/diffusion_engine.py b/vllm_omni/diffusion/diffusion_engine.py
index c36ac0459..5e3082f45 100644
--- a/vllm_omni/diffusion/diffusion_engine.py
+++ b/vllm_omni/diffusion/diffusion_engine.py
@@ -26,6 +26,8 @@ from vllm.v1.engine.exceptions import EngineDeadError
 from vllm.v1.kv_cache_interface import KVCacheConfig
 
 from vllm_omni.diffusion.data import (
+    DIFFUSION_REQUEST_LIFECYCLE_KEY,
+    DIFFUSION_REQUEST_STARTED,
     DiffusionOutput,
     DiffusionRequestAbortedError,
     OmniDiffusionConfig,
@@ -47,6 +49,7 @@ from vllm_omni.diffusion.output_formatter import (
     format_empty_diffusion_outputs,
     normalize_diffusion_postprocess_output,
 )
+from vllm_omni.diffusion.postprocess.media import finalize_diffusion_media
 from vllm_omni.diffusion.registry import (
     DiffusionModelRegistry,
     get_diffusion_post_process_func,
@@ -54,7 +57,7 @@ from vllm_omni.diffusion.registry import (
 )
 from vllm_omni.diffusion.request import DUMMY_DIFFUSION_REQUEST_ID, OmniDiffusionRequest
 from vllm_omni.diffusion.sched import BaseScheduler, RequestScheduler, StepScheduler
-from vllm_omni.diffusion.sched.interface import DiffusionRequestStatus
+from vllm_omni.diffusion.sched.interface import DiffusionRequestStatus, DiffusionSchedulerOutput
 from vllm_omni.diffusion.worker.utils import BaseRunnerOutput, BatchRunnerOutput, RunnerOutput
 from vllm_omni.errors import client_error_from_metadata, is_client_error_status
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams, OmniTextPrompt
@@ -532,28 +535,40 @@ class DiffusionEngine:
                     error_type=output.error_type,
                 )
             raise RuntimeError(output.error)
-        logger.debug("Generation completed successfully.")
+        if output.request_started:
+            return format_empty_diffusion_outputs(
+                request,
+                finished=False,
+                custom_output={DIFFUSION_REQUEST_LIFECYCLE_KEY: DIFFUSION_REQUEST_STARTED},
+            )
 
-        if output.output is None:
-            logger.warning("Output is None, returning empty OmniRequestOutput")
-            return format_empty_diffusion_outputs(request, finished=output.finished)
-
-        # When CPU offload is enabled, move output to CPU before
-        # post-processing to avoid device OOM — model weights may still
-        # reside on the device and leave no headroom for intermediates.
-        output_data = output.output
-        if self.od_config.enable_cpu_offload:
-            output_data = _move_tensor_tree_to_cpu(output_data)
-
-        if self.post_process_func is not None:
-            # Some video pipelines need request-level controls during
-            # postprocess (for example worker-side frame interpolation).
-            postprocess_kwargs: dict[str, object] = {}
-            if self._post_process_accepts_sampling_params:
-                postprocess_kwargs["sampling_params"] = request.sampling_params
-            outputs = self.post_process_func(output_data, **postprocess_kwargs)
+        if output.media is not None:
+            if output.output is not None:
+                raise ValueError("DiffusionOutput cannot contain both media and legacy output")
+            media = output.media.to_cpu() if self.od_config.enable_cpu_offload else output.media
+            output_data = media.video.tensor
+            outputs = finalize_diffusion_media(media, sampling_params=request.sampling_params)
         else:
-            outputs = output_data
+            if output.output is None:
+                logger.warning("Output is None, returning empty OmniRequestOutput")
+                return format_empty_diffusion_outputs(request, finished=output.finished)
+
+            # When CPU offload is enabled, move output to CPU before
+            # post-processing to avoid device OOM — model weights may still
+            # reside on the device and leave no headroom for intermediates.
+            output_data = output.output
+            if self.od_config.enable_cpu_offload:
+                output_data = _move_tensor_tree_to_cpu(output_data)
+
+            if self.post_process_func is not None:
+                # Some video pipelines need request-level controls during
+                # postprocess (for example worker-side frame interpolation).
+                postprocess_kwargs: dict[str, object] = {}
+                if self._post_process_accepts_sampling_params:
+                    postprocess_kwargs["sampling_params"] = request.sampling_params
+                outputs = self.post_process_func(output_data, **postprocess_kwargs)
+            else:
+                outputs = output_data
 
         postprocess_output = normalize_diffusion_postprocess_output(outputs)
 
@@ -588,16 +603,31 @@ 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)
+
             if sched_output.is_empty:
                 self._emit_finished_outputs(sched_output.finished_req_ids, None)
                 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
                 )
@@ -615,12 +645,38 @@ 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."))
 
+    def _emit_request_started_outputs(self, sched_output: DiffusionSchedulerOutput) -> None:
+        """Notify opted-in callers when requests leave the scheduler queue."""
+        for new_req in sched_output.scheduled_new_reqs:
+            request = getattr(new_req, "req", None)
+            sampling_params = getattr(request, "sampling_params", None)
+            if getattr(sampling_params, "emit_request_lifecycle", False):
+                self._put_output(
+                    new_req.request_id,
+                    DiffusionOutput(finished=False, request_started=True),
+                )
+
     def _wait_for_admission_if_needed_locked(self) -> None:
         """Apply scheduler admission policy while holding the engine condition.
 
@@ -727,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)
@@ -749,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()
 
@@ -947,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])
@@ -958,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,
@@ -977,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])
@@ -1072,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.
@@ -1089,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),
         )
@@ -1307,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():
@@ -1324,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/envs.py b/vllm_omni/diffusion/envs.py
index 32e006f7e..4cbc0907c 100644
--- a/vllm_omni/diffusion/envs.py
+++ b/vllm_omni/diffusion/envs.py
@@ -15,6 +15,7 @@ if TYPE_CHECKING:
     MASTER_PORT: int | None = None
     CUDA_HOME: str | None = None
     LOCAL_RANK: int = 0
+    VLLM_OMNI_FUSED_QK_NORM_ROPE_MIN_TOKENS: str | None = None
 
 environment_variables: dict[str, Callable[[], Any]] = {
     # ================== Runtime Env Vars ==================
@@ -28,6 +29,11 @@ environment_variables: dict[str, Callable[[], Any]] = {
     # local rank of the process in the distributed setting, used to determine
     # the GPU device id
     "LOCAL_RANK": lambda: int(os.environ.get("LOCAL_RANK", "0")),
+    # Minimum rotary-table span (B*S positions) at which consumers of the shared
+    # fused_qk_norm_rope op take the fused path instead of their eager chain;
+    # "0" = always fuse; unset = each consumer's own measured default. Raw
+    # string or None; validated by fused_qk_norm_rope_min_tokens().
+    "VLLM_OMNI_FUSED_QK_NORM_ROPE_MIN_TOKENS": lambda: os.environ.get("VLLM_OMNI_FUSED_QK_NORM_ROPE_MIN_TOKENS", None),
 }
 
 
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/executor/multiproc_executor.py b/vllm_omni/diffusion/executor/multiproc_executor.py
index 7b3400b21..8bdbe3a1d 100644
--- a/vllm_omni/diffusion/executor/multiproc_executor.py
+++ b/vllm_omni/diffusion/executor/multiproc_executor.py
@@ -13,7 +13,7 @@ import threading
 import time
 import weakref
 from collections.abc import Callable
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from multiprocessing.process import BaseProcess
 from multiprocessing.synchronize import Event
 from typing import TYPE_CHECKING, Any, cast
@@ -46,6 +46,7 @@ _DEQUEUE_TIMEOUT_S = 5.0
 _DLO_DP_WAVE_TIMEOUT_S = float(os.environ.get("VLLM_OMNI_DLO_DP_WAVE_TIMEOUT", 600.0))
 _WORKER_SHUTDOWN_GRACE_S = 15.0
 _WORKER_TERMINATE_GRACE_S = 5.0
+_WORKER_KILL_GRACE_S = 5.0
 _RESULT_PUMP_JOIN_TIMEOUT_S = 2.0
 
 
@@ -83,34 +84,62 @@ class _ExecutorShutdownCleaner:
 
     broadcast_mq: MessageQueue | None = None
     num_workers: int = 0
-    processes: list[BaseProcess] | None = None
+    processes: list[mp.Process] | None = None
+    _lock: threading.Lock = field(default_factory=threading.Lock, init=False, repr=False)
 
     def __call__(self) -> None:
         """Clean up background resources."""
+        # The worker monitor and an explicit shutdown may race. A retry must
+        # not signal/join the same Process objects while cleanup is in flight.
+        if not self._lock.acquire(blocking=False):
+            return
+        try:
+            self._cleanup()
+        finally:
+            self._lock.release()
+
+    def _cleanup(self) -> None:
         if self.broadcast_mq is not None:
             try:
                 for _ in range(self.num_workers):
                     self.broadcast_mq.enqueue(SHUTDOWN_MESSAGE, timeout=1.0)
 
-                self.broadcast_mq = None
             except Exception as exc:
                 logger.warning("Failed to send shutdown signal: %s", exc)
+            finally:
+                self.broadcast_mq = None
 
         if self.processes:
-            join_deadline = time.monotonic() + _WORKER_SHUTDOWN_GRACE_S
-            for proc in self.processes:
-                if not proc.is_alive():
-                    continue
-                proc.join(max(0.0, join_deadline - time.monotonic()))
-
             alive = [proc for proc in self.processes if proc.is_alive()]
-            for proc in alive:
-                logger.warning("Terminating diffusion worker %s after timeout", proc.name)
-                proc.terminate()
+            for action, grace in (
+                (None, _WORKER_SHUTDOWN_GRACE_S),
+                ("terminate", _WORKER_TERMINATE_GRACE_S),
+                ("kill", _WORKER_KILL_GRACE_S),
+            ):
+                if not alive:
+                    break
+                if action is not None:
+                    for proc in alive:
+                        try:
+                            logger.warning("Calling %s on diffusion worker %s (pid=%s)", action, proc.name, proc.pid)
+                            getattr(proc, action)()
+                        except OSError:
+                            logger.exception("Failed to %s diffusion worker %s (pid=%s)", action, proc.name, proc.pid)
 
-            terminate_deadline = time.monotonic() + _WORKER_TERMINATE_GRACE_S
-            for proc in alive:
-                proc.join(max(0.0, terminate_deadline - time.monotonic()))
+                deadline = time.monotonic() + grace
+                for proc in alive:
+                    try:
+                        proc.join(max(0.0, deadline - time.monotonic()))
+                    except OSError:
+                        logger.exception("Failed to join diffusion worker %s (pid=%s)", proc.name, proc.pid)
+                alive = [proc for proc in alive if proc.is_alive()]
+
+            self.processes = alive
+            if alive:
+                logger.error(
+                    "Diffusion worker cleanup incomplete after kill: %s; retaining processes for shutdown retry",
+                    [(proc.name, proc.pid) for proc in alive],
+                )
 
 
 class MultiprocDiffusionExecutor(DiffusionExecutor):
@@ -1010,8 +1039,12 @@ class MultiprocDiffusionExecutor(DiffusionExecutor):
     def shutdown(self) -> None:
         self._closed = True
         self._pump_stop.set()
+        cleaner = self._shutdown_cleaner
         try:
-            self._finalizer()
+            if self._finalizer.alive:
+                self._finalizer()
+            elif cleaner is not None:
+                cleaner()
         finally:
             pump_threads = getattr(self, "_result_pump_threads", [])
             for thread in pump_threads:
@@ -1035,5 +1068,6 @@ class MultiprocDiffusionExecutor(DiffusionExecutor):
                 self._rpc_futures.clear()
                 self._output_futures.clear()
                 self._batch_split_map.clear()
-            self._shutdown_cleaner = None
-            self._processes = []
+            self._processes = (cleaner.processes or []) if cleaner is not None else []
+            if not self._processes:
+                self._shutdown_cleaner = None
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/inline_stage_diffusion_client.py b/vllm_omni/diffusion/inline_stage_diffusion_client.py
index 6c8cc236c..f583aba14 100644
--- a/vllm_omni/diffusion/inline_stage_diffusion_client.py
+++ b/vllm_omni/diffusion/inline_stage_diffusion_client.py
@@ -19,7 +19,10 @@ from typing import TYPE_CHECKING, Any
 from vllm.logger import init_logger
 from vllm.v1.engine.exceptions import EngineDeadError
 
-from vllm_omni.diffusion.data import DiffusionRequestAbortedError
+from vllm_omni.diffusion.data import (
+    DiffusionRequestAbortedError,
+    is_diffusion_request_started_output,
+)
 from vllm_omni.diffusion.diffusion_engine import DiffusionEngine
 from vllm_omni.diffusion.request import OmniDiffusionRequest
 from vllm_omni.engine.stage_client import StageClientBase
@@ -158,7 +161,13 @@ class InlineStageDiffusionClient(StageClientBase):
                 # only publish the final output.
                 result = None
                 async for results in self._engine.step_streaming(request):
-                    result = results[0]
+                    output = results[0]
+                    if is_diffusion_request_started_output(output):
+                        if not output.request_id:
+                            output.request_id = request_id
+                        self._output_queue.put_nowait(output)
+                        continue
+                    result = output
                 if result is None:
                     raise RuntimeError("Diffusion execution finished without output.")
                 if not result.request_id:
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/ipc.py b/vllm_omni/diffusion/ipc.py
index 6eb24c540..f0e88a2c9 100644
--- a/vllm_omni/diffusion/ipc.py
+++ b/vllm_omni/diffusion/ipc.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
 
 """IPC utilities for transferring large tensors via POSIX shared memory.
 
@@ -11,15 +11,32 @@ serialised through the queue.
 
 from __future__ import annotations
 
+from collections.abc import Iterator
 from typing import Any
 
 import numpy as np
 import torch
 
 from vllm_omni.diffusion.data import DiffusionOutput
+from vllm_omni.diffusion.media import (
+    DiffusionMediaOutput,
+    FloatVideoConsumer,
+    VideoColorModel,
+    VideoMediaOutput,
+    VideoTensorEncoding,
+    VideoTensorLayout,
+    VideoTensorSpec,
+    VideoTransportConstraints,
+    VideoValueRange,
+)
 
 _SHM_TENSOR_THRESHOLD = 1_000_000  # 1 MB
 DIFFUSION_RPC_RESULT_ENVELOPE = "diffusion_rpc_result"
+_DIFFUSION_MEDIA_WIRE_TYPE = "diffusion_media_v1"
+
+# Sentinel so compute-then-assign packing can tell "field not packed" apart from
+# "field packed to None".
+_UNSET = object()
 
 
 def _array_to_shm(array: np.ndarray) -> dict[str, Any]:
@@ -61,9 +78,39 @@ def _array_from_shm(handle: dict[str, Any]) -> np.ndarray:
     return array
 
 
+def _unlink_shm_handle(handle: dict[str, Any]) -> None:
+    """Best-effort removal of a shared-memory segment created during packing."""
+    from multiprocessing import shared_memory
+
+    name = handle.get("name")
+    if not name:
+        return
+    try:
+        shm = shared_memory.SharedMemory(name=name)
+    except FileNotFoundError:
+        return
+    try:
+        shm.close()
+    finally:
+        try:
+            shm.unlink()
+        except FileNotFoundError:
+            pass
+
+
+def _unlink_shm_handles(handles: list[dict[str, Any]]) -> None:
+    for handle in handles:
+        try:
+            _unlink_shm_handle(handle)
+        except Exception:
+            # Cleanup is best-effort; never mask the original packing failure.
+            pass
+
+
 def _tensor_to_shm(
     tensor: torch.Tensor,
     d2h_stream: torch.Stream | None = None,
+    created: list[dict[str, Any]] | None = None,
 ) -> dict[str, Any]:
     """Copy a tensor into POSIX shared memory and return a metadata handle.
 
@@ -82,14 +129,17 @@ def _tensor_to_shm(
         torch.accelerator.set_stream(d2h_stream)
         try:
             t = tensor.detach()
-            if original_dtype == torch.bfloat16:
-                t = t.to(torch.float32)
             cpu = torch.empty(t.shape, dtype=t.dtype, pin_memory=True)
             cpu.copy_(t, non_blocking=True)
         finally:
             torch.accelerator.set_stream(old_stream)
         d2h_stream.synchronize()
         tensor = cpu
+        # numpy has no bfloat16, so widen on the host after D2H. Never widen on
+        # the accelerator before the copy: a payload that already fell back after
+        # an fp32 OOM would OOM again on a second device-side fp32 allocation.
+        if original_dtype == torch.bfloat16:
+            tensor = tensor.to(torch.float32)
     else:
         tensor = tensor.detach().cpu().contiguous()
         if original_dtype == torch.bfloat16:
@@ -101,6 +151,8 @@ def _tensor_to_shm(
             "torch_dtype": str(original_dtype),
         }
     )
+    if created is not None:
+        created.append(handle)
     return handle
 
 
@@ -120,6 +172,7 @@ def _tensor_from_shm(handle: dict[str, Any]) -> torch.Tensor:
 def _pack_tensor_if_large(
     val: torch.Tensor,
     d2h_stream: torch.Stream | None = None,
+    created: list[dict[str, Any]] | None = None,
 ) -> torch.Tensor | dict:
     """Replace a tensor with an SHM handle if it exceeds the threshold.
 
@@ -134,14 +187,16 @@ def _pack_tensor_if_large(
     except Exception:
         storage_bytes = view_bytes
     if max(view_bytes, storage_bytes) > _SHM_TENSOR_THRESHOLD:
-        return _tensor_to_shm(val, d2h_stream=d2h_stream)
+        return _tensor_to_shm(val, d2h_stream=d2h_stream, created=created)
     return val
 
 
-def _ndarray_to_shm(array: np.ndarray) -> dict[str, Any]:
+def _ndarray_to_shm(array: np.ndarray, created: list[dict[str, Any]] | None = None) -> dict[str, Any]:
     """Copy a contiguous NumPy array into POSIX shared memory."""
     handle = _array_to_shm(array)
     handle["__ndarray_shm__"] = True
+    if created is not None:
+        created.append(handle)
     return handle
 
 
@@ -153,6 +208,7 @@ def _ndarray_from_shm(handle: dict[str, Any]) -> np.ndarray:
 def _pack_value_if_large(
     val: object,
     d2h_stream: torch.Stream | None = None,
+    created: list[dict[str, Any]] | None = None,
 ) -> object:
     """Recursively replace large tensors with SHM handles.
 
@@ -163,15 +219,19 @@ def _pack_value_if_large(
     the two in sync.
     """
     if isinstance(val, torch.Tensor):
-        return _pack_tensor_if_large(val, d2h_stream=d2h_stream)
+        return _pack_tensor_if_large(val, d2h_stream=d2h_stream, created=created)
     if isinstance(val, np.ndarray):
-        return _ndarray_to_shm(val) if not val.dtype.hasobject and val.nbytes > _SHM_TENSOR_THRESHOLD else val
+        return (
+            _ndarray_to_shm(val, created=created)
+            if not val.dtype.hasobject and val.nbytes > _SHM_TENSOR_THRESHOLD
+            else val
+        )
     if isinstance(val, dict):
-        return {key: _pack_value_if_large(value, d2h_stream=d2h_stream) for key, value in val.items()}
+        return {key: _pack_value_if_large(value, d2h_stream=d2h_stream, created=created) for key, value in val.items()}
     if isinstance(val, list):
-        return [_pack_value_if_large(item, d2h_stream=d2h_stream) for item in val]
+        return [_pack_value_if_large(item, d2h_stream=d2h_stream, created=created) for item in val]
     if isinstance(val, tuple):
-        return tuple(_pack_value_if_large(item, d2h_stream=d2h_stream) for item in val)
+        return tuple(_pack_value_if_large(item, d2h_stream=d2h_stream, created=created) for item in val)
     return val
 
 
@@ -190,18 +250,116 @@ def _unpack_if_shm_handle(val: object) -> object:
     return val
 
 
+def _pack_diffusion_media(
+    media: DiffusionMediaOutput,
+    *,
+    d2h_stream: torch.Stream | None,
+    created: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    media.validate()
+    if not media.prepared_for_transport:
+        raise ValueError("Diffusion media must be prepared before IPC packing")
+    video = media.video
+    packed_tensor = _pack_tensor_if_large(video.tensor, d2h_stream=d2h_stream, created=created)
+    if isinstance(packed_tensor, torch.Tensor) and packed_tensor.device.type != "cpu":
+        packed_tensor = packed_tensor.detach().cpu().contiguous()
+    return {
+        "__type__": _DIFFUSION_MEDIA_WIRE_TYPE,
+        "schema_version": video.schema_version,
+        "prepared_for_transport": True,
+        "video": {
+            "tensor": packed_tensor,
+            "layout": video.spec.layout.value,
+            "encoding": video.spec.encoding.value,
+            "value_range": video.spec.value_range.value,
+            "color_model": video.spec.color_model.value,
+            "pending_float_consumers": sorted(consumer.value for consumer in video.constraints.pending_float_consumers),
+        },
+    }
+
+
+def _unpack_diffusion_media(packed: dict[str, Any]) -> DiffusionMediaOutput:
+    if packed.get("__type__") != _DIFFUSION_MEDIA_WIRE_TYPE:
+        raise ValueError("Invalid diffusion media wire payload")
+    video_payload = packed.get("video")
+    if not isinstance(video_payload, dict):
+        raise ValueError("Diffusion media wire payload is missing video metadata")
+    tensor = _unpack_if_shm_handle(video_payload.get("tensor"))
+    if not isinstance(tensor, torch.Tensor):
+        raise ValueError("Diffusion media wire payload contains an invalid video tensor")
+    schema_version = packed.get("schema_version")
+    if schema_version != 1:
+        raise ValueError(f"Unsupported video media schema version: {schema_version}")
+    if packed.get("prepared_for_transport") is not True:
+        raise ValueError("Diffusion media wire payload was not prepared for transport")
+    media = DiffusionMediaOutput(
+        video=VideoMediaOutput(
+            tensor=tensor,
+            spec=VideoTensorSpec(
+                layout=VideoTensorLayout(video_payload["layout"]),
+                encoding=VideoTensorEncoding(video_payload["encoding"]),
+                value_range=VideoValueRange(video_payload["value_range"]),
+                color_model=VideoColorModel(video_payload["color_model"]),
+            ),
+            constraints=VideoTransportConstraints(
+                pending_float_consumers=frozenset(
+                    FloatVideoConsumer(value) for value in video_payload.get("pending_float_consumers", [])
+                )
+            ),
+            schema_version=1,
+        ),
+        prepared_for_transport=True,
+    )
+    media.validate()
+    return media
+
+
 def _pack_diffusion_fields(
     output: DiffusionOutput,
     d2h_stream: torch.Stream | None = None,
+    created: list[dict[str, Any]] | None = None,
+    pending_updates: list[tuple[DiffusionOutput, str, object]] | None = None,
 ) -> DiffusionOutput:
+    if output.media is not None and output.output is not None:
+        raise ValueError("DiffusionOutput cannot contain both media and legacy output")
+    if output.media is not None and not isinstance(output.media, DiffusionMediaOutput):
+        raise TypeError(f"DiffusionOutput.media must be DiffusionMediaOutput, got {type(output.media).__name__}")
+
+    # Pack into locals first so a mid-payload failure leaves ``output`` unmutated
+    # (never enqueue a half-packed object); the caller unlinks any SHM segments
+    # accumulated in ``created`` on failure.
+    packed_output = _UNSET
     if output.output is not None:
-        output.output = _pack_value_if_large(output.output, d2h_stream=d2h_stream)
-    if output.trajectory_latents is not None and isinstance(output.trajectory_latents, torch.Tensor):
-        output.trajectory_latents = _pack_tensor_if_large(output.trajectory_latents, d2h_stream=d2h_stream)
-    if output.trajectory_timesteps is not None and isinstance(output.trajectory_timesteps, torch.Tensor):
-        output.trajectory_timesteps = _pack_tensor_if_large(output.trajectory_timesteps, d2h_stream=d2h_stream)
-    if output.trajectory_log_probs is not None and isinstance(output.trajectory_log_probs, torch.Tensor):
-        output.trajectory_log_probs = _pack_tensor_if_large(output.trajectory_log_probs, d2h_stream=d2h_stream)
+        packed_output = _pack_value_if_large(output.output, d2h_stream=d2h_stream, created=created)
+    packed_media = _UNSET
+    if output.media is not None:
+        packed_media = _pack_diffusion_media(output.media, d2h_stream=d2h_stream, created=created)
+    packed_latents = _UNSET
+    if isinstance(output.trajectory_latents, torch.Tensor):
+        packed_latents = _pack_tensor_if_large(output.trajectory_latents, d2h_stream=d2h_stream, created=created)
+    packed_timesteps = _UNSET
+    if isinstance(output.trajectory_timesteps, torch.Tensor):
+        packed_timesteps = _pack_tensor_if_large(output.trajectory_timesteps, d2h_stream=d2h_stream, created=created)
+    packed_log_probs = _UNSET
+    if isinstance(output.trajectory_log_probs, torch.Tensor):
+        packed_log_probs = _pack_tensor_if_large(output.trajectory_log_probs, d2h_stream=d2h_stream, created=created)
+
+    updates = [
+        (output, field_name, value)
+        for field_name, value in (
+            ("output", packed_output),
+            ("media", packed_media),
+            ("trajectory_latents", packed_latents),
+            ("trajectory_timesteps", packed_timesteps),
+            ("trajectory_log_probs", packed_log_probs),
+        )
+        if value is not _UNSET
+    ]
+    if pending_updates is None:
+        for target, field_name, value in updates:
+            setattr(target, field_name, value)
+    else:
+        pending_updates.extend(updates)
     return output
 
 
@@ -223,35 +381,84 @@ def pack_diffusion_output_shm(
 
     If *d2h_stream* is provided, D2H copies use that stream (non-blocking on
     the default stream).  The caller must synchronize *d2h_stream* afterward.
+
+    Packing is failure-atomic: every SHM segment created during the call is
+    tracked and unlinked if any part of the payload fails to pack, and field
+    mutations are committed only after the complete payload succeeds.
     """
+    created: list[dict[str, Any]] = []
+    pending_updates: list[tuple[DiffusionOutput, str, object]] = []
+    try:
+        packed = _pack_output_shm(
+            output,
+            d2h_stream=d2h_stream,
+            created=created,
+            pending_updates=pending_updates,
+        )
+    except BaseException:
+        _unlink_shm_handles(created)
+        raise
+
+    # Commit mutations only after every field and batch entry packed. Until
+    # this point, a failure leaves the complete caller-owned payload untouched.
+    for target, field_name, value in pending_updates:
+        setattr(target, field_name, value)
+    return packed
+
+
+def _iter_diffusion_outputs(output: object) -> Iterator[DiffusionOutput]:
+    """Yield every packable ``DiffusionOutput`` leaf in a worker payload."""
     if isinstance(output, DiffusionOutput):
-        return _pack_diffusion_fields(output, d2h_stream=d2h_stream)
+        yield output
+        return
 
     # DP multi-concurrency: {"dp_rank": int, "output": DiffusionOutput}
     if isinstance(output, dict) and "dp_rank" in output and "output" in output:
         inner = output["output"]
         if isinstance(inner, DiffusionOutput):
-            output["output"] = _pack_diffusion_fields(inner, d2h_stream=d2h_stream)
-        return output
+            yield inner
+        return
 
     if _is_rpc_result_envelope(output):
-        result = output.get("result")
-        output["result"] = pack_diffusion_output_shm(result, d2h_stream=d2h_stream)
-        return output
+        yield from _iter_diffusion_outputs(output.get("result"))
+        return
 
     result = getattr(output, "result", None)
     if isinstance(result, DiffusionOutput):
-        output.result = _pack_diffusion_fields(result, d2h_stream=d2h_stream)
+        yield result
 
     runner_outputs = getattr(output, "runner_outputs", None)
     if isinstance(runner_outputs, list):
         for runner_output in runner_outputs:
-            pack_diffusion_output_shm(runner_output, d2h_stream=d2h_stream)
+            yield from _iter_diffusion_outputs(runner_output)
+
+
+def payload_carries_typed_media(output: object) -> bool:
+    """True if *output* carries any typed ``DiffusionOutput.media`` payload."""
+    return any(item.media is not None for item in _iter_diffusion_outputs(output))
+
+
+def _pack_output_shm(
+    output: object,
+    *,
+    d2h_stream: torch.Stream | None,
+    created: list[dict[str, Any]],
+    pending_updates: list[tuple[DiffusionOutput, str, object]],
+) -> object:
+    for item in _iter_diffusion_outputs(output):
+        _pack_diffusion_fields(
+            item,
+            d2h_stream=d2h_stream,
+            created=created,
+            pending_updates=pending_updates,
+        )
     return output
 
 
 def _unpack_diffusion_fields(output: DiffusionOutput) -> DiffusionOutput:
     output.output = _unpack_if_shm_handle(output.output)
+    if isinstance(output.media, dict):
+        output.media = _unpack_diffusion_media(output.media)
     output.trajectory_latents = _unpack_if_shm_handle(output.trajectory_latents)
     output.trajectory_timesteps = _unpack_if_shm_handle(output.trajectory_timesteps)
     output.trajectory_log_probs = _unpack_if_shm_handle(output.trajectory_log_probs)
diff --git a/vllm_omni/diffusion/layers/fused_qk_norm_rope.py b/vllm_omni/diffusion/layers/fused_qk_norm_rope.py
index f7e27675c..9d530919a 100644
--- a/vllm_omni/diffusion/layers/fused_qk_norm_rope.py
+++ b/vllm_omni/diffusion/layers/fused_qk_norm_rope.py
@@ -1,18 +1,26 @@
 # SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
-"""Q/K RMSNorm followed by packed non-interleaved RoPE.
+"""Q/K RMSNorm followed by packed RoPE (non-interleaved or interleaved).
 
 The public contract is shared by diffusion attention implementations:
 
 * ``q`` and ``k`` are ``[tokens, heads, head_dim]``;
 * norm weights are one-dimensional ``[head_dim]`` tensors;
 * ``rope_table`` is ``[tokens, rotary_dim]`` and stores
-  ``[cos(theta), sin(theta)]`` with ``theta`` of width ``rotary_dim // 2``.
+  ``[cos(theta), sin(theta)]`` with ``theta`` of width ``rotary_dim // 2``;
+  its dtype is either the activation dtype or float32;
+* ``interleaved=False`` rotates half-split pairs ``(d, d + rotary_dim/2)``
+  (MiniMax-H3); ``interleaved=True`` rotates adjacent pairs ``(2i, 2i + 1)``
+  with ``theta_i`` (Boogu-Image, matching its ``apply_rotary_emb``).
 
 The CUDA fast path fuses RMSNorm and RoPE without materializing normalized Q/K
-or rotary-product intermediates. Ascend composes its RMSNorm and rotary fused
-primitives; unsupported inputs use the eager reference.
+or rotary-product intermediates. The interleaved mode supports any even
+``rotary_dim <= head_dim <= 256`` (``tl.arange`` padding to the next power of
+two); the half-split mode keeps the pre-existing kernel and its MiniMax-H3
+geometry contract (``head_dim == 128``, ``rotary_dim == 96``). Ascend
+composes its RMSNorm and rotary fused primitives on the MiniMax-H3 geometry;
+unsupported inputs use the eager reference.
 """
 
 from __future__ import annotations
@@ -26,31 +34,73 @@ 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
 
+from vllm_omni.diffusion import envs
 from vllm_omni.platforms import current_omni_platform
 
 _FUSED_HEAD_DIM = 128
 _FUSED_ROTARY_DIM = 96
+# Interleaved-mode geometry bounds (any even rotary_dim <= head_dim <= this).
+_FUSED_MAX_HEAD_DIM = 256
 _HEADS_PER_PROGRAM = 8
+# The combined interleaved kernel: small tiles + one warp measured fastest
+# (latency-bound shapes; see the kernel docstring).
+_INTERLEAVED_HEADS_PER_PROGRAM = 4
 
 
 def _apply_rope_table(
     x: torch.Tensor,
     rope_table: torch.Tensor,
     rotary_dim: int,
+    *,
+    interleaved: bool = False,
+    dtype: torch.dtype | None = None,
+    output_dtype: torch.dtype | None = None,
 ) -> torch.Tensor:
+    """Eager RoPE application: the fallback and the unit-test reference.
+
+    Shapes: ``x`` is the normalized ``[tokens, heads, head_dim]`` tensor;
+    ``rope_table`` is ``[tokens, rotary_dim]`` storing
+    ``[cos(theta) | sin(theta)]`` with ``theta`` of width ``rotary_dim // 2``.
+
+    ``interleaved`` selects the pairing: half-split ``(d, d + rotary_dim/2)``
+    sharing ``theta_d`` (MiniMax-H3) or adjacent pairs ``(2i, 2i + 1)``
+    sharing ``theta_i`` (Boogu-Image). ``dtype`` is the precision the
+    rotation arithmetic runs in and ``output_dtype`` the precision the result
+    is cast to; both default to ``x``'s dtype (the historical half-split
+    behaviour). The interleaved caller passes ``dtype=torch.float32`` to
+    match the Triton kernel's composition — fp32 rotation of the
+    bf16-rounded normalized value, one final rounding — which is also how
+    vLLM's own ``fused_qk_norm_rope`` Triton kernel and Boogu's eager
+    ``apply_rotary_emb`` order their rounding.
+    """
+    compute_dtype = x.dtype if dtype is None else dtype
+    out_dtype = x.dtype if output_dtype is None else output_dtype
     half = rotary_dim // 2
-    cos = rope_table[..., :half].to(x.dtype).unsqueeze(1)
-    sin = rope_table[..., half:].to(x.dtype).unsqueeze(1)
-    first = x[..., :half]
-    second = x[..., half:rotary_dim]
-    return torch.cat(
-        (
-            first * cos - second * sin,
-            second * cos + first * sin,
-            x[..., rotary_dim:],
-        ),
-        dim=-1,
-    )
+    x_c = x.to(compute_dtype)
+    cos = rope_table[..., :half].to(compute_dtype).unsqueeze(1)
+    sin = rope_table[..., half:].to(compute_dtype).unsqueeze(1)
+    first = x_c[..., 0:rotary_dim:2] if interleaved else x_c[..., :half]
+    second = x_c[..., 1:rotary_dim:2] if interleaved else x_c[..., half:rotary_dim]
+    rotated_first = first * cos - second * sin
+    rotated_second = second * cos + first * sin
+    if interleaved:
+        # stack(..., dim=-1) pairs (new_even_i, new_odd_i) into
+        # [..., half, 2]; flatten(-2) lays the pairs back out as
+        # [e0, o0, e1, o1, ...] — back to their interleaved positions.
+        rotated = torch.stack(
+            (rotated_first, rotated_second),
+            dim=-1,
+        ).flatten(-2)
+        return torch.cat((rotated, x_c[..., rotary_dim:]), dim=-1).to(out_dtype)
+    else:
+        return torch.cat(
+            (
+                rotated_first,
+                rotated_second,
+                x_c[..., rotary_dim:],
+            ),
+            dim=-1,
+        ).to(out_dtype)
 
 
 if HAS_TRITON:
@@ -74,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)
@@ -116,6 +167,136 @@ if HAS_TRITON:
         out_offsets = token * out_stride_t + heads[:, None] * out_stride_h + dims[None, :] * out_stride_d
         tl.store(out_ptr + out_offsets, output, mask=mask)
 
+    @triton.jit
+    def _qk_norm_rope_kernel(
+        q_ptr,
+        k_ptr,
+        q_weight_ptr,
+        k_weight_ptr,
+        rope_table_ptr,
+        out_q_ptr,
+        out_k_ptr,
+        q_stride_t,
+        q_stride_h,
+        q_stride_d,
+        k_stride_t,
+        k_stride_h,
+        k_stride_d,
+        rope_stride_t,
+        out_q_stride_t,
+        out_q_stride_h,
+        out_q_stride_d,
+        out_k_stride_t,
+        out_k_stride_h,
+        out_k_stride_d,
+        num_q_heads: tl.constexpr,
+        num_kv_heads: tl.constexpr,
+        head_dim: tl.constexpr,
+        padded_dim: tl.constexpr,  # next power of 2 >= head_dim (tl.arange needs a power of 2)
+        rotary_half: tl.constexpr,
+        eps: tl.constexpr,
+        heads_per_program: tl.constexpr,
+        q_head_groups: tl.constexpr,
+        interleaved: tl.constexpr,
+    ):
+        """Fused per-head RMSNorm + RoPE for Q and K in one launch.
+
+        Grid axis 1 assigns the first ``q_head_groups`` programs of a token
+        to Q and the rest to K, so the small K grid hides inside Q's waves
+        instead of paying its own latency-bound launch. ``interleaved``
+        selects the pairing, mirroring ``_apply_rope_table``:
+
+        * ``True`` — adjacent pairs ``(2i, 2i+1)`` sharing ``theta_i``.
+        * ``False`` — half-split pairs ``(d, d + rotary_half)`` sharing
+          ``theta_d``. Production traffic still routes half-split inputs
+          through ``_rms_norm_rope_kernel``; this mode is test-covered and
+          awaits the maintainers' call before taking over that path.
+
+        The modes differ only in the pair/frequency/selector index
+        expressions; the arithmetic is shared. Beyond the rotary width
+        (partial rotary or lane padding) the output is the normalized value
+        unchanged.
+        """
+        # 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
+        if head_group < q_head_groups:
+            heads = head_group * heads_per_program + tl.arange(0, heads_per_program)
+            # Valid-domain mask: rows beyond the head count (when it is not a
+            # multiple of heads_per_program) and padded lanes beyond head_dim.
+            mask = (heads[:, None] < num_q_heads) & dim_mask[None, :]
+            in_ptr = q_ptr
+            weight_ptr = q_weight_ptr
+            out_ptr = out_q_ptr
+            in_stride_t, in_stride_h, in_stride_d = q_stride_t, q_stride_h, q_stride_d
+            out_stride_t, out_stride_h, out_stride_d = (
+                out_q_stride_t,
+                out_q_stride_h,
+                out_q_stride_d,
+            )
+        else:
+            heads = (head_group - q_head_groups) * heads_per_program + tl.arange(0, heads_per_program)
+            mask = (heads[:, None] < num_kv_heads) & dim_mask[None, :]
+            in_ptr = k_ptr
+            weight_ptr = k_weight_ptr
+            out_ptr = out_k_ptr
+            in_stride_t, in_stride_h, in_stride_d = k_stride_t, k_stride_h, k_stride_d
+            out_stride_t, out_stride_h, out_stride_d = (
+                out_k_stride_t,
+                out_k_stride_h,
+                out_k_stride_d,
+            )
+
+        offsets = token * in_stride_t + heads[:, None] * in_stride_h + dims[None, :] * in_stride_d
+        x = tl.load(in_ptr + offsets, mask=mask, other=0.0).to(tl.float32)
+        weight = tl.load(weight_ptr + dims, mask=dim_mask, other=0.0).to(tl.float32)
+        # Padding lanes load 0 and do not perturb the sum; divide by the true
+        # head_dim, not the padded width.
+        inv_rms = tl.rsqrt(tl.sum(x * x, axis=1) / head_dim + eps)
+        normalized = (x * inv_rms[:, None] * weight[None, :]).to(tl.bfloat16)
+
+        # The two pairings differ only in three index expressions; the pair
+        # reload, the table gather, the rotation formulas and the write-back
+        # are shared (the same structure as _apply_rope_table).
+        rotary_dim = rotary_half * 2
+        if interleaved:
+            # Adjacent pairs (2i, 2i+1) sharing theta_i.
+            pair_dims = tl.where(dims < rotary_dim, dims ^ 1, dims)
+            freq_dims = tl.where(dims < rotary_dim, dims // 2, 0)
+            is_first = (dims % 2) == 0
+        else:
+            # Half-split pairs (d, d + rotary_half) sharing theta_d.
+            pair_dims = tl.where(
+                dims < rotary_half,
+                dims + rotary_half,
+                tl.where(dims < rotary_dim, dims - rotary_half, dims),
+            )
+            freq_dims = tl.where(
+                dims < rotary_half,
+                dims,
+                tl.where(dims < rotary_dim, dims - rotary_half, 0),
+            )
+            is_first = dims < rotary_half
+        pair_offsets = token * in_stride_t + heads[:, None] * in_stride_h + pair_dims[None, :] * in_stride_d
+        pair_x = tl.load(in_ptr + pair_offsets, mask=mask, other=0.0).to(tl.float32)
+        pair_weight = tl.load(weight_ptr + pair_dims, mask=pair_dims < head_dim, other=0.0).to(tl.float32)
+        pair_normalized = (pair_x * inv_rms[:, None] * pair_weight[None, :]).to(tl.bfloat16)
+        table_offsets = token * rope_stride_t + freq_dims
+        cos = tl.load(rope_table_ptr + table_offsets).to(tl.float32)
+        sin = tl.load(rope_table_ptr + table_offsets + rotary_half).to(tl.float32)
+        first = normalized.to(tl.float32) * cos - pair_normalized.to(tl.float32) * sin
+        second = normalized.to(tl.float32) * cos + pair_normalized.to(tl.float32) * sin
+        output = tl.where(
+            dims < rotary_dim,
+            tl.where(is_first, first, second),
+            normalized.to(tl.float32),
+        )
+
+        out_offsets = token * out_stride_t + heads[:, None] * out_stride_h + dims[None, :] * out_stride_d
+        tl.store(out_ptr + out_offsets, output, mask=mask)
+
 
 def _eager_qk_norm_rope(
     q: torch.Tensor,
@@ -126,12 +307,16 @@ def _eager_qk_norm_rope(
     eps: float,
     head_dim: int,
     rotary_dim: int,
+    interleaved: bool = False,
 ) -> tuple[torch.Tensor, torch.Tensor]:
     q_norm = F.rms_norm(q, (head_dim,), q_weight, eps)
     k_norm = F.rms_norm(k, (head_dim,), k_weight, eps)
+    # fp32 rotation for the interleaved (Boogu) semantics; the half-split
+    # (H3) reference keeps its historical x-dtype arithmetic via the defaults.
+    rope_dtype = torch.float32 if interleaved else None
     return (
-        _apply_rope_table(q_norm, rope_table, rotary_dim),
-        _apply_rope_table(k_norm, rope_table, rotary_dim),
+        _apply_rope_table(q_norm, rope_table, rotary_dim, interleaved=interleaved, dtype=rope_dtype),
+        _apply_rope_table(k_norm, rope_table, rotary_dim, interleaved=interleaved, dtype=rope_dtype),
     )
 
 
@@ -206,17 +391,23 @@ def _fused_cuda_supported(
     k: torch.Tensor,
     head_dim: int,
     rotary_dim: int,
+    interleaved: bool = False,
 ) -> bool:
-    return (
+    if not (
         HAS_TRITON
         and current_platform.is_cuda()
         and q.is_cuda
         and k.is_cuda
         and q.dtype == torch.bfloat16
         and k.dtype == torch.bfloat16
-        and head_dim == _FUSED_HEAD_DIM
-        and rotary_dim == _FUSED_ROTARY_DIM
-    )
+    ):
+        return False
+    if interleaved:
+        return rotary_dim % 2 == 0 and 2 <= rotary_dim <= head_dim <= _FUSED_MAX_HEAD_DIM
+    # Half-split traffic keeps the pre-existing per-tensor kernel and its
+    # exact MiniMax-H3 geometry contract (that kernel is untouched by the
+    # interleaved extension).
+    return head_dim == _FUSED_HEAD_DIM and rotary_dim == _FUSED_ROTARY_DIM
 
 
 def _fused_npu_supported(
@@ -224,10 +415,12 @@ def _fused_npu_supported(
     k: torch.Tensor,
     head_dim: int,
     rotary_dim: int,
+    interleaved: bool = False,
 ) -> bool:
     """Return whether the MiniMax-H3 Ascend fused-op contract is satisfied."""
     return (
-        current_omni_platform.is_npu()
+        not interleaved
+        and current_omni_platform.is_npu()
         and q.device.type == "npu"
         and k.device.type == "npu"
         and q.dtype == torch.bfloat16
@@ -271,6 +464,69 @@ def _launch_fused_rms_norm_rope(
     return out
 
 
+def _launch_fused_qk_norm_rope(
+    q: torch.Tensor,
+    k: torch.Tensor,
+    q_weight: torch.Tensor,
+    k_weight: torch.Tensor,
+    rope_table: torch.Tensor,
+    eps: float,
+    interleaved: bool,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    tokens, q_heads, head_dim = q.shape
+    kv_heads = k.shape[1]
+    rotary_half = rope_table.shape[-1] // 2
+    out_q = torch.empty(q.shape, dtype=q.dtype, device=q.device)
+    out_k = torch.empty(k.shape, dtype=k.dtype, device=k.device)
+    if tokens == 0:
+        return out_q, out_k
+    if interleaved:
+        heads_per_program = _INTERLEAVED_HEADS_PER_PROGRAM
+        num_warps, num_stages = 1, 2
+    else:
+        # Match the historical per-tensor launch shape (8 heads per program,
+        # 8 warps) so the half-split arithmetic keeps its reduction tree.
+        heads_per_program = _HEADS_PER_PROGRAM
+        num_warps, num_stages = 8, 3
+    q_head_groups = triton.cdiv(q_heads, heads_per_program)
+    kv_head_groups = triton.cdiv(kv_heads, heads_per_program)
+    grid = (tokens, q_head_groups + kv_head_groups)
+    _qk_norm_rope_kernel[grid](
+        q,
+        k,
+        q_weight,
+        k_weight,
+        rope_table,
+        out_q,
+        out_k,
+        q.stride(0),
+        q.stride(1),
+        q.stride(2),
+        k.stride(0),
+        k.stride(1),
+        k.stride(2),
+        rope_table.stride(0),
+        out_q.stride(0),
+        out_q.stride(1),
+        out_q.stride(2),
+        out_k.stride(0),
+        out_k.stride(1),
+        out_k.stride(2),
+        num_q_heads=q_heads,
+        num_kv_heads=kv_heads,
+        head_dim=head_dim,
+        padded_dim=triton.next_power_of_2(head_dim),
+        rotary_half=rotary_half,
+        eps=eps,
+        heads_per_program=heads_per_program,
+        q_head_groups=q_head_groups,
+        interleaved=interleaved,
+        num_warps=num_warps,
+        num_stages=num_stages,
+    )
+    return out_q, out_k
+
+
 def _fused_qk_norm_rope_impl(
     q: torch.Tensor,
     k: torch.Tensor,
@@ -280,8 +536,9 @@ def _fused_qk_norm_rope_impl(
     eps: float,
     head_dim: int,
     rotary_dim: int,
+    interleaved: bool,
 ) -> tuple[torch.Tensor, torch.Tensor]:
-    if _fused_npu_supported(q, k, head_dim, rotary_dim):
+    if _fused_npu_supported(q, k, head_dim, rotary_dim, interleaved):
         return _npu_qk_norm_rope(
             q,
             k,
@@ -291,7 +548,7 @@ def _fused_qk_norm_rope_impl(
             eps,
             rotary_dim,
         )
-    if not _fused_cuda_supported(q, k, head_dim, rotary_dim):
+    if not _fused_cuda_supported(q, k, head_dim, rotary_dim, interleaved):
         return _eager_qk_norm_rope(
             q,
             k,
@@ -301,7 +558,12 @@ def _fused_qk_norm_rope_impl(
             eps,
             head_dim,
             rotary_dim,
+            interleaved,
         )
+    if interleaved:
+        return _launch_fused_qk_norm_rope(q, k, q_weight, k_weight, rope_table, eps, interleaved=True)
+    # Half-split production traffic keeps the historical per-tensor kernel;
+    # _qk_norm_rope_kernel's half-split mode awaits the maintainers' call.
     return (
         _launch_fused_rms_norm_rope(q, q_weight, rope_table, eps),
         _launch_fused_rms_norm_rope(k, k_weight, rope_table, eps),
@@ -317,8 +579,9 @@ def _fused_qk_norm_rope_fake(
     eps: float,
     head_dim: int,
     rotary_dim: int,
+    interleaved: bool,
 ) -> tuple[torch.Tensor, torch.Tensor]:
-    del q_weight, k_weight, rope_table, eps, head_dim, rotary_dim
+    del q_weight, k_weight, rope_table, eps, head_dim, rotary_dim, interleaved
     return torch.empty_like(q), torch.empty_like(k)
 
 
@@ -333,6 +596,39 @@ if not hasattr(torch.ops.vllm_omni, "fused_qk_norm_rope"):
     )
 
 
+_MIN_TOKENS_ENV = "VLLM_OMNI_FUSED_QK_NORM_ROPE_MIN_TOKENS"
+
+
+def fused_qk_norm_rope_min_tokens(default: int) -> int:
+    """Token span below which a consumer should keep its eager chain.
+
+    Taking the fused path costs a fixed amount of host time per call (the
+    custom-op dispatch into the Python impl and the Triton launcher), while the
+    GPU time it saves grows with the number of tokens the call covers. Below a
+    host- and stack-dependent crossover a call is host-bound and the fused path
+    can cost more end-to-end than it saves; above it the fused path wins.
+    Consumers pass the default they measured on their reference hardware
+    (Boogu-Image: 2048 tokens on one H200) and a deployment on other hardware
+    overrides it once, for every consumer, through
+    ``VLLM_OMNI_FUSED_QK_NORM_ROPE_MIN_TOKENS`` (``0`` = always fuse).
+
+    Resolved at call time — consumers call this once per forward, not per
+    attention site — so tests and operators can flip it without re-importing.
+    Unset or blank means the caller's default; anything else that is not a
+    non-negative integer raises ``ValueError``.
+    """
+    raw = envs.VLLM_OMNI_FUSED_QK_NORM_ROPE_MIN_TOKENS
+    if raw is None or not raw.strip():
+        return default
+    try:
+        value = int(raw)
+    except ValueError:
+        value = -1
+    if value < 0:
+        raise ValueError(f"{_MIN_TOKENS_ENV} must be a non-negative integer, got {raw!r}")
+    return value
+
+
 def fused_qk_norm_rope(
     q: torch.Tensor,
     k: torch.Tensor,
@@ -343,8 +639,9 @@ def fused_qk_norm_rope(
     *,
     head_dim: int | None = None,
     rotary_dim: int | None = None,
+    interleaved: bool = False,
 ) -> tuple[torch.Tensor, torch.Tensor]:
-    """Apply Q/K RMSNorm and packed non-interleaved RoPE."""
+    """Apply Q/K RMSNorm and packed RoPE (half-split or adjacent pairs)."""
     if q.ndim != 3 or k.ndim != 3:
         raise ValueError(f"q and k must be [tokens, heads, head_dim], got {q.shape} and {k.shape}")
     if q.shape[0] != k.shape[0] or q.shape[2] != k.shape[2]:
@@ -364,15 +661,18 @@ def fused_qk_norm_rope(
         raise ValueError(f"Expected norm weights [{head_dim}], got {tuple(q_weight.shape)} and {tuple(k_weight.shape)}")
     if q_weight.device != q.device or k_weight.device != q.device:
         raise ValueError("Q/K norm weights must be on the activation device")
-    if rope_table.device != q.device or rope_table.dtype != q.dtype:
-        raise ValueError("rope_table must have the same dtype and device as q/k")
+    if rope_table.device != q.device or rope_table.dtype not in (
+        q.dtype,
+        torch.float32,
+    ):
+        raise ValueError("rope_table must be on q/k's device with their dtype or float32")
     if rope_table.shape != (q.shape[0], rotary_dim):
         raise ValueError(f"Expected rope_table [{q.shape[0]}, {rotary_dim}], got {tuple(rope_table.shape)}")
 
     q_weight = q_weight.contiguous()
     k_weight = k_weight.contiguous()
     rope_table = rope_table.contiguous()
-    if _fused_npu_supported(q, k, head_dim, rotary_dim):
+    if _fused_npu_supported(q, k, head_dim, rotary_dim, interleaved):
         return _npu_qk_norm_rope(
             q,
             k,
@@ -382,7 +682,7 @@ def fused_qk_norm_rope(
             eps,
             rotary_dim,
         )
-    if not _fused_cuda_supported(q, k, head_dim, rotary_dim):
+    if not _fused_cuda_supported(q, k, head_dim, rotary_dim, interleaved):
         return _fused_qk_norm_rope_impl(
             q,
             k,
@@ -392,6 +692,7 @@ def fused_qk_norm_rope(
             eps,
             head_dim,
             rotary_dim,
+            interleaved,
         )
     return torch.ops.vllm_omni.fused_qk_norm_rope(
         q,
@@ -402,7 +703,8 @@ def fused_qk_norm_rope(
         eps,
         head_dim,
         rotary_dim,
+        interleaved,
     )
 
 
-__all__ = ["fused_qk_norm_rope"]
+__all__ = ["fused_qk_norm_rope", "fused_qk_norm_rope_min_tokens"]
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/attention/ops/minimax_h3_modulation.py b/vllm_omni/diffusion/layers/indexed_modulation.py
similarity index 79%
rename from vllm_omni/diffusion/attention/ops/minimax_h3_modulation.py
rename to vllm_omni/diffusion/layers/indexed_modulation.py
index 20327b7e9..0f4f2e59e 100644
--- a/vllm_omni/diffusion/attention/ops/minimax_h3_modulation.py
+++ b/vllm_omni/diffusion/layers/indexed_modulation.py
@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-"""Fused MiniMax H3 modulation with FP32 accumulation."""
+"""Fused indexed modulation with FP32 accumulation."""
 
 from __future__ import annotations
 
@@ -24,6 +24,18 @@ def _launch_row_chunks(kernel, rows: int, device_type: str, *args, **kwargs) ->
         kernel[(chunk_rows,)](*args, row_offset, **kwargs)
 
 
+def _use_hopper_bf16_affine_semantics(x: torch.Tensor) -> bool:
+    """Use the unfused AdaLN dtype boundaries on Hopper.
+
+    The fused FP32 modulation path is stable on Blackwell, but the SM90
+    kernel can accumulate enough extra precision in the repeated RMSNorm and
+    AdaLN operations to move the 50-step I2VA result below its CI threshold.
+    Keep the existing path on other architectures until their numerical
+    baselines are independently validated.
+    """
+    return x.device.type == "cuda" and torch.cuda.get_device_capability(x.device)[0] == 9
+
+
 @triton.jit
 def _indexed_scale_shift_kernel(
     output_ptr,
@@ -102,6 +114,7 @@ def _rms_norm_indexed_scale_shift_kernel(
     stride_scale_row,
     stride_indices,
     row_offset,
+    use_bf16_affine: tl.constexpr,
     block_n: tl.constexpr,
 ):
     row = tl.program_id(0) + row_offset
@@ -112,13 +125,20 @@ 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
-    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)
+    if use_bf16_affine:
+        # Match the unfused RMSNorm output consumed by AdaLN on Hopper.
+        normalized = (x * tl.rsqrt(variance + eps) * weight).to(tl.bfloat16)
+        shift = tl.load(shift_ptr + index * stride_shift_row + columns, mask=mask, other=0.0)
+        scale = tl.load(scale_ptr + index * stride_scale_row + columns, mask=mask, other=0.0)
+        output = normalized * (scale + 1.0) + shift
+    else:
+        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,
     )
 
@@ -143,6 +163,7 @@ def _indexed_gate_rms_norm_scale_shift_kernel(
     stride_scale_row,
     stride_indices,
     row_offset,
+    use_bf16_affine: tl.constexpr,
     block_n: tl.constexpr,
 ):
     row = tl.program_id(0) + row_offset
@@ -159,12 +180,20 @@ def _indexed_gate_rms_norm_scale_shift_kernel(
 
     weight = tl.load(weight_ptr + columns, mask=mask, other=0.0).to(tl.float32)
     variance = tl.sum(updated * updated, axis=0) / hidden_size
-    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)
+    if use_bf16_affine:
+        # Match the unfused RMSNorm output consumed by AdaLN on Hopper.
+        normalized = (updated * tl.rsqrt(variance + eps) * weight).to(tl.bfloat16)
+        shift = tl.load(shift_ptr + index * stride_shift_row + columns, mask=mask, other=0.0)
+        scale = tl.load(scale_ptr + index * stride_scale_row + columns, mask=mask, other=0.0)
+        output = normalized * (scale + 1.0) + shift
+    else:
+        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,
     )
 
@@ -244,7 +273,7 @@ def rms_norm_indexed_scale_shift(
     indices: torch.Tensor,
     eps: float,
 ) -> torch.Tensor:
-    """Fuse H3 RMSNorm with its indexed AdaLN affine transform."""
+    """Fuse RMSNorm with an indexed affine transform."""
     if x.is_cpu:
         input_dtype = x.dtype
         normalized = x.float()
@@ -271,6 +300,7 @@ def rms_norm_indexed_scale_shift(
             shift.stride(0),
             scale.stride(0),
             indices.stride(0),
+            use_bf16_affine=_use_hopper_bf16_affine_semantics(x),
             block_n=triton.next_power_of_2(hidden_size),
             num_warps=8,
         )
@@ -324,6 +354,7 @@ def indexed_gate_rms_norm_scale_shift(
             shift.stride(0),
             scale.stride(0),
             indices.stride(0),
+            use_bf16_affine=_use_hopper_bf16_affine_semantics(residual),
             block_n=triton.next_power_of_2(hidden_size),
             num_warps=8,
         )
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/qwen_select01_modulation.py b/vllm_omni/diffusion/layers/qwen_select01_modulation.py
new file mode 100644
index 000000000..4fe1e3e0e
--- /dev/null
+++ b/vllm_omni/diffusion/layers/qwen_select01_modulation.py
@@ -0,0 +1,491 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from __future__ import annotations
+
+import torch
+import torch.nn.functional as F
+from vllm.platforms import current_platform
+from vllm.triton_utils import HAS_TRITON, tl, triton
+
+
+@triton.jit
+def _layernorm_select01_kernel(
+    output_ptr,
+    gate_out_ptr,
+    x_ptr,
+    weight_ptr,
+    bias_ptr,
+    scale0_ptr,
+    shift0_ptr,
+    gate0_ptr,
+    scale1_ptr,
+    shift1_ptr,
+    gate1_ptr,
+    index_ptr,
+    inner_dim,
+    seq_len,
+    stride_x_row,
+    stride_out_row,
+    stride_gate_out_row,
+    stride_w,
+    stride_b,
+    stride_s0_b,
+    stride_s0_c,
+    stride_sh0_b,
+    stride_sh0_c,
+    stride_g0_b,
+    stride_g0_c,
+    stride_s1_b,
+    stride_s1_c,
+    stride_sh1_b,
+    stride_sh1_c,
+    stride_g1_b,
+    stride_g1_c,
+    stride_i_b,
+    stride_i_l,
+    eps,
+    has_weight: tl.constexpr,
+    has_bias: tl.constexpr,
+    block_n: tl.constexpr,
+):
+    row = tl.program_id(0)
+    cols = tl.arange(0, block_n)
+    mask = cols < inner_dim
+
+    x_row_ptr = x_ptr + row * stride_x_row
+    x = tl.load(x_row_ptr + cols, mask=mask, other=0.0).to(tl.float32)
+
+    mean = tl.sum(x, axis=0) / inner_dim
+    xbar = tl.where(mask, x - mean, 0.0)
+    var = tl.sum(xbar * xbar, axis=0) / inner_dim
+    x_hat = (x - mean) * tl.rsqrt(var + eps)
+
+    if has_weight:
+        weight = tl.load(weight_ptr + cols * stride_w, mask=mask, other=1.0).to(tl.float32)
+        x_hat = x_hat * weight
+    if has_bias:
+        bias = tl.load(bias_ptr + cols * stride_b, mask=mask, other=0.0).to(tl.float32)
+        x_hat = x_hat + bias
+
+    batch_idx = row // seq_len
+    seq_idx = row % seq_len
+    idx = tl.load(index_ptr + batch_idx * stride_i_b + seq_idx * stride_i_l).to(tl.int1)
+
+    scale0_ptrs = scale0_ptr + batch_idx * stride_s0_b + cols * stride_s0_c
+    shift0_ptrs = shift0_ptr + batch_idx * stride_sh0_b + cols * stride_sh0_c
+    gate0_ptrs = gate0_ptr + batch_idx * stride_g0_b + cols * stride_g0_c
+    scale1_ptrs = scale1_ptr + batch_idx * stride_s1_b + cols * stride_s1_c
+    shift1_ptrs = shift1_ptr + batch_idx * stride_sh1_b + cols * stride_sh1_c
+    gate1_ptrs = gate1_ptr + batch_idx * stride_g1_b + cols * stride_g1_c
+
+    scale_ptrs = tl.where(idx, scale1_ptrs, scale0_ptrs)
+    shift_ptrs = tl.where(idx, shift1_ptrs, shift0_ptrs)
+    gate_ptrs = tl.where(idx, gate1_ptrs, gate0_ptrs)
+
+    scale = tl.load(scale_ptrs, mask=mask, other=0.0).to(tl.float32)
+    shift = tl.load(shift_ptrs, mask=mask, other=0.0).to(tl.float32)
+    gate = tl.load(gate_ptrs, mask=mask, other=0.0)
+
+    y = x_hat * (1.0 + scale) + shift
+    tl.store(output_ptr + row * stride_out_row + cols, y, mask=mask)
+    tl.store(gate_out_ptr + row * stride_gate_out_row + cols, gate, mask=mask)
+
+
+@triton.jit
+def _residual_layernorm_select01_kernel(
+    output_ptr,
+    residual_out_ptr,
+    gate_out_ptr,
+    x_ptr,
+    residual_ptr,
+    residual_gate_ptr,
+    weight_ptr,
+    bias_ptr,
+    scale0_ptr,
+    shift0_ptr,
+    gate0_ptr,
+    scale1_ptr,
+    shift1_ptr,
+    gate1_ptr,
+    index_ptr,
+    inner_dim,
+    seq_len,
+    stride_x_row,
+    stride_res_row,
+    stride_res_gate_row,
+    stride_out_row,
+    stride_res_out_row,
+    stride_gate_out_row,
+    stride_w,
+    stride_b,
+    stride_s0_b,
+    stride_s0_c,
+    stride_sh0_b,
+    stride_sh0_c,
+    stride_g0_b,
+    stride_g0_c,
+    stride_s1_b,
+    stride_s1_c,
+    stride_sh1_b,
+    stride_sh1_c,
+    stride_g1_b,
+    stride_g1_c,
+    stride_i_b,
+    stride_i_l,
+    eps,
+    has_weight: tl.constexpr,
+    has_bias: tl.constexpr,
+    block_n: tl.constexpr,
+):
+    row = tl.program_id(0)
+    cols = tl.arange(0, block_n)
+    mask = cols < inner_dim
+
+    x = tl.load(x_ptr + row * stride_x_row + cols, mask=mask, other=0.0).to(tl.float32)
+    residual = tl.load(residual_ptr + row * stride_res_row + cols, mask=mask, other=0.0).to(tl.float32)
+    residual_gate = tl.load(
+        residual_gate_ptr + row * stride_res_gate_row + cols,
+        mask=mask,
+        other=0.0,
+    ).to(tl.float32)
+
+    residual_out = residual + residual_gate * x
+    tl.store(residual_out_ptr + row * stride_res_out_row + cols, residual_out, mask=mask)
+
+    mean = tl.sum(residual_out, axis=0) / inner_dim
+    xbar = tl.where(mask, residual_out - mean, 0.0)
+    var = tl.sum(xbar * xbar, axis=0) / inner_dim
+    x_hat = (residual_out - mean) * tl.rsqrt(var + eps)
+
+    if has_weight:
+        weight = tl.load(weight_ptr + cols * stride_w, mask=mask, other=1.0).to(tl.float32)
+        x_hat = x_hat * weight
+    if has_bias:
+        bias = tl.load(bias_ptr + cols * stride_b, mask=mask, other=0.0).to(tl.float32)
+        x_hat = x_hat + bias
+
+    batch_idx = row // seq_len
+    seq_idx = row % seq_len
+    idx = tl.load(index_ptr + batch_idx * stride_i_b + seq_idx * stride_i_l).to(tl.int1)
+
+    scale0_ptrs = scale0_ptr + batch_idx * stride_s0_b + cols * stride_s0_c
+    shift0_ptrs = shift0_ptr + batch_idx * stride_sh0_b + cols * stride_sh0_c
+    gate0_ptrs = gate0_ptr + batch_idx * stride_g0_b + cols * stride_g0_c
+    scale1_ptrs = scale1_ptr + batch_idx * stride_s1_b + cols * stride_s1_c
+    shift1_ptrs = shift1_ptr + batch_idx * stride_sh1_b + cols * stride_sh1_c
+    gate1_ptrs = gate1_ptr + batch_idx * stride_g1_b + cols * stride_g1_c
+
+    scale_ptrs = tl.where(idx, scale1_ptrs, scale0_ptrs)
+    shift_ptrs = tl.where(idx, shift1_ptrs, shift0_ptrs)
+    gate_ptrs = tl.where(idx, gate1_ptrs, gate0_ptrs)
+
+    scale = tl.load(scale_ptrs, mask=mask, other=0.0).to(tl.float32)
+    shift = tl.load(shift_ptrs, mask=mask, other=0.0).to(tl.float32)
+    gate = tl.load(gate_ptrs, mask=mask, other=0.0)
+
+    y = x_hat * (1.0 + scale) + shift
+    tl.store(output_ptr + row * stride_out_row + cols, y, mask=mask)
+    tl.store(gate_out_ptr + row * stride_gate_out_row + cols, gate, mask=mask)
+
+
+def split_select01_mod_params(mod_params: torch.Tensor) -> tuple[torch.Tensor, ...]:
+    shift, scale, gate = mod_params.chunk(3, dim=-1)
+    actual_batch = shift.size(0) // 2
+    if actual_batch == 0 or shift.size(0) != actual_batch * 2:
+        raise ValueError("select01 modulation expects mod_params batch dim to be 2 * batch")
+    return (
+        scale[:actual_batch],
+        shift[:actual_batch],
+        gate[:actual_batch],
+        scale[actual_batch:],
+        shift[actual_batch:],
+        gate[actual_batch:],
+    )
+
+
+def select01_modulation_native(
+    mod_params: torch.Tensor,
+    index: torch.Tensor,
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    scale0, shift0, gate0, scale1, shift1, gate1 = split_select01_mod_params(mod_params)
+    idx = index.to(dtype=torch.bool).unsqueeze(-1)
+    scale = torch.where(idx, scale1.unsqueeze(1), scale0.unsqueeze(1))
+    shift = torch.where(idx, shift1.unsqueeze(1), shift0.unsqueeze(1))
+    gate = torch.where(idx, gate1.unsqueeze(1), gate0.unsqueeze(1))
+    return scale, shift, gate
+
+
+def _validate_select01_inputs(
+    x: torch.Tensor,
+    index: torch.Tensor,
+    tensors: tuple[torch.Tensor, ...],
+) -> None:
+    if x.dim() != 3:
+        raise ValueError("x must be 3D [B, L, C]")
+    if index.dim() != 2 or index.shape[1] != x.shape[1] or index.shape[0] not in (1, x.shape[0]):
+        raise ValueError("index must be 2D [B or 1, L] and match x batch/sequence")
+    batch_size, _, hidden_size = x.shape
+    for tensor in tensors:
+        if tensor.dim() != 2 or tensor.shape != (batch_size, hidden_size):
+            raise ValueError("scale/shift/gate tensors must be 2D [B, C]")
+
+
+def _maybe_contiguous(x: torch.Tensor) -> torch.Tensor:
+    return x if x.is_contiguous() else x.contiguous()
+
+
+def _launch_layernorm_select01(
+    x: torch.Tensor,
+    weight: torch.Tensor | None,
+    bias: torch.Tensor | None,
+    scale0: torch.Tensor,
+    shift0: torch.Tensor,
+    gate0: torch.Tensor,
+    scale1: torch.Tensor,
+    shift1: torch.Tensor,
+    gate1: torch.Tensor,
+    index: torch.Tensor,
+    eps: float,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    _validate_select01_inputs(x, index, (scale0, shift0, gate0, scale1, shift1, gate1))
+    batch_size, seq_len, hidden_size = x.shape
+    output = torch.empty_like(x)
+    gate_out = torch.empty_like(x)
+
+    x_2d = _maybe_contiguous(x).view(batch_size * seq_len, hidden_size)
+    output_2d = output.view(batch_size * seq_len, hidden_size)
+    gate_out_2d = gate_out.view(batch_size * seq_len, hidden_size)
+    index = _maybe_contiguous(index)
+    scale0 = _maybe_contiguous(scale0)
+    shift0 = _maybe_contiguous(shift0)
+    gate0 = _maybe_contiguous(gate0)
+    scale1 = _maybe_contiguous(scale1)
+    shift1 = _maybe_contiguous(shift1)
+    gate1 = _maybe_contiguous(gate1)
+
+    weight_arg = _maybe_contiguous(weight) if weight is not None else x_2d
+    bias_arg = _maybe_contiguous(bias) if bias is not None else x_2d
+    block_n = min(65536 // x_2d.element_size(), triton.next_power_of_2(hidden_size))
+    if hidden_size > block_n:
+        raise RuntimeError("This layer norm doesn't support feature dim >= 64KB.")
+
+    _layernorm_select01_kernel[(batch_size * seq_len,)](
+        output_2d,
+        gate_out_2d,
+        x_2d,
+        weight_arg,
+        bias_arg,
+        scale0,
+        shift0,
+        gate0,
+        scale1,
+        shift1,
+        gate1,
+        index,
+        hidden_size,
+        seq_len,
+        x_2d.stride(0),
+        output_2d.stride(0),
+        gate_out_2d.stride(0),
+        weight_arg.stride(0) if weight is not None else 0,
+        bias_arg.stride(0) if bias is not None else 0,
+        scale0.stride(0),
+        scale0.stride(1),
+        shift0.stride(0),
+        shift0.stride(1),
+        gate0.stride(0),
+        gate0.stride(1),
+        scale1.stride(0),
+        scale1.stride(1),
+        shift1.stride(0),
+        shift1.stride(1),
+        gate1.stride(0),
+        gate1.stride(1),
+        index.stride(0) if index.shape[0] > 1 else 0,
+        index.stride(1),
+        eps,
+        has_weight=weight is not None,
+        has_bias=bias is not None,
+        block_n=block_n,
+        num_warps=4,
+        num_stages=4,
+    )
+    return output, gate_out
+
+
+def _launch_residual_layernorm_select01(
+    x: torch.Tensor,
+    residual: torch.Tensor,
+    residual_gate: torch.Tensor,
+    weight: torch.Tensor | None,
+    bias: torch.Tensor | None,
+    scale0: torch.Tensor,
+    shift0: torch.Tensor,
+    gate0: torch.Tensor,
+    scale1: torch.Tensor,
+    shift1: torch.Tensor,
+    gate1: torch.Tensor,
+    index: torch.Tensor,
+    eps: float,
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    _validate_select01_inputs(x, index, (scale0, shift0, gate0, scale1, shift1, gate1))
+    if residual.shape != x.shape:
+        raise ValueError("residual must have the same shape as x")
+    if residual_gate.shape != x.shape:
+        raise ValueError("residual_gate must have the same shape as x")
+
+    batch_size, seq_len, hidden_size = x.shape
+    output = torch.empty_like(x)
+    residual_out = torch.empty_like(x)
+    gate_out = torch.empty_like(x)
+
+    x_2d = _maybe_contiguous(x).view(batch_size * seq_len, hidden_size)
+    residual_2d = _maybe_contiguous(residual).view(batch_size * seq_len, hidden_size)
+    residual_gate_2d = _maybe_contiguous(residual_gate).view(batch_size * seq_len, hidden_size)
+    output_2d = output.view(batch_size * seq_len, hidden_size)
+    residual_out_2d = residual_out.view(batch_size * seq_len, hidden_size)
+    gate_out_2d = gate_out.view(batch_size * seq_len, hidden_size)
+    index = _maybe_contiguous(index)
+    scale0 = _maybe_contiguous(scale0)
+    shift0 = _maybe_contiguous(shift0)
+    gate0 = _maybe_contiguous(gate0)
+    scale1 = _maybe_contiguous(scale1)
+    shift1 = _maybe_contiguous(shift1)
+    gate1 = _maybe_contiguous(gate1)
+
+    weight_arg = _maybe_contiguous(weight) if weight is not None else x_2d
+    bias_arg = _maybe_contiguous(bias) if bias is not None else x_2d
+    block_n = min(65536 // x_2d.element_size(), triton.next_power_of_2(hidden_size))
+    if hidden_size > block_n:
+        raise RuntimeError("This layer norm doesn't support feature dim >= 64KB.")
+
+    _residual_layernorm_select01_kernel[(batch_size * seq_len,)](
+        output_2d,
+        residual_out_2d,
+        gate_out_2d,
+        x_2d,
+        residual_2d,
+        residual_gate_2d,
+        weight_arg,
+        bias_arg,
+        scale0,
+        shift0,
+        gate0,
+        scale1,
+        shift1,
+        gate1,
+        index,
+        hidden_size,
+        seq_len,
+        x_2d.stride(0),
+        residual_2d.stride(0),
+        residual_gate_2d.stride(0),
+        output_2d.stride(0),
+        residual_out_2d.stride(0),
+        gate_out_2d.stride(0),
+        weight_arg.stride(0) if weight is not None else 0,
+        bias_arg.stride(0) if bias is not None else 0,
+        scale0.stride(0),
+        scale0.stride(1),
+        shift0.stride(0),
+        shift0.stride(1),
+        gate0.stride(0),
+        gate0.stride(1),
+        scale1.stride(0),
+        scale1.stride(1),
+        shift1.stride(0),
+        shift1.stride(1),
+        gate1.stride(0),
+        gate1.stride(1),
+        index.stride(0) if index.shape[0] > 1 else 0,
+        index.stride(1),
+        eps,
+        has_weight=weight is not None,
+        has_bias=bias is not None,
+        block_n=block_n,
+        num_warps=4,
+        num_stages=4,
+    )
+    return output, residual_out, gate_out
+
+
+def can_use_qwen_select01_triton(x: torch.Tensor) -> bool:
+    return HAS_TRITON and current_platform.is_cuda() and x.is_cuda
+
+
+def fused_layernorm_select01(
+    x: torch.Tensor,
+    mod_params: torch.Tensor,
+    index: torch.Tensor,
+    eps: float,
+    weight: torch.Tensor | None = None,
+    bias: torch.Tensor | None = None,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    scale0, shift0, gate0, scale1, shift1, gate1 = split_select01_mod_params(mod_params)
+    is_compiling = torch.compiler.is_compiling()
+    if can_use_qwen_select01_triton(x) and not is_compiling:
+        return _launch_layernorm_select01(
+            x,
+            weight,
+            bias,
+            scale0,
+            shift0,
+            gate0,
+            scale1,
+            shift1,
+            gate1,
+            index,
+            eps,
+        )
+
+    scale, shift, gate = select01_modulation_native(mod_params, index)
+    out = F.layer_norm(
+        x.float(),
+        (x.shape[-1],),
+        weight=weight.float() if weight is not None else None,
+        bias=bias.float() if bias is not None else None,
+        eps=eps,
+    ).to(x.dtype)
+    return out * (1 + scale) + shift, gate
+
+
+def fused_residual_layernorm_select01(
+    x: torch.Tensor,
+    residual: torch.Tensor,
+    residual_gate: torch.Tensor,
+    mod_params: torch.Tensor,
+    index: torch.Tensor,
+    eps: float,
+    weight: torch.Tensor | None = None,
+    bias: torch.Tensor | None = None,
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    scale0, shift0, gate0, scale1, shift1, gate1 = split_select01_mod_params(mod_params)
+    is_compiling = torch.compiler.is_compiling()
+    if can_use_qwen_select01_triton(x) and not is_compiling:
+        return _launch_residual_layernorm_select01(
+            x,
+            residual,
+            residual_gate,
+            weight,
+            bias,
+            scale0,
+            shift0,
+            gate0,
+            scale1,
+            shift1,
+            gate1,
+            index,
+            eps,
+        )
+
+    scale, shift, gate = select01_modulation_native(mod_params, index)
+    residual_out = residual + residual_gate * x
+    out = F.layer_norm(
+        residual_out.float(),
+        (residual_out.shape[-1],),
+        weight=weight.float() if weight is not None else None,
+        bias=bias.float() if bias is not None else None,
+        eps=eps,
+    ).to(residual_out.dtype)
+    return out * (1 + scale) + shift, residual_out, gate
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 8c6713d58..d4b3cdb7c 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
 
@@ -48,6 +49,7 @@ def _prepare_lora_delta(
     lora_a_suffix: str = "lora_A.weight",
     lora_b_suffix: str = "lora_B.weight",
     lora_bias_suffix: str = "bias",
+    compute_device: torch.device | None = None,
 ):
     used_keys: set[str] = set()
     # stacked_params_mapping                       param_to_weight_names
@@ -75,6 +77,8 @@ def _prepare_lora_delta(
                 if lora_bias_key not in lora_state_dict:
                     return None, used_keys
                 delta = lora_state_dict[lora_bias_key]
+                if compute_device is not None and compute_device.type != "cpu":
+                    delta = delta.to(compute_device)
                 stacked_deltas.append(delta)
                 used_keys.add(lora_bias_key)
         else:
@@ -85,6 +89,9 @@ def _prepare_lora_delta(
                     return None, used_keys
                 a = lora_state_dict[lora_a_key]
                 b = lora_state_dict[lora_b_key]
+                if compute_device is not None and compute_device.type != "cpu":
+                    a = a.to(compute_device)
+                    b = b.to(compute_device)
                 delta = torch.matmul(b, a)
                 stacked_deltas.append(delta)
                 used_keys.add(lora_a_key)
@@ -99,7 +106,10 @@ def _prepare_lora_delta(
         if lora_bias_key not in lora_state_dict:
             return None, used_keys
         used_keys.add(lora_bias_key)
-        return lora_state_dict[lora_bias_key], used_keys
+        delta = lora_state_dict[lora_bias_key]
+        if compute_device is not None and compute_device.type != "cpu":
+            delta = delta.to(compute_device)
+        return delta, used_keys
 
     lora_a_key = f"{base_key}.{lora_a_suffix}"
     lora_b_key = f"{base_key}.{lora_b_suffix}"
@@ -107,9 +117,29 @@ def _prepare_lora_delta(
         return None, used_keys
     a = lora_state_dict[lora_a_key]
     b = lora_state_dict[lora_b_key]
+    if compute_device is not None and compute_device.type != "cpu":
+        a = a.to(compute_device)
+        b = b.to(compute_device)
+    delta = torch.matmul(b, a)
     used_keys.add(lora_a_key)
     used_keys.add(lora_b_key)
-    return torch.matmul(b, a), used_keys
+    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(
@@ -262,6 +292,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"):
@@ -272,6 +305,7 @@ class LoraLoaderMixin:
             else:
                 continue
 
+            compute_dev = params.device if params.device.type != "cpu" else accel_dev
             delta, used_keys = _prepare_lora_delta(
                 state_dict,
                 base_key,
@@ -280,6 +314,7 @@ class LoraLoaderMixin:
                 lora_a_suffix,
                 lora_b_suffix,
                 lora_bias_suffix,
+                compute_device=compute_dev,
             )
             if delta is None:
                 continue
@@ -314,6 +349,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"):
@@ -324,6 +362,7 @@ class LoraLoaderMixin:
             else:
                 continue
 
+            compute_dev = param.device if param.device.type != "cpu" else accel_dev
             delta, used_keys = _prepare_lora_delta(
                 state_dict,
                 base_key,
@@ -332,6 +371,7 @@ class LoraLoaderMixin:
                 lora_a_suffix,
                 lora_b_suffix,
                 lora_bias_suffix,
+                compute_device=compute_dev,
             )
             if delta is None:
                 continue
diff --git a/vllm_omni/diffusion/lora/manager.py b/vllm_omni/diffusion/lora/manager.py
index 2f6d47780..3a8230530 100644
--- a/vllm_omni/diffusion/lora/manager.py
+++ b/vllm_omni/diffusion/lora/manager.py
@@ -394,17 +394,20 @@ class DiffusionLoRAManager:
             fully_sharded_loras=False,
         )
 
-        # Default denoising components, declared DiT components, and any a
-        # pipeline opts into via ``_lora_components``.
+        # Components scanned for LoRA-capable layers: framework defaults,
+        # declared DiT components, and any a pipeline opts into via
+        # ``_lora_components``. The defaults only cover the generic diffusers
+        # naming convention: ``transformer`` (plus ``transformer_2`` for
+        # dual-DiT pipelines such as Wan2.2) and ``unet`` for SDXL-style
+        # pipelines. Model-specific attribute names must be declared by the
+        # pipeline itself via ``_dit_modules`` or ``_lora_components``.
         #
-        # NOTE: SDXL-style pipelines expose the denoiser as ``unet``.
-        # Without scanning this component, adapters can load/activate while
-        # effectively applying to zero layers, producing base-identical output.
+        # NOTE: if the denoiser component is not scanned here, adapters can
+        # load/activate while effectively applying to zero layers, producing
+        # base-identical output.
         default_components = (
             "transformer",
             "transformer_2",
-            "dit",
-            "bagel",
             "unet",
         )
         declared_components = tuple(getattr(self.pipeline, "_dit_modules", ()) or ())
@@ -556,9 +559,9 @@ class DiffusionLoRAManager:
 
     def _bind_adapter_weights(self, lora_model: LoRAModel, scale: float) -> None:
         binding_validator = getattr(self.pipeline, "_validate_diffusion_lora_binding", None)
-        lora_names_by_id = (
-            {id(weights): name for name, weights in lora_model.loras.items()} if callable(binding_validator) else {}
-        )
+        # Track bindings unconditionally. The zero-binding guard below needs this
+        # bookkeeping on every pipeline, not only the ones that supply a validator.
+        lora_names_by_id = {id(weights): name for name, weights in lora_model.loras.items()}
         bound_lora_names: set[str] = set()
 
         def _record_bound(weights: LoRALayerWeights | PackedLoRALayerWeights) -> None:
@@ -677,6 +680,13 @@ class DiffusionLoRAManager:
                 scale,
             )
 
+        if not bound_lora_names:
+            raise ValueError(
+                f"LoRA adapter {lora_model.id} applies to no layer: expected target modules in "
+                f"{sorted(self._expected_lora_modules)} but received {sorted(lora_model.loras)}. "
+                "Activating it would leave the base model unchanged."
+            )
+
         if callable(binding_validator):
             binding_validator(
                 lora_model=lora_model,
diff --git a/vllm_omni/diffusion/media.py b/vllm_omni/diffusion/media.py
new file mode 100644
index 000000000..34f4a1224
--- /dev/null
+++ b/vllm_omni/diffusion/media.py
@@ -0,0 +1,187 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field, replace
+from enum import Enum
+from typing import Literal
+
+import torch
+
+
+class VideoTensorLayout(str, Enum):
+    BCTHW = "bcthw"
+    BTHWC = "bthwc"
+
+
+class VideoTensorEncoding(str, Enum):
+    NORMALIZED_FLOAT = "normalized_float"
+    UINT8_FRAMES = "uint8_frames"
+
+
+class VideoValueRange(str, Enum):
+    NEGATIVE_ONE_TO_ONE = "negative_one_to_one"
+    ZERO_TO_ONE = "zero_to_one"
+    ZERO_TO_255 = "zero_to_255"
+
+
+class VideoColorModel(str, Enum):
+    RGB = "rgb"
+
+
+class FloatVideoConsumer(str, Enum):
+    FRAME_INTERPOLATION = "frame_interpolation"
+    VIDEO_GUARDRAILS = "video_guardrails"
+
+
+@dataclass(frozen=True, slots=True)
+class VideoTensorSpec:
+    layout: VideoTensorLayout
+    encoding: VideoTensorEncoding
+    value_range: VideoValueRange
+    color_model: VideoColorModel = VideoColorModel.RGB
+
+
+@dataclass(frozen=True, slots=True)
+class VideoTransportConstraints:
+    pending_float_consumers: frozenset[FloatVideoConsumer] = frozenset()
+
+
+@dataclass(frozen=True, slots=True)
+class VideoMediaOutput:
+    tensor: torch.Tensor
+    spec: VideoTensorSpec
+    constraints: VideoTransportConstraints = field(default_factory=VideoTransportConstraints)
+    schema_version: Literal[1] = 1
+
+    def validate(self) -> None:
+        if self.schema_version != 1:
+            raise ValueError(f"Unsupported video media schema version: {self.schema_version}")
+        if not isinstance(self.spec, VideoTensorSpec):
+            raise TypeError(f"Video media spec must be a VideoTensorSpec, got {type(self.spec).__name__}")
+        if not isinstance(self.constraints, VideoTransportConstraints):
+            raise TypeError(
+                f"Video media constraints must be VideoTransportConstraints, got {type(self.constraints).__name__}"
+            )
+        if not isinstance(self.constraints.pending_float_consumers, frozenset):
+            raise TypeError("pending_float_consumers must be a frozenset")
+        if not isinstance(self.tensor, torch.Tensor):
+            raise TypeError(f"Video media tensor must be a torch.Tensor, got {type(self.tensor).__name__}")
+        if self.tensor.ndim != 5:
+            raise ValueError(f"Video media tensor must be rank 5, got shape {tuple(self.tensor.shape)}")
+        if any(size <= 0 for size in self.tensor.shape):
+            raise ValueError(f"Video media dimensions must be positive, got shape {tuple(self.tensor.shape)}")
+        if self.spec.color_model is not VideoColorModel.RGB:
+            raise ValueError(f"Unsupported video color model: {self.spec.color_model}")
+        if any(not isinstance(consumer, FloatVideoConsumer) for consumer in self.constraints.pending_float_consumers):
+            raise ValueError("pending_float_consumers must contain only FloatVideoConsumer values")
+
+        if self.spec.encoding is VideoTensorEncoding.NORMALIZED_FLOAT:
+            self._validate_normalized_float()
+            return
+        if self.spec.encoding is VideoTensorEncoding.UINT8_FRAMES:
+            self._validate_uint8_frames()
+            return
+        raise ValueError(f"Unsupported video tensor encoding: {self.spec.encoding}")
+
+    def _validate_normalized_float(self) -> None:
+        if self.spec.layout is not VideoTensorLayout.BCTHW:
+            raise ValueError("NORMALIZED_FLOAT video must use BCTHW layout")
+        if self.tensor.shape[1] != 3:
+            raise ValueError(f"RGB BCTHW video must have 3 channels, got {self.tensor.shape[1]}")
+        if self.tensor.dtype not in {torch.float16, torch.bfloat16, torch.float32}:
+            raise ValueError(f"NORMALIZED_FLOAT video must use fp16, bf16, or fp32, got {self.tensor.dtype}")
+        if self.spec.value_range not in {
+            VideoValueRange.NEGATIVE_ONE_TO_ONE,
+            VideoValueRange.ZERO_TO_ONE,
+        }:
+            raise ValueError(f"NORMALIZED_FLOAT video has incompatible value range: {self.spec.value_range}")
+
+    def _validate_uint8_frames(self) -> None:
+        if self.spec.layout is not VideoTensorLayout.BTHWC:
+            raise ValueError("UINT8_FRAMES video must use BTHWC layout")
+        if self.tensor.shape[-1] != 3:
+            raise ValueError(f"RGB BTHWC video must have 3 channels, got {self.tensor.shape[-1]}")
+        if self.tensor.dtype is not torch.uint8:
+            raise ValueError(f"UINT8_FRAMES video must use torch.uint8, got {self.tensor.dtype}")
+        if self.spec.value_range is not VideoValueRange.ZERO_TO_255:
+            raise ValueError(f"UINT8_FRAMES video has incompatible value range: {self.spec.value_range}")
+        if self.constraints.pending_float_consumers:
+            raise ValueError("UINT8_FRAMES video cannot have pending float consumers")
+        if not self.tensor.is_contiguous():
+            raise ValueError("UINT8_FRAMES video tensor must be contiguous")
+
+    def with_tensor(self, tensor: torch.Tensor) -> VideoMediaOutput:
+        return replace(self, tensor=tensor)
+
+    def to_cpu(self) -> VideoMediaOutput:
+        return self.with_tensor(self.tensor.detach().cpu())
+
+
+@dataclass(frozen=True, slots=True)
+class DiffusionMediaOutput:
+    video: VideoMediaOutput
+    # Only the model runner may set this before worker output packing.
+    prepared_for_transport: bool = False
+
+    def validate(self) -> None:
+        if not isinstance(self.video, VideoMediaOutput):
+            raise TypeError(f"Diffusion media video must be a VideoMediaOutput, got {type(self.video).__name__}")
+        if not isinstance(self.prepared_for_transport, bool):
+            raise TypeError("prepared_for_transport must be a bool")
+        self.video.validate()
+        if not self.prepared_for_transport:
+            return
+        if not self.video.tensor.is_contiguous():
+            raise ValueError("Prepared video media tensor must be contiguous")
+        if not _owns_compact_storage(self.video.tensor):
+            raise ValueError("Prepared video media tensor must own request-local storage")
+
+    def with_video(self, video: VideoMediaOutput) -> DiffusionMediaOutput:
+        return replace(self, video=video)
+
+    def to_cpu(self) -> DiffusionMediaOutput:
+        self.validate()
+        moved = self.with_video(self.video.to_cpu())
+        moved.validate()
+        return moved
+
+
+def _owns_compact_storage(tensor: torch.Tensor) -> bool:
+    """True if *tensor* is contiguous and backed by exactly its own elements.
+
+    ``tensor._base is None`` is not sufficient: ``batch[i : i + 1].detach()`` is
+    contiguous with ``_base=None`` yet keeps a nonzero storage offset and the
+    whole batch storage, so serializing it would leak every other request's
+    pixels. Require a zero offset and a storage sized to the logical elements.
+    """
+    if not tensor.is_contiguous():
+        return False
+    if tensor.storage_offset() != 0:
+        return False
+    try:
+        storage_bytes = tensor.untyped_storage().nbytes()
+    except Exception:
+        return False
+    return storage_bytes == tensor.numel() * tensor.element_size()
+
+
+def ensure_request_owned_tensor(tensor: torch.Tensor) -> torch.Tensor:
+    if _owns_compact_storage(tensor):
+        return tensor
+    # A contiguous view may still retain another request's full batch storage.
+    return tensor.clone(memory_format=torch.contiguous_format)
+
+
+def slice_diffusion_media_output(
+    media: DiffusionMediaOutput,
+    start: int,
+    stop: int,
+) -> DiffusionMediaOutput:
+    media.validate()
+    source = media.video.tensor
+    tensor = source if start == 0 and stop == source.shape[0] else source[start:stop]
+    sliced = replace(media, video=media.video.with_tensor(tensor), prepared_for_transport=False)
+    sliced.validate()
+    return sliced
diff --git a/vllm_omni/diffusion/model_loader/checkpoint_adapters/modelopt.py b/vllm_omni/diffusion/model_loader/checkpoint_adapters/modelopt.py
index 68ec98d5a..f3c703b09 100644
--- a/vllm_omni/diffusion/model_loader/checkpoint_adapters/modelopt.py
+++ b/vllm_omni/diffusion/model_loader/checkpoint_adapters/modelopt.py
@@ -17,10 +17,17 @@ MODEL_OPT_SCALE_SUFFIXES = (
     ".weight_scale_2",
     ".weight_scale_inv",
 )
+# Fused projections following the generic diffusers Attention naming
+# convention. ``to_q``/``to_k``/``to_v`` and the joint-attention
+# ``add_q_proj``/``add_k_proj``/``add_v_proj`` shard names are fused into
+# ``to_qkv``/``add_kv_proj`` by most vllm-omni DiT implementations, many of
+# which do not declare their own ``packed_modules_mapping``; keeping these
+# two entries here avoids repeating them in every such model. Model-specific
+# fusions (e.g. Z-Image's ``w13``) must be declared on the model class via
+# ``packed_modules_mapping``, which is merged on top of these defaults.
 DEFAULT_PACKED_MODULES_MAPPING = {
     "to_qkv": ("to_q", "to_k", "to_v"),
     "add_kv_proj": ("add_q_proj", "add_k_proj", "add_v_proj"),
-    "w13": ("w1", "w3"),
 }
 FP8_DTYPES = tuple(
     dtype
diff --git a/vllm_omni/diffusion/model_loader/diffusers_loader.py b/vllm_omni/diffusion/model_loader/diffusers_loader.py
index 27774aa37..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.
@@ -509,11 +515,6 @@ class DiffusersPipelineLoader(HWRLoaderMixin):
         if getattr(model, "lora_is_fused", False):
             return
 
-        # A warm HWR restore already brings back the fused final-layout weights.
-        if self._hwr_state is not None and self._hwr_state.get("warm_snapshot") is not None:
-            setattr(model, "lora_is_fused", True)
-            return
-
         lora_path = getattr(self.od_config, "lora_path", None)
         if not lora_path:
             return
@@ -531,6 +532,111 @@ class DiffusersPipelineLoader(HWRLoaderMixin):
         else:
             logger.warning("Pipeline %s does not support loading distilled LoRA weights.", model.__class__.__name__)
 
+    def _broadcast_model_weights(
+        self,
+        model: nn.Module,
+        target_device: torch.device,
+        src_rank: int = 0,
+        bucket_cap_bytes: int = 256 * 1024 * 1024,
+    ) -> None:
+        """Broadcast model parameters and buffers from src_rank to all other ranks using coalesced bucketing."""
+        if not torch.distributed.is_initialized() or torch.distributed.get_world_size() <= 1:
+            return
+
+        rank = torch.distributed.get_rank()
+        world_size = torch.distributed.get_world_size()
+        backend = torch.distributed.get_backend()
+        is_cpu_backend = backend == "gloo"
+
+        logger.info(
+            "Worker %d: %s full model weights via %s across %d ranks",
+            rank,
+            "Broadcasting" if rank == src_rank else "Receiving",
+            backend,
+            world_size,
+        )
+        t0 = time.perf_counter()
+
+        all_tensors = [p.data for _, p in model.named_parameters() if p.numel() > 0] + [
+            b.data for _, b in model.named_buffers() if b.numel() > 0
+        ]
+        if not all_tensors:
+            return
+
+        count = len(all_tensors)
+        total_bytes = sum(t.numel() * t.element_size() for t in all_tensors)
+
+        # Group tensors into buckets by dtype and maximum byte size
+        buckets: list[list[torch.Tensor]] = []
+        curr_bucket: list[torch.Tensor] = []
+        curr_bytes = 0
+
+        for tensor in all_tensors:
+            t_bytes = tensor.numel() * tensor.element_size()
+            if curr_bucket and (curr_bucket[0].dtype != tensor.dtype or curr_bytes + t_bytes > bucket_cap_bytes):
+                buckets.append(curr_bucket)
+                curr_bucket = []
+                curr_bytes = 0
+            curr_bucket.append(tensor)
+            curr_bytes += t_bytes
+
+        if curr_bucket:
+            buckets.append(curr_bucket)
+
+        for bucket in buckets:
+            tot_numel = sum(t.numel() for t in bucket)
+            dtype = bucket[0].dtype
+
+            if is_cpu_backend:
+                if rank == src_rank:
+                    flat_cpu = torch.cat([t.detach().to("cpu").reshape(-1) for t in bucket])
+                else:
+                    flat_cpu = torch.empty(tot_numel, dtype=dtype)
+                torch.distributed.broadcast(flat_cpu, src=src_rank)
+                if rank != src_rank:
+                    offset = 0
+                    for t in bucket:
+                        n = t.numel()
+                        t.copy_(flat_cpu[offset : offset + n].view_as(t))
+                        offset += n
+                del flat_cpu
+            else:
+                if rank == src_rank:
+                    flat_cpu = torch.cat([t.detach().to("cpu").reshape(-1) for t in bucket])
+                    dev_flat = flat_cpu.to(target_device, non_blocking=False)
+                    del flat_cpu
+                    torch.distributed.broadcast(dev_flat, src=src_rank)
+                    del dev_flat
+                else:
+                    dev_flat = torch.empty(tot_numel, dtype=dtype, device=target_device)
+                    torch.distributed.broadcast(dev_flat, src=src_rank)
+                    flat_cpu = dev_flat.to("cpu", non_blocking=False)
+                    del dev_flat
+                    offset = 0
+                    for t in bucket:
+                        n = t.numel()
+                        t.copy_(flat_cpu[offset : offset + n].view_as(t), non_blocking=False)
+                        offset += n
+                    del flat_cpu
+
+        if not is_cpu_backend and target_device.type != "cpu":
+            from vllm_omni.platforms import current_omni_platform
+
+            current_omni_platform.synchronize()
+        torch.distributed.barrier()
+
+        elapsed = time.perf_counter() - t0
+        gb = total_bytes / 1e9
+        logger.info(
+            "Worker %d: Shared weight broadcast complete (%d tensors, %d buckets, %.2f GB) in %.2fs (%.2f GB/s)",
+            rank,
+            count,
+            len(buckets),
+            gb,
+            elapsed,
+            gb / max(elapsed, 1e-6),
+        )
+
     def load_model(
         self,
         load_device: str,
@@ -573,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
@@ -615,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."
                         )
@@ -654,6 +772,10 @@ class DiffusersPipelineLoader(HWRLoaderMixin):
                 if hwr_active and hwr_state is not None:
                     self.host_weight_plan = cast(HostWeightPlan | None, hwr_state.get("plan"))
                 if dit_distributed_offload and not hwr_active and not self._force_canonical_load:
+                    lora_backend = getattr(self.od_config, "lora_backend", None)
+                    has_distilled_lora = lora_backend in (LoRABackend.DISTILL, "distill") and bool(
+                        getattr(self.od_config, "lora_path", None)
+                    )
                     plan_result = build_checkpoint_mmap_plan(
                         model,
                         dit_modules=tuple(zip(modules.dit_names, modules.dits)),
@@ -662,6 +784,7 @@ class DiffusersPipelineLoader(HWRLoaderMixin):
                         tensor_parallel_size=tensor_parallel_size,
                         use_hsdp=use_hsdp,
                         online_quantization=any(self._has_online_quant(dit) for dit in modules.dits),
+                        has_distilled_lora=has_distilled_lora,
                     )
                     self.host_weight_plan = plan_result.plan
 
@@ -689,7 +812,6 @@ class DiffusersPipelineLoader(HWRLoaderMixin):
                             sources=ordinary_sources,
                             planned_weights=host_weight_plan.bindings,
                         )
-                    self._maybe_fuse_distilled_lora(model)
                 else:
                     if dit_distributed_offload and plan_result is not None:
                         logger.info(
@@ -749,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.
@@ -805,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,
@@ -813,6 +955,7 @@ class DiffusersPipelineLoader(HWRLoaderMixin):
         from vllm_omni.quantization.int8_config import (
             Int8OnlineLinearMethod,
             NPUInt8OnlineLinearMethod,
+            UnquantizedHostLinearMethod,
         )
 
         try:
@@ -834,6 +977,7 @@ class DiffusersPipelineLoader(HWRLoaderMixin):
             Fp8PerTensorOnlineLinearMethod,
             Int8OnlineLinearMethod,
             NPUInt8OnlineLinearMethod,
+            UnquantizedHostLinearMethod,
             *mxfp8_online_methods,
         )
 
@@ -961,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
@@ -1073,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.
 
@@ -1096,9 +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)
-        self.load_weights(model)
-        self._maybe_fuse_distilled_lora(model)
+        # 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
+
+        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()
+
+            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
+
+            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)
 
         # 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/host_weight_plan.py b/vllm_omni/diffusion/model_loader/host_weight_plan.py
index e6301b0ec..f0ea8024d 100644
--- a/vllm_omni/diffusion/model_loader/host_weight_plan.py
+++ b/vllm_omni/diffusion/model_loader/host_weight_plan.py
@@ -322,6 +322,7 @@ def build_checkpoint_mmap_plan(
     tensor_parallel_size: int,
     use_hsdp: bool,
     online_quantization: bool,
+    has_distilled_lora: bool = False,
 ) -> HostWeightPlanResult:
     """Build a complete direct-checkpoint plan or return a fallback reason."""
     if tensor_parallel_size != 1:
@@ -330,6 +331,8 @@ def build_checkpoint_mmap_plan(
         return HostWeightPlanResult(None, "HSDP requires the ordinary loader")
     if online_quantization:
         return HostWeightPlanResult(None, "online quantization requires the ordinary loader")
+    if has_distilled_lora:
+        return HostWeightPlanResult(None, "distilled LoRA requires the ordinary loader")
 
     remap_fn = getattr(type(pipeline), "_remap_ckpt_key", None)
     if not callable(remap_fn):
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 329ce44dd..53b19c189 100644
--- a/vllm_omni/diffusion/model_metadata.py
+++ b/vllm_omni/diffusion/model_metadata.py
@@ -17,8 +17,14 @@ 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.
+FLUX2_KLEIN_MAX_INPUT_IMAGES = 4
 QWEN_IMAGE_EDIT_PLUS_MAX_INPUT_IMAGES = 4
 # Qwen-Image 2.1 image-conditioned generation caps condition images at 4.
 QWEN_IMAGE_21_MAX_INPUT_IMAGES = 4
@@ -29,6 +35,10 @@ BOOGU_IMAGE_MAX_INPUT_IMAGES = 1
 
 
 _DIFFUSION_MODEL_METADATA: dict[str, DiffusionModelMetadata] = {
+    "Flux2KleinPipeline": DiffusionModelMetadata(
+        supports_multimodal_inputs=True,
+        max_multimodal_image_inputs=FLUX2_KLEIN_MAX_INPUT_IMAGES,
+    ),
     "QwenImageEditPlusPipeline": DiffusionModelMetadata(
         supports_multimodal_inputs=True,
         max_multimodal_image_inputs=QWEN_IMAGE_EDIT_PLUS_MAX_INPUT_IMAGES,
@@ -54,6 +64,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.
@@ -68,6 +79,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/auk/__init__.py b/vllm_omni/diffusion/models/auk/__init__.py
new file mode 100644
index 000000000..fd987d42b
--- /dev/null
+++ b/vllm_omni/diffusion/models/auk/__init__.py
@@ -0,0 +1,16 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""AuK diffusion-stage components: the flow transformer, the codec, the pipeline."""
+
+from vllm_omni.diffusion.models.auk.auk_transformer import AuKTransformer, dit_state_dict, sample_latents
+from vllm_omni.diffusion.models.auk.auk_vae import AuKVAE
+from vllm_omni.diffusion.models.auk.pipeline_auk import AuKPipeline, get_auk_post_process_func
+
+__all__ = [
+    "AuKPipeline",
+    "AuKTransformer",
+    "AuKVAE",
+    "dit_state_dict",
+    "get_auk_post_process_func",
+    "sample_latents",
+]
diff --git a/vllm_omni/diffusion/models/auk/auk_transformer.py b/vllm_omni/diffusion/models/auk/auk_transformer.py
new file mode 100644
index 000000000..5aca8f39b
--- /dev/null
+++ b/vllm_omni/diffusion/models/auk/auk_transformer.py
@@ -0,0 +1,677 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""The AuK audio DiT as a self-contained inference module.
+
+Two phases. ``num_layers`` double-stream blocks attend jointly over text and
+audio while keeping each stream's residual separate, then
+``num_single_layers`` single-stream blocks run over the concatenated
+``[text | ref audio | target audio]`` sequence. Only the target-audio slice is
+projected back to latent space, so the module predicts a flow-matching
+velocity for the target frames and :func:`sample_latents` integrates it.
+
+Parameter names and shapes match the AuK reference backbone, so a released
+checkpoint loads with ``load_state_dict(strict=True)`` once the
+``transformer.`` prefix is stripped (see :func:`dit_state_dict`).
+
+Deliberate differences from the reference, all inference-only:
+
+* ``x_transformers`` and ``torchdiffeq`` are gone. Rotary embeddings are
+  computed here (interleaved GPT-J pairs, no xpos scaling) and the ODE is an
+  explicit Euler loop.
+* Dropout, activation checkpointing, the ``flash_attn`` backend switch and the
+  zero-init of the modulation layers are training concerns and are dropped.
+* The timestep sinusoid is cast to the time MLP's weight dtype rather than to
+  the timestep's own dtype, so an fp32 timestep works against half-precision
+  weights outside autocast.
+* ``attn_mask_enabled`` defaults to ``True``, the value the released config
+  sets, rather than the reference's ``False``.
+"""
+
+import math
+from collections.abc import Iterable, Mapping
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+__all__ = ["AuKTransformer", "dit_state_dict", "sample_latents"]
+
+
+def _sdpa(q: torch.Tensor, k: torch.Tensor, v: torch.Tensor, mask: torch.Tensor | None) -> torch.Tensor:
+    """The single attention call site, so the backend can be swapped in one place.
+
+    ``q``/``k``/``v`` are ``[B, H, N, D]``. ``mask`` is a boolean key-padding
+    mask ``[B, K]`` in which ``True`` marks a valid key; it is broadcast to
+    ``[B, H, Q, K]`` only when given.
+    """
+    attn_mask = None
+    if mask is not None:
+        attn_mask = mask[:, None, None, :].expand(q.shape[0], q.shape[1], q.shape[-2], k.shape[-2])
+    return F.scaled_dot_product_attention(q, k, v, attn_mask=attn_mask, dropout_p=0.0, is_causal=False)
+
+
+def _rotate_half(x: torch.Tensor) -> torch.Tensor:
+    """Rotate interleaved GPT-J pairs: ``(x1, x2) -> (-x2, x1)``."""
+    pairs = x.reshape(*x.shape[:-1], -1, 2)
+    x1, x2 = pairs.unbind(dim=-1)
+    return torch.stack((-x2, x1), dim=-1).flatten(-2)
+
+
+def _apply_rope(x: torch.Tensor, freqs: torch.Tensor) -> torch.Tensor:
+    """Apply rotary frequencies ``[1, 1, N, D]`` to ``x`` ``[B, H, N, D]`` in fp32."""
+    out_dtype = x.dtype
+    x32 = x.float()
+    out = x32 * freqs.cos() + _rotate_half(x32) * freqs.sin()
+    return out.to(out_dtype)
+
+
+class Rotary(nn.Module):
+    """Rotary position frequencies for one stream, evaluated in fp32.
+
+    The frequencies live in a buffer so that a released checkpoint's own copy
+    of them loads with ``strict=True``. They are recomputed whenever the
+    module has been cast below fp32: rounding either the frequencies or the
+    integer positions to bf16 wrecks the phase at long positions.
+    """
+
+    def __init__(self, dim: int, base: float = 10000.0) -> None:
+        super().__init__()
+        if dim % 2 != 0:
+            raise ValueError(f"rotary dim must be even, got {dim}")
+        self.dim = dim
+        self.base = base
+        self.register_buffer("inv_freq", self._frequencies(torch.device("cpu")))
+
+    def _frequencies(self, device: torch.device) -> torch.Tensor:
+        exponents = torch.arange(0, self.dim, 2, device=device, dtype=torch.float32) / self.dim
+        return 1.0 / (self.base**exponents)
+
+    def forward(self, seq_len: int) -> torch.Tensor:
+        """Return frequencies ``[1, 1, seq_len, dim]`` for positions ``0..seq_len-1``."""
+        inv_freq = self.inv_freq
+        if inv_freq.dtype != torch.float32:
+            inv_freq = self._frequencies(inv_freq.device)
+        pos = torch.arange(seq_len, device=inv_freq.device, dtype=torch.float32)
+        freqs = torch.outer(pos, inv_freq)
+        return torch.stack((freqs, freqs), dim=-1).flatten(-2)[None, None]
+
+
+class TimeEmbedding(nn.Module):
+    """Sinusoidal timestep features followed by a two-layer MLP."""
+
+    def __init__(self, dim: int, freq_embed_dim: int = 256) -> None:
+        super().__init__()
+        self.freq_embed_dim = freq_embed_dim
+        self.time_mlp = nn.Sequential(nn.Linear(freq_embed_dim, dim), nn.SiLU(), nn.Linear(dim, dim))
+
+    def forward(self, timestep: torch.Tensor, scale: float = 1000.0) -> torch.Tensor:
+        half = self.freq_embed_dim // 2
+        decay = math.log(10000) / (half - 1)
+        freqs = torch.exp(torch.arange(half, device=timestep.device, dtype=torch.float32) * -decay)
+        angles = scale * timestep.unsqueeze(1) * freqs.unsqueeze(0)
+        hidden = torch.cat((angles.sin(), angles.cos()), dim=-1)
+        return self.time_mlp(hidden.to(self.time_mlp[0].weight.dtype))
+
+
+class ConvPosEmbedding(nn.Module):
+    """Depthwise-grouped conv stack that adds local position information."""
+
+    def __init__(self, dim: int, kernel_size: int = 31, groups: int = 16) -> None:
+        super().__init__()
+        if kernel_size % 2 == 0:
+            raise ValueError(f"kernel_size must be odd, got {kernel_size}")
+        padding = kernel_size // 2
+        self.conv1d = nn.Sequential(
+            nn.Conv1d(dim, dim, kernel_size, groups=groups, padding=padding),
+            nn.Mish(),
+            nn.Conv1d(dim, dim, kernel_size, groups=groups, padding=padding),
+            nn.Mish(),
+        )
+
+    def forward(self, x: torch.Tensor, mask: torch.Tensor | None = None) -> torch.Tensor:
+        keep = None if mask is None else mask.unsqueeze(1)
+        x = x.transpose(1, 2)
+        if keep is not None:
+            x = x.masked_fill(~keep, 0.0)
+        for layer in self.conv1d:
+            x = layer(x)
+            # Re-zero padding after each convolution so it cannot bleed into
+            # valid frames through the kernel window.
+            if keep is not None and isinstance(layer, nn.Conv1d):
+                x = x.masked_fill(~keep, 0.0)
+        return x.transpose(1, 2)
+
+
+class AudioEmbedding(nn.Module):
+    """Project audio latents to model width and add conv position information."""
+
+    def __init__(self, latent_dim: int, dim: int) -> None:
+        super().__init__()
+        self.linear = nn.Linear(latent_dim, dim)
+        self.conv_pos_embed = ConvPosEmbedding(dim)
+
+    def forward(self, x: torch.Tensor, mask: torch.Tensor | None = None) -> torch.Tensor:
+        x = self.linear(x)
+        return self.conv_pos_embed(x, mask=mask) + x
+
+
+class AdaLayerNorm(nn.Module):
+    """Timestep-conditioned modulation for a block: six chunks from one projection."""
+
+    def __init__(self, dim: int) -> None:
+        super().__init__()
+        self.silu = nn.SiLU()
+        self.linear = nn.Linear(dim, dim * 6)
+        self.norm = nn.LayerNorm(dim, elementwise_affine=False, eps=1e-6)
+
+    def forward(
+        self, x: torch.Tensor, emb: torch.Tensor
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.linear(self.silu(emb)).chunk(6, dim=1)
+        x = self.norm(x) * (1 + scale_msa[:, None]) + shift_msa[:, None]
+        return x, gate_msa, shift_mlp, scale_mlp, gate_mlp
+
+
+class AdaLayerNormFinal(nn.Module):
+    """Timestep-conditioned modulation before the output projection."""
+
+    def __init__(self, dim: int) -> None:
+        super().__init__()
+        self.silu = nn.SiLU()
+        self.linear = nn.Linear(dim, dim * 2)
+        self.norm = nn.LayerNorm(dim, elementwise_affine=False, eps=1e-6)
+
+    def forward(self, x: torch.Tensor, emb: torch.Tensor) -> torch.Tensor:
+        scale, shift = self.linear(self.silu(emb)).chunk(2, dim=1)
+        return self.norm(x) * (1 + scale)[:, None, :] + shift[:, None, :]
+
+
+class FeedForward(nn.Module):
+    """SwiGLU feed-forward with the gate projection fused into ``linear_in``."""
+
+    def __init__(self, dim: int, mult: float = 4.0) -> None:
+        super().__init__()
+        inner_dim = int(dim * mult)
+        self.linear_in = nn.Linear(dim, inner_dim * 2, bias=False)
+        self.linear_out = nn.Linear(inner_dim, dim, bias=False)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        gate, up = self.linear_in(x).chunk(2, dim=-1)
+        return self.linear_out(F.silu(gate) * up)
+
+
+class Attention(nn.Module):
+    """Self-attention with per-head QK RMSNorm and rotary positions.
+
+    ``to_out`` stays a ``ModuleList`` because the released checkpoints name the
+    output projection ``to_out.0``; the reference's trailing dropout carries no
+    parameters and is dropped.
+    """
+
+    def __init__(self, dim: int, heads: int, dim_head: int, attn_mask_enabled: bool = True) -> None:
+        super().__init__()
+        self.heads = heads
+        self.dim_head = dim_head
+        self.attn_mask_enabled = attn_mask_enabled
+        inner_dim = heads * dim_head
+        self.to_qkv = nn.Linear(dim, 3 * inner_dim)
+        self.q_norm = nn.RMSNorm(dim_head, elementwise_affine=True)
+        self.k_norm = nn.RMSNorm(dim_head, elementwise_affine=True)
+        self.to_out = nn.ModuleList([nn.Linear(inner_dim, dim)])
+
+    def _merge_heads(self, x: torch.Tensor) -> torch.Tensor:
+        return x.transpose(1, 2).reshape(x.shape[0], -1, self.heads * self.dim_head)
+
+    def _qkv(
+        self,
+        packed: torch.Tensor,
+        q_norm: nn.Module,
+        k_norm: nn.Module,
+        rope: torch.Tensor | None,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        """Split a packed QKV projection into heads, RMSNorm Q/K, then rotate."""
+        q, k, v = (t.view(t.shape[0], -1, self.heads, self.dim_head).transpose(1, 2) for t in packed.chunk(3, dim=-1))
+        q = q_norm(q)
+        k = k_norm(k)
+        if rope is not None:
+            q = _apply_rope(q, rope)
+            k = _apply_rope(k, rope)
+        return q, k, v
+
+    def _project(self, x: torch.Tensor, rope: torch.Tensor | None) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        return self._qkv(self.to_qkv(x), self.q_norm, self.k_norm, rope)
+
+    def forward(
+        self, x: torch.Tensor, mask: torch.Tensor | None = None, rope: torch.Tensor | None = None
+    ) -> torch.Tensor:
+        q, k, v = self._project(x, rope)
+        attn_mask = mask if self.attn_mask_enabled else None
+        out = self._merge_heads(_sdpa(q, k, v, attn_mask).to(q.dtype))
+        out = self.to_out[0](out)
+        if mask is not None:
+            out = out.masked_fill(~mask.unsqueeze(-1), 0.0)
+        return out
+
+
+class JointAttention(Attention):
+    """Attention over the audio and text streams jointly, with separate projections."""
+
+    def __init__(self, dim: int, heads: int, dim_head: int, context_dim: int, attn_mask_enabled: bool = True) -> None:
+        super().__init__(dim, heads, dim_head, attn_mask_enabled)
+        inner_dim = heads * dim_head
+        self.to_qkv_c = nn.Linear(context_dim, 3 * inner_dim)
+        self.c_q_norm = nn.RMSNorm(dim_head, elementwise_affine=True)
+        self.c_k_norm = nn.RMSNorm(dim_head, elementwise_affine=True)
+        self.to_out_c = nn.Linear(inner_dim, context_dim)
+
+    def _project_context(self, c: torch.Tensor, c_rope: torch.Tensor | None) -> tuple[torch.Tensor, ...]:
+        return self._qkv(self.to_qkv_c(c), self.c_q_norm, self.c_k_norm, c_rope)
+
+    def forward(  # type: ignore[override]  # joint attention takes the context stream too
+        self,
+        x: torch.Tensor,
+        c: torch.Tensor,
+        mask: torch.Tensor | None = None,
+        rope: torch.Tensor | None = None,
+        c_rope: torch.Tensor | None = None,
+        c_mask: torch.Tensor | None = None,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        audio_len = x.shape[1]
+        q, k, v = self._project(x, rope)
+        c_q, c_k, c_v = self._project_context(c, c_rope)
+
+        q = torch.cat([q, c_q], dim=2)
+        k = torch.cat([k, c_k], dim=2)
+        v = torch.cat([v, c_v], dim=2)
+
+        joint_mask = None
+        if self.attn_mask_enabled and mask is not None:
+            if c_mask is not None:
+                joint_mask = torch.cat([mask, c_mask], dim=1)
+            else:
+                joint_mask = F.pad(mask, (0, c.shape[1]), value=True)
+
+        out = self._merge_heads(_sdpa(q, k, v, joint_mask).to(q.dtype))
+        x_out = self.to_out[0](out[:, :audio_len])
+        c_out = self.to_out_c(out[:, audio_len:])
+
+        if mask is not None:
+            x_out = x_out.masked_fill(~mask.unsqueeze(-1), 0.0)
+        if c_mask is not None:
+            c_out = c_out.masked_fill(~c_mask.unsqueeze(-1), 0.0)
+        return x_out, c_out
+
+
+class DoubleBlock(nn.Module):
+    """MM-DiT block: joint attention, separate modulation and feed-forward per stream."""
+
+    def __init__(self, dim: int, heads: int, dim_head: int, ff_mult: float, attn_mask_enabled: bool) -> None:
+        super().__init__()
+        self.attn_norm_c = AdaLayerNorm(dim)
+        self.attn_norm_x = AdaLayerNorm(dim)
+        self.attn = JointAttention(
+            dim=dim, heads=heads, dim_head=dim_head, context_dim=dim, attn_mask_enabled=attn_mask_enabled
+        )
+        self.ff_norm_c = nn.LayerNorm(dim, elementwise_affine=False, eps=1e-6)
+        self.ff_c = FeedForward(dim=dim, mult=ff_mult)
+        self.ff_norm_x = nn.LayerNorm(dim, elementwise_affine=False, eps=1e-6)
+        self.ff_x = FeedForward(dim=dim, mult=ff_mult)
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        c: torch.Tensor,
+        t: torch.Tensor,
+        mask: torch.Tensor | None,
+        rope: torch.Tensor,
+        c_rope: torch.Tensor,
+        c_mask: torch.Tensor | None,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        norm_c, c_gate_msa, c_shift_mlp, c_scale_mlp, c_gate_mlp = self.attn_norm_c(c, t)
+        norm_x, x_gate_msa, x_shift_mlp, x_scale_mlp, x_gate_mlp = self.attn_norm_x(x, t)
+
+        x_attn, c_attn = self.attn(x=norm_x, c=norm_c, mask=mask, rope=rope, c_rope=c_rope, c_mask=c_mask)
+
+        c = c + c_gate_msa[:, None] * c_attn
+        norm_c = self.ff_norm_c(c) * (1 + c_scale_mlp[:, None]) + c_shift_mlp[:, None]
+        c = c + c_gate_mlp[:, None] * self.ff_c(norm_c)
+
+        x = x + x_gate_msa[:, None] * x_attn
+        norm_x = self.ff_norm_x(x) * (1 + x_scale_mlp[:, None]) + x_shift_mlp[:, None]
+        x = x + x_gate_mlp[:, None] * self.ff_x(norm_x)
+        return c, x
+
+
+class SingleBlock(nn.Module):
+    """DiT block over the concatenated text and audio sequence."""
+
+    def __init__(self, dim: int, heads: int, dim_head: int, ff_mult: float, attn_mask_enabled: bool) -> None:
+        super().__init__()
+        self.attn_norm = AdaLayerNorm(dim)
+        self.attn = Attention(dim=dim, heads=heads, dim_head=dim_head, attn_mask_enabled=attn_mask_enabled)
+        self.ff_norm = nn.LayerNorm(dim, elementwise_affine=False, eps=1e-6)
+        self.ff = FeedForward(dim=dim, mult=ff_mult)
+
+    def forward(self, x: torch.Tensor, t: torch.Tensor, mask: torch.Tensor | None, rope: torch.Tensor) -> torch.Tensor:
+        norm, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.attn_norm(x, t)
+        x = x + gate_msa[:, None] * self.attn(x=norm, mask=mask, rope=rope)
+        norm = self.ff_norm(x) * (1 + scale_mlp[:, None]) + shift_mlp[:, None]
+        return x + gate_mlp[:, None] * self.ff(norm)
+
+
+class AuKTransformer(nn.Module):
+    """Flow-matching velocity predictor for AuK audio latents.
+
+    Args:
+        dim: Model width.
+        heads: Attention heads.
+        dim_head: Per-head width.
+        ff_mult: Feed-forward expansion factor.
+        latent_dim: Audio VAE latent channels, the input and output width.
+        text_hidden_dim: Width of the pre-encoded text hidden states.
+        num_layers: Double-stream (joint attention) block count.
+        num_single_layers: Single-stream block count.
+        attn_mask_enabled: Apply padding masks inside attention. When ``False``
+            attention runs unmasked, though padded outputs are still zeroed,
+            which is what the reference does with the flag off.
+    """
+
+    def __init__(
+        self,
+        *,
+        dim: int,
+        heads: int,
+        dim_head: int,
+        ff_mult: float,
+        latent_dim: int,
+        text_hidden_dim: int,
+        num_layers: int,
+        num_single_layers: int,
+        attn_mask_enabled: bool = True,
+    ) -> None:
+        super().__init__()
+        self.dim = dim
+        self.latent_dim = latent_dim
+        self.text_cond: torch.Tensor | None = None
+        self.text_uncond: torch.Tensor | None = None
+
+        self.time_embed = TimeEmbedding(dim)
+        self.txt_norm = nn.RMSNorm(dim, elementwise_affine=True)
+        self.txt_proj = nn.Linear(text_hidden_dim, dim)
+        self.audio_embed = AudioEmbedding(latent_dim, dim)
+        self.rotary_embed = Rotary(dim_head)
+
+        self.transformer_blocks = nn.ModuleList(
+            [
+                DoubleBlock(
+                    dim=dim, heads=heads, dim_head=dim_head, ff_mult=ff_mult, attn_mask_enabled=attn_mask_enabled
+                )
+                for _ in range(num_layers)
+            ]
+        )
+        self.single_transformer_blocks = nn.ModuleList(
+            [
+                SingleBlock(
+                    dim=dim, heads=heads, dim_head=dim_head, ff_mult=ff_mult, attn_mask_enabled=attn_mask_enabled
+                )
+                for _ in range(num_single_layers)
+            ]
+        )
+
+        self.norm_out = AdaLayerNormFinal(dim)
+        self.proj_out = nn.Linear(dim, latent_dim)
+
+    def project_text(self, text: torch.Tensor) -> torch.Tensor:
+        """Project LLM hidden states ``[B, nt, text_hidden_dim]`` to model width."""
+        return self.txt_norm(self.txt_proj(text))
+
+    def clear_cache(self) -> None:
+        """Drop the cached text projection. Call this when the conditioning changes."""
+        self.text_cond = None
+        self.text_uncond = None
+
+    def _embed_audio(
+        self,
+        x: torch.Tensor,
+        ref: torch.Tensor | None,
+        drop_audio_cond: bool,
+        mask: torch.Tensor | None,
+        ref_mask: torch.Tensor | None,
+    ) -> tuple[torch.Tensor, torch.Tensor | None, int]:
+        """Embed the target latents, prepending the reference prompt when present.
+
+        Returns the ``[ref | target]`` sequence, its padding mask and the
+        reference length, which the caller uses to slice the target back out.
+        """
+        if ref is not None and ref.shape[1] == 0:
+            ref = None
+
+        target = self.audio_embed(x, mask=mask)
+        if ref is None:
+            return target, mask, 0
+
+        if drop_audio_cond:
+            ref = torch.zeros_like(ref)
+        prompt = self.audio_embed(ref, mask=ref_mask)
+        audio = torch.cat([prompt, target], dim=1)
+        prompt_len = prompt.shape[1]
+
+        audio_mask = None
+        if mask is not None or ref_mask is not None:
+            if mask is None:
+                mask = x.new_ones(x.shape[:2], dtype=torch.bool)
+            if ref_mask is None:
+                ref_mask = ref.new_ones(ref.shape[:2], dtype=torch.bool)
+            audio_mask = torch.cat([ref_mask, mask], dim=1)
+        return audio, audio_mask, prompt_len
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        text: torch.Tensor,
+        time: torch.Tensor,
+        *,
+        mask: torch.Tensor | None = None,
+        c_mask: torch.Tensor | None = None,
+        ref: torch.Tensor | None = None,
+        ref_mask: torch.Tensor | None = None,
+        drop_audio_cond: bool = False,
+        drop_text: bool = False,
+        cfg_infer: bool = False,
+        cache: bool = False,
+    ) -> torch.Tensor:
+        """Predict the flow-matching velocity for the target frames of ``x``.
+
+        Args:
+            x: Noised target latents ``[B, n, latent_dim]``.
+            text: Pre-encoded text hidden states ``[B, nt, text_hidden_dim]``.
+            time: Flow-matching timestep, a scalar or ``[B]``.
+            mask: Target padding mask ``[B, n]``, ``True`` where valid.
+            c_mask: Text padding mask ``[B, nt]``. Inferred from all-zero text
+                rows when omitted.
+            ref: Reference prompt latents ``[B, np, latent_dim]``, prepended to
+                the audio sequence. A zero-length ``ref`` counts as absent.
+            ref_mask: Reference padding mask ``[B, np]``.
+            drop_audio_cond: Zero the reference prompt, for the CFG uncond branch.
+            drop_text: Zero the projected text, for the CFG uncond branch.
+            cfg_infer: Run the cond and uncond branches as one batch of ``2B``,
+                cond first. ``drop_audio_cond`` and ``drop_text`` are then
+                driven per branch and ignored.
+            cache: Reuse the projected text across calls, for an ODE loop over
+                fixed conditioning. Only the ``cfg_infer`` path caches, as in
+                the reference. Call :meth:`clear_cache` when the text changes.
+
+        Returns:
+            Velocity ``[B, n, latent_dim]``, or ``[2B, n, latent_dim]`` under
+            ``cfg_infer``.
+        """
+        batch = x.shape[0]
+        if time.ndim == 0:
+            time = time.repeat(batch)
+        t = self.time_embed(time)
+
+        if c_mask is None:
+            # Padding rows are all-zero in the text encoder's output.
+            c_mask = text.abs().sum(-1) > 0
+
+        if cfg_infer:
+            if cache and self.text_cond is not None:
+                c_cond, c_uncond = self.text_cond, self.text_uncond
+            else:
+                c_cond = self.project_text(text)
+                # The uncond branch drops the text, which is exactly a zeroed projection.
+                c_uncond = torch.zeros_like(c_cond)
+                if cache:
+                    self.text_cond, self.text_uncond = c_cond, c_uncond
+            x_cond, mask_cond, prompt_len = self._embed_audio(x, ref, False, mask, ref_mask)
+            x_uncond, mask_uncond, _ = self._embed_audio(x, ref, True, mask, ref_mask)
+
+            x = torch.cat((x_cond, x_uncond), dim=0)
+            c = torch.cat((c_cond, c_uncond), dim=0)
+            t = torch.cat((t, t), dim=0)
+            c_mask = torch.cat((c_mask, c_mask), dim=0)
+            audio_mask = None
+            if mask_cond is not None and mask_uncond is not None:
+                audio_mask = torch.cat((mask_cond, mask_uncond), dim=0)
+        else:
+            c = self.project_text(text)
+            if drop_text:
+                c = torch.zeros_like(c)
+            x, audio_mask, prompt_len = self._embed_audio(x, ref, drop_audio_cond, mask, ref_mask)
+
+        seq_len = x.shape[1]
+        text_len = c.shape[1]
+        rope_audio = self.rotary_embed(seq_len)
+        rope_text = self.rotary_embed(text_len)
+
+        for block in self.transformer_blocks:
+            c, x = block(x, c, t, mask=audio_mask, rope=rope_audio, c_rope=rope_text, c_mask=c_mask)
+
+        x = torch.cat([c, x], dim=1)
+        rope = self.rotary_embed(text_len + seq_len)
+        single_mask = None if audio_mask is None else torch.cat([c_mask, audio_mask], dim=1)
+
+        for block in self.single_transformer_blocks:
+            x = block(x, t, mask=single_mask, rope=rope)
+
+        x = x[:, text_len + prompt_len :]
+        return self.proj_out(self.norm_out(x, t))
+
+
+def dit_state_dict(
+    checkpoint: Mapping[str, torch.Tensor] | Iterable[tuple[str, torch.Tensor]],
+    prefix: str = "transformer.",
+) -> dict[str, torch.Tensor]:
+    """Select the DiT tensors out of a full AuK checkpoint and strip ``prefix``.
+
+    Released checkpoints wrap the backbone under ``transformer.`` alongside the
+    text-encoder layer-fusion parameters, which this module does not own.
+    """
+    items = checkpoint.items() if isinstance(checkpoint, Mapping) else checkpoint
+    return {name[len(prefix) :]: tensor for name, tensor in items if name.startswith(prefix)}
+
+
+@torch.no_grad()
+def sample_latents(
+    dit: AuKTransformer,
+    *,
+    text: torch.Tensor,
+    c_mask: torch.Tensor | None,
+    ref: torch.Tensor,
+    ref_mask: torch.Tensor | None,
+    gen_frames: int,
+    nfe: int = 32,
+    cfg_strength: float = 1.0,
+    sway_sampling_coef: float | None = None,
+    t_grid: list[float] | None = None,
+    seed: int | None = None,
+    generator: torch.Generator | None = None,
+    latent_dim: int | None = None,
+    device: torch.device | str | None = None,
+    dtype: torch.dtype | None = None,
+) -> torch.Tensor:
+    """Integrate the flow from noise to audio latents with explicit Euler steps.
+
+    Single-request only: the batch dimension carries the CFG branches, not
+    separate prompts, so no target padding mask is needed.
+
+    Args:
+        dit: The velocity model.
+        text: Pre-encoded text hidden states ``[1, nt, text_hidden_dim]``.
+        c_mask: Text padding mask ``[1, nt]``.
+        ref: Reference prompt latents ``[1, np, latent_dim]``.
+        ref_mask: Reference padding mask ``[1, np]``.
+        gen_frames: Target latent frames to generate.
+        nfe: Euler steps, ignored when ``t_grid`` is given.
+        cfg_strength: Classifier-free guidance weight. Below ``1e-5`` the
+            uncond branch is skipped entirely.
+        sway_sampling_coef: Reshapes the uniform time grid towards ``t=0``.
+        t_grid: Explicit timesteps, overriding ``nfe`` and the sway reshape.
+        seed: Seeds the global RNG before drawing the noise. Ignored when
+            ``generator`` is given.
+        generator: Draws the initial noise from its own RNG, leaving the global
+            one untouched.
+        latent_dim: Latent channels; defaults to the model's.
+        device: Device for the noise; defaults to the reference's.
+        dtype: Dtype for the noise and the Euler accumulator; defaults to the
+            reference's, which is the reference implementation's rule. Pass
+            ``torch.float32`` explicitly when serving half-precision weights.
+            Drawing the noise at bf16 instead of fp32 moves a 32-step CFG
+            trajectory by 0.025 relative MSE, roughly 17 times what bf16
+            weights themselves cost, because the draw consumes the generator
+            differently and starts the ODE somewhere else. Keeping it fp32
+            costs a few tens of KB and no measurable time.
+
+    Returns:
+        The target latents at ``t=1``, ``[1, gen_frames, latent_dim]``.
+    """
+    device = torch.device(device) if device is not None else ref.device
+    dtype = dtype if dtype is not None else ref.dtype
+    latent_dim = latent_dim if latent_dim is not None else dit.latent_dim
+
+    if generator is None:
+        if seed is not None:
+            torch.manual_seed(seed)
+        x = torch.randn(gen_frames, latent_dim, device=device, dtype=dtype).unsqueeze(0)
+    else:
+        x = (
+            torch.randn(gen_frames, latent_dim, generator=generator, device=generator.device, dtype=dtype)
+            .to(device)
+            .unsqueeze(0)
+        )
+
+    if t_grid is not None:
+        t = torch.tensor(t_grid, device=device, dtype=torch.float32)
+    else:
+        t = torch.linspace(0, 1, nfe + 1, device=device, dtype=torch.float32)
+        if sway_sampling_coef is not None:
+            t = t + sway_sampling_coef * (torch.cos(math.pi / 2 * t) - 1 + t)
+
+    guided = cfg_strength >= 1e-5
+    if t.numel() < 2 or not bool(torch.all(t[1:] > t[:-1])):
+        raise ValueError(
+            f"AuK sampling needs a strictly increasing time grid with at least two points; got {t.tolist()}"
+        )
+    try:
+        for i in range(t.shape[0] - 1):
+            if guided:
+                pred = dit(
+                    x,
+                    text,
+                    t[i],
+                    c_mask=c_mask,
+                    ref=ref,
+                    ref_mask=ref_mask,
+                    cfg_infer=True,
+                    cache=True,
+                )
+                v_cond, v_uncond = pred.chunk(2, dim=0)
+                v = v_cond + (v_cond - v_uncond) * cfg_strength
+            else:
+                v = dit(x, text, t[i], c_mask=c_mask, ref=ref, ref_mask=ref_mask)
+            x = x + (t[i + 1] - t[i]) * v
+    finally:
+        # The cached text projections belong to this request only; a failed
+        # step must not leak them into the next one.
+        dit.clear_cache()
+    return x
diff --git a/vllm_omni/diffusion/models/auk/auk_vae.py b/vllm_omni/diffusion/models/auk/auk_vae.py
new file mode 100644
index 000000000..1fabeb327
--- /dev/null
+++ b/vllm_omni/diffusion/models/auk/auk_vae.py
@@ -0,0 +1,505 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+#
+# Adapted from the AuK reference release (MIT), which in turn adapts NVIDIA
+# BigVGAN (MIT), jik876/hifi-gan (MIT), junjun3518/alias-free-torch
+# (Apache-2.0), EdwardDixon/snake (MIT) and adefossez/julius (MIT).
+"""BigVGAN-flow VAE for AuK: 24 kHz mono waveform <-> 50 Hz, 64-channel latents.
+
+Inference only. The reference module also carries a residual coupling flow, a KL
+term and a discriminator; all three are training-only, so the released
+``flow.*`` tensors are skipped (see :meth:`AuKVAE.load_weights`).
+
+Parameter and buffer names follow the reference release, so the published
+``vae.safetensors`` loads without a key map. That is also why the convolutions
+are built with the legacy ``weight_norm`` parametrization (``weight_g`` /
+``weight_v``): :meth:`remove_weight_norm` folds them into plain weights once
+the checkpoint is in.
+"""
+
+from __future__ import annotations
+
+import inspect
+import math
+import warnings
+from pathlib import Path
+
+import torch
+import torch.nn.functional as F
+from safetensors.torch import load_file
+from torch import nn
+from torch.nn.utils import remove_weight_norm as _fold_weight_norm
+from torch.nn.utils import weight_norm as _apply_weight_norm
+from vllm.logger import init_logger
+
+logger = init_logger(__name__)
+
+__all__ = ["AuKVAE"]
+
+# Checkpoint prefix owned by the training-only coupling flow.
+TRAINING_ONLY_PREFIX = "flow."
+
+
+def _weight_norm(module: nn.Module) -> nn.Module:
+    """Legacy ``weight_g``/``weight_v`` split, which is how the release stores these tensors."""
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore", message=".*weight_norm.*deprecated.*", category=FutureWarning)
+        return _apply_weight_norm(module)
+
+
+def _same_padding(kernel_size: int, dilation: int = 1) -> int:
+    return int((kernel_size * dilation - dilation) / 2)
+
+
+def _kaiser_sinc_filter(cutoff: float, half_width: float, kernel_size: int) -> torch.Tensor:
+    """Kaiser-windowed sinc low-pass, returned as a ``[1, 1, kernel_size]`` conv kernel."""
+    half_size = kernel_size // 2
+    attenuation = 2.285 * (half_size - 1) * math.pi * (4 * half_width) + 7.95
+    if attenuation > 50.0:
+        beta = 0.1102 * (attenuation - 8.7)
+    elif attenuation >= 21.0:
+        beta = 0.5842 * (attenuation - 21.0) ** 0.4 + 0.07886 * (attenuation - 21.0)
+    else:
+        beta = 0.0
+    window = torch.kaiser_window(kernel_size, beta=beta, periodic=False)
+    if kernel_size % 2 == 0:
+        time = torch.arange(-half_size, half_size) + 0.5
+    else:
+        time = torch.arange(kernel_size) - half_size
+    if cutoff == 0:
+        return torch.zeros_like(time).view(1, 1, kernel_size)
+    taps = 2 * cutoff * window * torch.sinc(2 * cutoff * time)
+    # Normalize to unit sum so a constant input passes through unscaled.
+    return (taps / taps.sum()).view(1, 1, kernel_size)
+
+
+class Conv(nn.Conv1d):
+    """1-D convolution over ``[B, C, T]``; ``causal`` swaps centred padding for a left pad."""
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        kernel_size: int = 1,
+        stride: int = 1,
+        dilation: int = 1,
+        bias: bool = True,
+        causal: bool = False,
+    ) -> None:
+        super().__init__(
+            in_channels,
+            out_channels,
+            kernel_size,
+            stride=stride,
+            padding=0 if causal else _same_padding(kernel_size, dilation),
+            dilation=dilation,
+            bias=bias,
+        )
+        self.causal = causal
+        self.left_padding = dilation * (kernel_size - 1) if causal else 0
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        if self.causal:
+            x = F.pad(x, (self.left_padding, 0))
+        return super().forward(x)
+
+
+class ConvTranspose(nn.ConvTranspose1d):
+    """Transposed 1-D convolution; ``causal`` drops the trailing ``stride`` samples instead of padding."""
+
+    def __init__(
+        self, in_channels: int, out_channels: int, kernel_size: int, stride: int, causal: bool = False
+    ) -> None:
+        if causal and kernel_size != 2 * stride:
+            raise ValueError(f"causal ConvTranspose needs kernel_size == 2 * stride, got {kernel_size} and {stride}")
+        super().__init__(
+            in_channels,
+            out_channels,
+            kernel_size,
+            stride=stride,
+            padding=0 if causal else (kernel_size - stride) // 2,
+        )
+        self.causal = causal
+        self.trim = stride
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = super().forward(x)
+        return x[:, :, : -self.trim] if self.causal else x
+
+
+class NormConv(nn.Module):
+    """Weight-normalized conv held under ``layer``; the attribute name is load-bearing for the checkpoint."""
+
+    def __init__(self, in_channels: int, out_channels: int, kernel_size: int = 1, stride: int = 1) -> None:
+        super().__init__()
+        self.layer = _weight_norm(
+            nn.Conv1d(in_channels, out_channels, kernel_size, stride=stride, padding=(kernel_size - 1) // 2)
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.layer(x)
+
+
+class ResStack(nn.Module):
+    """Stack of dilated residual conv pairs. The leaky slope is torch's 0.01 default, as upstream."""
+
+    def __init__(self, channels: int, kernel_size: int = 3, base: int = 3, nums: int = 4) -> None:
+        super().__init__()
+        self.layers = nn.ModuleList(
+            [
+                nn.Sequential(
+                    nn.LeakyReLU(),
+                    _weight_norm(nn.Conv1d(channels, channels, kernel_size, dilation=base**i, padding=base**i)),
+                    nn.LeakyReLU(),
+                    _weight_norm(nn.Conv1d(channels, channels, kernel_size, dilation=1, padding=1)),
+                )
+                for i in range(nums)
+            ]
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        for layer in self.layers:
+            x = x + layer(x)
+        return x
+
+
+class Encoder(nn.Module):
+    """Strided conv encoder over ``[B, 1, T]``, emitting ``[B, 2 * latent_dim, T / hop]`` mean/log-std pairs."""
+
+    def __init__(
+        self,
+        latent_dim: int,
+        channels: tuple[int, ...],
+        down_sample_factors: tuple[int, ...],
+        in_channels: int = 1,
+        proj_kernel_size: int = 3,
+        stack_kernel_size: int = 3,
+        stack_dilation_base: int = 2,
+        stacks: int = 6,
+    ) -> None:
+        super().__init__()
+        layers: list[nn.Module] = [
+            NormConv(in_channels, channels[0], kernel_size=proj_kernel_size),
+            nn.LeakyReLU(0.2, True),
+        ]
+        for in_c, out_c, factor in zip(channels[:-1], channels[1:], down_sample_factors, strict=True):
+            layers += [
+                NormConv(in_c, out_c, kernel_size=factor * 2, stride=factor),
+                ResStack(out_c, stack_kernel_size, stack_dilation_base, stacks),
+                nn.LeakyReLU(0.2, True),
+            ]
+        layers.append(NormConv(channels[-1], latent_dim * 2, kernel_size=proj_kernel_size))
+        self.generator = nn.Sequential(*layers)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.generator(x)
+
+
+class SnakeBeta(nn.Module):
+    """``x + sin^2(alpha * x) / beta`` with per-channel learned alpha and beta (log-scale in AuK)."""
+
+    def __init__(self, channels: int, alpha_logscale: bool = False) -> None:
+        super().__init__()
+        self.alpha_logscale = alpha_logscale
+        init = torch.zeros(channels) if alpha_logscale else torch.ones(channels)
+        self.alpha = nn.Parameter(init.clone())
+        self.beta = nn.Parameter(init.clone())
+        self.eps = 1e-9
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        alpha = self.alpha.unsqueeze(0).unsqueeze(-1)
+        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.eps)) * torch.sin(x * alpha).pow(2)
+
+
+class LowPass(nn.Module):
+    """Fixed FIR low-pass with replicate padding, applied per channel."""
+
+    def __init__(
+        self,
+        cutoff: float = 0.5,
+        half_width: float = 0.6,
+        stride: int = 1,
+        kernel_size: int = 12,
+        causal: bool = False,
+    ) -> None:
+        super().__init__()
+        if not 0.0 <= cutoff <= 0.5:
+            raise ValueError(f"cutoff must lie in [0, 0.5], got {cutoff}")
+        if causal:
+            self.pad_left, self.pad_right = kernel_size - 1, 0
+        else:
+            even = kernel_size % 2 == 0
+            self.pad_left = kernel_size // 2 - int(even)
+            self.pad_right = kernel_size // 2
+        self.stride = stride
+        self.register_buffer("filter", _kaiser_sinc_filter(cutoff, half_width, kernel_size))
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        channels = x.size(1)
+        x = F.pad(x, (self.pad_left, self.pad_right), mode="replicate")
+        return F.conv1d(x, self.filter.expand(channels, -1, -1), stride=self.stride, groups=channels)
+
+
+class Upsample(nn.Module):
+    """Band-limited interpolation by ``ratio``. Always non-causal, matching how AuK builds it."""
+
+    def __init__(self, ratio: int = 2, kernel_size: int = 12) -> None:
+        super().__init__()
+        self.ratio = ratio
+        self.pad = kernel_size // ratio - 1
+        self.pad_left = self.pad * ratio + (kernel_size - ratio) // 2
+        self.pad_right = self.pad * ratio + (kernel_size - ratio + 1) // 2
+        self.register_buffer("filter", _kaiser_sinc_filter(0.5 / ratio, 0.6 / ratio, kernel_size))
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        channels = x.size(1)
+        x = F.pad(x, (self.pad, self.pad), mode="replicate")
+        x = self.ratio * F.conv_transpose1d(x, self.filter.expand(channels, -1, -1), stride=self.ratio, groups=channels)
+        return x[..., self.pad_left : -self.pad_right]
+
+
+class Downsample(nn.Module):
+    """Decimation by ``ratio`` behind a low-pass; ``lowpass`` holds the filter buffer."""
+
+    def __init__(self, ratio: int = 2, kernel_size: int = 12, causal: bool = False) -> None:
+        super().__init__()
+        self.lowpass = LowPass(
+            cutoff=0.5 / ratio, half_width=0.6 / ratio, stride=ratio, kernel_size=kernel_size, causal=causal
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.lowpass(x)
+
+
+class AliasFreeActivation(nn.Module):
+    """Oversample, apply the pointwise activation, decimate, so snake harmonics do not fold back."""
+
+    def __init__(
+        self,
+        activation: nn.Module,
+        up_ratio: int = 2,
+        down_ratio: int = 2,
+        up_kernel_size: int = 12,
+        down_kernel_size: int = 12,
+        causal: bool = False,
+    ) -> None:
+        super().__init__()
+        self.act = activation
+        self.upsample = Upsample(up_ratio, up_kernel_size)
+        self.downsample = Downsample(down_ratio, down_kernel_size, causal=causal)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.downsample(self.act(self.upsample(x)))
+
+
+class AmpBlock(nn.Module):
+    """Anti-aliased multi-periodicity residual block: alternating alias-free snake and dilated convs."""
+
+    def __init__(
+        self,
+        channels: int,
+        kernel_size: int,
+        dilations: tuple[int, ...],
+        snake_logscale: bool = True,
+        causal: bool = True,
+        act_causal: bool = False,
+    ) -> None:
+        super().__init__()
+        self.convs1 = nn.ModuleList(
+            [_weight_norm(Conv(channels, channels, kernel_size, 1, dilation=d, causal=causal)) for d in dilations]
+        )
+        self.convs2 = nn.ModuleList(
+            [_weight_norm(Conv(channels, channels, kernel_size, 1, dilation=1, causal=causal)) for _ in dilations]
+        )
+        self.activations = nn.ModuleList(
+            [
+                AliasFreeActivation(SnakeBeta(channels, alpha_logscale=snake_logscale), causal=act_causal)
+                for _ in range(len(self.convs1) + len(self.convs2))
+            ]
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        acts1, acts2 = self.activations[::2], self.activations[1::2]
+        for conv1, conv2, act1, act2 in zip(self.convs1, self.convs2, acts1, acts2, strict=True):
+            x = conv2(act2(conv1(act1(x)))) + x
+        return x
+
+
+class AuKVAE(nn.Module):
+    """AuK's audio codec: :meth:`encode` waveform to normalized latents, :meth:`decode` back.
+
+    Build from the released ``model.vae.model_init_kwargs`` with :meth:`from_config`, then
+    :meth:`load_weights`. Latents are normalized by the checkpoint's global statistics, which is
+    the space the rectified-flow transformer works in.
+    """
+
+    def __init__(
+        self,
+        *,
+        upsample_rates: tuple[int, ...] = (5, 4, 3, 2, 2, 2),
+        upsample_kernel_sizes: tuple[int, ...] = (10, 8, 6, 4, 4, 4),
+        upsample_initial_channel: int = 1536,
+        resblock_kernel_sizes: tuple[int, ...] = (3, 7, 11),
+        resblock_dilation_sizes: tuple[tuple[int, ...], ...] = ((1, 3, 5), (1, 3, 5), (1, 3, 5)),
+        downsample_rates: tuple[int, ...] = (2, 2, 2, 3, 4, 5),
+        downsample_channels: tuple[int, ...] = (12, 24, 48, 96, 192, 384, 768),
+        snake_logscale: bool = True,
+        latent_dim: int = 64,
+        use_vae: bool = True,
+        causal: bool = True,
+        act_causal: bool = True,
+        sample_rate: int = 24000,
+    ) -> None:
+        super().__init__()
+        if not use_vae:
+            raise ValueError("AuKVAE requires use_vae=True: the encoder head emits mean/log-std pairs")
+        self.latent_dim = latent_dim
+        self.sample_rate = sample_rate
+        self.hop_size = math.prod(downsample_rates)
+        self.num_kernels = len(resblock_kernel_sizes)
+        self.num_upsamples = len(upsample_rates)
+        self._norm_folded = False
+
+        self.register_buffer("global_mean", torch.zeros(latent_dim, dtype=torch.float32))
+        self.register_buffer("global_log_std", torch.ones(latent_dim, dtype=torch.float32))
+
+        self.audio_encoder = Encoder(
+            latent_dim=latent_dim,
+            channels=tuple(downsample_channels),
+            down_sample_factors=tuple(downsample_rates),
+        )
+
+        self.conv_pre = _weight_norm(Conv(latent_dim, upsample_initial_channel, 7, 1, causal=False))
+        self.ups = nn.ModuleList()
+        for i, (rate, kernel) in enumerate(zip(upsample_rates, upsample_kernel_sizes, strict=True)):
+            # One-element inner list: the checkpoint keys are ``ups.<i>.0.*``.
+            self.ups.append(
+                nn.ModuleList(
+                    [
+                        _weight_norm(
+                            ConvTranspose(
+                                upsample_initial_channel // (2**i),
+                                upsample_initial_channel // (2 ** (i + 1)),
+                                kernel,
+                                rate,
+                                causal=causal,
+                            )
+                        )
+                    ]
+                )
+            )
+
+        self.resblocks = nn.ModuleList()
+        channels = upsample_initial_channel
+        for i in range(self.num_upsamples):
+            channels = upsample_initial_channel // (2 ** (i + 1))
+            for kernel, dilations in zip(resblock_kernel_sizes, resblock_dilation_sizes, strict=True):
+                self.resblocks.append(
+                    AmpBlock(
+                        channels,
+                        kernel,
+                        tuple(dilations),
+                        snake_logscale=snake_logscale,
+                        causal=causal,
+                        act_causal=act_causal,
+                    )
+                )
+
+        self.activation_post = AliasFreeActivation(
+            SnakeBeta(channels, alpha_logscale=snake_logscale), causal=act_causal
+        )
+        self.conv_post = _weight_norm(Conv(channels, 1, 7, 1, causal=causal, bias=False))
+
+    @classmethod
+    def from_config(cls, cfg: dict) -> AuKVAE:
+        """Build from the released ``model_init_kwargs`` mapping, ignoring training-only entries."""
+        accepted = set(inspect.signature(cls.__init__).parameters) - {"self"}
+        return cls(**{key: value for key, value in cfg.items() if key in accepted})
+
+    def load_weights(
+        self, path: str | Path, *, device: str | torch.device | None = None, fold_weight_norm: bool = True
+    ) -> tuple[list[str], list[str]]:
+        """Load a released ``vae.safetensors``, then fold weight norm away. Returns (missing, unexpected).
+
+        ``device`` defaults to where the module already lives, which is the placement that matters:
+        the fold reduces ``weight_v`` to a norm, and a CPU reduction lands up to one ULP away from the
+        accelerator's. The encoder amplifies its activations roughly fiftyfold, so that one ULP grows
+        into a ~4e-4 relative drift by the latent head. Move the module first, then load.
+        """
+        target = self.global_mean.device if device is None else torch.device(device)
+        missing, unexpected = self.load_state_dict(load_file(str(path), device=str(target)), strict=False)
+        missing, unexpected = list(missing), list(unexpected)
+        stray = [key for key in missing + unexpected if not key.startswith(TRAINING_ONLY_PREFIX)]
+        if stray:
+            raise ValueError(f"AuK VAE weights at {path} do not match this module: {sorted(stray)[:8]}")
+        logger.info(
+            "Loaded AuK VAE from %s (skipped %d training-only %s* tensors)", path, len(unexpected), TRAINING_ONLY_PREFIX
+        )
+        if fold_weight_norm:
+            self.remove_weight_norm()
+        return missing, unexpected
+
+    def remove_weight_norm(self) -> None:
+        """Fold ``weight_g``/``weight_v`` into plain weights, on whichever device the module is on.
+
+        Idempotent, and meant to run once the checkpoint is in. See :meth:`load_weights` for why the
+        device this runs on is a numeric decision rather than a convenience.
+        """
+        if self._norm_folded:
+            return
+        folded = 0
+        for module in self.modules():
+            if hasattr(module, "weight_g"):
+                _fold_weight_norm(module)
+                folded += 1
+        self._norm_folded = True
+        logger.debug("Folded weight norm on %d AuK VAE convolutions", folded)
+
+    def encode(
+        self, wav: torch.Tensor, *, sample: bool = False, generator: torch.Generator | None = None
+    ) -> torch.Tensor:
+        """Encode a mono ``[1, T]`` waveform at :attr:`sample_rate` into ``[1, T / hop_size, latent_dim]``.
+
+        ``sample=False`` takes the posterior mean, which is what a reproducible pipeline wants;
+        ``sample=True`` draws ``mean + randn * exp(log_std)`` from ``generator``. Latents come back
+        normalized by the checkpoint's global statistics.
+        """
+        if wav.dim() != 2 or wav.size(0) != 1:
+            raise ValueError(f"encode expects a mono [1, T] waveform, got {tuple(wav.shape)}")
+        # Statistics stay in fp32 even under an ambient autocast, as in the reference.
+        with torch.autocast(device_type=wav.device.type, enabled=False):
+            mean, log_std = self.audio_encoder(wav.unsqueeze(1)).chunk(2, dim=1)
+            if sample:
+                latents = mean + self._noise_like(mean, generator) * torch.exp(log_std)
+            else:
+                latents = mean
+            latents = latents.transpose(1, 2).float()
+            return (latents - self.global_mean.float()) / torch.sqrt(self.global_log_std.float())
+
+    def decode(self, latents: torch.Tensor) -> torch.Tensor:
+        """Decode normalized ``[B, Np, latent_dim]`` latents into a ``[B, Np * hop_size]`` waveform in [-1, 1]."""
+        if latents.dim() != 3 or latents.size(-1) != self.latent_dim:
+            raise ValueError(f"decode expects [B, Np, {self.latent_dim}] latents, got {tuple(latents.shape)}")
+        x = latents.float() * torch.sqrt(self.global_log_std.float()) + self.global_mean.float()
+        x = self.conv_pre(x.permute(0, 2, 1))
+        for i in range(self.num_upsamples):
+            for up in self.ups[i]:
+                x = up(x)
+            first = i * self.num_kernels
+            residual = self.resblocks[first](x)
+            for j in range(1, self.num_kernels):
+                residual = residual + self.resblocks[first + j](x)
+            x = residual / self.num_kernels
+        x = self.conv_post(self.activation_post(x))
+        return torch.clamp(x, min=-1.0, max=1.0).squeeze(1)
+
+    @staticmethod
+    def _noise_like(reference: torch.Tensor, generator: torch.Generator | None) -> torch.Tensor:
+        """Draw standard normal noise shaped like ``reference``; ``generator`` decides which RNG stream."""
+        device = reference.device if generator is None else generator.device
+        noise = torch.randn(reference.shape, generator=generator, dtype=reference.dtype, device=device)
+        return noise.to(reference.device)
diff --git a/vllm_omni/diffusion/models/auk/pipeline_auk.py b/vllm_omni/diffusion/models/auk/pipeline_auk.py
new file mode 100644
index 000000000..6ad12b02d
--- /dev/null
+++ b/vllm_omni/diffusion/models/auk/pipeline_auk.py
@@ -0,0 +1,486 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""AuK audio-editing pipeline for vLLM-Omni.
+
+Turns a layer-fused text condition (produced by the encoder stage) plus an
+optional source clip into a 24 kHz waveform: the source clip is encoded to VAE
+latents, a rectified-flow DiT integrates the target latents conditioned on
+both, and the BigVGAN-flow decoder renders the waveform.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from collections.abc import Iterable
+from typing import Any, ClassVar
+
+import numpy as np
+import torch
+import torchaudio
+from safetensors import safe_open
+from torch import nn
+from vllm.logger import init_logger
+
+from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
+from vllm_omni.diffusion.distributed.utils import get_local_device
+from vllm_omni.diffusion.models.auk.auk_transformer import AuKTransformer, dit_state_dict, sample_latents
+from vllm_omni.diffusion.models.auk.auk_vae import AuKVAE
+from vllm_omni.diffusion.models.interface import (
+    SupportAudioInput,
+    SupportAudioOutput,
+    SupportsComponentDiscovery,
+)
+from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
+from vllm_omni.model_extras.auk import resolve_gen_frames
+
+logger = init_logger(__name__)
+
+# Longest ref + target latent sequence the released checkpoints accept.
+MAX_LATENT_FRAMES = 65536
+
+# Weight-file layout: the DiT lives under this prefix; the layer-fusion
+# parameters sit next to it but belong to the encoder stage.
+_DIT_PREFIX = "transformer."
+_FUSION_KEYS = frozenset({"layer_weights", "layer_scale"})
+
+# The distilled variant only reproduces its training recipe at these settings.
+_FLASH_NFE = 4
+_FLASH_CFG = 0.0
+# Decorrelates the VAE posterior draw from the initial latent for the same request seed.
+_VAE_SEED_OFFSET = 0x5EED_0A0C
+
+
+def get_auk_post_process_func(od_config: OmniDiffusionConfig):
+    """Create the post-processing function for AuK audio output.
+
+    Tensor output types pass through; anything else becomes a numpy waveform.
+    The sample rate is not attached here: the output formatter reads
+    ``AuKPipeline.audio_sample_rate`` for audio-output pipelines.
+    """
+
+    del od_config  # The conversion does not depend on the config.
+
+    def post_process_func(
+        audio: torch.Tensor,
+        output_type: str = "np",
+    ):
+        if output_type in ("pt", "latent"):
+            return audio
+        return audio.cpu().float().numpy()
+
+    return post_process_func
+
+
+def _prompt_mapping(prompt: Any) -> dict[str, Any]:
+    """Return the prompt dict, or an empty mapping for a bare text prompt."""
+
+    if isinstance(prompt, dict):
+        return prompt
+    return {}
+
+
+def _unwrap_single(value: Any) -> Any:
+    """Unwrap the one-element lists the serving layer sometimes produces."""
+
+    if isinstance(value, list) and len(value) == 1:
+        return value[0]
+    return value
+
+
+def _split_audio(audio: Any, default_sample_rate: int) -> tuple[Any, int]:
+    """Split a multimodal audio item into raw samples and a sample rate."""
+
+    if isinstance(audio, (tuple, list)) and len(audio) == 2 and isinstance(audio[1], (int, float)):
+        return audio[0], int(audio[1])
+    return audio, default_sample_rate
+
+
+class AuKPipeline(nn.Module, SupportAudioInput, SupportAudioOutput, SupportsComponentDiscovery):
+    """Instruction-driven audio generation and editing with AuK.
+
+    One request per forward: the rectified-flow ODE runs over the whole target
+    span and the batch dimension carries the CFG branches, so there is nothing
+    to share between requests yet.
+
+    Args:
+        od_config: OmniDiffusion configuration. ``od_config.model`` must be an
+            assembled AuK directory (``config.json``, ``auk.safetensors``,
+            ``vae.safetensors``), as produced by
+            ``tools/prepare_auk_checkpoint.py``.
+        prefix: Unused; kept for the pipeline construction contract.
+    """
+
+    supports_request_batch = False
+
+    # Picked up by ``supports_audio_output`` in the diffusion engine so the
+    # default stage metadata reports ``final_output_type="audio"`` and the
+    # ``multimodal_output`` payload includes the sample rate.
+    support_audio_output: ClassVar[bool] = True
+    support_audio_input: ClassVar[bool] = True
+    audio_sample_rate: ClassVar[int] = 24000
+
+    # The DiT cannot run without an encoder-stage text condition, which the
+    # engine's synthetic warmup request has no way to produce.
+    dummy_run_num_frames: ClassVar[int] = 0
+
+    _dit_modules: ClassVar[list[str]] = ["dit"]
+    _encoder_modules: ClassVar[list[str]] = []
+    _vae_modules: ClassVar[list[str]] = ["vae"]
+
+    def __init__(
+        self,
+        *,
+        od_config: OmniDiffusionConfig,
+        prefix: str = "",
+    ) -> None:
+        super().__init__()
+        del prefix  # Weights are not namespaced: one checkpoint, one pipeline.
+        self.od_config = od_config
+        self.device = get_local_device()
+        self.dtype = getattr(od_config, "dtype", None) or torch.bfloat16
+
+        model_dir = od_config.model
+        if not model_dir or not os.path.isdir(model_dir):
+            raise ValueError(
+                f"AuK needs an assembled local checkpoint directory, got {model_dir!r}. "
+                "Build one with tools/prepare_auk_checkpoint.py."
+            )
+        config = _read_config(model_dir)
+
+        vae_config = dict(config["vae"])
+        self.latent_dim = int(vae_config["latent_dim"])
+        self.hop_size = int(vae_config["downsample_rate"])
+        self.sample_rate = int(vae_config["target_sample_rate"])
+
+        self.variant = str(config.get("variant", "base"))
+        self.is_flash = self.variant == "flash"
+        self.flash_t_grid = [float(t) for t in config.get("flash_t_grid") or ()]
+        if self.is_flash and len(self.flash_t_grid) != _FLASH_NFE + 1:
+            raise ValueError(f"The flash variant needs a {_FLASH_NFE + 1}-point flash_t_grid, got {self.flash_t_grid}.")
+        defaults = dict(config.get("defaults") or {})
+        self.default_nfe = int(defaults.get("nfe", 32))
+        self.default_cfg = float(defaults.get("cfg", 2.0))
+        self.default_sway = defaults.get("sway", -1.0)
+        self._flash_lock_logged = False
+
+        # The codec is small and numerically sensitive: it stays in fp32. It
+        # must sit on the inference device BEFORE load_weights folds weight
+        # norm: a CPU fold lands one ULP off the accelerator's and the encoder
+        # amplifies that into a 1e-2 latent drift.
+        self.vae = AuKVAE.from_config(vae_config["model_init_kwargs"]).to(device=self.device, dtype=torch.float32)
+        self.vae.load_weights(os.path.join(model_dir, "vae.safetensors"))
+        self.vae = self.vae.eval()
+        self.vae.requires_grad_(False)
+        self._check_vae_geometry()
+
+        # The transformer owns every key the checkpoint tool writes into `dit`,
+        # `attn_mask_enabled` included, so the section passes straight through.
+        self.dit = AuKTransformer(latent_dim=self.latent_dim, **config["dit"])
+        self.dit = self.dit.to(dtype=self.dtype)
+        self.dit.load_state_dict(_read_dit_weights(model_dir, self.dtype), strict=True)
+        self.dit = self.dit.to(device=self.device).eval()
+        self.dit.requires_grad_(False)
+
+        logger.info(
+            "AuK pipeline ready: variant=%s dtype=%s latent_dim=%d hop=%d sample_rate=%d",
+            self.variant,
+            self.dtype,
+            self.latent_dim,
+            self.hop_size,
+            self.sample_rate,
+        )
+
+    # The assembled checkpoint is not a diffusers layout: __init__ reads
+    # auk.safetensors and vae.safetensors directly, so the loader has no
+    # component sources to stream and load_weights only reports what is loaded.
+    weights_sources: ClassVar[tuple] = ()
+
+    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
+        stray = [name for name, _ in weights]
+        if stray:
+            logger.warning("AuKPipeline ignores %d loader-provided weights (e.g. %s)", len(stray), stray[:3])
+        return {name for name, _ in self.named_parameters()}
+
+    def _check_vae_geometry(self) -> None:
+        """Fail fast when config.json and the VAE disagree on latent geometry."""
+
+        declared = {
+            "latent_dim": (self.latent_dim, int(self.vae.latent_dim)),
+            "downsample_rate": (self.hop_size, int(self.vae.hop_size)),
+            "target_sample_rate": (self.sample_rate, int(self.vae.sample_rate)),
+        }
+        bad = {name: pair for name, pair in declared.items() if pair[0] != pair[1]}
+        if bad:
+            raise ValueError(f"config.json and the AuK VAE disagree (config, vae): {bad}")
+        if self.sample_rate != self.audio_sample_rate:
+            raise ValueError(
+                f"AuK advertises {self.audio_sample_rate} Hz output but the checkpoint is {self.sample_rate} Hz."
+            )
+
+    def _resolve_generator(self, sampling_params: Any) -> torch.Generator | None:
+        """Per-request generator; the process-global RNG is never seeded."""
+
+        generator = sampling_params.generator
+        if isinstance(generator, list):
+            if len(generator) > 1:
+                logger.warning(
+                    "AuKPipeline runs one request per forward; using the first of %d generators", len(generator)
+                )
+            generator = generator[0] if generator else None
+        if generator is None and sampling_params.seed is not None:
+            generator = torch.Generator(device=self.device).manual_seed(int(sampling_params.seed))
+        return generator
+
+    def _prepare_waveform(self, audio: Any) -> torch.Tensor:
+        """Return mono float32 samples ``[1, T]`` at the VAE sample rate.
+
+        ``T`` is truncated to a whole number of latent frames. The encoder is
+        causal, so dropping a trailing partial frame leaves every emitted frame
+        unchanged.
+        """
+
+        data, sample_rate = _split_audio(audio, self.sample_rate)
+        if isinstance(data, np.ndarray):
+            wav = torch.from_numpy(np.ascontiguousarray(data))
+        else:
+            wav = torch.as_tensor(data)
+        wav = wav.detach().to(device="cpu", dtype=torch.float32)
+
+        if wav.ndim == 1:
+            wav = wav.unsqueeze(0)
+        elif wav.ndim == 2:
+            # Accept both [channels, samples] and soundfile's [samples, channels];
+            # the channel axis is the short one (at most 8 wide).
+            if wav.shape[0] > wav.shape[1] and wav.shape[1] <= 8:
+                wav = wav.transpose(0, 1)
+            if wav.shape[0] > 1:
+                wav = wav.mean(dim=0, keepdim=True)
+        else:
+            raise ValueError(f"AuK audio input must be [samples] or [channels, samples], got {tuple(wav.shape)}.")
+
+        if wav.shape[-1] == 0:
+            raise ValueError("AuK audio input is empty.")
+        if not torch.isfinite(wav).all():
+            raise ValueError("AuK audio input contains NaN or Inf.")
+
+        if sample_rate != self.sample_rate:
+            wav = torchaudio.functional.resample(wav, sample_rate, self.sample_rate)
+
+        frames = wav.shape[-1] // self.hop_size
+        if frames < 1:
+            raise ValueError(
+                f"AuK audio input is shorter than one latent frame ({self.hop_size} samples at {self.sample_rate} Hz)."
+            )
+        return wav[..., : frames * self.hop_size]
+
+    def _encode_source(
+        self,
+        audio: Any,
+        *,
+        sample: bool,
+        generator: torch.Generator | None,
+    ) -> torch.Tensor:
+        """Encode the source clip to normalized latents ``[1, np, latent_dim]``."""
+
+        if audio is None:
+            return torch.zeros(1, 0, self.latent_dim, device=self.device, dtype=torch.float32)
+        wav = self._prepare_waveform(_unwrap_single(audio)).to(self.device)
+        return self.vae.encode(wav, sample=sample, generator=generator)
+
+    def _target_frames(self, gen_seconds: Any, ref_frames: int) -> int:
+        """Target latent length, capped by the remaining context."""
+
+        frames = resolve_gen_frames(
+            None if gen_seconds is None else float(gen_seconds),
+            ref_frames,
+            sample_rate=self.sample_rate,
+            hop=self.hop_size,
+        )
+        budget = MAX_LATENT_FRAMES - ref_frames
+        if budget < 1:
+            raise ValueError(
+                f"The source clip already fills the {MAX_LATENT_FRAMES}-frame context ({ref_frames} frames)."
+            )
+        if frames > budget:
+            logger.warning("AuK target of %d frames exceeds the remaining context; clamping to %d.", frames, budget)
+            frames = budget
+        return frames
+
+    def _resolve_schedule(
+        self,
+        sampling_params: Any,
+        knobs: dict[str, Any],
+    ) -> tuple[int, float, float | None, list[float] | None]:
+        """Resolve (nfe, cfg, sway, t_grid), locking the distilled recipe on Flash.
+
+        A knob present but ``None`` counts as unspecified: the stage input
+        processor fills every key it knows about, whether the caller set it or
+        not.
+        """
+
+        steps = sampling_params.num_inference_steps
+        nfe = self.default_nfe if steps is None else int(steps)
+        if nfe < 1:
+            raise ValueError(f"num_inference_steps must be >= 1 for AuK; got {steps}")
+        cfg = float(sampling_params.guidance_scale) if sampling_params.guidance_scale_provided else self.default_cfg
+        sway = knobs.get("sway")
+        sway = self.default_sway if sway is None else float(sway)
+        raw_grid = knobs.get("t_grid")
+        t_grid = [float(t) for t in raw_grid] if raw_grid else None
+
+        if not self.is_flash:
+            return nfe, cfg, sway, t_grid
+
+        locked = (_FLASH_NFE, _FLASH_CFG, None, self.flash_t_grid)
+        if (nfe, cfg, sway, t_grid) != locked and not self._flash_lock_logged:
+            self._flash_lock_logged = True
+            logger.warning(
+                "AuK-Flash ignores per-request sampling knobs (asked nfe=%s cfg=%s sway=%s t_grid=%s); "
+                "using the distilled recipe nfe=%d cfg=%s with the checkpoint time grid.",
+                nfe,
+                cfg,
+                sway,
+                t_grid,
+                _FLASH_NFE,
+                _FLASH_CFG,
+            )
+        return locked
+
+    def _dit_autocast(self):
+        """Match the reference, which runs the DiT under bf16 autocast."""
+
+        return torch.autocast(
+            device_type=self.device.type,
+            dtype=self.dtype,
+            enabled=self.dtype in (torch.bfloat16, torch.float16),
+        )
+
+    def forward(self, req: DiffusionRequestBatch) -> list[DiffusionOutput]:
+        """Generate one waveform.
+
+        Args:
+            req: Request batch holding exactly one request. The prompt carries
+                ``prompt_embeds`` (the fused text condition ``[nt, 2048]``), an
+                optional ``multi_modal_data["audio"]`` source clip, and
+                ``additional_information["auk"]`` with ``gen_seconds``,
+                ``sway``, ``t_grid`` and ``vae_sample``. ``num_inference_steps``,
+                ``guidance_scale`` and ``seed``/``generator`` come from the
+                sampling params.
+
+        Returns:
+            One ``DiffusionOutput`` whose ``output`` is a float32 mono waveform
+            ``[T]`` at 24 kHz, or the normalized target latents
+            ``[1, gen_frames, latent_dim]`` when ``output_type`` is ``latent``.
+        """
+
+        assert req.num_reqs == 1, f"AuKPipeline runs one request per forward, got {req.num_reqs}."
+        prompt = _prompt_mapping(req.prompts[0])
+        sampling_params = req.sampling_params
+        knobs = dict((prompt.get("additional_information") or {}).get("auk") or {})
+
+        text = _unwrap_single(prompt.get("prompt_embeds"))
+        if text is None:
+            raise ValueError("AuK stage 1 needs `prompt_embeds`, the fused text condition from the encoder stage.")
+        text = torch.as_tensor(text).to(device=self.device, dtype=self.dtype)
+        if text.ndim == 3 and text.shape[0] == 1:
+            text = text[0]
+        if text.ndim != 2:
+            raise ValueError(f"AuK `prompt_embeds` must be [nt, text_hidden_dim], got {tuple(text.shape)}.")
+        text = text.unsqueeze(0)
+        c_mask = torch.ones(text.shape[:2], dtype=torch.bool, device=self.device)
+
+        generator = self._resolve_generator(sampling_params)
+        audio = (prompt.get("multi_modal_data") or {}).get("audio")
+        output_type = sampling_params.output_type or "np"
+
+        with torch.inference_mode():
+            # The VAE posterior draw gets its own generator, seeded with a
+            # fixed offset from the request seed: the initial latent below then
+            # still equals the reference's fresh manual_seed draw, and the two
+            # noise streams are not copies of each other.
+            vae_generator = None
+            if knobs.get("vae_sample") and generator is not None:
+                vae_seed = (int(generator.initial_seed()) + _VAE_SEED_OFFSET) % (2**63)
+                vae_generator = torch.Generator(device=self.device).manual_seed(vae_seed)
+            ref = self._encode_source(audio, sample=bool(knobs.get("vae_sample")), generator=vae_generator)
+            ref_frames = ref.shape[1]
+            ref_mask = torch.ones(ref.shape[:2], dtype=torch.bool, device=self.device)
+            gen_frames = self._target_frames(knobs.get("gen_seconds"), ref_frames)
+            nfe, cfg, sway, t_grid = self._resolve_schedule(sampling_params, knobs)
+
+            with self._dit_autocast():
+                latents = sample_latents(
+                    self.dit,
+                    text=text,
+                    c_mask=c_mask,
+                    ref=ref,
+                    ref_mask=ref_mask,
+                    gen_frames=gen_frames,
+                    nfe=nfe,
+                    cfg_strength=cfg,
+                    sway_sampling_coef=sway,
+                    t_grid=t_grid,
+                    seed=None,
+                    latent_dim=self.latent_dim,
+                    device=self.device,
+                    dtype=torch.float32,
+                    generator=generator,
+                )
+
+            latents = latents.float()
+            if not torch.isfinite(latents).all():
+                raise RuntimeError("AuK generated latents contain NaN or Inf.")
+            if output_type == "latent":
+                return [DiffusionOutput(output=latents.detach().cpu())]
+
+            wav = self.vae.decode(latents)
+
+        # One mono waveform per request; the formatter expects [T].
+        wav = wav.detach().to(device="cpu", dtype=torch.float32).reshape(-1)
+        if not torch.isfinite(wav).all():
+            raise RuntimeError("AuK generated audio contains NaN or Inf.")
+        return [DiffusionOutput(output=wav)]
+
+
+def _read_config(model_dir: str) -> dict[str, Any]:
+    """Read the assembled AuK ``config.json``."""
+
+    path = os.path.join(model_dir, "config.json")
+    try:
+        with open(path) as handle:
+            config = json.load(handle)
+    except FileNotFoundError as exc:
+        raise ValueError(f"AuK checkpoint is missing config.json: {path}") from exc
+    except json.JSONDecodeError as exc:
+        logger.error("AuK config.json is not valid JSON: %s", path)
+        raise ValueError(f"AuK config.json is not valid JSON: {path}") from exc
+
+    missing = [key for key in ("dit", "vae") if key not in config]
+    if missing:
+        raise ValueError(f"AuK config.json is missing required sections {missing}: {path}")
+    return config
+
+
+def _read_dit_weights(model_dir: str, dtype: torch.dtype) -> dict[str, torch.Tensor]:
+    """Read the DiT state dict from ``auk.safetensors``, cast to ``dtype``.
+
+    Tensors are cast one at a time so the fp32 checkpoint is never fully
+    resident alongside the model.
+    """
+
+    path = os.path.join(model_dir, "auk.safetensors")
+    if not os.path.isfile(path):
+        raise ValueError(f"AuK checkpoint is missing auk.safetensors: {path}")
+
+    with safe_open(path, framework="pt", device="cpu") as checkpoint:
+        keys = list(checkpoint.keys())
+        state = dit_state_dict(((key, checkpoint.get_tensor(key).to(dtype)) for key in keys), _DIT_PREFIX)
+
+    if not state:
+        raise ValueError(f"AuK checkpoint has no '{_DIT_PREFIX}*' weights: {path}")
+    unexpected = sorted(key for key in keys if key not in _FUSION_KEYS and not key.startswith(_DIT_PREFIX))
+    if unexpected:
+        logger.warning("Ignoring %d unrecognized keys in %s, e.g. %s", len(unexpected), path, unexpected[:5])
+    return state
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/models/bagel/mot/__init__.py b/vllm_omni/diffusion/models/bagel/mot/__init__.py
new file mode 100644
index 000000000..e69de29bb
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 f27601148..d805fd3b8 100644
--- a/vllm_omni/diffusion/models/bagel/pipeline_bagel.py
+++ b/vllm_omni/diffusion/models/bagel/pipeline_bagel.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
 """
 BagelPipeline implementation for vLLM-Omni.
 """
@@ -316,6 +316,11 @@ class BagelPipeline(nn.Module, SupportsComponentDiscovery, DiffusionPipelineProf
         "bagel.connector",
         "bagel.vit_pos_embed",
     ]
+    # LoRA scanning target. ``_dit_modules`` holds the dotted path
+    # "language_model.model", which DiffusionLoRAManager cannot resolve as a
+    # pipeline attribute, so the top-level ``bagel`` module (LLM plus ViT,
+    # connector, and VAE projections) is declared explicitly here.
+    _lora_components: ClassVar[list[str]] = ["bagel"]
     supports_step_execution: ClassVar[bool] = True
 
     def __init__(self, *, od_config: OmniDiffusionConfig, prefix: str = ""):
diff --git a/vllm_omni/diffusion/models/boogu_image/boogu_image_transformer.py b/vllm_omni/diffusion/models/boogu_image/boogu_image_transformer.py
index 66031ca3a..f3fdeedc8 100644
--- a/vllm_omni/diffusion/models/boogu_image/boogu_image_transformer.py
+++ b/vllm_omni/diffusion/models/boogu_image/boogu_image_transformer.py
@@ -15,6 +15,7 @@
 #     inference caches (TeaCache/TaylorSeer) are not ported.
 
 import itertools
+from collections import defaultdict
 from collections.abc import Iterable
 from typing import TYPE_CHECKING
 
@@ -24,17 +25,25 @@ import torch.nn.functional as F
 from diffusers.models.embeddings import Timesteps, get_1d_rotary_pos_embed
 from einops import rearrange, repeat
 from vllm.logger import init_logger
-from vllm.model_executor.layers.layernorm import RMSNorm
 from vllm.model_executor.layers.linear import (
-    ColumnParallelLinear,
+    MergedColumnParallelLinear,
+    QKVParallelLinear,
     ReplicatedLinear,
     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
 from vllm_omni.diffusion.data import OmniDiffusionConfig
+from vllm_omni.diffusion.layers.fused_qk_norm_rope import (
+    _fused_cuda_supported,
+    fused_qk_norm_rope,
+    fused_qk_norm_rope_min_tokens,
+)
+from vllm_omni.diffusion.layers.norm import RMSNorm
 from vllm_omni.diffusion.models.utils import make_attention_mask
 from vllm_omni.platforms import current_omni_platform
 
@@ -43,7 +52,10 @@ if TYPE_CHECKING:
 
 logger = init_logger(__name__)
 
-RotaryEmbedding = tuple[torch.Tensor, torch.Tensor]
+# (cos, sin) — optionally (cos, sin, packed_table) where packed_table is the
+# fp32 [tokens, head_dim] = [cos(theta) | sin(theta)] layout the fused
+# qk-norm+RoPE op consumes; the eager path ignores the third element.
+RotaryEmbedding = tuple[torch.Tensor, ...]
 RotaryFrequencyTables = list[RotaryEmbedding]
 
 
@@ -56,9 +68,12 @@ def apply_rotary_emb(x: torch.Tensor, rotary_emb: RotaryEmbedding) -> torch.Tens
 
     Args:
         x: Query or key tensor of shape [B, S, H, D].
-        rotary_emb: Cosine and sine tensors, each shaped [B, S, D].
+        rotary_emb: Cosine and sine tensors, each shaped [B, S, D]. The tuple
+            may carry a third element (the packed table for the fused
+            qk-norm+RoPE path); it is ignored here, hence the indexed access
+            instead of tuple unpacking.
     """
-    freqs_cos, freqs_sin = rotary_emb
+    freqs_cos, freqs_sin = rotary_emb[0], rotary_emb[1]
     freqs_cos = freqs_cos.unsqueeze(2)
     freqs_sin = freqs_sin.unsqueeze(2)
 
@@ -73,6 +88,87 @@ def apply_rotary_emb(x: torch.Tensor, rotary_emb: RotaryEmbedding) -> torch.Tens
     return x_out.type_as(x)
 
 
+# The fused qk-norm+RoPE path is always on where the fast path exists; on
+# other platforms the eager chain below is the behaviour-identical fallback.
+_FUSED_QK_NORM_ROPE = HAS_TRITON and current_platform.is_cuda()
+
+# Boogu's default for the fused-path token gate: fuse only when a rotary table
+# spans at least this many positions (counted as B*S). Below the crossover a
+# request is host-bound and the fused path's per-call Python launch (custom-op
+# impl + Triton launcher) can cost more end-to-end than the kernel saves.
+# Measured on one H200: on the pre-#6871 main, 512^2 (1.1k tokens) paid
+# +191 ms/request and the crossover sat at ~2,350 tokens; on the current main
+# the 512^2 family measures as noise (+/-25 ms, sign-inconsistent) while
+# >=768^2 (2.3k tokens) gains. The crossover is host-dependent — re-benchmark
+# on your hardware and override with VLLM_OMNI_FUSED_QK_NORM_ROPE_MIN_TOKENS
+# (0 = always fuse); see fused_qk_norm_rope_min_tokens().
+_FUSED_MIN_TOKENS = 2048
+
+
+def _with_packed_rope_table(rotary_emb: RotaryEmbedding) -> RotaryEmbedding:
+    """Append the packed fp32 table the fused qk-norm+RoPE op consumes.
+
+    ``freqs_cos``/``freqs_sin`` are theta-repeat-interleaved ``[B, S, D]``
+    (``cos[2i] == cos[2i+1] == cos(theta_i)``), so taking every even column
+    yields the theta-width halves and the packed table is
+    ``[B*S, D] = [cos(theta) | sin(theta)]``. Tables spanning fewer positions
+    (counted as ``B*S``) than the token gate — Boogu's ``_FUSED_MIN_TOKENS``
+    default, overridable through ``VLLM_OMNI_FUSED_QK_NORM_ROPE_MIN_TOKENS``
+    (``0`` = always fuse) — are returned unchanged: without the third element
+    every consumer stays on the eager chain (this also keeps short tables like
+    the context refiner's off the fused path).
+    """
+    freqs_cos, freqs_sin = rotary_emb[0], rotary_emb[1]
+    if freqs_cos.shape[0] * freqs_cos.shape[1] < fused_qk_norm_rope_min_tokens(_FUSED_MIN_TOKENS):
+        return rotary_emb
+    packed = torch.cat((freqs_cos[..., ::2], freqs_sin[..., ::2]), dim=-1)
+    return freqs_cos, freqs_sin, packed.reshape(-1, freqs_cos.shape[-1]).float()
+
+
+def _qk_norm_rope(
+    query: torch.Tensor,
+    key: torch.Tensor,
+    norm_q,
+    norm_k,
+    rotary_emb: RotaryEmbedding | None,
+    dtype: torch.dtype,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """Per-head Q/K RMSNorm + RoPE + cast, fused into one kernel launch when
+    a packed rope table is present; otherwise the original eager chain."""
+    # Gate on the op's own fast-path predicate: when the fused CUDA kernel
+    # cannot run (dtype, device, or geometry outside even
+    # rotary_dim <= head_dim <= 256), the original chain below must be used
+    # bit-exactly rather than the op's internal eager fallback, whose rounding
+    # differs from vLLM's RMSNorm by one ulp on a fraction of elements.
+    if (
+        rotary_emb is not None
+        and len(rotary_emb) > 2
+        and rotary_emb[2] is not None
+        and _fused_cuda_supported(query, key, query.shape[-1], query.shape[-1], interleaved=True)
+    ):
+        batch, seq_len, num_heads, head_dim = query.shape
+        num_kv_heads = key.shape[2]
+        fused_q, fused_k = fused_qk_norm_rope(
+            query.view(batch * seq_len, num_heads, head_dim),
+            key.view(batch * seq_len, num_kv_heads, head_dim),
+            norm_q.weight,
+            norm_k.weight,
+            rotary_emb[2],
+            norm_q.variance_epsilon,
+            interleaved=True,
+        )
+        return (
+            fused_q.view(batch, seq_len, num_heads, head_dim),
+            fused_k.view(batch, seq_len, num_kv_heads, head_dim),
+        )
+    query = norm_q(query)
+    key = norm_k(key)
+    if rotary_emb is not None:
+        query = apply_rotary_emb(query, rotary_emb)
+        key = apply_rotary_emb(key, rotary_emb)
+    return query.to(dtype), key.to(dtype)
+
+
 def swiglu(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
     return F.silu(x.float(), inplace=False).to(x.dtype) * y
 
@@ -166,7 +262,14 @@ class LuminaLayerNormContinuous(nn.Module):
 
 
 class LuminaFeedForward(nn.Module):
-    """SwiGLU feed-forward with tensor-parallel projections."""
+    """SwiGLU feed-forward with tensor-parallel projections.
+
+    The ``gate`` and ``input`` projections are fused into a single
+    ``MergedColumnParallelLinear`` (one GEMM instead of two), matching the
+    ``gate_up_proj`` convention used by the Hunyuan Image 3 port. The SwiGLU
+    activation keeps its float32 computation for numerical parity with
+    upstream.
+    """
 
     def __init__(
         self,
@@ -182,20 +285,13 @@ class LuminaFeedForward(nn.Module):
             inner_dim = int(ffn_dim_multiplier * inner_dim)
         inner_dim = multiple_of * ((inner_dim + multiple_of - 1) // multiple_of)
 
-        self.linear_1 = ColumnParallelLinear(
-            dim,
-            inner_dim,
+        self.gate_up_proj = MergedColumnParallelLinear(
+            input_size=dim,
+            output_sizes=[inner_dim, inner_dim],
             bias=False,
             quant_config=quant_config,
-            prefix=_join_prefix(prefix, "linear_1"),
-        )  # gate
-        self.linear_3 = ColumnParallelLinear(
-            dim,
-            inner_dim,
-            bias=False,
-            quant_config=quant_config,
-            prefix=_join_prefix(prefix, "linear_3"),
-        )  # input
+            prefix=_join_prefix(prefix, "gate_up_proj"),
+        )
         self.linear_2 = RowParallelLinear(
             inner_dim,
             dim,
@@ -205,8 +301,8 @@ class LuminaFeedForward(nn.Module):
         )
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        h1, _ = self.linear_1(x)
-        h2, _ = self.linear_3(x)
+        gate_up, _ = self.gate_up_proj(x)
+        h1, h2 = gate_up.chunk(2, dim=-1)
         out, _ = self.linear_2(swiglu(h1, h2))
         return out
 
@@ -499,28 +595,15 @@ class BooguImageSelfAttention(nn.Module):
     ) -> None:
         super().__init__()
         self.head_dim = dim // num_attention_heads
-        kv_dim = self.head_dim * num_kv_heads
 
-        self.to_q = ColumnParallelLinear(
-            dim,
-            dim,
+        self.to_qkv = QKVParallelLinear(
+            hidden_size=dim,
+            head_size=self.head_dim,
+            total_num_heads=num_attention_heads,
+            total_num_kv_heads=num_kv_heads,
             bias=False,
             quant_config=quant_config,
-            prefix=_join_prefix(prefix, "to_q"),
-        )
-        self.to_k = ColumnParallelLinear(
-            dim,
-            kv_dim,
-            bias=False,
-            quant_config=quant_config,
-            prefix=_join_prefix(prefix, "to_k"),
-        )
-        self.to_v = ColumnParallelLinear(
-            dim,
-            kv_dim,
-            bias=False,
-            quant_config=quant_config,
-            prefix=_join_prefix(prefix, "to_v"),
+            prefix=_join_prefix(prefix, "to_qkv"),
         )
         self.norm_q = RMSNorm(self.head_dim, eps=1e-5)
         self.norm_k = RMSNorm(self.head_dim, eps=1e-5)
@@ -532,8 +615,10 @@ class BooguImageSelfAttention(nn.Module):
             prefix=_join_prefix(prefix, "to_out"),
         )
 
-        self.num_local_heads = self.to_q.output_size_per_partition // self.head_dim
-        self.num_local_kv_heads = self.to_k.output_size_per_partition // self.head_dim
+        self.num_local_heads = self.to_qkv.num_heads
+        self.num_local_kv_heads = self.to_qkv.num_kv_heads
+        self.q_size = self.num_local_heads * self.head_dim
+        self.kv_size = self.num_local_kv_heads * self.head_dim
 
         self.attn = Attention(
             num_heads=self.num_local_heads,
@@ -551,21 +636,14 @@ class BooguImageSelfAttention(nn.Module):
     ) -> torch.Tensor:
         dtype = hidden_states.dtype
 
-        query, _ = self.to_q(hidden_states)
-        key, _ = self.to_k(hidden_states)
-        value, _ = self.to_v(hidden_states)
+        qkv, _ = self.to_qkv(hidden_states)
+        query, key, value = qkv.split([self.q_size, self.kv_size, self.kv_size], dim=-1)
 
         query = query.unflatten(-1, (self.num_local_heads, self.head_dim))
         key = key.unflatten(-1, (self.num_local_kv_heads, self.head_dim))
         value = value.unflatten(-1, (self.num_local_kv_heads, self.head_dim))
 
-        query = self.norm_q(query)
-        key = self.norm_k(key)
-
-        if rotary_emb is not None:
-            query = apply_rotary_emb(query, rotary_emb)
-            key = apply_rotary_emb(key, rotary_emb)
-        query, key = query.to(dtype), key.to(dtype)
+        query, key = _qk_norm_rope(query, key, self.norm_q, self.norm_k, rotary_emb, dtype)
 
         attn_metadata = AttentionMetadata(attn_mask=attention_mask) if attention_mask is not None else None
         attn_output = self.attn(query, key, value, attn_metadata)
@@ -595,50 +673,24 @@ class BooguImageJointAttention(nn.Module):
     ) -> None:
         super().__init__()
         self.head_dim = dim // num_attention_heads
-        kv_dim = self.head_dim * num_kv_heads
 
-        self.img_to_q = ColumnParallelLinear(
-            dim,
-            dim,
+        self.img_to_qkv = QKVParallelLinear(
+            hidden_size=dim,
+            head_size=self.head_dim,
+            total_num_heads=num_attention_heads,
+            total_num_kv_heads=num_kv_heads,
             bias=False,
             quant_config=quant_config,
-            prefix=_join_prefix(prefix, "img_to_q"),
+            prefix=_join_prefix(prefix, "img_to_qkv"),
         )
-        self.img_to_k = ColumnParallelLinear(
-            dim,
-            kv_dim,
+        self.instruct_to_qkv = QKVParallelLinear(
+            hidden_size=dim,
+            head_size=self.head_dim,
+            total_num_heads=num_attention_heads,
+            total_num_kv_heads=num_kv_heads,
             bias=False,
             quant_config=quant_config,
-            prefix=_join_prefix(prefix, "img_to_k"),
-        )
-        self.img_to_v = ColumnParallelLinear(
-            dim,
-            kv_dim,
-            bias=False,
-            quant_config=quant_config,
-            prefix=_join_prefix(prefix, "img_to_v"),
-        )
-
-        self.instruct_to_q = ColumnParallelLinear(
-            dim,
-            dim,
-            bias=False,
-            quant_config=quant_config,
-            prefix=_join_prefix(prefix, "instruct_to_q"),
-        )
-        self.instruct_to_k = ColumnParallelLinear(
-            dim,
-            kv_dim,
-            bias=False,
-            quant_config=quant_config,
-            prefix=_join_prefix(prefix, "instruct_to_k"),
-        )
-        self.instruct_to_v = ColumnParallelLinear(
-            dim,
-            kv_dim,
-            bias=False,
-            quant_config=quant_config,
-            prefix=_join_prefix(prefix, "instruct_to_v"),
+            prefix=_join_prefix(prefix, "instruct_to_qkv"),
         )
 
         self.norm_q = RMSNorm(self.head_dim, eps=1e-5)
@@ -669,8 +721,10 @@ class BooguImageJointAttention(nn.Module):
             prefix=_join_prefix(prefix, "to_out"),
         )
 
-        self.num_local_heads = self.img_to_q.output_size_per_partition // self.head_dim
-        self.num_local_kv_heads = self.img_to_k.output_size_per_partition // self.head_dim
+        self.num_local_heads = self.img_to_qkv.num_heads
+        self.num_local_kv_heads = self.img_to_qkv.num_kv_heads
+        self.q_size = self.num_local_heads * self.head_dim
+        self.kv_size = self.num_local_kv_heads * self.head_dim
 
         self.attn = Attention(
             num_heads=self.num_local_heads,
@@ -692,13 +746,13 @@ class BooguImageJointAttention(nn.Module):
         dtype = img_hidden_states.dtype
         batch_size = img_hidden_states.shape[0]
 
-        img_query, _ = self.img_to_q(img_hidden_states)
-        img_key, _ = self.img_to_k(img_hidden_states)
-        img_value, _ = self.img_to_v(img_hidden_states)
+        img_qkv, _ = self.img_to_qkv(img_hidden_states)
+        img_query, img_key, img_value = img_qkv.split([self.q_size, self.kv_size, self.kv_size], dim=-1)
 
-        instruct_query, _ = self.instruct_to_q(instruct_hidden_states)
-        instruct_key, _ = self.instruct_to_k(instruct_hidden_states)
-        instruct_value, _ = self.instruct_to_v(instruct_hidden_states)
+        instruct_qkv, _ = self.instruct_to_qkv(instruct_hidden_states)
+        instruct_query, instruct_key, instruct_value = instruct_qkv.split(
+            [self.q_size, self.kv_size, self.kv_size], dim=-1
+        )
 
         query, key, value = _concat_instruction_image_features(
             [img_query, img_key, img_value],
@@ -711,13 +765,7 @@ class BooguImageJointAttention(nn.Module):
         key = key.view(batch_size, -1, self.num_local_kv_heads, self.head_dim)
         value = value.view(batch_size, -1, self.num_local_kv_heads, self.head_dim)
 
-        query = self.norm_q(query)
-        key = self.norm_k(key)
-
-        if rotary_emb is not None:
-            query = apply_rotary_emb(query, rotary_emb)
-            key = apply_rotary_emb(key, rotary_emb)
-        query, key = query.to(dtype), key.to(dtype)
+        query, key = _qk_norm_rope(query, key, self.norm_q, self.norm_k, rotary_emb, dtype)
 
         attn_metadata = AttentionMetadata(attn_mask=joint_attention_mask) if joint_attention_mask is not None else None
         attn_output = self.attn(query, key, value, attn_metadata)
@@ -1053,6 +1101,44 @@ def _cal_preprocessed_instruction_feat_dim(instruction_feature_configs: dict) ->
         raise ValueError(f"Invalid reduce_type: {reduce_type}")
 
 
+# Packed (fused) projections vs. the logical sub-projections the diffusers
+# checkpoint stores, in the ``(param_name, shard_name, shard_id)`` form used
+# across vllm-omni. ``load_weights`` consumes it directly, and loader consumers
+# that discover it via ``stacked_params_mapping`` (LoRA, quantized loaders) get
+# the packed -> sub-layer relationship for free.
+#
+# The QKV entries stay leaf-scoped: each fused source (``to_q`` on the
+# self-attention module, ``img_to_q`` / ``instruct_to_q`` on the joint
+# attention) has a distinct leaf, and ``.to_q.`` cannot collide with
+# ``.img_to_q.`` because the preceding character is ``_`` rather than ``.``.
+# The FFN entries are path-qualified instead: ``linear_1`` also names the
+# timestep embedder and the ``norm_out`` projections, which must load 1:1 and
+# are not fused.
+_BOOGU_STACKED_PARAMS_MAPPING = (
+    # self-attention: noise / reference-image / context refiners, the
+    # single-stream blocks, and the double-stream image self-attention.
+    (".to_qkv.", ".to_q.", "q"),
+    (".to_qkv.", ".to_k.", "k"),
+    (".to_qkv.", ".to_v.", "v"),
+    # joint (instruction + image) attention of the double-stream blocks.
+    (".img_to_qkv.", ".img_to_q.", "q"),
+    (".img_to_qkv.", ".img_to_k.", "k"),
+    (".img_to_qkv.", ".img_to_v.", "v"),
+    (".instruct_to_qkv.", ".instruct_to_q.", "q"),
+    (".instruct_to_qkv.", ".instruct_to_k.", "k"),
+    (".instruct_to_qkv.", ".instruct_to_v.", "v"),
+    # feed-forward gate/up: ``linear_1`` is the gate (shard 0) and
+    # ``linear_3`` the input (shard 1), matching the packed order the SwiGLU
+    # activation consumes.
+    (".feed_forward.gate_up_proj.", ".feed_forward.linear_1.", 0),
+    (".feed_forward.gate_up_proj.", ".feed_forward.linear_3.", 1),
+    (".img_feed_forward.gate_up_proj.", ".img_feed_forward.linear_1.", 0),
+    (".img_feed_forward.gate_up_proj.", ".img_feed_forward.linear_3.", 1),
+    (".instruct_feed_forward.gate_up_proj.", ".instruct_feed_forward.linear_1.", 0),
+    (".instruct_feed_forward.gate_up_proj.", ".instruct_feed_forward.linear_3.", 1),
+)
+
+
 class BooguImageTransformer2DModel(nn.Module):
     """Boogu-Image transformer with mixed stream topology.
 
@@ -1078,6 +1164,10 @@ class BooguImageTransformer2DModel(nn.Module):
         prefix: str = "",
     ) -> None:
         super().__init__()
+        # Published here rather than in ``load_weights`` so loader consumers
+        # that only inspect the module tree (LoRA discovery, quantized weight
+        # loaders) always see the packed -> sub-layer relationship.
+        self.stacked_params_mapping = list(_BOOGU_STACKED_PARAMS_MAPPING)
         self.od_config = od_config
         cfg = od_config.tf_model_config
 
@@ -1449,6 +1539,11 @@ class BooguImageTransformer2DModel(nn.Module):
                     shift += ref_img_len
                     idx += 1
 
+            if _FUSED_QK_NORM_ROPE:
+                # The rebuilt per-reference-image tuple needs its own packed
+                # table; the forward-level tuples do not flow into this batch.
+                batch_ref_img_rotary_emb = _with_packed_rope_table(batch_ref_img_rotary_emb)
+
             for layer in self.ref_image_refiner:
                 batch_ref_image_hidden_states = layer(
                     batch_ref_image_hidden_states, batch_ref_img_mask, batch_ref_img_rotary_emb, batch_temb
@@ -1534,6 +1629,17 @@ class BooguImageTransformer2DModel(nn.Module):
             device,
         )
 
+        if _FUSED_QK_NORM_ROPE:
+            # One packed [cos|sin] table per rotary embedding that reaches an
+            # attention, built once per forward; the tuples grow a third
+            # element that the fused path consumes and the eager path ignores.
+            # (ref_img_rotary_emb is packed inside img_patch_embed_and_refine,
+            # on the rebuilt per-reference-image batch tuple.)
+            context_rotary_emb = _with_packed_rope_table(context_rotary_emb)
+            noise_rotary_emb = _with_packed_rope_table(noise_rotary_emb)
+            rotary_emb = _with_packed_rope_table(rotary_emb)
+            combined_img_rotary_emb = _with_packed_rope_table(combined_img_rotary_emb)
+
         # Context refinement.
         for layer in self.context_refiner:
             instruction_hidden_states = layer(instruction_hidden_states, instruction_attention_mask, context_rotary_emb)
@@ -1612,7 +1718,7 @@ class BooguImageTransformer2DModel(nn.Module):
     def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
         """Load diffusers-named checkpoint weights into the native module.
 
-        Two name promotions relative to upstream (see step 8/10 findings):
+        Name promotions relative to upstream (see step 8/10 findings):
 
         - ``*.img_instruct_attn.processor.{img,instruct}_{to_q,to_k,to_v}`` /
           ``{instruct,img}_out`` -> drop ``.processor`` (upstream keeps the
@@ -1621,9 +1727,29 @@ class BooguImageTransformer2DModel(nn.Module):
         - ``*.to_out.0.weight`` -> ``*.to_out.weight`` (diffusers wraps the
           output projection in a ``ModuleList``; the native module uses a plain
           linear).
+
+        Packed Q/K/V and FFN gate/input matrices are folded onto the fused
+        ``QKVParallelLinear`` / ``MergedColumnParallelLinear`` parameters using
+        :attr:`stacked_params_mapping` — the same mapping loader consumers such
+        as LoRA discovery and quantized weight loaders read.
+
+        A fused parameter is only reported as loaded once *every* one of its
+        source matrices has arrived. The caller compares parameter names, so
+        reporting e.g. ``to_qkv`` complete after the first shard would let a
+        checkpoint carrying only ``to_q`` start up with the ``k``/``v`` slices
+        left uninitialized.
         """
+        stacked_params_mapping = self.stacked_params_mapping
+        # The shard ids each fused parameter is assembled from, keyed by the
+        # mapping entry that produces it.
+        expected_shards: dict[str, set[str | int]] = defaultdict(set)
+        for param_name, _weight_name, packed_shard_id in stacked_params_mapping:
+            expected_shards[param_name].add(packed_shard_id)
+
         params_dict = dict(self.named_parameters())
         loaded_params: set[str] = set()
+        # Fused parameter -> (mapping entry that produced it, shards received).
+        fused_params: dict[str, tuple[str, set[str | int]]] = {}
 
         for name, loaded_weight in weights:
             original_name = name
@@ -1632,15 +1758,36 @@ class BooguImageTransformer2DModel(nn.Module):
             if ".to_out.0." in name:
                 name = name.replace(".to_out.0.", ".to_out.")
 
+            shard_id: str | int | None = None
+            matched_entry: str | None = None
+            for param_name, weight_name, packed_shard_id in stacked_params_mapping:
+                if weight_name in name:
+                    name = name.replace(weight_name, param_name)
+                    shard_id = packed_shard_id
+                    matched_entry = param_name
+                    break
+
             if name not in params_dict:
                 logger.warning("Skipping unexpected checkpoint weight %s", original_name)
                 continue
 
             param = params_dict[name]
             weight_loader = getattr(param, "weight_loader", default_weight_loader)
-            weight_loader(param, loaded_weight)
+            if matched_entry is None:
+                weight_loader(param, loaded_weight)
+            else:
+                weight_loader(param, loaded_weight, shard_id)
+                _, received = fused_params.setdefault(name, (matched_entry, set()))
+                received.add(shard_id)
             loaded_params.add(name)
 
+        # Withdraw any fused parameter that only received part of its source
+        # matrices, so the caller's "not initialized from checkpoint" check
+        # reports it as missing instead of accepting a half-filled parameter.
+        for name, (matched_entry, received) in fused_params.items():
+            if received != expected_shards[matched_entry]:
+                loaded_params.discard(name)
+
         unloaded_params = sorted(params_dict.keys() - loaded_params)
         if unloaded_params:
             logger.warning("Model parameters not loaded from checkpoint: %s", unloaded_params)
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/cosmos3/action.py b/vllm_omni/diffusion/models/cosmos3/action.py
index dc755b39c..affba4195 100644
--- a/vllm_omni/diffusion/models/cosmos3/action.py
+++ b/vllm_omni/diffusion/models/cosmos3/action.py
@@ -38,13 +38,24 @@ EMBODIMENT_TO_DOMAIN_ID: dict[str, int] = {
     "bridge_orig_lerobot": 7,
     "droid_lerobot": 8,
     "robomind-franka": 8,
+    "embodiment_b": 9,
+    # Backward-compatible alias for the pre-generator Cosmos Framework name.
     "galbot": 9,
     "robomind-franka-dual": 12,
     "robomind-ur": 13,
     "agibotworld": 15,
+    "embodiment_c_gripper": 15,
+    "embodiment_c_gripper_ext": 15,
+    # Backward-compatible aliases for the pre-generator Cosmos Framework names.
     "agibot_gear_gripper": 15,
     "agibot_gear_gripper_ext": 15,
+    "xdof_yam": 16,
+    "molmoact2_yam": 16,
+    "abc_yam": 16,
     "fractal": 20,
+    "drawanything": 21,
+    "behavior1k_lerobot": 22,
+    "maniparena": 23,
 }
 
 
diff --git a/vllm_omni/diffusion/models/cosmos3/mixed_precision/__init__.py b/vllm_omni/diffusion/models/cosmos3/mixed_precision/__init__.py
new file mode 100644
index 000000000..1d5ee972b
--- /dev/null
+++ b/vllm_omni/diffusion/models/cosmos3/mixed_precision/__init__.py
@@ -0,0 +1,14 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Scheduled A16 execution for quantized Cosmos3 checkpoints."""
+
+from .checkpoint import resolve_mixed_precision_config
+from .config import Cosmos3MixedPrecisionConfig
+from .runtime import Cosmos3MixedPrecisionRuntime
+
+__all__ = [
+    "Cosmos3MixedPrecisionConfig",
+    "Cosmos3MixedPrecisionRuntime",
+    "resolve_mixed_precision_config",
+]
diff --git a/vllm_omni/diffusion/models/cosmos3/mixed_precision/checkpoint.py b/vllm_omni/diffusion/models/cosmos3/mixed_precision/checkpoint.py
new file mode 100644
index 000000000..c8a62f142
--- /dev/null
+++ b/vllm_omni/diffusion/models/cosmos3/mixed_precision/checkpoint.py
@@ -0,0 +1,176 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Checkpoint discovery for the Cosmos3 diffusion-step precision policy."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Literal, cast
+
+from .config import Cosmos3MixedPrecisionConfig, ReasonerPolicy, _non_negative_int
+
+PolicySource = Literal[
+    "none",
+    "checkpoint",
+    "additional_config",
+    "additional_config_disabled",
+]
+
+_COMPONENT = "transformer"
+_POLICY_FIELDS = frozenset(
+    {
+        "schema_version",
+        "type",
+        "index_space",
+        "scope",
+        "default_mode",
+        "first_steps",
+        "last_steps",
+        "overlap",
+        "reasoner",
+    }
+)
+_STEP_RANGE_FIELDS = frozenset({"count", "mode"})
+_SUPPORTED_MODEL_OPT_CONFIGS = frozenset(
+    {
+        "modelopt",
+        "modelopt_fp4",
+    }
+)
+
+
+def resolve_mixed_precision_config(
+    od_config: object,
+) -> tuple[Cosmos3MixedPrecisionConfig | None, PolicySource]:
+    """Resolve an explicit runtime override before the checkpoint default."""
+    override_present, override = Cosmos3MixedPrecisionConfig.resolve_additional_config(
+        getattr(od_config, "additional_config", None)
+    )
+    if override_present:
+        if override is not None:
+            _validate_checkpoint_quantization(od_config)
+        source: PolicySource = "additional_config" if override is not None else "additional_config_disabled"
+        return override, source
+
+    checkpoint = read_checkpoint_policy(od_config)
+    if checkpoint is not None:
+        return checkpoint, "checkpoint"
+    return None, "none"
+
+
+def read_checkpoint_policy(od_config: object) -> Cosmos3MixedPrecisionConfig | None:
+    """Read and validate a policy from ``transformer/config.json``.
+
+    Missing metadata preserves ordinary checkpoint behavior.  Metadata that is
+    present but malformed or incompatible fails closed.
+    """
+    tf_config = getattr(od_config, "tf_model_config", None)
+    params = getattr(tf_config, "params", None)
+    if not isinstance(params, Mapping):
+        return None
+
+    disk_quant_config = params.get("quantization_config")
+    if not isinstance(disk_quant_config, Mapping):
+        return None
+
+    if "runtime" not in disk_quant_config:
+        return None
+    runtime_config = disk_quant_config["runtime"]
+    if not isinstance(runtime_config, Mapping):
+        raise TypeError("quantization_config.runtime must be a mapping")
+
+    if "diffusion_step_policy" not in runtime_config:
+        return None
+    raw_policy = runtime_config["diffusion_step_policy"]
+    if not isinstance(raw_policy, Mapping):
+        raise TypeError("quantization_config.runtime.diffusion_step_policy must be a mapping")
+
+    policy = _parse_policy(raw_policy)
+    if policy is None:
+        return None
+    _validate_checkpoint_quantization(od_config)
+    return policy
+
+
+def _parse_policy(policy: Mapping[str, object]) -> Cosmos3MixedPrecisionConfig | None:
+    fields = set(policy)
+    unknown = fields - _POLICY_FIELDS
+    if unknown:
+        raise ValueError(f"Unknown diffusion_step_policy fields: {sorted(unknown)}")
+    missing = _POLICY_FIELDS - fields
+    if missing:
+        raise ValueError(f"Missing diffusion_step_policy fields: {sorted(missing)}")
+
+    schema_version = policy["schema_version"]
+    if not isinstance(schema_version, int) or isinstance(schema_version, bool) or schema_version != 1:
+        raise ValueError("diffusion_step_policy.schema_version must be the integer 1")
+    if policy["type"] != "first_last_n":
+        raise ValueError("diffusion_step_policy.type must be 'first_last_n'")
+    if policy["index_space"] != "denoising_loop_iteration":
+        raise ValueError("diffusion_step_policy.index_space must be 'denoising_loop_iteration'")
+    if policy["default_mode"] != "native":
+        raise ValueError("diffusion_step_policy.default_mode must be 'native'")
+    if policy["overlap"] != "a16":
+        raise ValueError("diffusion_step_policy.overlap must be 'a16'")
+
+    scope = policy["scope"]
+    if not isinstance(scope, list) or not scope or not all(isinstance(item, str) for item in scope):
+        raise TypeError("diffusion_step_policy.scope must be a non-empty list of strings")
+
+    first_steps = _parse_step_range(policy["first_steps"], "first_steps")
+    last_steps = _parse_step_range(policy["last_steps"], "last_steps")
+
+    reasoner = policy["reasoner"]
+    if reasoner not in {"native", "a16"}:
+        raise ValueError("diffusion_step_policy.reasoner must be 'native' or 'a16'")
+
+    if _COMPONENT not in scope:
+        return None
+    return Cosmos3MixedPrecisionConfig(
+        first_steps=first_steps,
+        last_steps=last_steps,
+        reasoner=cast(ReasonerPolicy, reasoner),
+    )
+
+
+def _parse_step_range(value: object, name: str) -> int:
+    if not isinstance(value, Mapping):
+        raise TypeError(f"diffusion_step_policy.{name} must be a mapping")
+    fields = set(value)
+    unknown = fields - _STEP_RANGE_FIELDS
+    if unknown:
+        raise ValueError(f"Unknown diffusion_step_policy.{name} fields: {sorted(unknown)}")
+    missing = _STEP_RANGE_FIELDS - fields
+    if missing:
+        raise ValueError(f"Missing diffusion_step_policy.{name} fields: {sorted(missing)}")
+    if value["mode"] != "a16":
+        raise ValueError(f"diffusion_step_policy.{name}.mode must be 'a16'")
+    return _non_negative_int(value["count"], f"diffusion_step_policy.{name}.count")
+
+
+def _validate_checkpoint_quantization(od_config: object) -> None:
+    # Match the effective quantization used to construct the transformer linears.
+    quant_config = getattr(od_config, "quantization_config", None)
+    if quant_config is None:
+        tf_config = getattr(od_config, "tf_model_config", None)
+        quant_config = getattr(tf_config, "quant_config", None)
+
+    get_name = getattr(quant_config, "get_name", None)
+    name = get_name() if callable(get_name) else None
+    if name not in _SUPPORTED_MODEL_OPT_CONFIGS:
+        raise ValueError(f"diffusion_step_policy requires a serialized ModelOpt FP8 or NVFP4 checkpoint, got {name!r}")
+
+    if name == "modelopt":
+        _require_serialized(quant_config, "is_checkpoint_fp8_serialized", "FP8")
+        return
+    if name == "modelopt_fp4":
+        if getattr(quant_config, "quant_method", "NVFP4") != "NVFP4":
+            raise ValueError("diffusion_step_policy requires checkpoint-native NVFP4 W4A4 linears")
+        _require_serialized(quant_config, "is_checkpoint_nvfp4_serialized", "NVFP4")
+        return
+
+
+def _require_serialized(quant_config: object | None, flag: str, format_name: str) -> None:
+    if not bool(getattr(quant_config, flag, False)):
+        raise ValueError(f"diffusion_step_policy requires serialized ModelOpt {format_name} weights")
diff --git a/vllm_omni/diffusion/models/cosmos3/mixed_precision/config.py b/vllm_omni/diffusion/models/cosmos3/mixed_precision/config.py
new file mode 100644
index 000000000..13748c8fd
--- /dev/null
+++ b/vllm_omni/diffusion/models/cosmos3/mixed_precision/config.py
@@ -0,0 +1,106 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Configuration parsing and denoising-step policy for mixed precision."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Literal, cast
+
+ReasonerPolicy = Literal["native", "a16"]
+
+_REASONER_POLICIES = frozenset({"native", "a16"})
+_CONFIG_FIELDS = frozenset({"enabled", "first_steps", "last_steps", "reasoner"})
+
+
+@dataclass(frozen=True)
+class Cosmos3MixedPrecisionConfig:
+    """Validated precision policy shared by every quantization strategy."""
+
+    first_steps: int = 3
+    last_steps: int = 3
+    reasoner: ReasonerPolicy = "a16"
+
+    @classmethod
+    def from_additional_config(
+        cls,
+        additional_config: Mapping[str, object] | None,
+    ) -> Cosmos3MixedPrecisionConfig | None:
+        """Parse Cosmos3 fields from vLLM-Omni's additional configuration."""
+        _, config = cls.resolve_additional_config(additional_config)
+        return config
+
+    @classmethod
+    def resolve_additional_config(
+        cls,
+        additional_config: Mapping[str, object] | None,
+    ) -> tuple[bool, Cosmos3MixedPrecisionConfig | None]:
+        """Return whether an override was supplied and its effective policy.
+
+        The separate presence bit distinguishes an absent runtime override from
+        an explicit disable.  That distinction matters when a checkpoint owns a
+        default policy.
+        """
+        if additional_config is not None and not isinstance(additional_config, Mapping):
+            raise TypeError("additional_config must be a mapping")
+        values = additional_config or {}
+        if "cosmos3_mixed_precision" not in values:
+            return False, None
+        raw_config = values["cosmos3_mixed_precision"]
+        if not isinstance(raw_config, Mapping):
+            raise TypeError("cosmos3_mixed_precision must be a mapping")
+        unknown = set(raw_config) - _CONFIG_FIELDS
+        if unknown:
+            raise ValueError(f"Unknown cosmos3_mixed_precision fields: {sorted(unknown)}")
+
+        enabled = raw_config.get("enabled", True)
+        if not isinstance(enabled, bool):
+            raise TypeError("cosmos3_mixed_precision.enabled must be a boolean")
+        if not enabled:
+            conflicting = set(raw_config) - {"enabled"}
+            if conflicting:
+                raise ValueError(
+                    "cosmos3_mixed_precision.enabled=false cannot be combined with "
+                    f"schedule fields: {sorted(conflicting)}"
+                )
+            return True, None
+
+        first_steps = _non_negative_int(
+            raw_config.get("first_steps", 3),
+            "cosmos3_mixed_precision.first_steps",
+        )
+        last_steps = _non_negative_int(
+            raw_config.get("last_steps", 3),
+            "cosmos3_mixed_precision.last_steps",
+        )
+
+        reasoner = str(raw_config.get("reasoner", "a16")).lower()
+        if reasoner not in _REASONER_POLICIES:
+            raise ValueError(
+                f"cosmos3_mixed_precision.reasoner must be one of {sorted(_REASONER_POLICIES)}, got {reasoner!r}"
+            )
+        config = cls(
+            first_steps=first_steps,
+            last_steps=last_steps,
+            reasoner=cast(ReasonerPolicy, reasoner),
+        )
+        if first_steps == 0 and last_steps == 0 and reasoner == "native":
+            return True, None
+        return True, config
+
+    def use_high_precision(self, step_index: int, num_steps: int) -> bool:
+        """Select the high path for an actual scheduler-step index."""
+        if num_steps <= 0:
+            raise ValueError(f"num_steps must be positive, got {num_steps}")
+        if step_index < 0 or step_index >= num_steps:
+            raise IndexError(f"step_index must be in [0, {num_steps}), got {step_index}")
+        return step_index < self.first_steps or step_index >= num_steps - self.last_steps
+
+
+def _non_negative_int(value: object, name: str) -> int:
+    """Validate an integer configuration field without accepting booleans."""
+    if not isinstance(value, int) or isinstance(value, bool) or value < 0:
+        raise TypeError(f"{name} must be a non-negative integer")
+    return value
diff --git a/vllm_omni/diffusion/models/cosmos3/mixed_precision/runtime.py b/vllm_omni/diffusion/models/cosmos3/mixed_precision/runtime.py
new file mode 100644
index 000000000..f528262e5
--- /dev/null
+++ b/vllm_omni/diffusion/models/cosmos3/mixed_precision/runtime.py
@@ -0,0 +1,116 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Format-agnostic schedule state, linear discovery, and dispatch."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+import torch
+from vllm.model_executor.layers.linear import LinearBase, LinearMethodBase
+
+from .config import Cosmos3MixedPrecisionConfig
+from .strategy import (
+    Cosmos3PrecisionStrategy,
+    Fp8W8A8W8A16Strategy,
+    Nvfp4W4A4W4A16Strategy,
+)
+
+PrecisionPath = Literal["reasoner", "generation"]
+_STRATEGIES: tuple[Cosmos3PrecisionStrategy, ...] = (
+    Fp8W8A8W8A16Strategy(),
+    Nvfp4W4A4W4A16Strategy(),
+)
+
+
+def _strategy_for(method: object | None) -> Cosmos3PrecisionStrategy | None:
+    return next((strategy for strategy in _STRATEGIES if strategy.accepts(method)), None)
+
+
+class Cosmos3MixedPrecisionLinearMethod(LinearMethodBase):
+    """Dispatch between a checkpoint-native method and dense A16."""
+
+    def __init__(
+        self,
+        base_method: LinearMethodBase,
+        strategy: Cosmos3PrecisionStrategy,
+        runtime: Cosmos3MixedPrecisionRuntime,
+        module_name: str,
+        path: PrecisionPath,
+    ) -> None:
+        self.base_method = base_method
+        self.strategy = strategy
+        self.runtime = runtime
+        self.module_name = module_name
+        self.path = path
+
+    def create_weights(self, *args, **kwargs) -> None:
+        self.base_method.create_weights(*args, **kwargs)
+
+    def process_weights_after_loading(self, layer: torch.nn.Module) -> None:
+        self.strategy.validate_before_processing(
+            self.base_method,
+            layer,
+            self.module_name,
+        )
+        self.base_method.process_weights_after_loading(layer)
+        self.strategy.validate_after_processing(layer, self.module_name)
+
+    def apply(
+        self,
+        layer: torch.nn.Module,
+        x: torch.Tensor,
+        bias: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        if not self.runtime.use_high_precision(self.path):
+            return self.base_method.apply(layer, x, bias)
+        return self.strategy.apply_high(layer, x, bias)
+
+
+class Cosmos3MixedPrecisionRuntime:
+    """Own one transformer's schedule state and wrapped linear inventory."""
+
+    def __init__(self, config: Cosmos3MixedPrecisionConfig) -> None:
+        self.config = config
+        # TODO: Make this request-local before Cosmos3 supports interleaved
+        # denoising requests on one transformer instance.
+        self._generation_high_precision = False
+
+    def install(self, transformer: torch.nn.Module) -> None:
+        components: dict[PrecisionPath, torch.nn.Module] = {
+            "generation": transformer.gen_layers,
+        }
+        if self.config.reasoner == "a16":
+            components["reasoner"] = transformer.language_model.layers
+
+        wrapped_count = 0
+        for path, component in components.items():
+            for local_name, layer in component.named_modules():
+                if not isinstance(layer, LinearBase):
+                    continue
+                base_method = getattr(layer, "quant_method", None)
+                strategy = _strategy_for(base_method)
+                if strategy is None:
+                    continue
+                module_name = getattr(layer, "prefix", None) or f"{path}.{local_name}"
+                layer.quant_method = Cosmos3MixedPrecisionLinearMethod(
+                    base_method,
+                    strategy,
+                    self,
+                    module_name,
+                    path,
+                )
+                wrapped_count += 1
+
+        if not wrapped_count:
+            raise ValueError("Cosmos3 mixed precision found no compatible FP8 or NVFP4 ModelOpt linears")
+
+    def use_high_precision(self, path: PrecisionPath) -> bool:
+        return self.config.reasoner == "a16" if path == "reasoner" else self._generation_high_precision
+
+    def set_step(self, step_index: int, num_steps: int) -> None:
+        self._generation_high_precision = self.config.use_high_precision(step_index, num_steps)
+
+    def reset(self) -> None:
+        self._generation_high_precision = False
diff --git a/vllm_omni/diffusion/models/cosmos3/mixed_precision/strategy.py b/vllm_omni/diffusion/models/cosmos3/mixed_precision/strategy.py
new file mode 100644
index 000000000..8208b7622
--- /dev/null
+++ b/vllm_omni/diffusion/models/cosmos3/mixed_precision/strategy.py
@@ -0,0 +1,218 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+"""Format-specific live-weight validation and reference A16 materialization."""
+
+from __future__ import annotations
+
+import torch
+import torch.nn.functional as F
+from vllm.model_executor.layers.quantization.modelopt import (
+    ModelOptFp8LinearMethod,
+    ModelOptNvFp4LinearMethod,
+)
+from vllm.model_executor.layers.quantization.utils import nvfp4_emulation_utils
+
+_NVFP4_BLOCK_SIZE = 16
+
+
+class Cosmos3PrecisionStrategy:
+    """Quantization-format boundary behind the shared precision schedule."""
+
+    def accepts(self, method: object | None) -> bool:
+        """Return whether this strategy owns a native linear method."""
+        raise NotImplementedError
+
+    def validate_before_processing(
+        self,
+        method: object,
+        layer: torch.nn.Module,
+        module_name: str,
+    ) -> None:
+        """Reject native transforms that cannot support live dequantization."""
+
+    def validate_after_processing(
+        self,
+        layer: torch.nn.Module,
+        module_name: str,
+    ) -> None:
+        """Validate the live native weight representation."""
+        raise NotImplementedError
+
+    def materialize(self, layer: torch.nn.Module) -> torch.Tensor:
+        """Materialize the live quantized weight as a dense BF16 matrix."""
+        raise NotImplementedError
+
+    def apply_high(
+        self,
+        layer: torch.nn.Module,
+        x: torch.Tensor,
+        bias: torch.Tensor | None,
+    ) -> torch.Tensor:
+        """Apply the reference dense A16 path."""
+        input_size = int(layer.input_size_per_partition)
+        output_size = int(layer.output_size_per_partition)
+        weight = self.materialize(layer)
+        expected_shape = (output_size, input_size)
+        if tuple(weight.shape) != expected_shape:
+            raise RuntimeError(f"Dense weight shape {tuple(weight.shape)} does not match {expected_shape}")
+        x_2d = x.reshape(-1, x.shape[-1])
+        if x_2d.shape[1] != input_size:
+            raise ValueError(f"Expected activation width {input_size}, got {x_2d.shape[1]}")
+        weight = weight.to(dtype=x.dtype)
+        if bias is not None and bias.dtype != x.dtype:
+            bias = bias.to(dtype=x.dtype)
+        output = F.linear(x_2d, weight, bias)
+        return output.view(*x.shape[:-1], output_size)
+
+
+class Fp8W8A8W8A16Strategy(Cosmos3PrecisionStrategy):
+    """Use native ModelOpt W8A8 or reference dense W8A16."""
+
+    def accepts(self, method: object | None) -> bool:
+        return isinstance(method, ModelOptFp8LinearMethod)
+
+    def validate_before_processing(
+        self,
+        method: object,
+        layer: torch.nn.Module,
+        module_name: str,
+    ) -> None:
+        if hasattr(layer, "pre_quant_scale"):
+            raise ValueError(f"{module_name} uses unsupported SmoothQuant pre_quant_scale")
+        weight_scale = getattr(layer, "weight_scale", None)
+        if not isinstance(weight_scale, torch.Tensor) or weight_scale.numel() != 1:
+            raise ValueError(f"{module_name} requires serialized tensorwise FP8 weights")
+        fp8_kernel = getattr(method, "fp8_linear", None)
+        from vllm.model_executor.kernels.linear.scaled_mm.marlin import (
+            MarlinFP8ScaledMMLinearKernel,
+        )
+
+        if isinstance(fp8_kernel, MarlinFP8ScaledMMLinearKernel):
+            raise ValueError(
+                f"{module_name} selected Marlin FP8, which repacks the only weight copy; "
+                "use a backend that retains canonical FP8 weights"
+            )
+
+    def validate_after_processing(
+        self,
+        layer: torch.nn.Module,
+        module_name: str,
+    ) -> None:
+        weight = getattr(layer, "weight", None)
+        scale = getattr(layer, "weight_scale", None)
+        if not isinstance(weight, torch.Tensor) or weight.dtype != torch.float8_e4m3fn:
+            dtype = getattr(weight, "dtype", None)
+            raise TypeError(f"{module_name} requires a canonical FP8 weight, got {dtype}")
+        if weight.ndim != 2:
+            raise ValueError(f"{module_name} requires a rank-2 FP8 weight, got {tuple(weight.shape)}")
+        if not isinstance(scale, torch.Tensor):
+            raise ValueError(f"{module_name} has an FP8 weight but no weight_scale")
+        if scale.numel() != 1:
+            raise ValueError(f"{module_name} requires one live FP8 weight scale")
+        input_size = int(layer.input_size_per_partition)
+        output_size = int(layer.output_size_per_partition)
+        if weight.shape[0] < input_size or weight.shape[1] < output_size:
+            raise ValueError(
+                f"{module_name} live FP8 weight shape {tuple(weight.shape)} does not cover "
+                f"(K, N)=({input_size}, {output_size})"
+            )
+        _validate_positive_finite_scale(scale, module_name)
+
+    def materialize(self, layer: torch.nn.Module) -> torch.Tensor:
+        input_size = int(layer.input_size_per_partition)
+        output_size = int(layer.output_size_per_partition)
+        weight = layer.weight[:input_size, :output_size]
+        scale = layer.weight_scale.reshape(1).to(device=weight.device, dtype=torch.float32)
+        return (weight.to(torch.float32) * scale).t().to(torch.bfloat16)
+
+
+class Nvfp4W4A4W4A16Strategy(Cosmos3PrecisionStrategy):
+    """Use native ModelOpt W4A4 or reference dense W4A16."""
+
+    def accepts(self, method: object | None) -> bool:
+        return isinstance(method, ModelOptNvFp4LinearMethod)
+
+    def validate_before_processing(
+        self,
+        method: object,
+        layer: torch.nn.Module,
+        module_name: str,
+    ) -> None:
+        kernel = getattr(method, "kernel", None)
+        from vllm.model_executor.kernels.linear.nvfp4.cutlass import (
+            CutlassNvFp4LinearKernel,
+        )
+        from vllm.model_executor.kernels.linear.nvfp4.flashinfer import (
+            FlashInferCuteDslNvFp4LinearKernel,
+            FlashInferCutlassNvFp4LinearKernel,
+        )
+
+        compatible_kernels = (
+            CutlassNvFp4LinearKernel,
+            FlashInferCuteDslNvFp4LinearKernel,
+            FlashInferCutlassNvFp4LinearKernel,
+        )
+        if not isinstance(kernel, compatible_kernels):
+            kernel_name = type(kernel).__name__ if kernel is not None else "none"
+            raise ValueError(
+                f"{module_name} selected unsupported NVFP4 backend {kernel_name}; "
+                "live W4A16 dequantization requires a CUTLASS-compatible layout"
+            )
+        global_scale = _nvfp4_global_scale(layer)
+        if global_scale is None or global_scale.numel() != 1:
+            raise ValueError(f"{module_name} is missing ModelOpt NVFP4 scales")
+
+    def validate_after_processing(
+        self,
+        layer: torch.nn.Module,
+        module_name: str,
+    ) -> None:
+        packed = getattr(layer, "weight", None)
+        scale = getattr(layer, "weight_scale", None)
+        global_scale = getattr(layer, "weight_global_scale", None)
+        if not isinstance(packed, torch.Tensor) or packed.dtype != torch.uint8:
+            dtype = getattr(packed, "dtype", None)
+            raise TypeError(f"{module_name} requires a live packed NVFP4 weight, got {dtype}")
+        if not isinstance(scale, torch.Tensor) or not isinstance(global_scale, torch.Tensor):
+            raise ValueError(f"{module_name} is missing live NVFP4 scales")
+        output_size = int(layer.output_size_per_partition)
+        input_size = int(layer.input_size_per_partition)
+        if input_size % _NVFP4_BLOCK_SIZE != 0:
+            raise ValueError(f"{module_name} input size {input_size} is not divisible by {_NVFP4_BLOCK_SIZE}")
+        expected_weight = (output_size, input_size // 2)
+        if packed.shape[0] < expected_weight[0] or packed.shape[1] < expected_weight[1]:
+            raise ValueError(
+                f"{module_name} live NVFP4 weight shape {tuple(packed.shape)} does not cover {expected_weight}"
+            )
+        _validate_positive_finite_scale(global_scale, module_name)
+        lut_handle = nvfp4_emulation_utils.kE2M1ToFloat_handle
+        if lut_handle.val.device != packed.device:
+            lut_handle.val = lut_handle.val.to(packed.device)
+
+    def materialize(self, layer: torch.nn.Module) -> torch.Tensor:
+        output_size = int(layer.output_size_per_partition)
+        input_size = int(layer.input_size_per_partition)
+        packed = layer.weight[:output_size, : input_size // 2]
+        return nvfp4_emulation_utils.dequantize_to_dtype(
+            packed,
+            layer.weight_scale,
+            layer.weight_global_scale,
+            torch.bfloat16,
+            _NVFP4_BLOCK_SIZE,
+            True,
+        )
+
+
+def _validate_positive_finite_scale(scale: torch.Tensor, module_name: str) -> None:
+    values = scale.detach().float()
+    if not torch.isfinite(values).all() or not (values > 0).all():
+        raise ValueError(f"{module_name} has a non-finite or non-positive weight scale")
+
+
+def _nvfp4_global_scale(layer: torch.nn.Module) -> torch.Tensor | None:
+    for name in ("weight_scale_2", "weight_global_scale"):
+        value = getattr(layer, name, None)
+        if isinstance(value, torch.Tensor):
+            return value
+    return None
diff --git a/vllm_omni/diffusion/models/cosmos3/pipeline_cosmos3.py b/vllm_omni/diffusion/models/cosmos3/pipeline_cosmos3.py
index 49a4e4027..04f25ac58 100644
--- a/vllm_omni/diffusion/models/cosmos3/pipeline_cosmos3.py
+++ b/vllm_omni/diffusion/models/cosmos3/pipeline_cosmos3.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
 """Cosmos3 text/image/video/sound/action pipeline for vllm-omni.
 
 One pipeline class serves the Cosmos3 family modes. Output modality is selected
@@ -34,6 +34,7 @@ import math
 import os
 import time
 from collections.abc import Iterable, Mapping
+from contextlib import nullcontext
 from dataclasses import fields
 from typing import Any, ClassVar
 
@@ -138,6 +139,7 @@ from .utils import (
     ensure_gripper_array,
     extract_robolab_image,
     extract_robolab_prompt_image,
+    get_robolab_domain_id,
     lazy_action_transform_pipeline,
     make_robolab_action_postprocess_inputs,
     next_robolab_seed,
@@ -947,6 +949,20 @@ class Cosmos3OmniDiffusersPipeline(
         model_path = od_config.model
         local_files_only = os.path.exists(model_path)
 
+        # Validate guidance parallelism from checkpoint metadata before loading
+        # components. Distilled checkpoints have only a conditional branch.
+        scheduler_config = FlowUniPCMultistepScheduler.load_config(
+            model_path,
+            subfolder="scheduler",
+            local_files_only=local_files_only,
+        )
+        self.is_distilled_model = scheduler_config.get("_class_name") == COSMOS3_DISTILLED_CHECKPOINT_SCHEDULER_CLASS
+        if self.is_distilled_model and od_config.parallel_config.cfg_parallel_size > 1:
+            raise ValueError(
+                "Distilled Cosmos3 checkpoints run without classifier-free guidance. "
+                "Set --cfg-parallel-size 1 and use --ulysses-degree for multi-GPU inference."
+            )
+
         # --- Tokenizer ---
         self.tokenizer = AutoTokenizer.from_pretrained(
             model_path,
@@ -1009,20 +1025,7 @@ class Cosmos3OmniDiffusersPipeline(
             logger.info("Cosmos3: session state manager enabled (max_sessions=%d)", mm_max_sessions)
 
         # --- Scheduler ---
-        # Distilled model differs from regular one only by scheduler,
-        # distilled one uses FlowMatchEulerDiscreteScheduler, while
-        # regular should use FlowUniPCMultistepScheduler
-
-        scheduler_config = FlowUniPCMultistepScheduler.load_config(
-            model_path,
-            subfolder="scheduler",
-            local_files_only=local_files_only,
-        )
-
-        scheduler_class_name = scheduler_config.get("_class_name")
-
-        self.is_distilled_model = False
-        if scheduler_class_name == COSMOS3_DISTILLED_CHECKPOINT_SCHEDULER_CLASS:
+        if self.is_distilled_model:
             fixed_step_config = scheduler_config.get("fixed_step_sampler_config")
             if not isinstance(fixed_step_config, dict) or fixed_step_config.get("sample_type") != "sde":
                 raise ValueError("Cosmos3 distilled scheduler requires fixed_step_sampler_config.sample_type=sde.")
@@ -1034,7 +1037,6 @@ class Cosmos3OmniDiffusersPipeline(
                 stochastic_sampling=True,
             )
             self._scheduler_init_t_list = list(t_list)
-            self.is_distilled_model = True
         else:
             # Preserve compatible solver settings from the checkpoint, but keep
             # the base shift neutral. The concrete request shift is applied when
@@ -1074,8 +1076,10 @@ class Cosmos3OmniDiffusersPipeline(
 
         self._guidance_scale = None
         self._num_timesteps = None
+        self._current_step_index = None
+        self._current_sigma = None
         self._cosmos3_branch_caches: dict[str, tuple[Any, Any]] | None = None
-        self._robolab_transform = None
+        self._robolab_transforms: dict[bool, Any] = {}
 
         # Set True by ``enable_cache_for_cosmos3`` when cache-dit is enabled on
         # this pipeline. Tells the sequential-CFG loop to keep paired
@@ -1290,17 +1294,24 @@ class Cosmos3OmniDiffusersPipeline(
         or a tuple in video, action, sound order for multimodal generation.
         """
         cache_key = kwargs.pop("_cosmos3_cache_key", None)
-        if cache_key is None:
-            return self.transformer(**kwargs)
+        context_name = str(kwargs.pop("_cache_context", "cond"))
 
-        branch_caches = self._cosmos3_branch_caches
-        if branch_caches is None:
-            return self.transformer(**kwargs)
-
-        cache_key = str(cache_key)
-        self.transformer.cached_kv, self.transformer.cached_freqs_gen = branch_caches.get(cache_key, (None, None))
-        prediction = self.transformer(**kwargs)
-        branch_caches[cache_key] = (self.transformer.cached_kv, self.transformer.cached_freqs_gen)
+        context_factory = getattr(self, "_cache_context_factory", None)
+        context = context_factory(context_name) if callable(context_factory) else nullcontext()
+        with context:
+            if cache_key is None:
+                prediction = self.transformer(**kwargs)
+            else:
+                branch_caches = self._cosmos3_branch_caches
+                if branch_caches is None:
+                    prediction = self.transformer(**kwargs)
+                else:
+                    cache_key = str(cache_key)
+                    self.transformer.cached_kv, self.transformer.cached_freqs_gen = branch_caches.get(
+                        cache_key, (None, None)
+                    )
+                    prediction = self.transformer(**kwargs)
+                    branch_caches[cache_key] = (self.transformer.cached_kv, self.transformer.cached_freqs_gen)
         return prediction
 
     def combine_multi_branch_cfg_noise(
@@ -1394,11 +1405,18 @@ class Cosmos3OmniDiffusersPipeline(
             return val
         return default
 
-    def _get_robolab_transform(self):
-        if self._robolab_transform is None:
+    def _get_robolab_transform(self, *, format_prompt_as_json: bool = False):
+        transforms = getattr(self, "_robolab_transforms", None)
+        if transforms is None:
+            transforms = {}
+            self._robolab_transforms = transforms
+        if format_prompt_as_json not in transforms:
             action_dim = int(getattr(self.transformer, "action_dim", 64))
-            self._robolab_transform = lazy_action_transform_pipeline(action_dim)
-        return self._robolab_transform
+            transforms[format_prompt_as_json] = lazy_action_transform_pipeline(
+                action_dim,
+                format_prompt_as_json=format_prompt_as_json,
+            )
+        return transforms[format_prompt_as_json]
 
     def _build_robolab_policy_inputs(
         self,
@@ -1443,7 +1461,8 @@ class Cosmos3OmniDiffusersPipeline(
         resolution = str(extra_param("resolution", ROBOLAB_DEFAULT_RESOLUTION))
         fps = float(extra_param("conditioning_fps", ROBOLAB_DEFAULT_CONDITIONING_FPS))
         domain_name = str(extra_param("domain_name", ROBOLAB_DEFAULT_DOMAIN_NAME))
-        domain_id = resolve_domain_id(domain_name=domain_name, require_explicit=True)
+        domain_id = get_robolab_domain_id(domain_name)
+        format_prompt_as_json = self._truthy(extra_param("format_prompt_as_json", False))
 
         if use_state and history_length < 1:
             raise ValueError("RoboLab history_length must be >= 1 when use_state is true.")
@@ -1506,7 +1525,9 @@ class Cosmos3OmniDiffusersPipeline(
             "action": action,
             # Cosmos Framework consumes this as an integer conditioning bucket.
             "conditioning_fps": torch.tensor(fps, dtype=torch.long),
-            "mode": ACTION_MODE_POLICY,
+            # Cosmos Framework 1.2 renamed the internal policy transform mode to
+            # ``wam``. The public vLLM action_mode remains ``policy``.
+            "mode": "wam",
             "domain_id": torch.tensor(domain_id, dtype=torch.long),
             "viewpoint": "concat_view",
             "additional_view_description": ROBOLAB_CONCAT_VIEW_DESCRIPTION,
@@ -1514,7 +1535,9 @@ class Cosmos3OmniDiffusersPipeline(
         if history_action is not None:
             sample["history_action"] = history_action
 
-        sample = self._get_robolab_transform()(sample, resolution)
+        sample = self._get_robolab_transform(format_prompt_as_json=format_prompt_as_json)(sample, resolution)
+        if isinstance(sample.get("ai_caption"), dict):
+            sample["ai_caption"] = json.dumps(sample["ai_caption"])
         sequence_plan = sample["sequence_plan"]
         video_tensor = sample["video"].float() / 127.5 - 1.0
         raw_action_dim_tensor = sample.get("raw_action_dim")
@@ -1798,6 +1821,11 @@ class Cosmos3OmniDiffusersPipeline(
 
     def _resolve_guidance_scale(self, sp: OmniDiffusionSamplingParams, default: float) -> float:
         if self.is_distilled_model:
+            if sp.guidance_scale_provided and float(sp.guidance_scale) != 1.0:
+                logger.warning_once(
+                    "Distilled Cosmos3 checkpoints run without classifier-free guidance. "
+                    "The requested guidance_scale is overridden to 1.0; negative_prompt does not affect generation."
+                )
             return 1.0
         if sp.guidance_scale_provided:
             return float(sp.guidance_scale)
@@ -1822,6 +1850,39 @@ class Cosmos3OmniDiffusersPipeline(
     def num_timesteps(self):
         return self._num_timesteps
 
+    @property
+    def current_step_index(self):
+        return self._current_step_index
+
+    @property
+    def current_sigma(self):
+        return self._current_sigma
+
+    def _set_denoise_step_metadata(
+        self,
+        step_index: int,
+        timesteps: torch.Tensor,
+        scheduler: Any,
+    ) -> None:
+        self._current_step_index = step_index
+        self._num_timesteps = len(timesteps)
+        sigmas = getattr(scheduler, "sigmas", None)
+        self._current_sigma = sigmas[step_index] if sigmas is not None and step_index < len(sigmas) else None
+
+    def _clear_denoise_step_metadata(self) -> None:
+        self._current_step_index = None
+        self._current_sigma = None
+
+    def _set_mixed_precision_step(self, step_index: int, num_steps: int) -> None:
+        setter = getattr(self.transformer, "set_mixed_precision_step", None)
+        if setter is not None:
+            setter(step_index, num_steps)
+
+    def _reset_mixed_precision(self) -> None:
+        resetter = getattr(self.transformer, "reset_mixed_precision", None)
+        if resetter is not None:
+            resetter()
+
     @staticmethod
     def _distilled_unsupported_error(detail: str) -> ValueError:
         return ValueError(
@@ -2819,7 +2880,9 @@ class Cosmos3OmniDiffusersPipeline(
                 # Each CFG-parallel rank runs exactly one branch (rank 0 -> cond,
                 # else uncond), so session keying loads/stores only this rank's branch.
                 cfg_rank_is_negative = get_classifier_free_guidance_rank() != 0
-                for t in self.progress_bar(timesteps):
+                for step_index, t in enumerate(self.progress_bar(timesteps)):
+                    self._set_denoise_step_metadata(step_index, timesteps, step_scheduler)
+                    self._set_mixed_precision_step(step_index, len(timesteps))
                     timestep = t.unsqueeze(0)
                     # Outside the interval, scale=1 makes the combined output equal
                     # the cond branch. Every rank remains on the same iteration and
@@ -2830,6 +2893,7 @@ class Cosmos3OmniDiffusersPipeline(
                         do_true_cfg=True,
                         true_cfg_scale=step_scale,
                         positive_kwargs=dict(
+                            _cache_context="cond",
                             hidden_states=latents,
                             timestep=timestep,
                             text_ids=cond_ids,
@@ -2839,6 +2903,7 @@ class Cosmos3OmniDiffusersPipeline(
                             **shared_kwargs,
                         ),
                         negative_kwargs=dict(
+                            _cache_context="uncond",
                             hidden_states=latents,
                             timestep=timestep,
                             text_ids=uncond_ids,
@@ -2858,13 +2923,16 @@ class Cosmos3OmniDiffusersPipeline(
                 uncond_cache: tuple = (None, None)
                 keep_uncond_for_cache = self._cache_requires_paired_cfg()
 
-                for t in self.progress_bar(timesteps):
+                for step_index, t in enumerate(self.progress_bar(timesteps)):
+                    self._set_denoise_step_metadata(step_index, timesteps, step_scheduler)
+                    self._set_mixed_precision_step(step_index, len(timesteps))
                     timestep = t.unsqueeze(0)
                     cfg_active = _cfg_active_at(t)
 
                     if not self._kv_load_und(kv_state, is_negative=False):
                         self.transformer.cached_kv, self.transformer.cached_freqs_gen = cond_cache
-                    noise_cond = self.transformer(
+                    noise_cond = self.predict_noise(
+                        _cache_context="cond",
                         hidden_states=latents,
                         timestep=timestep,
                         text_ids=cond_ids,
@@ -2881,7 +2949,8 @@ class Cosmos3OmniDiffusersPipeline(
                     if cfg_active or keep_uncond_for_cache:
                         if not self._kv_load_und(kv_state, is_negative=True):
                             self.transformer.cached_kv, self.transformer.cached_freqs_gen = uncond_cache
-                        noise_uncond = self.transformer(
+                        noise_uncond = self.predict_noise(
+                            _cache_context="uncond",
                             hidden_states=latents,
                             timestep=timestep,
                             text_ids=uncond_ids,
@@ -2912,10 +2981,13 @@ class Cosmos3OmniDiffusersPipeline(
             else:
                 # No CFG: a single cond branch per step. Bespoke (state None) keeps
                 # using the transformer-instance cache exactly as before.
-                for t in self.progress_bar(timesteps):
+                for step_index, t in enumerate(self.progress_bar(timesteps)):
+                    self._set_denoise_step_metadata(step_index, timesteps, step_scheduler)
+                    self._set_mixed_precision_step(step_index, len(timesteps))
                     timestep = t.unsqueeze(0)
                     self._kv_load_und(kv_state, is_negative=False)
-                    noise_pred = self.transformer(
+                    noise_pred = self.predict_noise(
+                        _cache_context="cond",
                         hidden_states=latents,
                         timestep=timestep,
                         text_ids=cond_ids,
@@ -2928,6 +3000,8 @@ class Cosmos3OmniDiffusersPipeline(
                         self._kv_capture_und(kv_state, is_negative=False)
                     _assign_step_out(_step(noise_pred, t, latents, action_latents, sound_latents))
         finally:
+            self._clear_denoise_step_metadata()
+            self._reset_mixed_precision()
             # Cosmos3 currently receives a unique request_id rather than a
             # reusable rollout session id. Retaining its state would only pin
             # K/V buffers on device after this generation finishes.
@@ -3112,7 +3186,9 @@ class Cosmos3OmniDiffusersPipeline(
         self.transformer.reset_cache()
         self._cosmos3_branch_caches = {}
         try:
-            for t in self.progress_bar(timesteps):
+            for step_index, t in enumerate(self.progress_bar(timesteps)):
+                self._set_denoise_step_metadata(step_index, timesteps, self.scheduler)
+                self._set_mixed_precision_step(step_index, len(timesteps))
                 timestep = t.unsqueeze(0)
                 step_guidance = guidance_scale if _active_at(t, guidance_interval) else 1.0
                 step_control = control_guidance if _active_at(t, control_guidance_interval) else 1.0
@@ -3120,6 +3196,7 @@ class Cosmos3OmniDiffusersPipeline(
                 needs_control_cfg = step_control != 1.0
 
                 cond_full_kwargs = dict(
+                    _cache_context="cond",
                     hidden_states=latents,
                     timestep=timestep,
                     text_ids=cond_ids,
@@ -3133,6 +3210,7 @@ class Cosmos3OmniDiffusersPipeline(
                     branches_kwargs = [
                         cond_full_kwargs,
                         dict(
+                            _cache_context="cond_no_control",
                             hidden_states=latents,
                             timestep=timestep,
                             text_ids=cond_ids,
@@ -3142,6 +3220,7 @@ class Cosmos3OmniDiffusersPipeline(
                             **shared_kwargs,
                         ),
                         dict(
+                            _cache_context="uncond",
                             hidden_states=latents,
                             timestep=timestep,
                             text_ids=uncond_ids,
@@ -3167,6 +3246,7 @@ class Cosmos3OmniDiffusersPipeline(
                     branches_kwargs = [
                         cond_full_kwargs,
                         dict(
+                            _cache_context="cond_no_control",
                             hidden_states=latents,
                             timestep=timestep,
                             text_ids=cond_ids,
@@ -3190,6 +3270,7 @@ class Cosmos3OmniDiffusersPipeline(
                     branches_kwargs = [
                         cond_full_kwargs,
                         dict(
+                            _cache_context="uncond",
                             hidden_states=latents,
                             timestep=timestep,
                             text_ids=uncond_ids,
@@ -3224,6 +3305,8 @@ class Cosmos3OmniDiffusersPipeline(
                 )[0]
                 latents = velocity_mask * latents + (1.0 - velocity_mask) * condition_latents
         finally:
+            self._clear_denoise_step_metadata()
+            self._reset_mixed_precision()
             self._cosmos3_branch_caches = None
             self.transformer.reset_cache()
         return latents
diff --git a/vllm_omni/diffusion/models/cosmos3/transformer_cosmos3.py b/vllm_omni/diffusion/models/cosmos3/transformer_cosmos3.py
index fe7a34c8b..fc5a6f7cc 100644
--- a/vllm_omni/diffusion/models/cosmos3/transformer_cosmos3.py
+++ b/vllm_omni/diffusion/models/cosmos3/transformer_cosmos3.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
 """Cosmos3 VFM Transformer for vllm-omni.
 
 Implements the Mixture-of-Transformers architecture with two pathways:
@@ -14,7 +14,7 @@ from __future__ import annotations
 import math
 from collections.abc import Iterator
 from contextlib import AbstractContextManager, contextmanager, nullcontext
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, NamedTuple
 
 import torch
 import torch.distributed as dist
@@ -40,6 +40,12 @@ from vllm_omni.diffusion.forward_context import get_forward_context, is_forward_
 from vllm_omni.diffusion.layers.norm import RMSNorm as _VllmRMSNorm
 from vllm_omni.platforms import current_omni_platform
 
+from .mixed_precision import (
+    Cosmos3MixedPrecisionConfig,
+    Cosmos3MixedPrecisionRuntime,
+    resolve_mixed_precision_config,
+)
+
 if TYPE_CHECKING:
     from vllm_omni.diffusion.offloader.sequential_backend import SequentialOffloadHook
 
@@ -136,6 +142,26 @@ def _od_config_get(od_config: Any, key: str, default: Any = None) -> Any:
     return default if value is None else value
 
 
+def _validate_mixed_precision_runtime(
+    config: Cosmos3MixedPrecisionConfig | None,
+    od_config: OmniDiffusionConfig,
+) -> None:
+    if config is None:
+        return
+    if get_tensor_model_parallel_world_size() != 1:
+        raise ValueError("Cosmos3 mixed precision currently supports tensor parallel size 1 only")
+    if int(getattr(od_config, "max_num_seqs", 1)) != 1:
+        raise ValueError("Cosmos3 mixed precision currently supports one active request per worker")
+    if bool(getattr(od_config, "enable_distributed_layerwise_offload", False)):
+        raise ValueError(
+            "Cosmos3 mixed precision does not support distributed layer-wise offload "
+            "because its direct loader bypasses ModelOpt post-load transformations"
+        )
+    parallel_config = getattr(od_config, "parallel_config", None)
+    if bool(getattr(parallel_config, "use_hsdp", False)):
+        raise ValueError("Cosmos3 mixed precision has not validated live backend weights under HSDP")
+
+
 def _as_bool(value: Any) -> bool:
     if isinstance(value, str):
         return value.strip().lower() in {"1", "true", "yes", "on"}
@@ -401,7 +427,7 @@ class TimestepEmbedder(nn.Module):
         max_period: int = 10000,
     ) -> None:
         super().__init__()
-        # Following diffusers naming pattern here for checkpoint compatibility.
+        # Preserve checkpoint-compatible parameter names.
         self.linear_1 = nn.Linear(frequency_embedding_size, hidden_size, bias=True)
         self.act = nn.SiLU()
         self.linear_2 = nn.Linear(hidden_size, hidden_size, bias=True)
@@ -1079,6 +1105,28 @@ class Cosmos3GenSPPrepare(nn.Module):
         return hidden_gen, freqs_cos, freqs_sin
 
 
+class _GenPrepared(NamedTuple):
+    """GEN-pathway state shared by normal and cached execution."""
+
+    hidden_gen: torch.Tensor
+    time_embed: torch.Tensor
+    t: int
+    h: int
+    w: int
+    s_video: int
+    s_control: int
+    s_action: int
+    s_sound: int
+    has_control: bool
+    has_action: bool
+    has_sound: bool
+    action_domain_ids: torch.Tensor | None
+    ulysses_size: int
+    use_multi_control_attention: bool
+    multi_control_token_sizes: tuple[int, ...] | None
+    multi_control_weights: tuple[float, ...] | None
+
+
 class Cosmos3VFMTransformer(nn.Module):
     """Cosmos3 VFM Transformer: UND language model + GEN denoising layers.
 
@@ -1241,6 +1289,19 @@ class Cosmos3VFMTransformer(nn.Module):
 
         dtype = od_config.dtype
         quant_config = getattr(od_config, "quantization_config", None) if od_config else None
+        mixed_precision_config, mixed_precision_source = resolve_mixed_precision_config(od_config)
+        if mixed_precision_config is None:
+            if mixed_precision_source == "additional_config_disabled":
+                logger.info("Cosmos3 checkpoint mixed-precision policy disabled by additional_config")
+        else:
+            logger.info(
+                "Cosmos3 mixed precision active (source=%s): first_steps=%d last_steps=%d reasoner=%s",
+                mixed_precision_source,
+                mixed_precision_config.first_steps,
+                mixed_precision_config.last_steps,
+                mixed_precision_config.reasoner,
+            )
+        _validate_mixed_precision_runtime(mixed_precision_config, od_config)
 
         self.language_model = self._language_model_cls(
             hidden_size=self.hidden_size,
@@ -1300,6 +1361,11 @@ class Cosmos3VFMTransformer(nn.Module):
             ]
         )
 
+        self.mixed_precision_runtime: Cosmos3MixedPrecisionRuntime | None = None
+        if mixed_precision_config is not None:
+            self.mixed_precision_runtime = Cosmos3MixedPrecisionRuntime(mixed_precision_config)
+            self.mixed_precision_runtime.install(self)
+
         self.norm_moe_gen = RMSNorm(self.hidden_size, eps=self.rms_norm_eps)
         self.gen_sp_prepare = Cosmos3GenSPPrepare()
         self.gen_sp_gather = nn.Identity()
@@ -1631,6 +1697,61 @@ class Cosmos3VFMTransformer(nn.Module):
         pad = (-(base + sound_frames)) % ulysses_size
         return sound_frames + pad
 
+    def _run_gen_layers(
+        self,
+        hidden_gen: torch.Tensor,
+        *,
+        s_video: int,
+        s_control: int,
+        s_action: int,
+        s_sound: int,
+        has_action: bool,
+        has_sound: bool,
+        has_control: bool,
+        ulysses_size: int,
+        use_multi_control_attention: bool,
+        multi_control_token_sizes: tuple[int, ...] | None,
+        multi_control_weights: tuple[float, ...] | None,
+    ) -> torch.Tensor:
+        """Run the complete GEN decoder between full-layout boundaries."""
+        if self.cached_kv is None or self.cached_freqs_gen is None:
+            raise RuntimeError("Cosmos3 GEN cache was not initialized before running GEN layers.")
+        freqs_cos, freqs_sin = self.cached_freqs_gen
+        if not use_multi_control_attention:
+            hidden_gen, freqs_cos, freqs_sin = self.gen_sp_prepare(hidden_gen, freqs_cos, freqs_sin)
+        freqs_gen = (freqs_cos, freqs_sin)
+
+        if len(self.gen_layers) == len(self.cached_kv):
+            for layer, (k_und, v_und) in zip(self.gen_layers, self.cached_kv, strict=True):
+                hidden_gen = layer(
+                    hidden_gen,
+                    k_und=k_und,
+                    v_und=v_und,
+                    freqs_cos=freqs_cos,
+                    freqs_sin=freqs_sin,
+                    control_token_sizes=multi_control_token_sizes,
+                    control_weights=multi_control_weights,
+                )
+                # Cache-dit's block wrapper may return a tuple; unwrap it.
+                if isinstance(hidden_gen, tuple):
+                    hidden_gen = hidden_gen[0]
+        else:
+            # Cache-dit patches gen_layers to a grouped wrapper.
+            for layer in self.gen_layers:
+                hidden_gen = layer(
+                    hidden_gen,
+                    cached_kv=self.cached_kv,
+                    freqs_gen=freqs_gen,
+                    control_token_sizes=multi_control_token_sizes,
+                    control_weights=multi_control_weights,
+                )
+                if isinstance(hidden_gen, tuple):
+                    hidden_gen = hidden_gen[0]
+
+        if not use_multi_control_attention:
+            hidden_gen = self.gen_sp_gather(hidden_gen)
+        return hidden_gen
+
     # -- Forward -------------------------------------------------------------
 
     def forward(
@@ -1653,7 +1774,51 @@ class Cosmos3VFMTransformer(nn.Module):
         transfer_share_vision_temporal_positions: bool = True,
         **kwargs,
     ) -> torch.Tensor | tuple[torch.Tensor, ...]:
+        """Run the shared Cosmos3 GEN preprocess, stack, and postprocess path."""
+        if kwargs:
+            raise TypeError(f"Unexpected Cosmos3 transformer kwargs: {sorted(kwargs)}")
+        prep = self._gen_preprocess(
+            hidden_states,
+            timestep,
+            text_ids,
+            text_mask,
+            video_shape,
+            fps=fps,
+            action_latents=action_latents,
+            action_domain_ids=action_domain_ids,
+            action_noisy_mask=action_noisy_mask,
+            action_start_frame_offset=action_start_frame_offset,
+            action_fps=action_fps,
+            sound_latents=sound_latents,
+            noisy_frame_mask=noisy_frame_mask,
+            control_latents=control_latents,
+            control_weights=control_weights,
+            transfer_share_vision_temporal_positions=transfer_share_vision_temporal_positions,
+        )
+        return self._gen_postprocess(self._run_gen_stack(prep), prep)
+
+    def _gen_preprocess(
+        self,
+        hidden_states: torch.Tensor,
+        timestep: torch.Tensor,
+        text_ids: torch.Tensor,
+        text_mask: torch.Tensor,
+        video_shape: tuple[int, int, int],
+        fps: float | None = None,
+        action_latents: torch.Tensor | None = None,
+        action_domain_ids: torch.Tensor | None = None,
+        action_noisy_mask: torch.Tensor | None = None,
+        action_start_frame_offset: int = 1,
+        action_fps: float | None = None,
+        sound_latents: torch.Tensor | None = None,
+        noisy_frame_mask: torch.Tensor | None = None,
+        control_latents: list[torch.Tensor] | tuple[torch.Tensor, ...] | torch.Tensor | None = None,
+        control_weights: list[float] | tuple[float, ...] | torch.Tensor | None = None,
+        transfer_share_vision_temporal_positions: bool = True,
+    ) -> _GenPrepared:
         """
+        Prepare the packed GEN sequence before its cacheable execution region.
+
         Args:
             hidden_states: [B, C, t, h, w] noisy latents
             timestep: [B] diffusion timestep
@@ -1676,13 +1841,9 @@ class Cosmos3VFMTransformer(nn.Module):
                 transfer controls. Values are normalized to sum to one.
 
         Returns:
-            [B, C, t, h, w] velocity prediction, or
-            tuple outputs in video, action, sound order when action/sound streams
-            are provided. Transfer-control streams condition the video prediction
-            and are not returned.
+            Packed GEN inputs and metadata consumed by the shared execution and
+            postprocessing helpers.
         """
-        if kwargs:
-            raise TypeError(f"Unexpected Cosmos3 transformer kwargs: {sorted(kwargs)}")
         t, h, w = video_shape
         hp, wp, _, _ = self._pad_to_patch_size(h, w)
         text_lengths = text_mask.sum(dim=1)
@@ -1882,79 +2043,90 @@ class Cosmos3VFMTransformer(nn.Module):
                 hidden_parts.append(hidden_sound)
             hidden_gen = torch.cat(hidden_parts, dim=1)
 
-            # Run GEN layers.  UND K/V (replicated) is passed to each layer;
-            # the Cosmos3CrossAttention forwards them as joint_key/value so the
-            # framework Attention handles the Ulysses head-slicing internally.
-            if self.cached_kv is None or self.cached_freqs_gen is None:
-                raise RuntimeError("Cosmos3 GEN cache was not initialized before running GEN layers.")
-            freqs_cos, freqs_sin = self.cached_freqs_gen
-            if not use_multi_control_attention:
-                hidden_gen, freqs_cos, freqs_sin = self.gen_sp_prepare(hidden_gen, freqs_cos, freqs_sin)
-            freqs_gen = (freqs_cos, freqs_sin)
+            return _GenPrepared(
+                hidden_gen=hidden_gen,
+                time_embed=time_embed,
+                t=t,
+                h=h,
+                w=w,
+                s_video=s_video,
+                s_control=s_control,
+                s_action=s_action,
+                s_sound=s_sound,
+                has_control=has_control,
+                has_action=has_action,
+                has_sound=has_sound,
+                action_domain_ids=action_domain_ids,
+                ulysses_size=ulysses_size,
+                use_multi_control_attention=use_multi_control_attention,
+                multi_control_token_sizes=multi_control_token_sizes,
+                multi_control_weights=multi_control_weights,
+            )
 
-            if len(self.gen_layers) == len(self.cached_kv):
-                for layer, (k_und, v_und) in zip(self.gen_layers, self.cached_kv, strict=True):
-                    hidden_gen = layer(
-                        hidden_gen,
-                        k_und=k_und,
-                        v_und=v_und,
-                        freqs_cos=freqs_cos,
-                        freqs_sin=freqs_sin,
-                        control_token_sizes=multi_control_token_sizes,
-                        control_weights=multi_control_weights,
-                    )
-                    # Cache-dit's block wrapper may return a tuple; unwrap it.
-                    if isinstance(hidden_gen, tuple):
-                        hidden_gen = hidden_gen[0]
-            else:
-                # Cache-dit patches gen_layers to a grouped wrapper.
-                for layer in self.gen_layers:
-                    hidden_gen = layer(
-                        hidden_gen,
-                        cached_kv=self.cached_kv,
-                        freqs_gen=freqs_gen,
-                        control_token_sizes=multi_control_token_sizes,
-                        control_weights=multi_control_weights,
-                    )
-                    if isinstance(hidden_gen, tuple):
-                        hidden_gen = hidden_gen[0]
+    def _run_gen_stack(self, prep: _GenPrepared) -> torch.Tensor:
+        """Execute the cacheable full-layout GEN stack, including final norm."""
+        hidden_gen = self._run_gen_layers(
+            prep.hidden_gen,
+            s_video=prep.s_video,
+            s_control=prep.s_control,
+            s_action=prep.s_action,
+            s_sound=prep.s_sound,
+            has_action=prep.has_action,
+            has_sound=prep.has_sound,
+            has_control=prep.has_control,
+            ulysses_size=prep.ulysses_size,
+            use_multi_control_attention=prep.use_multi_control_attention,
+            multi_control_token_sizes=prep.multi_control_token_sizes,
+            multi_control_weights=prep.multi_control_weights,
+        )
+        return self.norm_moe_gen(hidden_gen)
 
-            if not use_multi_control_attention:
-                hidden_gen = self.gen_sp_gather(hidden_gen)
+    def _gen_postprocess(
+        self,
+        hidden_gen: torch.Tensor,
+        prep: _GenPrepared,
+    ) -> torch.Tensor | tuple[torch.Tensor, ...]:
+        """Project an already-normalized packed GEN state to model outputs."""
+        if not prep.has_action and not prep.has_sound and not prep.has_control:
+            return self.unpatchify(self.proj_out(hidden_gen), prep.t, prep.h, prep.w)
 
-            # Final norm and project back to latent space
-            hidden_gen = self.norm_moe_gen(hidden_gen)
-            if not has_action and not has_sound and not has_control:
-                return self.unpatchify(self.proj_out(hidden_gen), t, h, w)
-
-            split_sizes = []
-            if has_control:
-                split_sizes.append(s_control)
-            split_sizes.append(s_video)
-            if has_action:
-                split_sizes.append(s_action)
-            if has_sound:
-                split_sizes.append(s_sound)
-            split_hidden = hidden_gen.split(split_sizes, dim=1)
-            split_idx = 0
-            if has_control:
-                split_idx += 1
-            hidden_video = split_hidden[split_idx]
+        split_sizes = []
+        if prep.has_control:
+            split_sizes.append(prep.s_control)
+        split_sizes.append(prep.s_video)
+        if prep.has_action:
+            split_sizes.append(prep.s_action)
+        if prep.has_sound:
+            split_sizes.append(prep.s_sound)
+        split_hidden = hidden_gen.split(split_sizes, dim=1)
+        split_idx = 0
+        if prep.has_control:
             split_idx += 1
-            video_pred = self.unpatchify(self.proj_out(hidden_video), t, h, w)
-            if has_control:
-                return video_pred
-            outputs: list[torch.Tensor] = [video_pred]
-            if has_action:
-                hidden_action = split_hidden[split_idx]
-                split_idx += 1
-                assert action_domain_ids is not None
-                outputs.append(self.unpack_action(self.action_proj_out(hidden_action, action_domain_ids)))
-            if has_sound:
-                hidden_sound = split_hidden[split_idx]
-                outputs.append(self.unpack_sound(self.audio_proj_out(hidden_sound)))
-            return tuple(outputs)
+        hidden_video = split_hidden[split_idx]
+        split_idx += 1
+        video_pred = self.unpatchify(self.proj_out(hidden_video), prep.t, prep.h, prep.w)
+        if prep.has_control:
+            return video_pred
+
+        outputs: list[torch.Tensor] = [video_pred]
+        if prep.has_action:
+            hidden_action = split_hidden[split_idx]
+            split_idx += 1
+            assert prep.action_domain_ids is not None
+            outputs.append(self.unpack_action(self.action_proj_out(hidden_action, prep.action_domain_ids)))
+        if prep.has_sound:
+            hidden_sound = split_hidden[split_idx]
+            outputs.append(self.unpack_sound(self.audio_proj_out(hidden_sound)))
+        return tuple(outputs)
 
     def post_load_weights(self) -> None:
         """Post-load processing: ensure correct dtypes."""
         self.time_embedder.to(torch.float32)
+
+    def set_mixed_precision_step(self, step_index: int, num_steps: int) -> None:
+        if self.mixed_precision_runtime is not None:
+            self.mixed_precision_runtime.set_step(step_index, num_steps)
+
+    def reset_mixed_precision(self) -> None:
+        if self.mixed_precision_runtime is not None:
+            self.mixed_precision_runtime.reset()
diff --git a/vllm_omni/diffusion/models/cosmos3/utils.py b/vllm_omni/diffusion/models/cosmos3/utils.py
index 76df64b3b..8d104e987 100644
--- a/vllm_omni/diffusion/models/cosmos3/utils.py
+++ b/vllm_omni/diffusion/models/cosmos3/utils.py
@@ -78,6 +78,12 @@ ROBOLAB_CONCAT_VIEW_DESCRIPTION = (
     "sides, with the robot visible."
 )
 
+_LEGACY_EMBODIMENT_ALIASES = {
+    "galbot": "embodiment_b",
+    "agibot_gear_gripper": "embodiment_c_gripper",
+    "agibot_gear_gripper_ext": "embodiment_c_gripper_ext",
+}
+
 
 @dataclass(frozen=True)
 class RoboLabPolicyInputs:
@@ -252,33 +258,83 @@ def extract_robolab_prompt_image(prompt_data: Any | None) -> np.ndarray | None:
     return ensure_rgb_uint8_image(image, "multi_modal_data.image")
 
 
+_ROBOLAB_FRAMEWORK_IMPORT_ERROR = (
+    "Cosmos3 RoboLab policy serving requires a compatible cosmos_framework source on PYTHONPATH."
+)
+_ROBOLAB_FRAMEWORK_IMPORTS: dict[str, tuple[str, str]] = {
+    "ActionTransformPipeline": (
+        "cosmos_framework.data.generator.action.utils.transforms",
+        "ActionTransformPipeline",
+    ),
+    "convert_rotation": (
+        "cosmos_framework.data.generator.action.utils.pose_utils",
+        "convert_rotation",
+    ),
+    "pose_abs_to_rel": (
+        "cosmos_framework.data.generator.action.utils.pose_utils",
+        "pose_abs_to_rel",
+    ),
+    "pose_rel_to_abs": (
+        "cosmos_framework.data.generator.action.utils.pose_utils",
+        "pose_rel_to_abs",
+    ),
+    "build_abs_pose_from_components": (
+        "cosmos_framework.data.generator.action.utils.pose_utils",
+        "build_abs_pose_from_components",
+    ),
+    "FlowUniPCMultistepScheduler": (
+        "cosmos_framework.model.generator.diffusion.samplers.fm_solvers_unipc",
+        "FlowUniPCMultistepScheduler",
+    ),
+    "get_domain_id": (
+        "cosmos_framework.data.generator.action.utils.domain_utils",
+        "get_domain_id",
+    ),
+}
+
+
 def lazy_import(module_name: str, symbol_name: str, error_message: str):
     try:
         module = import_module(module_name)
-    except ModuleNotFoundError as exc:
-        raise ModuleNotFoundError(error_message) from exc
-    return getattr(module, symbol_name)
+        return getattr(module, symbol_name)
+    except (ImportError, AttributeError) as exc:
+        raise ImportError(
+            f"{error_message} Could not import required symbol {symbol_name!r} from {module_name!r}."
+        ) from exc
 
 
-def lazy_action_transform_pipeline(max_action_dim: int):
-    ActionTransformPipeline = lazy_import(
-        "cosmos_framework.data.vfm.action.transforms",
-        "ActionTransformPipeline",
-        "Cosmos3 RoboLab policy serving requires cosmos_framework on PYTHONPATH so the "
-        "golden ActionTransformPipeline can be reused.",
+def _load_robolab_framework_symbol(symbol_name: str):
+    module_name, exported_name = _ROBOLAB_FRAMEWORK_IMPORTS[symbol_name]
+    return lazy_import(
+        module_name,
+        exported_name,
+        _ROBOLAB_FRAMEWORK_IMPORT_ERROR,
     )
-    return ActionTransformPipeline(max_action_dim=max_action_dim, cfg_dropout_rate=0.0)
+
+
+def preflight_cosmos3_action_framework_imports() -> None:
+    """Validate every Cosmos Framework symbol used by action policy serving."""
+    for symbol_name in _ROBOLAB_FRAMEWORK_IMPORTS:
+        _load_robolab_framework_symbol(symbol_name)
+
+
+def lazy_action_transform_pipeline(max_action_dim: int, *, format_prompt_as_json: bool = False):
+    ActionTransformPipeline = _load_robolab_framework_symbol("ActionTransformPipeline")
+    return ActionTransformPipeline(
+        max_action_dim=max_action_dim,
+        cfg_dropout_rate=0.0,
+        format_prompt_as_json=format_prompt_as_json,
+    )
+
+
+def get_robolab_domain_id(domain_name: str) -> int:
+    get_domain_id = _load_robolab_framework_symbol("get_domain_id")
+    canonical_name = _LEGACY_EMBODIMENT_ALIASES.get(domain_name.lower().strip(), domain_name)
+    return int(get_domain_id(canonical_name))
 
 
 def build_robolab_unipc_scheduler(num_steps: int, shift: float, device: torch.device):
-    FlowUniPCMultistepScheduler = lazy_import(
-        "cosmos_framework.model.vfm.diffusion.samplers.fm_solvers_unipc",
-        "FlowUniPCMultistepScheduler",
-        (
-            "Cosmos3 RoboLab policy serving requires cosmos_framework on PYTHONPATH so the "
-            "golden FlowUniPCMultistepScheduler can be reused."
-        ),
-    )
+    FlowUniPCMultistepScheduler = _load_robolab_framework_symbol("FlowUniPCMultistepScheduler")
 
     scheduler = FlowUniPCMultistepScheduler(
         num_train_timesteps=1000,
@@ -290,38 +346,22 @@ def build_robolab_unipc_scheduler(num_steps: int, shift: float, device: torch.de
 
 
 def convert_midtrain_rotation(value: Any, src: str, dst: str) -> np.ndarray:
-    convert_rotation = lazy_import(
-        "cosmos_framework.data.vfm.action.pose_utils",
-        "convert_rotation",
-        "Cosmos3 RoboLab midtrain action serving requires cosmos_framework pose_utils on PYTHONPATH.",
-    )
+    convert_rotation = _load_robolab_framework_symbol("convert_rotation")
     return convert_rotation(value, src, dst)
 
 
 def pose_abs_to_rel(*args, **kwargs) -> np.ndarray:
-    pose_abs_to_rel_func = lazy_import(
-        "cosmos_framework.data.vfm.action.pose_utils",
-        "pose_abs_to_rel",
-        "Cosmos3 RoboLab midtrain action serving requires cosmos_framework pose_utils on PYTHONPATH.",
-    )
+    pose_abs_to_rel_func = _load_robolab_framework_symbol("pose_abs_to_rel")
     return pose_abs_to_rel_func(*args, **kwargs)
 
 
 def pose_rel_to_abs(*args, **kwargs) -> np.ndarray:
-    pose_rel_to_abs_func = lazy_import(
-        "cosmos_framework.data.vfm.action.pose_utils",
-        "pose_rel_to_abs",
-        "Cosmos3 RoboLab midtrain action serving requires cosmos_framework pose_utils on PYTHONPATH.",
-    )
+    pose_rel_to_abs_func = _load_robolab_framework_symbol("pose_rel_to_abs")
     return pose_rel_to_abs_func(*args, **kwargs)
 
 
 def build_abs_pose_from_components(*args, **kwargs) -> np.ndarray:
-    build_abs_pose_from_components_func = lazy_import(
-        "cosmos_framework.data.vfm.action.pose_utils",
-        "build_abs_pose_from_components",
-        "Cosmos3 RoboLab midtrain action serving requires cosmos_framework pose_utils on PYTHONPATH.",
-    )
+    build_abs_pose_from_components_func = _load_robolab_framework_symbol("build_abs_pose_from_components")
     return build_abs_pose_from_components_func(*args, **kwargs)
 
 
diff --git a/vllm_omni/diffusion/models/cosyvoice3_audio/cosyvoice3_dit.py b/vllm_omni/diffusion/models/cosyvoice3_audio/cosyvoice3_dit.py
index 5ae75b256..d0538d79f 100644
--- a/vllm_omni/diffusion/models/cosyvoice3_audio/cosyvoice3_dit.py
+++ b/vllm_omni/diffusion/models/cosyvoice3_audio/cosyvoice3_dit.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
 # Adapted from https://github.com/FunAudioLLM/CosyVoice/tree/main/cosyvoice/flow/DiT
 # Refactored to use vllm_omni diffusion infrastructure for optimized attention backends
 
@@ -15,8 +15,10 @@ from torch import nn
 from vllm.logger import init_logger
 from x_transformers.x_transformers import RotaryEmbedding, apply_rotary_pos_emb
 
+from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata
 from vllm_omni.diffusion.attention.layer import Attention as DiffusionAttention
 from vllm_omni.model_executor.layers.timestep_embedding import DiTTimestepEmbedding
+from vllm_omni.model_executor.models.cosyvoice3.runtime import cosyvoice3_batch_flow_profile
 
 logger = init_logger(__name__)
 
@@ -52,6 +54,22 @@ def get_pos_embed_indices(start, length, max_pos, scale=1.0):
     return pos
 
 
+def _normalize_attention_mask(mask: torch.Tensor | None, batch_size: int, seq_len: int) -> torch.Tensor | None:
+    if mask is None:
+        return None
+    if mask.dim() == 2:
+        attn_mask = mask
+    elif mask.dim() == 3 and mask.shape[1] == 1:
+        attn_mask = mask[:, 0]
+    elif mask.dim() == 4:
+        attn_mask = mask[:, 0, -1]
+    else:
+        return None
+    if attn_mask.shape != (batch_size, seq_len):
+        return None
+    return attn_mask.bool()
+
+
 class FeedForward(nn.Module):
     """Feed-forward network with GELU activation."""
 
@@ -114,42 +132,39 @@ class DiTAttention(nn.Module):
     ) -> torch.Tensor:
         batch_size, seq_len = x.shape[0], x.shape[1]
 
-        # Project to Q, K, V
-        query = self.to_q(x)
-        key = self.to_k(x)
-        value = self.to_v(x)
+        with cosyvoice3_batch_flow_profile("cosyvoice3_dit_attention_qkv_projection"):
+            query = self.to_q(x)
+            key = self.to_k(x)
+            value = self.to_v(x)
 
-        # Apply rotary position embedding
-        if rope is not None:
-            freqs, xpos_scale = rope
-            q_xpos_scale, k_xpos_scale = (xpos_scale, xpos_scale**-1.0) if xpos_scale is not None else (1.0, 1.0)
-            query = apply_rotary_pos_emb(query, freqs, q_xpos_scale)
-            key = apply_rotary_pos_emb(key, freqs, k_xpos_scale)
+        with cosyvoice3_batch_flow_profile("cosyvoice3_dit_attention_rope"):
+            if rope is not None:
+                freqs, xpos_scale = rope
+                q_xpos_scale, k_xpos_scale = (xpos_scale, xpos_scale**-1.0) if xpos_scale is not None else (1.0, 1.0)
+                query = apply_rotary_pos_emb(query, freqs, q_xpos_scale)
+                key = apply_rotary_pos_emb(key, freqs, k_xpos_scale)
 
-        # Reshape for attention: (batch, seq, heads, head_dim)
-        query = query.view(batch_size, seq_len, self.heads, self.dim_head)
-        key = key.view(batch_size, seq_len, self.heads, self.dim_head)
-        value = value.view(batch_size, seq_len, self.heads, self.dim_head)
+        with cosyvoice3_batch_flow_profile("cosyvoice3_dit_attention_backend"):
+            # Reshape for attention: (batch, seq, heads, head_dim)
+            query = query.view(batch_size, seq_len, self.heads, self.dim_head)
+            key = key.view(batch_size, seq_len, self.heads, self.dim_head)
+            value = value.view(batch_size, seq_len, self.heads, self.dim_head)
 
-        # Use diffusion attention backend
-        # The diffusion Attention layer expects (batch, seq, heads, head_dim)
-        out = self.attn(query, key, value, attn_metadata=None)
+            # The diffusion Attention layer expects (batch, seq, heads, head_dim)
+            attn_mask = _normalize_attention_mask(mask, batch_size, seq_len)
+            attn_metadata = AttentionMetadata(attn_mask=attn_mask) if attn_mask is not None else None
+            out = self.attn(query, key, value, attn_metadata=attn_metadata)
 
-        # Some attention backends return a non-contiguous layout.
-        out = out.reshape(batch_size, seq_len, self.inner_dim)
-        out = out.to(query.dtype)
-
-        # Output projection
-        out = self.to_out(out)
+        with cosyvoice3_batch_flow_profile("cosyvoice3_dit_attention_output_projection"):
+            # Some attention backends return a non-contiguous layout.
+            out = out.reshape(batch_size, seq_len, self.inner_dim)
+            out = out.to(x.dtype)
+            out = self.to_out(out)
 
         # Apply mask if provided
-        if mask is not None:
-            if mask.dim() == 2:
-                mask = mask.unsqueeze(-1)
-            elif mask.dim() == 4:
-                # (batch, heads, seq, seq) -> use last dim
-                mask = mask[:, 0, -1].unsqueeze(-1)
-            out = out.masked_fill(~mask.bool(), 0.0)
+        attn_mask = _normalize_attention_mask(mask, batch_size, seq_len)
+        if attn_mask is not None:
+            out = out.masked_fill(~attn_mask.unsqueeze(-1), 0.0)
 
         return out
 
@@ -172,18 +187,19 @@ class DiTBlock(nn.Module):
         self.ff = FeedForward(dim=dim, mult=ff_mult, dropout=dropout, approximate="tanh")
 
     def forward(self, x, t, mask=None, rope=None):
-        # pre-norm & modulation for attention input
-        norm, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.attn_norm(x, emb=t)
+        with cosyvoice3_batch_flow_profile("cosyvoice3_dit_adalayernorm_attention"):
+            norm, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.attn_norm(x, emb=t)
 
-        # attention
-        attn_output = self.attn(x=norm, mask=mask, rope=rope)
+        with cosyvoice3_batch_flow_profile("cosyvoice3_dit_attention"):
+            attn_output = self.attn(x=norm, mask=mask, rope=rope)
 
-        # process attention output for input x
-        x = x + gate_msa.unsqueeze(1) * attn_output
+        with cosyvoice3_batch_flow_profile("cosyvoice3_dit_attention_residual"):
+            x = x + gate_msa.unsqueeze(1) * attn_output
 
-        ff_norm = self.ff_norm(x) * (1 + scale_mlp[:, None]) + shift_mlp[:, None]
-        ff_output = self.ff(ff_norm)
-        x = x + gate_mlp.unsqueeze(1) * ff_output
+        with cosyvoice3_batch_flow_profile("cosyvoice3_dit_layernorm_ffn"):
+            ff_norm = self.ff_norm(x) * (1 + scale_mlp[:, None]) + shift_mlp[:, None]
+            ff_output = self.ff(ff_norm)
+            x = x + gate_mlp.unsqueeze(1) * ff_output
 
         return x
 
@@ -205,19 +221,20 @@ class CausalConvPositionEmbedding(nn.Module):
         )
 
     def forward(self, x: torch.Tensor, mask: torch.Tensor | None = None):
-        if mask is not None:
-            mask = mask[..., None]
-            x = x.masked_fill(~mask, 0.0)
+        with cosyvoice3_batch_flow_profile("cosyvoice3_dit_causal_conv_position_embedding"):
+            if mask is not None:
+                mask = mask[..., None]
+                x = x.masked_fill(~mask, 0.0)
 
-        x = x.permute(0, 2, 1)
-        x = F.pad(x, (self.kernel_size - 1, 0, 0, 0))
-        x = self.conv1(x)
-        x = F.pad(x, (self.kernel_size - 1, 0, 0, 0))
-        x = self.conv2(x)
-        out = x.permute(0, 2, 1)
+            x = x.permute(0, 2, 1)
+            x = F.pad(x, (self.kernel_size - 1, 0, 0, 0))
+            x = self.conv1(x)
+            x = F.pad(x, (self.kernel_size - 1, 0, 0, 0))
+            x = self.conv2(x)
+            out = x.permute(0, 2, 1)
 
-        if mask is not None:
-            out = out.masked_fill(~mask, 0.0)
+            if mask is not None:
+                out = out.masked_fill(~mask, 0.0)
 
         return out
 
@@ -327,13 +344,15 @@ class InputEmbedding(nn.Module):
         self.conv_pos_embed = CausalConvPositionEmbedding(dim=out_dim)
 
     def forward(self, x, cond, text_embed, spks):
-        to_cat = [x, cond, text_embed]
-        if self.spk_dim > 0:
-            spks = repeat(spks, "b c -> b t c", t=x.shape[1])
-            to_cat.append(spks)
+        with cosyvoice3_batch_flow_profile("cosyvoice3_dit_input_projection"):
+            to_cat = [x, cond, text_embed]
+            if self.spk_dim > 0:
+                spks = repeat(spks, "b c -> b t c", t=x.shape[1])
+                to_cat.append(spks)
 
-        x = self.proj(torch.cat(to_cat, dim=-1))
-        x = self.conv_pos_embed(x) + x
+            x = self.proj(torch.cat(to_cat, dim=-1))
+        with cosyvoice3_batch_flow_profile("cosyvoice3_dit_input_causal_conv"):
+            x = self.conv_pos_embed(x) + x
         return x
 
 
@@ -385,31 +404,37 @@ class DiT(nn.Module):
         self.num_decoding_left_chunks = num_decoding_left_chunks
 
     def forward(self, x, mask, mu, t, spks=None, cond=None):
-        x = x.transpose(1, 2)
-        mu = mu.transpose(1, 2)
-        cond = cond.transpose(1, 2)
-        spks = spks.unsqueeze(dim=1)
-        batch, seq_len = x.shape[0], x.shape[1]
-        if t.ndim == 0:
-            t = t.repeat(batch)
+        with cosyvoice3_batch_flow_profile("cosyvoice3_dit_prepare_inputs"):
+            x = x.transpose(1, 2)
+            mu = mu.transpose(1, 2)
+            cond = cond.transpose(1, 2)
+            spks = spks.unsqueeze(dim=1)
+            batch, seq_len = x.shape[0], x.shape[1]
+            if t.ndim == 0:
+                t = t.repeat(batch)
 
-        # t: conditioning time, c: context (text + masked cond audio), x: noised input audio
-        t = self.time_embed(t)
+        with cosyvoice3_batch_flow_profile("cosyvoice3_dit_time_embedding"):
+            t = self.time_embed(t)
         x = self.input_embed(x, cond, mu, spks.squeeze(1))
 
-        rope = self.rotary_embed.forward_from_seq_len(seq_len)
+        with cosyvoice3_batch_flow_profile("cosyvoice3_dit_rope_and_mask"):
+            rope = self.rotary_embed.forward_from_seq_len(seq_len)
+            attn_mask = mask[:, 0].bool() if mask.dim() == 3 and mask.shape[1] == 1 else mask.bool()
 
         if self.long_skip_connection is not None:
             residual = x
 
-        attn_mask = mask.bool().repeat(1, x.size(1), 1).unsqueeze(dim=1)
-
-        for block in self.transformer_blocks:
-            x = block(x, t, mask=attn_mask.bool(), rope=rope)
+        with cosyvoice3_batch_flow_profile("cosyvoice3_dit_transformer_blocks"):
+            for block_index, block in enumerate(self.transformer_blocks):
+                with cosyvoice3_batch_flow_profile(f"cosyvoice3_dit_transformer_block_{block_index}"):
+                    x = block(x, t, mask=attn_mask.bool(), rope=rope)
 
         if self.long_skip_connection is not None:
-            x = self.long_skip_connection(torch.cat((x, residual), dim=-1))
+            with cosyvoice3_batch_flow_profile("cosyvoice3_dit_long_skip_projection"):
+                x = self.long_skip_connection(torch.cat((x, residual), dim=-1))
 
-        x = self.norm_out(x, t)
-        output = self.proj_out(x).transpose(1, 2)
+        with cosyvoice3_batch_flow_profile("cosyvoice3_dit_final_adalayernorm"):
+            x = self.norm_out(x, t)
+        with cosyvoice3_batch_flow_profile("cosyvoice3_dit_final_projection"):
+            output = self.proj_out(x).transpose(1, 2)
         return output
diff --git a/vllm_omni/diffusion/models/dreamzero/pipeline_dreamzero.py b/vllm_omni/diffusion/models/dreamzero/pipeline_dreamzero.py
index 09bd536cd..3ebda6b6e 100644
--- a/vllm_omni/diffusion/models/dreamzero/pipeline_dreamzero.py
+++ b/vllm_omni/diffusion/models/dreamzero/pipeline_dreamzero.py
@@ -17,6 +17,7 @@ import re as re_module
 from collections import OrderedDict
 from collections.abc import Iterable
 from contextlib import contextmanager
+from typing import ClassVar
 
 import numpy as np
 import torch
@@ -121,6 +122,10 @@ class DreamZeroPipeline(nn.Module, CFGParallelMixin):
     methods below. The runner binds one session state only for ``forward()``.
     """
 
+    # Generic warmup cannot synthesize robot observations. AR-Diffusion uses
+    # ar_diffusion_warmup_requests() for model-specific warmup instead.
+    dummy_run_num_frames: ClassVar[int] = 0
+
     _POSITIVE_BRANCH = "positive"
     _NEGATIVE_BRANCH = "negative"
     _ar_diffusion_kv_state = None
@@ -715,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
@@ -796,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 244aeeb95..eb26e5389 100644
--- a/vllm_omni/diffusion/models/ernie_image/ernie_image_transformer.py
+++ b/vllm_omni/diffusion/models/ernie_image/ernie_image_transformer.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
 # Adapted from: https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/transformer_ernie_image.py
 
 from collections.abc import Iterable
@@ -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:
@@ -599,17 +621,12 @@ class ErnieImageTransformer2DModel(nn.Module):
         hidden_states, freqs_cos, freqs_sin, attention_mask = self.unified_prepare(hidden_states, text_bth, text_lens)
         attention_mask = self._slice_attention_mask_for_ring(attention_mask)
         rotary_pos_emb = (freqs_cos, freqs_sin)
-        S = hidden_states.shape[0]
-
         sample = self.time_proj(timestep)
         sample = sample.to(dtype=dtype)
         c = self.time_embedding(sample)
-        shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = [
-            t.unsqueeze(0).expand(S, -1, -1).contiguous() for t in self.adaLN_modulation(c).chunk(6, dim=-1)
-        ]
+        temb = self.adaLN_modulation(c).chunk(6, dim=-1)
 
         for layer in self.layers:
-            temb = [shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp]
             if torch.is_grad_enabled() and self.gradient_checkpointing:
                 hidden_states = self._gradient_checkpointing_func(
                     layer,
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/glm_image/glm_image_transformer.py b/vllm_omni/diffusion/models/glm_image/glm_image_transformer.py
index 75ba60203..1b0868400 100644
--- a/vllm_omni/diffusion/models/glm_image/glm_image_transformer.py
+++ b/vllm_omni/diffusion/models/glm_image/glm_image_transformer.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 math
 from collections.abc import Iterable
@@ -124,8 +124,8 @@ class GlmImageImageProjector(nn.Module):
 
     def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
         batch_size, channel, height, width = hidden_states.shape
-        post_patch_height = torch.tensor(height // self.patch_size, device=hidden_states.device, dtype=torch.int64)
-        post_patch_width = torch.tensor(width // self.patch_size, device=hidden_states.device, dtype=torch.int64)
+        post_patch_height = height // self.patch_size
+        post_patch_width = width // self.patch_size
 
         # Reshape: [B, C, H, W] -> [B, H', W', C*p*p] -> [B, H'*W', C*p*p]
         hidden_states = hidden_states.reshape(
@@ -189,18 +189,16 @@ class GlmImagePrepare(nn.Module):
         self,
         image_projector: nn.Module,
         rope: GlmImageRotaryPosEmbed,
-        patch_size: int,
     ):
         super().__init__()
         self.image_projector = image_projector
         self.rope = rope
-        self.patch_size = patch_size
 
     def forward(
         self,
         hidden_states: torch.Tensor,
         prior_hidden_states: torch.Tensor | None = None,
-    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
         """Process hidden_states and compute RoPE embeddings.
 
         Args:
@@ -211,14 +209,7 @@ class GlmImagePrepare(nn.Module):
             hidden_states: Patched hidden states [B, seq_len, D]
             rope_cos: RoPE cos embeddings [seq_len, dim]
             rope_sin: RoPE sin embeddings [seq_len, dim]
-            post_patch_height: Scalar tensor for height after patching
-            post_patch_width: Scalar tensor for width after patching
         """
-        batch_size, num_channels, height, width = hidden_states.shape
-
-        post_patch_height = torch.tensor(height // self.patch_size, device=hidden_states.device, dtype=torch.int64)
-        post_patch_width = torch.tensor(width // self.patch_size, device=hidden_states.device, dtype=torch.int64)
-
         # Compute RoPE (uses original 4D hidden_states shape)
         image_rotary_emb = self.rope(hidden_states)
         rope_cos = image_rotary_emb[0].to(hidden_states.device)
@@ -231,7 +222,7 @@ class GlmImagePrepare(nn.Module):
         if prior_hidden_states is not None:
             hidden_states = hidden_states + prior_hidden_states
 
-        return hidden_states, rope_cos, rope_sin, post_patch_height, post_patch_width
+        return hidden_states, rope_cos, rope_sin
 
 
 class GlmImageAdaLayerNormZero(nn.Module):
@@ -961,7 +952,6 @@ class GlmImageTransformer2DModel(CachedTransformer):
             1: SequenceParallelInput(split_dim=0, expected_dims=2, split_output=True, auto_pad=True),
             # RoPE sin: [seq_len, dim] - shard along sequence dimension
             2: SequenceParallelInput(split_dim=0, expected_dims=2, split_output=True, auto_pad=True),
-            # post_patch_height and post_patch_width are scalars, not sharded
         },
         # Gather output at proj_out
         "proj_out": SequenceParallelOutput(gather_dim=1, expected_dims=3),
@@ -1044,7 +1034,7 @@ class GlmImageTransformer2DModel(CachedTransformer):
         )
 
         # Prepare module for SP (encapsulates patch embedding and RoPE for _sp_plan)
-        self.prepare = GlmImagePrepare(self.image_projector, self.rope, patch_size)
+        self.prepare = GlmImagePrepare(self.image_projector, self.rope)
 
         self.time_condition_embed = GlmImageCombinedTimestepSizeEmbeddings(
             embedding_dim=time_embed_dim,
@@ -1137,12 +1127,10 @@ class GlmImageTransformer2DModel(CachedTransformer):
 
         # 1. Prepare hidden_states and RoPE via GlmImagePrepare module
         # _sp_plan will shard hidden_states and RoPE together via split_output=True
-        hidden_states, rope_cos, rope_sin, post_patch_height_t, post_patch_width_t = self.prepare(
-            hidden_states, prior_hidden_states
-        )
+        hidden_states, rope_cos, rope_sin = self.prepare(hidden_states, prior_hidden_states)
         image_rotary_emb = (rope_cos, rope_sin)
-        post_patch_height = int(post_patch_height_t.item())
-        post_patch_width = int(post_patch_width_t.item())
+        post_patch_height = height // self.patch_size
+        post_patch_width = width // self.patch_size
 
         # Timestep conditioning
         temb = self.time_condition_embed(timestep, target_size, crop_coords, hidden_states.dtype)
@@ -1163,8 +1151,6 @@ class GlmImageTransformer2DModel(CachedTransformer):
                         device=hidden_states.device,
                     )
                     hidden_states_mask[:, ctx.sp_original_seq_len :] = False
-                    if hidden_states_mask.all():
-                        hidden_states_mask = None
 
         # 2. Transformer blocks
         for layer_idx, block in enumerate(self.transformer_blocks):
diff --git a/vllm_omni/diffusion/models/helios/helios_transformer.py b/vllm_omni/diffusion/models/helios/helios_transformer.py
index 4e3cf5078..6c6ec223d 100644
--- a/vllm_omni/diffusion/models/helios/helios_transformer.py
+++ b/vllm_omni/diffusion/models/helios/helios_transformer.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
 # Adapted from Helios (https://github.com/BestWishYsh/Helios)
 
 import math
@@ -27,10 +27,7 @@ from vllm.model_executor.model_loader.weight_utils import default_weight_loader
 
 from vllm_omni.diffusion.attention.layer import Attention
 from vllm_omni.diffusion.cache.cachedit import CacheDiTAdapterConfig
-from vllm_omni.diffusion.distributed.sp_plan import (
-    SequenceParallelInput,
-    SequenceParallelOutput,
-)
+from vllm_omni.diffusion.distributed.sp_plan import SequenceParallelOutput
 
 if TYPE_CHECKING:
     from vllm.model_executor.layers.quantization.base_config import (
@@ -448,6 +445,12 @@ class HeliosCrossAttention(nn.Module):
             num_kv_heads=self.num_heads,
             softmax_scale=1.0 / (head_dim**0.5),
             causal=False,
+            # Text K/V is replicated on every SP rank, so Ulysses must not be
+            # used here: its all-to-all would treat the per-rank replicas as
+            # sequence shards and ws-fold duplicate the keys. Sharded Q over
+            # full replicated K/V is correct locally and needs no
+            # communication (same as Wan2.2 cross-attn).
+            skip_sequence_parallel=True,
         )
 
     def project_kv(self, encoder_hidden_states: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
@@ -624,16 +627,50 @@ class HeliosTransformer3DModel(nn.Module):
     _hsdp_shard_conditions = [_is_transformer_block]
 
     _sp_plan = {
-        "rope": {
-            0: SequenceParallelInput(split_dim=1, expected_dims=4, split_output=True, auto_pad=True),
-            1: SequenceParallelInput(split_dim=1, expected_dims=4, split_output=True, auto_pad=True),
-        },
-        "blocks.0": {
-            "hidden_states": SequenceParallelInput(split_dim=1, expected_dims=3, auto_pad=True),
-        },
+        # "rope" and "blocks.0" are intentionally omitted.
+        # The rope hook splits along dim=1 of the 5D output [B, D, T, H, W],
+        # which is the frequency dimension, NOT the sequence dimension.
+        # The blocks.0 hook splits the concatenated hidden_states as a whole,
+        # which can put all history tokens in one rank (original_context_length=0).
+        # Instead, hidden_states and rotary_emb are split per-component in
+        # forward() after flatten+transpose, ensuring each rank gets half
+        # of each component (history and current).
         "proj_out": SequenceParallelOutput(gather_dim=1, expected_dims=3),
     }
 
+    def _sp_split_seq(self, x: torch.Tensor) -> torch.Tensor:
+        """Split tensor along sequence dim (dim=1) for Ulysses SP.
+
+        If seq_len is not divisible by world_size, replicate the last
+        token(s) to pad to a divisible length.  This avoids crashing
+        on non-divisible history components (which use different patch
+        sizes and thus produce different token counts).
+
+        Residual caveat: the replicated padding tokens attend unmasked
+        in attn1 on the last rank (at most ws-1 replicas per component).
+        The impact is bounded, but this is the first place to look if
+        odd resolutions ever show quality drift.
+        """
+        from vllm_omni.diffusion.distributed.parallel_state import (
+            get_sequence_parallel_rank,
+            get_sequence_parallel_world_size,
+        )
+
+        ws = get_sequence_parallel_world_size()
+        if ws > 1 and x.dim() >= 2 and x.shape[1] > 0:
+            seq_len = x.shape[1]
+            remainder = seq_len % ws
+            if remainder != 0:
+                pad = ws - remainder
+                # Replicate the last token to fill the padding
+                last = x[:, -1:, ...].expand(-1, pad, *([-1] * (x.dim() - 2)))
+                x = torch.cat([x, last], dim=1)
+                seq_len = x.shape[1]
+            r = get_sequence_parallel_rank()
+            n = seq_len // ws
+            x = x[:, r * n : (r + 1) * n, ...].contiguous()
+        return x
+
     def __init__(
         self,
         patch_size: tuple[int, ...] = (1, 2, 2),
@@ -860,6 +897,9 @@ class HeliosTransformer3DModel(nn.Module):
             device=hidden_states.device,
         )
         rotary_emb = rotary_emb.flatten(2).transpose(1, 2)
+        # USP: per-component split (each rank gets half of current frames)
+        hidden_states = self._sp_split_seq(hidden_states)
+        rotary_emb = self._sp_split_seq(rotary_emb)
         original_context_length = hidden_states.shape[1]
 
         # 2. Process short history latents
@@ -876,6 +916,9 @@ class HeliosTransformer3DModel(nn.Module):
                 device=latents_history_short.device,
             )
             rotary_emb_history_short = rotary_emb_history_short.flatten(2).transpose(1, 2)
+            # USP: per-component split
+            latents_history_short = self._sp_split_seq(latents_history_short)
+            rotary_emb_history_short = self._sp_split_seq(rotary_emb_history_short)
 
             hidden_states = torch.cat([latents_history_short, hidden_states], dim=1)
             rotary_emb = torch.cat([rotary_emb_history_short, rotary_emb], dim=1)
@@ -896,6 +939,9 @@ class HeliosTransformer3DModel(nn.Module):
             rotary_emb_history_mid = pad_for_3d_conv(rotary_emb_history_mid, (2, 2, 2))
             rotary_emb_history_mid = center_down_sample_3d(rotary_emb_history_mid, (2, 2, 2))
             rotary_emb_history_mid = rotary_emb_history_mid.flatten(2).transpose(1, 2)
+            # USP: per-component split
+            latents_history_mid = self._sp_split_seq(latents_history_mid)
+            rotary_emb_history_mid = self._sp_split_seq(rotary_emb_history_mid)
 
             hidden_states = torch.cat([latents_history_mid, hidden_states], dim=1)
             rotary_emb = torch.cat([rotary_emb_history_mid, rotary_emb], dim=1)
@@ -916,6 +962,9 @@ class HeliosTransformer3DModel(nn.Module):
             rotary_emb_history_long = pad_for_3d_conv(rotary_emb_history_long, (4, 4, 4))
             rotary_emb_history_long = center_down_sample_3d(rotary_emb_history_long, (4, 4, 4))
             rotary_emb_history_long = rotary_emb_history_long.flatten(2).transpose(1, 2)
+            # USP: per-component split
+            latents_history_long = self._sp_split_seq(latents_history_long)
+            rotary_emb_history_long = self._sp_split_seq(rotary_emb_history_long)
 
             hidden_states = torch.cat([latents_history_long, hidden_states], dim=1)
             rotary_emb = torch.cat([rotary_emb_history_long, rotary_emb], dim=1)
@@ -958,6 +1007,18 @@ class HeliosTransformer3DModel(nn.Module):
             timestep_proj = timestep_proj.permute(0, 2, 1, 3)
 
         # 6. Transformer blocks
+        # Manually increment _sp_shard_depth so that attention layers
+        # know SP is active and perform Ulysses All-to-All communication.
+        # Normally this is done by split_output=True hooks (e.g. rope),
+        # but those are removed because they split the wrong dimension.
+        from vllm_omni.diffusion.forward_context import (
+            get_forward_context,
+            is_forward_context_available,
+        )
+
+        if is_forward_context_available():
+            get_forward_context()._sp_shard_depth += 1
+
         hidden_states = hidden_states.contiguous()
         encoder_hidden_states = encoder_hidden_states.contiguous()
         rotary_emb = rotary_emb.contiguous()
@@ -979,6 +1040,11 @@ class HeliosTransformer3DModel(nn.Module):
         hidden_states = self.proj_out(hidden_states)
 
         # 8. Unpatchify
+        # proj_out gather may include padded tokens from non-divisible
+        # sequences. Slice to the expected size before reshape.
+        expected_seq = post_patch_num_frames * post_patch_height * post_patch_width
+        if hidden_states.shape[1] > expected_seq:
+            hidden_states = hidden_states[:, :expected_seq, :]
         hidden_states = hidden_states.reshape(
             batch_size, post_patch_num_frames, post_patch_height, post_patch_width, p_t, p_h, p_w, -1
         )
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/prompt_utils.py b/vllm_omni/diffusion/models/hunyuan_image3/prompt_utils.py
index b64fe2e97..b4ecd7dca 100644
--- a/vllm_omni/diffusion/models/hunyuan_image3/prompt_utils.py
+++ b/vllm_omni/diffusion/models/hunyuan_image3/prompt_utils.py
@@ -60,6 +60,48 @@ HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS: dict[str, int] = {
     "<img_ratio_36>": 130106,
 }
 
+
+def validate_special_token_ids(tokenizer: Any) -> None:
+    """Fail fast if a real tokenizer's ids drift from the hardcoded table.
+
+    ``HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS`` exists so stop-token / trigger-tag
+    resolution doesn't need a tokenizer round-trip, but that only holds as
+    long as the ids match ``tokenizer.json`` for whatever model repo/revision
+    is actually loaded. Call this once a real tokenizer is available (the
+    example scripts do, right after loading it) to catch drift immediately
+    instead of silently producing a request that runs to completion with the
+    wrong stop tokens. Not wired into ``build_prompt_tokens`` itself: callers
+    that intentionally pass a stand-in tokenizer with different ids (e.g.
+    this module's own unit tests) must not be forced through this check.
+
+    Both ``tencent/HunyuanImage-3.0`` (base) and ``-Instruct`` report the
+    same ``model_class_name`` (``HunyuanImage3ForCausalMM``), so this hook
+    fires for either checkpoint -- but the base tokenizer's vocab doesn't
+    include the Instruct-only ``<img_ratio_33>``-``<img_ratio_36>`` tokens
+    (added for it2i's second aspect-ratio range). A token the tokenizer
+    doesn't recognize at all (``convert_tokens_to_ids`` returning
+    ``unk_token_id``, or ``None`` for tokenizers without an unk concept) is
+    "not part of this checkpoint's vocab," not "drifted"; only an id that
+    resolves to something *else* indicates the hardcoded table is stale.
+    """
+    unk_id = getattr(tokenizer, "unk_token_id", None)
+    mismatches: dict[str, tuple[int, int]] = {}
+    for tok, expected_id in HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS.items():
+        actual_id = tokenizer.convert_tokens_to_ids(tok)
+        if actual_id is None or (unk_id is not None and actual_id == unk_id):
+            continue  # not in this checkpoint's vocab -- nothing to compare
+        if actual_id != expected_id:
+            mismatches[tok] = (expected_id, actual_id)
+    if mismatches:
+        details = ", ".join(f"{tok!r}: expected {exp}, got {act}" for tok, (exp, act) in mismatches.items())
+        raise ValueError(
+            "HunyuanImage-3.0 tokenizer special-token ids no longer match "
+            f"HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS ({details}). The loaded "
+            "tokenizer/model revision has likely changed; update the hardcoded "
+            "table in prompt_utils.py to match."
+        )
+
+
 # bot_task -> (sys_type, trigger_tag).
 # ``vanilla`` is special-cased downstream: it bypasses the chat template
 # (no ``User:`` / ``Assistant:`` framing) and is only valid with
@@ -317,12 +359,106 @@ def build_prompt_tokens(
     )
 
 
+@dataclass
+class ARPromptInputs:
+    """Fully-resolved AR-stage inputs for one HunyuanImage3 request.
+
+    Consolidates the three things every caller (offline example, OpenAI
+    server) must compute before submitting an AR request: the AR prefill
+    (as segment-tokenized ``prompt_token_ids`` when a tokenizer is
+    available, else a formatted ``prompt`` string), the resolved DiT
+    system-prompt type, and the AR ``stop_token_ids``.
+    """
+
+    prompt: str | None
+    prompt_token_ids: list[int] | None
+    system_prompt_type: str
+    stop_token_ids: list[int]
+
+
+def build_ar_prompt_inputs(
+    user_prompt: str,
+    task: str = "t2i",
+    bot_task: str | None | _DefaultBotTask = _DEFAULT_BOT_TASK,
+    sys_type: str | None = None,
+    custom_system_prompt: str | None = None,
+    num_images: int = 1,
+    tokenizer: Any | None = None,
+    image_size: str | None = None,
+) -> ARPromptInputs:
+    """Build the complete AR-stage inputs for a HunyuanImage3 request.
+
+    Wraps :func:`build_prompt_tokens` (byte-for-byte HF parity when
+    ``tokenizer`` is given), the :func:`build_prompt` string fallback (when
+    no tokenizer is available), and :func:`resolve_stop_token_ids` behind
+    one call, so a caller doesn't have to re-derive the AR prefill/stop-token
+    logic -- and, critically, doesn't have to independently resolve
+    ``bot_task`` for the prompt-building call vs. the stop-token call, which
+    can silently diverge if a caller passes the same nominal ``bot_task``
+    value to both but resolves "omitted" vs. "explicit None" differently for
+    each (this seam always forwards the identical resolved value to both).
+
+    Used by all four offline shared task examples: ``text_to_image.py`` /
+    ``image_edit.py`` (via ``model_extras.hunyuan_image3.build_ar_stage_inputs``)
+    and ``x_to_text.py`` (via ``build_x_to_text_prompt``, which also calls
+    ``build_ar_stage_inputs``). The OpenAI server's ``serving_chat.py`` does
+    not currently call this seam -- it still independently calls
+    ``build_prompt``/``build_prompt_tokens``/``resolve_stop_token_ids``, and
+    can hit exactly the divergence described above when ``bot_task`` is
+    omitted from ``extra_body`` (pre-existing, unrelated to this module).
+    ``image_size`` follows the same convention as :func:`resolve_stop_token_ids`
+    (``None``/``"auto"`` lets the AR predict the aspect ratio; an explicit
+    ``"{w}x{h}"`` makes it stop at the terminator).
+    """
+    if tokenizer is not None:
+        result = build_prompt_tokens(
+            user_prompt,
+            tokenizer,
+            task=task,
+            bot_task=bot_task,
+            sys_type=sys_type,
+            custom_system_prompt=custom_system_prompt,
+            num_images=num_images,
+        )
+        prompt_str: str | None = None
+        prompt_token_ids: list[int] | None = result.token_ids
+        system_prompt_type = result.system_prompt_type
+    else:
+        prompt_str = build_prompt(
+            user_prompt,
+            task=task,
+            bot_task=bot_task,
+            sys_type=sys_type,
+            custom_system_prompt=custom_system_prompt,
+            num_images=num_images,
+        )
+        prompt_token_ids = None
+        _, resolved_bot_task = _normalize_task_and_bot_task(task, bot_task)
+        system_prompt_type = sys_type or resolve_sys_type(resolved_bot_task)
+
+    stop_token_ids = resolve_stop_token_ids(
+        task=task,
+        bot_task=bot_task,
+        tokenizer=tokenizer,
+        image_size=image_size,
+    )
+    return ARPromptInputs(
+        prompt=prompt_str,
+        prompt_token_ids=prompt_token_ids,
+        system_prompt_type=system_prompt_type,
+        stop_token_ids=stop_token_ids,
+    )
+
+
 __all__ = [
     "HUNYUAN_IMAGE3_SPECIAL_TOKEN_IDS",
+    "validate_special_token_ids",
     "MAX_IMAGES_PER_REQUEST",
     "_TASK_PRESETS",
+    "ARPromptInputs",
     "available_bot_tasks",
     "available_tasks",
+    "build_ar_prompt_inputs",
     "build_prompt",
     "build_prompt_tokens",
     "resolve_stop_token_ids",
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/lance/pipeline_lance.py b/vllm_omni/diffusion/models/lance/pipeline_lance.py
index dc885ac44..f33a35b96 100644
--- a/vllm_omni/diffusion/models/lance/pipeline_lance.py
+++ b/vllm_omni/diffusion/models/lance/pipeline_lance.py
@@ -62,6 +62,7 @@ from vllm_omni.diffusion.models.bagel.pipeline_bagel import (
 from vllm_omni.model_executor.model_loader.weight_utils import (
     download_weights_from_hf_specific,
 )
+from vllm_omni.model_executor.models.utils import normalize_decoded_video_frames
 
 from .lance_transformer import (
     LanceBagel,
@@ -1454,6 +1455,8 @@ class LancePipeline(BagelPipeline):
                     frames_bgr.append(_cv2.cvtColor(f, _cv2.COLOR_BGR2RGB))
                 cap.release()
                 video_raw = _np.stack(frames_bgr, axis=0)
+        elif isinstance(video_input, (list, tuple)):
+            video_raw, origin_fps = normalize_decoded_video_frames(video_input, default_fps=origin_fps_default)
         elif isinstance(video_input, _np.ndarray):
             video_raw = video_input
             origin_fps = origin_fps_default
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 0e78e53e6..45e3add44 100644
--- a/vllm_omni/diffusion/models/lingbot_world/camera.py
+++ b/vllm_omni/diffusion/models/lingbot_world/camera.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
 """Camera trajectory loading and geometry for LingBot World v2 conditioning."""
 
 from __future__ import annotations
@@ -19,7 +19,6 @@ import torch
 
 _REFERENCE_HEIGHT = 480
 _REFERENCE_WIDTH = 832
-_MAX_ACTION_FRAMES = 117
 _MAX_SOURCE_ACTION_FRAMES = 4096
 _MAX_NPY_HEADER_BYTES = 10_000
 _DIRECTORY_OPEN_FLAGS = os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW
@@ -207,9 +206,7 @@ def _load_bounded_npy(
             array = np.load(snapshot_file, allow_pickle=False)
         except (EOFError, TypeError, ValueError):
             raise ValueError(f"{filename} does not contain a valid numeric NPY array.") from None
-    # Official LingBot trajectories may be longer than one request. Only
-    # materialize the bounded prefix that any supported request can consume.
-    result: np.ndarray = np.asarray(array[:_MAX_ACTION_FRAMES], dtype=np.float32)
+    result: np.ndarray = np.asarray(array, dtype=np.float32)
     return result
 
 
@@ -392,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.
@@ -405,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
 
 
@@ -423,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."""
 
@@ -441,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..b179eb773 100644
--- a/vllm_omni/diffusion/models/lingbot_world/dmd_block.py
+++ b/vllm_omni/diffusion/models/lingbot_world/dmd_block.py
@@ -22,6 +22,7 @@ from diffusers.utils.torch_utils import randn_tensor
 
 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,
 )
@@ -109,11 +110,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.
+
+        ``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()
@@ -130,6 +136,7 @@ class LingBotDMDBlockRunner:
             cache=self._block_cache(condition=condition, cache=cache, ar=ar, commit_current=False),
             start_frame=start_frame,
             update_cache=False,
+            camera_modulation_cache=camera_cache,
         )
         if flow_prediction.shape != current_latents.shape:
             raise RuntimeError(
@@ -172,11 +179,13 @@ 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()``.
+        on the stepwise path it belongs to ``post_decode()``. ``camera_cache``
+        is as in ``probe_step``.
         """
         # 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)
@@ -190,6 +199,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 +220,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 +235,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 +250,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 b41abd861..48c2ca568 100644
--- a/vllm_omni/diffusion/models/lingbot_world/pipeline.py
+++ b/vllm_omni/diffusion/models/lingbot_world/pipeline.py
@@ -4,10 +4,12 @@
 
 from __future__ import annotations
 
+import functools
 import math
 import os
+from collections import OrderedDict
 from collections.abc import Callable, Iterable, Iterator, Sequence
-from contextlib import contextmanager
+from contextlib import contextmanager, nullcontext
 from dataclasses import dataclass, replace
 from typing import TYPE_CHECKING, Any, ClassVar, cast
 
@@ -15,25 +17,31 @@ import numpy as np
 import PIL.Image
 import torch
 import torch.nn.functional as F
+from diffusers.models.autoencoders.autoencoder_kl_wan import CACHE_T, WanAttentionBlock, WanResample, WanResidualBlock
 from diffusers.utils.torch_utils import randn_tensor
 from torch import nn
 from transformers import AutoTokenizer, UMT5EncoderModel
-from vllm.distributed import get_tensor_model_parallel_world_size
+from vllm.logger import init_logger
 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,
@@ -47,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,
@@ -63,13 +72,27 @@ from vllm_omni.experimental.ar_diffusion.capability import (
     ARDiffusionKVBranchSpec,
     ARDiffusionKVCacheSpec,
 )
+from vllm_omni.experimental.ar_diffusion.streaming_decode import (
+    StreamingDecodeState,
+    WanStreamingDecoder,
+)
 from vllm_omni.experimental.ar_diffusion.tick_protocol import (
     ARDiffusionChunkMetadata,
     ARDiffusionTickRequest,
 )
 
+logger = init_logger(__name__)
+
+# Resident streaming-decoder cache per session, as bytes per output pixel in
+# fp32: measured once on the reference checkpoint at 37832 KiB for a 64x64
+# output. Every cached tensor is [B, C, <= CACHE_T, H/8, W/8] per causal
+# convolution, so the total scales with height * width and never with session
+# length; tests/diffusion/ar_diffusion/test_streaming_decode.py pins that
+# scaling, and at 832x480 in bf16 this yields the 1801 MiB the decoder was
+# measured to hold.
+_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
@@ -82,8 +105,11 @@ LINGBOT_DMD_TIMESTEPS = (1000, 750, 500, 250)
 _CAMERA_SPATIAL_FOLD = 8
 _MAX_PIXEL_AREA = 480 * 832
 _MAX_SOURCE_IMAGE_PIXELS = 4096 * 4096
-_MAX_RAW_FRAMES = 117
 _MAX_SEQUENCE_LENGTH = 512
+# Distinct prompts whose text encodes are kept. One entry is a single padded
+# sequence -- a few MiB at 512 tokens -- so a handful covers a session's prompt
+# plus the switches it makes, at no meaningful cost next to its KV.
+_PROMPT_EMBEDS_CACHE_SIZE = 4
 _ACTION_ROOT_ENV = "VLLM_OMNI_LINGBOT_ACTION_ROOT"
 _PREPROCESSED_CAMERA_KEY = "_lingbot_camera_trajectory"
 _PREPROCESSED_CAMERA_ACTIONS_KEY = "_lingbot_camera_actions"
@@ -127,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
@@ -135,12 +164,23 @@ class _LingBotRequestInputs:
 
 @dataclass
 class _LingBotARSessionState:
-    """Small model-owned state; attention tensors remain runner-owned."""
+    """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
-    image_condition: 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
 
@@ -203,7 +243,6 @@ def _validate_parallel_config(od_config: OmniDiffusionConfig) -> None:
         return
     unsupported_sizes = {
         "pipeline_parallel_size": "pipeline parallelism",
-        "sequence_parallel_size": "sequence parallelism",
         "cfg_parallel_size": "CFG parallelism",
         "vae_patch_parallel_size": "VAE parallelism",
     }
@@ -211,6 +250,25 @@ def _validate_parallel_config(od_config: OmniDiffusionConfig) -> None:
         size = getattr(parallel_config, field, 1) or 1
         if size > 1:
             raise NotImplementedError(f"LingBot World v1 does not support {feature} ({field}={size}).")
+    sequence_parallel_size = getattr(parallel_config, "sequence_parallel_size", 1) or 1
+    ulysses_degree = getattr(parallel_config, "ulysses_degree", 1) or 1
+    ring_degree = getattr(parallel_config, "ring_degree", 1) or 1
+    allgather_degree = getattr(parallel_config, "allgather_degree", 1) or 1
+    ulysses_mode = getattr(parallel_config, "ulysses_mode", "strict")
+    ulysses_a2a_permute = bool(getattr(parallel_config, "ulysses_a2a_permute", False))
+    if (
+        sequence_parallel_size != ulysses_degree
+        or ring_degree != 1
+        or allgather_degree != 1
+        or ulysses_mode != "strict"
+        or ulysses_a2a_permute
+    ):
+        raise NotImplementedError(
+            "LingBot World sequence parallelism requires pure Ulysses with ulysses_a2a_permute disabled: "
+            f"sequence_parallel_size={sequence_parallel_size}, ulysses_degree={ulysses_degree}, "
+            f"ring_degree={ring_degree}, allgather_degree={allgather_degree}, ulysses_mode={ulysses_mode!r}, "
+            f"ulysses_a2a_permute={ulysses_a2a_permute}."
+        )
     if getattr(parallel_config, "use_hsdp", False):
         raise NotImplementedError("LingBot World v1 does not support HSDP.")
     if getattr(parallel_config, "enable_expert_parallel", False):
@@ -240,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):
@@ -346,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)
@@ -421,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"]
@@ -535,10 +671,23 @@ class LingBotWorldCausalDMDPipeline(
         self._ar_width = int(model_config.get("ar_diffusion_width", 832))
         self._ar_diffusion_kv_state: ARDiffusionKVState | None = None
         self._ar_sessions: dict[str, _LingBotARSessionState] = {}
+        # Text encodes keyed by what they depend on; see encode_prompt.
+        self._prompt_embeds_cache: OrderedDict[tuple[str, int, torch.dtype], torch.Tensor] = OrderedDict()
+        # One temporal decoder cache per stepwise session, keyed the way the
+        # runner keys AR sessions (session_id == request_id) so both are
+        # released together rather than through two independent lifecycles.
+        self._streaming_decode_states: dict[str, StreamingDecodeState] = {}
+        self._cached_streaming_decoder: WanStreamingDecoder | None = None
+        self._streaming_decode_unsupported = False
         self.setup_diffusion_pipeline_profiler(
             profiler_targets=[
                 "vae.encode",
+                "_prepare_condition_chunk",
                 "vae.decode",
+                # Streaming decode never reaches vae.decode, so it needs its
+                # own stage or a streamed rollout reports no decode time at
+                # all -- the one stage this path changes.
+                "_streaming_decode_chunk",
                 "_generate_block",
                 "text_encoder.forward",
                 "tokenizer.forward",
@@ -557,8 +706,6 @@ class LingBotWorldCausalDMDPipeline(
         latent_height = self._ar_height // spatial
         latent_width = self._ar_width // spatial
         tokens_per_frame = (latent_height // patch_height) * (latent_width // patch_width)
-        tp_size = get_tensor_model_parallel_world_size()
-        num_local_heads = int(self.transformer.config.num_attention_heads) // tp_size
         total_window_frames = (
             int(self.transformer.config.local_attn_size)
             if int(self.transformer.config.local_attn_size) != -1
@@ -568,18 +715,27 @@ class LingBotWorldCausalDMDPipeline(
         recent_window_frames = total_window_frames - sink_frames
         if recent_window_frames <= 0:
             raise ValueError("LingBot AR-Diffusion cache needs a positive recent window after reserving sink frames.")
-        horizon_latent_frames = (_MAX_RAW_FRAMES - 1) // self.vae_scale_factor_temporal + 1
+        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
-            * horizon_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),
-            num_kv_heads=num_local_heads,
+            num_kv_heads=int(self.transformer.blocks[0].self_attn.num_sp_heads),
             head_size=int(self.transformer.config.attention_head_dim),
             tokens_per_frame=tokens_per_frame,
             frames_per_block=int(self.transformer.config.num_frames_per_block),
@@ -591,9 +747,62 @@ 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,
+            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()
+            ),
+        )
+
+    def _condition_encoder_cache_bytes(self) -> int:
+        """Bound one Wan encoder history from its per-convolution input grids."""
+        if getattr(self.vae.config, "patch_size", None) is not None:
+            raise ValueError("Stateful LingBot conditioning requires an unpatched Wan VAE.")
+        encoder = self.vae.encoder
+        height, width = self._ar_height, self._ar_width
+        elements = CACHE_T * encoder.conv_in.in_channels * height * width
+        for layer in encoder.down_blocks:
+            if isinstance(layer, WanResidualBlock):
+                elements += CACHE_T * (layer.conv1.in_channels + layer.conv2.in_channels) * height * width
+            elif isinstance(layer, WanResample) and layer.mode in ("downsample2d", "downsample3d"):
+                height, width = height // 2, width // 2
+                if layer.mode == "downsample3d":
+                    # Temporal downsampling retains one frame after spatial downsampling.
+                    elements += layer.time_conv.in_channels * height * width
+            elif not isinstance(layer, WanAttentionBlock):
+                raise ValueError("Stateful LingBot conditioning requires the Wan encoder cache layout.")
+        for layer in encoder.mid_block.resnets:
+            elements += CACHE_T * (layer.conv1.in_channels + layer.conv2.in_channels) * height * width
+        elements += CACHE_T * encoder.conv_out.in_channels * height * width
+        return elements * torch.empty((), dtype=self.vae.dtype).element_size()
+
+    def _streaming_decode_bytes_per_session(self) -> int:
+        """Resident streaming-decoder bytes one session can hold, for admission.
+
+        ``model_owned_state_bytes_per_session`` is what the runner subtracts
+        from the KV budget before sizing the block pools, and this cache is
+        three orders of magnitude larger than the image condition that used to
+        be the only entry: leaving it out lets the profiler report a
+        configuration as fitting and then OOM partway through the second
+        session's rollout.
+
+        Declared for every session rather than only for pixel-output ones: the
+        field is documented as a conservative upper bound, it is fixed at load
+        time, and whether a request asks for pixels is not known then.
+        """
+        decoder = self._streaming_decoder()
+        if decoder is None:
+            return 0
+        return decoder.declared_state_bytes(
+            height=self._ar_height,
+            width=self._ar_width,
+            dtype=self.vae.dtype,
         )
 
     @contextmanager
@@ -612,11 +821,20 @@ class LingBotWorldCausalDMDPipeline(
         finally:
             self._ar_diffusion_kv_state = None
 
+    def _release_condition_encoder_state(self, session_id: str) -> None:
+        state = self._ar_sessions.pop(session_id, None)
+        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._ar_sessions.pop(session_id, None)
+        self._release_condition_encoder_state(session_id)
+        self._release_streaming_decode_state(session_id)
 
     def close_ar_diffusion_session(self, session_id: str) -> None:
-        self._ar_sessions.pop(session_id, None)
+        self._release_condition_encoder_state(session_id)
+        self._release_streaming_decode_state(session_id)
 
     def _parse_request(self, req: DiffusionRequestBatch) -> _LingBotRequestInputs:
         if req.num_reqs != 1 or len(req.prompts) != 1:
@@ -672,8 +890,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)
@@ -742,8 +962,6 @@ class LingBotWorldCausalDMDPipeline(
         num_frames = getattr(sampling, "num_frames", None)
         if isinstance(num_frames, bool) or not isinstance(num_frames, int) or num_frames <= 0:
             raise ValueError(f"num_frames must be a positive integer, got {num_frames!r}.")
-        if num_frames > _MAX_RAW_FRAMES:
-            raise ValueError(f"num_frames must not exceed {_MAX_RAW_FRAMES}.")
         temporal_factor = self.vae_scale_factor_temporal
         if (num_frames - 1) % temporal_factor:
             raise ValueError(
@@ -846,16 +1064,16 @@ class LingBotWorldCausalDMDPipeline(
             raise RuntimeError(
                 f"vae.encode returned an incompatible image latent shape: got {tuple(latent_condition.shape)}."
             )
+        return self._condition_from_latents(latent_condition, first_frame=True, dtype=dtype)
+
+    def _condition_from_latents(
+        self, latent_condition: torch.Tensor, *, first_frame: bool, dtype: torch.dtype
+    ) -> torch.Tensor:
         latent_mean, latent_std = self._vae_latent_stats(latent_condition)
         latent_condition = (latent_condition - latent_mean) / latent_std
-        temporal_mask = latent_condition.new_zeros(
-            1,
-            self.vae_scale_factor_temporal,
-            inputs.num_latent_frames,
-            latent_condition.shape[-2],
-            latent_condition.shape[-1],
-        )
-        temporal_mask[:, :, 0] = 1
+        temporal_mask = latent_condition.new_zeros(1, self.vae_scale_factor_temporal, *latent_condition.shape[2:])
+        if first_frame:
+            temporal_mask[:, :, 0] = 1
         condition = torch.cat((temporal_mask, latent_condition), dim=1).to(dtype=dtype)
         if condition.shape[1] != 20:
             raise RuntimeError(
@@ -864,13 +1082,129 @@ 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,
+        inputs: _LingBotRequestInputs,
+        *,
+        start_frame: int,
+        encoder_cache: list[torch.Tensor | None] | None,
+        dtype: torch.dtype,
+    ) -> tuple[torch.Tensor, list[torch.Tensor | None]]:
+        """Continue the causal encoder without modifying its committed history."""
+        if getattr(self.vae.config, "patch_size", None) is not None or self.vae_scale_factor_temporal != 4:
+            raise ValueError("Stateful LingBot conditioning requires an unpatched Wan VAE with temporal factor 4.")
+        if getattr(self.vae, "use_tiling", False) and (
+            inputs.height > self.vae.tile_sample_min_height or inputs.width > self.vae.tile_sample_min_width
+        ):
+            raise ValueError("Stateful LingBot conditioning does not support tiled VAE encoding.")
+        if (encoder_cache is None) != (start_frame == 0):
+            raise ValueError("LingBot condition encoder history must match the current temporal position.")
+
+        count = int(self.vae._cached_conv_counts["encoder"])
+        # Wan replaces cache entries with new tensors; a separate list keeps the
+        # committed history intact until this AR block succeeds.
+        pending_cache = [None] * count if encoder_cache is None else list(encoder_cache)
+        if len(pending_cache) != count:
+            raise ValueError("LingBot condition encoder cache has an incompatible number of slots.")
+        block_frames = int(self.transformer.config.num_frames_per_block)
+        zeros = torch.zeros(
+            1,
+            3,
+            self.vae_scale_factor_temporal,
+            inputs.height,
+            inputs.width,
+            device=self.device,
+            dtype=self.vae.dtype,
+        )
+        image = (
+            self._prepare_image_tensor(inputs.image, height=inputs.height, width=inputs.width)
+            .unsqueeze(2)
+            .to(dtype=self.vae.dtype)
+            if start_frame == 0
+            else None
+        )
+        context = getattr(self.vae, "_execution_context", None)
+        encoded_frames = []
+        with context() if callable(context) else nullcontext():
+            for index in range(block_frames):
+                # Match Wan's encode loop: one opening pixel frame, then four
+                # fresh zero pixel frames per subsequent latent frame.
+                pixel_frames = image if start_frame == 0 and index == 0 else zeros
+                encoded_frames.append(self.vae.encoder(pixel_frames, feat_cache=pending_cache, feat_idx=[0]))
+            # The posterior projection is pointwise in time. GPU bitwise parity
+            # with the whole-clip projection still requires the real-weight gate.
+            moments = self.vae.quant_conv(torch.cat(encoded_frames, dim=2))
+        latent_condition = moments.chunk(2, dim=1)[0]
+        expected_shape = (
+            1,
+            self.transformer.config.out_channels,
+            block_frames,
+            inputs.height // self.vae_scale_factor_spatial,
+            inputs.width // self.vae_scale_factor_spatial,
+        )
+        if latent_condition.shape != expected_shape:
+            raise RuntimeError(
+                f"Wan condition encoder returned {tuple(latent_condition.shape)}, expected {expected_shape}."
+            )
+        condition = self._condition_from_latents(
+            latent_condition,
+            first_frame=start_frame == 0,
+            dtype=dtype,
+        )
+        return condition, pending_cache
+
     def _prepare_camera(
         self,
         inputs: _LingBotRequestInputs,
         *,
         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."""
 
@@ -906,10 +1240,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,
@@ -923,6 +1257,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,
@@ -931,6 +1267,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:]
@@ -960,20 +1297,9 @@ class LingBotWorldCausalDMDPipeline(
             def layer_kv() -> Iterator[tuple[torch.Tensor, torch.Tensor]]:
                 for block in self.transformer.blocks:
                     cross_attention = block.cross_attn
-                    key = cross_attention.norm_k(cross_attention.k(projected_text)).unflatten(
-                        2,
-                        (
-                            cross_attention.num_local_heads,
-                            cross_attention.head_dim,
-                        ),
-                    )
-                    value = cross_attention.v(projected_text).unflatten(
-                        2,
-                        (
-                            cross_attention.num_local_heads,
-                            cross_attention.head_dim,
-                        ),
-                    )
+                    shape = (cross_attention.num_local_heads, cross_attention.head_dim)
+                    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(
@@ -1053,6 +1379,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,
@@ -1060,8 +1414,27 @@ class LingBotWorldCausalDMDPipeline(
         max_sequence_length: int,
         dtype: torch.dtype,
     ) -> torch.Tensor:
+        """Encode ``prompt`` with UMT5, reusing the result for a prompt already encoded.
+
+        The encode depends only on the whitespace-normalised text, the sequence
+        length and the dtype -- the tokenizer and text encoder are fixed once
+        loaded -- so those three are the key. That covers every caller the same
+        way: a realtime tick repeats its session's prompt on every block, a
+        stepwise request encodes once per request, and a server tends to open
+        many sessions with the same scene prompt.
+
+        A hit returns the stored tensor itself. Callers only read it: the
+        cross-attention projection and the DMD transformer both work out of
+        place, so a shared encode is never changed under another session.
+        """
+        text = " ".join(prompt.strip().split())
+        key = (text, int(max_sequence_length), dtype)
+        cached = self._prompt_embeds_cache.get(key)
+        if cached is not None:
+            self._prompt_embeds_cache.move_to_end(key)
+            return cached
         text_inputs = self.tokenizer(
-            [" ".join(prompt.strip().split())],
+            [text],
             padding="max_length",
             max_length=max_sequence_length,
             truncation=True,
@@ -1073,7 +1446,11 @@ class LingBotWorldCausalDMDPipeline(
         attention_mask = text_inputs.attention_mask.to(self.device)
         prompt_embeds = self.text_encoder(input_ids, attention_mask).last_hidden_state
         prompt_embeds = prompt_embeds.to(device=self.device, dtype=dtype)
-        return prompt_embeds * attention_mask.unsqueeze(-1).to(dtype=prompt_embeds.dtype)
+        prompt_embeds = prompt_embeds * attention_mask.unsqueeze(-1).to(dtype=prompt_embeds.dtype)
+        self._prompt_embeds_cache[key] = prompt_embeds
+        if len(self._prompt_embeds_cache) > _PROMPT_EMBEDS_CACHE_SIZE:
+            self._prompt_embeds_cache.popitem(last=False)
+        return prompt_embeds
 
     def forward(self, req: DiffusionRequestBatch) -> DiffusionOutput:
         inputs = self._parse_request(req)
@@ -1086,11 +1463,21 @@ 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.")
         if tick is None and self._ar_diffusion_kv_state is not None:
             raise ValueError("LingBot ARDiffusionEngine requests must carry ar_diffusion_tick.")
+        if tick is not None and inputs.output_type != "latent":
+            raise ValueError(
+                "LingBot realtime ticks currently require output_type='latent'; "
+                "stateful streaming VAE decode is a separate integration step."
+            )
         session_state: _LingBotARSessionState | None = None
         if tick is not None:
             if tick.prompt is not None and " ".join(tick.prompt.split()) != " ".join(inputs.prompt.split()):
@@ -1107,16 +1494,6 @@ class LingBotWorldCausalDMDPipeline(
                     "fixed cache geometry "
                     f"{self._ar_height}x{self._ar_width}."
                 )
-            horizon_latent_frames = (_MAX_RAW_FRAMES - 1) // self.vae_scale_factor_temporal + 1
-            max_realtime_ticks = horizon_latent_frames // block_frames
-            if tick.chunk_index >= max_realtime_ticks:
-                raise ValueError(
-                    "LingBot realtime generation currently supports at most "
-                    f"{max_realtime_ticks} ticks per generation epoch "
-                    f"(chunk_index 0 through {max_realtime_ticks - 1}) because "
-                    f"the image-condition horizon is {_MAX_RAW_FRAMES} pixel "
-                    "frames; reset or create a session to start a new world."
-                )
             session_state = self._ar_sessions.setdefault(
                 tick.session_id,
                 _LingBotARSessionState(),
@@ -1132,6 +1509,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,
@@ -1141,26 +1521,12 @@ class LingBotWorldCausalDMDPipeline(
             condition = self._prepare_condition(inputs, dtype=dtype)
         else:
             assert session_state is not None
-            if session_state.image_condition is None:
-                horizon_latent_frames = (_MAX_RAW_FRAMES - 1) // self.vae_scale_factor_temporal + 1
-                session_state.image_condition = self._prepare_condition(
-                    replace(
-                        inputs,
-                        num_frames=_MAX_RAW_FRAMES,
-                        num_latent_frames=horizon_latent_frames,
-                    ),
-                    dtype=dtype,
-                )
-            block_frames = int(self.transformer.config.num_frames_per_block)
-            condition_start = tick.chunk_index * block_frames
-            condition_stop = condition_start + block_frames
-            if condition_stop > session_state.image_condition.shape[2]:
-                raise ValueError("LingBot chunk_index exceeds the configured causal image condition horizon.")
-            condition = session_state.image_condition[
-                :,
-                :,
-                condition_start:condition_stop,
-            ]
+            condition, pending_encoder_cache = self._next_condition_chunk(
+                inputs,
+                start_frame=tick.chunk_index * block_frames,
+                session_state=session_state,
+                dtype=dtype,
+            )
         camera_pitch: float | None = None
         if inputs.camera_actions is not None:
             assert session_state is not None
@@ -1197,12 +1563,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)
@@ -1238,8 +1605,8 @@ 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
             if camera_pitch is not None:
                 session_state.camera_pitch = camera_pitch
@@ -1248,11 +1615,6 @@ class LingBotWorldCausalDMDPipeline(
         # Phase 4: either expose model-space latents or invert the checkpoint's
         # latent normalization and decode to pixel-space video.
         if tick is not None:
-            if inputs.output_type != "latent":
-                raise ValueError(
-                    "LingBot realtime ticks currently require output_type='latent'; "
-                    "stateful streaming VAE decode is a separate integration step."
-                )
             output = {
                 "payload": {"latents": generated_latents},
                 "metadata": {"ar_diffusion": ARDiffusionChunkMetadata.from_tick(tick).to_dict()},
@@ -1273,15 +1635,94 @@ class LingBotWorldCausalDMDPipeline(
             stage_durations=self.stage_durations if hasattr(self, "stage_durations") else None,
         )
 
-    def _decode_chunk_to_pixels(
-        self, latents: torch.Tensor, *, output_type: str
-    ) -> torch.Tensor | np.ndarray | list[list[PIL.Image.Image]]:
+    def _vae_would_tile(self, latents: torch.Tensor) -> bool:
+        """Whether ``vae.decode`` would take its tiled path for this shape.
+
+        Tiled decode splits a frame spatially and drives the module's own
+        ``feat_cache`` across those tiles, so a per-session cache threaded
+        through it is a separate design and is not attempted here. The test
+        mirrors ``AutoencoderKLWan._decode``: the flag alone does not tile, the
+        latent also has to exceed a tile, so a sub-threshold resolution with
+        tiling enabled still streams. A VAE that sets the flag but reports no
+        tile size is treated as tiling, because the safe answer when the
+        threshold is unknown is the one that keeps ``vae.decode`` in charge.
+        """
+        if not bool(getattr(self.vae, "use_tiling", False)):
+            return False
+        compression = int(getattr(self.vae, "spatial_compression_ratio", None) or self.vae_scale_factor_spatial)
+        tile_latent_min_height = int(getattr(self.vae, "tile_sample_min_height", None) or 0) // compression
+        tile_latent_min_width = int(getattr(self.vae, "tile_sample_min_width", None) or 0) // compression
+        return bool(latents.shape[-2] > tile_latent_min_height or latents.shape[-1] > tile_latent_min_width)
+
+    def _streaming_decoder(self) -> WanStreamingDecoder | None:
+        """The session-owned streaming decoder, or ``None`` on a VAE that cannot stream.
+
+        Only the decoder's own capability is decided here, and the decision is
+        cached including the negative. Whether a particular *shape* would have
+        been tiled is a per-call question and lives in :meth:`_vae_would_tile`.
+        """
+        if self._streaming_decode_unsupported:
+            return None
+        if self._cached_streaming_decoder is not None:
+            return self._cached_streaming_decoder
+        try:
+            decoder = WanStreamingDecoder(
+                self.vae,
+                bytes_per_pixel_fp32=_STREAMING_DECODE_BYTES_PER_PIXEL_FP32,
+            )
+            # Materialize the cache geometry now: a decoder that cannot report
+            # it would otherwise fail on the first chunk instead.
+            _ = decoder.num_causal_convs
+        except TypeError as exc:
+            logger.warning(
+                "LingBot streaming decode is unavailable (%s); AR blocks will be decoded independently, "
+                "which drops each block's opening frame and restarts temporal context at every boundary.",
+                exc,
+            )
+            self._streaming_decode_unsupported = True
+            return None
+        self._cached_streaming_decoder = decoder
+        return decoder
+
+    def _streaming_decode_state(self, decoder: WanStreamingDecoder, session_id: str) -> StreamingDecodeState:
+        state = self._streaming_decode_states.get(session_id)
+        if state is None:
+            state = decoder.new_decode_state(session_id)
+            self._streaming_decode_states[session_id] = state
+        return state
+
+    def _release_streaming_decode_state(self, session_id: str) -> None:
+        """Drop one session's decoder cache. Safe for a session that never decoded.
+
+        The state is released directly rather than through
+        ``WanStreamingDecoder.release``, which is the same one-line call: the
+        decoder's method exists for a caller holding only the
+        ``SupportsStreamingDecode`` protocol, and this pipeline holds the state.
+        """
+        state = self._streaming_decode_states.pop(session_id, None)
+        if state is not None:
+            state.release()
+
+    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.
 
-        Blocks are decoded independently, which keeps the shared VAE stateless
-        and lets a rollout be served without a per-session temporal cache. That
-        is the same shape Helios streams today; cross-block ``feat_cache``
-        continuity is a separate decision and is not made here.
+        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
+        later one to the full temporal factor, which is the frame timeline an
+        offline whole-clip decode of the same latents produces. The cache lives
+        on the session rather than on the shared VAE module, so concurrent
+        sessions cannot overwrite one another's temporal context.
+
+        Without a ``session_id`` -- or on a VAE that cannot stream -- blocks are
+        decoded independently: every block re-expands its own opening frame, so
+        the rollout loses frames and continuity at each block boundary.
 
         The registered post-process hook returns a ``{"payload", "metadata"}``
         envelope untouched, so the pixel conversion it would do for a bare
@@ -1289,23 +1730,33 @@ class LingBotWorldCausalDMDPipeline(
         """
         latent_mean, latent_std = self._vae_latent_stats(latents)
         vae_latents = (latents * latent_std + latent_mean).to(dtype=self.vae.dtype)
-        video = self.vae.decode(vae_latents, return_dict=False)[0]
-        return self._video_processor().postprocess_video(video, output_type=output_type)
+        decoder = None
+        if session_id is not None and not self._vae_would_tile(vae_latents):
+            decoder = self._streaming_decoder()
+        if decoder is None:
+            video = self.vae.decode(vae_latents, return_dict=False)[0]
+        else:
+            video = self._streaming_decode_chunk(decoder, vae_latents, cast(str, session_id))
+        return _uint8_frames(video)
 
-    def _video_processor(self) -> VideoProcessor:
-        processor = getattr(self, "_cached_video_processor", None)
-        if processor is None:
-            from diffusers.video_processor import VideoProcessor
+    def _streaming_decode_chunk(
+        self, decoder: WanStreamingDecoder, vae_latents: torch.Tensor, session_id: str
+    ) -> torch.Tensor:
+        """Decode one chunk through ``session_id``'s temporal cache.
 
-            processor = VideoProcessor(vae_scale_factor=self.vae_scale_factor_spatial)
-            self._cached_video_processor = processor
-        return processor
-
-    def _horizon_latent_frames(self) -> int:
-        return (_MAX_RAW_FRAMES - 1) // self.vae_scale_factor_temporal + 1
-
-    def _max_realtime_chunks(self) -> int:
-        return self._horizon_latent_frames() // int(self.transformer.config.num_frames_per_block)
+        A separate method so the profiler has a stage to wrap: streaming never
+        calls ``vae.decode``, and without this a profiled rollout would report
+        no decode time for the one stage this path changes.
+        """
+        state = self._streaming_decode_state(decoder, session_id)
+        try:
+            return decoder.decode_chunk(vae_latents, state)
+        except Exception:
+            # A half-advanced cache cannot be resumed: the session's next chunk
+            # would continue from a temporal context that was never completed,
+            # so drop it here rather than at close.
+            self._release_streaming_decode_state(session_id)
+            raise
 
     def _require_bound_ar_state(self) -> None:
         if self._ar_diffusion_kv_state is None:
@@ -1333,13 +1784,6 @@ class LingBotWorldCausalDMDPipeline(
             )
         block_frames = int(self.transformer.config.num_frames_per_block)
         total_chunks = inputs.num_latent_frames // block_frames
-        max_chunks = self._max_realtime_chunks()
-        if total_chunks > max_chunks:
-            raise ValueError(
-                "LingBot step execution currently supports at most "
-                f"{max_chunks} chunks because the image-condition horizon is "
-                f"{_MAX_RAW_FRAMES} pixel frames."
-            )
         if inputs.camera_action_script is not None and len(inputs.camera_action_script) != total_chunks:
             raise ValueError(
                 "camera_action_script must contain one action list per generated chunk; "
@@ -1351,14 +1795,6 @@ class LingBotWorldCausalDMDPipeline(
             max_sequence_length=inputs.max_sequence_length,
             dtype=dtype,
         )
-        image_condition = self._prepare_condition(
-            replace(
-                inputs,
-                num_frames=_MAX_RAW_FRAMES,
-                num_latent_frames=self._horizon_latent_frames(),
-            ),
-            dtype=dtype,
-        )
         camera_trajectory_cache = None
         camera_embedding_cache = None
         if inputs.camera_trajectory is not None:
@@ -1387,7 +1823,6 @@ class LingBotWorldCausalDMDPipeline(
         state.chunk_num_steps = len(LINGBOT_DMD_TIMESTEPS)
         state.extra = {
             "inputs": inputs,
-            "image_condition": image_condition,
             "schedule": _build_shifted_flow_schedule(flow_shift=inputs.flow_shift),
             "dtype": dtype,
             "block_frames": block_frames,
@@ -1398,7 +1833,7 @@ class LingBotWorldCausalDMDPipeline(
             "camera_embedding_cache": camera_embedding_cache,
         }
         self._ar_text_caches(prompt_embeds, invalidate=False)
-        self._prepare_next_chunk(state)
+        self._ar_sessions[state.request_id] = _LingBotARSessionState()
         return state
 
     def _prepare_next_chunk(self, state: StepRequestState) -> None:
@@ -1407,12 +1842,24 @@ class LingBotWorldCausalDMDPipeline(
         block_frames = int(extra["block_frames"])
         start_frame = state.chunk_index * block_frames
         stop_frame = start_frame + block_frames
-        image_condition = extra["image_condition"]
-        if stop_frame > image_condition.shape[2]:
-            raise ValueError("LingBot chunk_index exceeds the configured causal image condition horizon.")
-        condition = image_condition[:, :, start_frame:stop_frame]
+        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._next_condition_chunk(
+            inputs,
+            start_frame=start_frame,
+            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,
@@ -1422,11 +1869,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(
@@ -1435,14 +1883,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:]:
@@ -1455,6 +1942,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(
@@ -1480,6 +1973,7 @@ class LingBotWorldCausalDMDPipeline(
         )
         state.step_in_chunk = 0
         state.step_index = 0
+        session_state.pending_encoder_cache = pending_encoder_cache
 
     def denoise_step(
         self,
@@ -1512,6 +2006,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:
@@ -1543,6 +2038,9 @@ class LingBotWorldCausalDMDPipeline(
         latents = state.latents
         if latents is None:
             raise RuntimeError("LingBot step execution requires latents before post_decode.")
+        session_state = self._ar_sessions[state.request_id]
+        if session_state.pending_encoder_cache is None:
+            raise RuntimeError("LingBot condition encoder has no prepared chunk to commit.")
         self._dmd_blocks.commit_block_kv(
             latents=latents,
             condition=extra["condition"],
@@ -1551,6 +2049,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"]
@@ -1560,7 +2059,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)}
+            payload = {"video": self._decode_chunk_to_pixels(latents, session_id=state.request_id)}
         output = {
             "payload": payload,
             "metadata": {
@@ -1572,18 +2071,52 @@ class LingBotWorldCausalDMDPipeline(
                 ).to_dict()
             },
         }
+        session_state.encoder_cache = session_state.pending_encoder_cache
+        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)
         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 35ec18801..9a270e611 100644
--- a/vllm_omni/diffusion/models/lingbot_world/transformer.py
+++ b/vllm_omni/diffusion/models/lingbot_world/transformer.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
 """Checkpoint-compatible causal DiT for the LingBot World v2 model package."""
 
 from __future__ import annotations
@@ -24,6 +24,9 @@ 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, 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
 from vllm_omni.diffusion.layers.rope import RotaryEmbeddingWan
 from vllm_omni.experimental.ar_diffusion.kv_cache.paged_attention import (
@@ -127,6 +130,37 @@ def _projection_prefix(prefix: str, name: str) -> str:
     return f"{prefix}.{name}" if prefix else name
 
 
+def _ulysses_state() -> tuple[int, int, torch.distributed.ProcessGroup | None]:
+    coordinator = get_sp_group()
+    return (
+        int(coordinator.ulysses_world_size),
+        int(coordinator.ulysses_rank),
+        coordinator.ulysses_group,
+    )
+
+
+class _LingBotSPPrepare(nn.Module):
+    """Expand frame conditioning only when Ulysses shards the token sequence."""
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        camera_hidden_states: torch.Tensor,
+        timestep_projection: torch.Tensor,
+        rotary_emb: tuple[torch.Tensor, torch.Tensor],
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        num_frames = timestep_projection.shape[1]
+        if hidden_states.shape[1] % num_frames:
+            raise ValueError("LingBot token count must be divisible by the latent frame count.")
+        tokens_per_frame = hidden_states.shape[1] // num_frames
+        if get_sp_group().ulysses_world_size > 1:
+            timestep_projection = (
+                timestep_projection.unsqueeze(2).expand(-1, -1, tokens_per_frame, -1, -1).flatten(1, 2)
+            )
+        cosine, sine = rotary_emb
+        return hidden_states, camera_hidden_states, timestep_projection, cosine, sine
+
+
 class LingBotSelfAttention(nn.Module):
     """Block-causal self-attention over retained history and one full chunk."""
 
@@ -157,6 +191,13 @@ class LingBotSelfAttention(nn.Module):
             prefix=_projection_prefix(prefix, "qkv"),
         )
         self.num_local_heads = self.qkv.num_heads
+        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 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
         self.tp_inner_dim = self.num_local_heads * self.head_dim
         self.o = RowParallelLinear(
             dim,
@@ -170,9 +211,9 @@ class LingBotSelfAttention(nn.Module):
         self.norm_k = _LingBotRMSNorm(self.tp_inner_dim, eps)
         self.rotary_embedding = RotaryEmbeddingWan(is_neox_style=False, half_head_dim=True)
         self.attn = Attention(
-            num_heads=self.num_local_heads,
+            num_heads=self.num_sp_heads,
             head_size=self.head_dim,
-            num_kv_heads=self.num_local_heads,
+            num_kv_heads=self.num_sp_heads,
             softmax_scale=self.head_dim**-0.5,
             causal=False,
             role="self",
@@ -287,6 +328,20 @@ class LingBotSelfAttention(nn.Module):
             query = self.rotary_embedding(query, cos, sin)
             key = self.rotary_embedding(key, cos, sin)
 
+        if self.ulysses_world_size > 1:
+            # 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:
                 raise RuntimeError("LingBot AR-Diffusion paged attention requires batch_size=1.")
@@ -347,6 +402,8 @@ class LingBotSelfAttention(nn.Module):
                 )
             else:
                 output = self.attn(query, visible_key, visible_value)
+        if self.ulysses_world_size > 1:
+            output = SeqAllToAll4D.apply(self.ulysses_group, output, 1, 2, False)
         return self.o(output.flatten(2, 3))
 
 
@@ -373,6 +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
+        # 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(
@@ -525,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,
@@ -538,9 +610,21 @@ 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 (
+            timestep_projection.ndim != 4
+            or timestep_projection.shape[0] != batch_size
+            or timestep_projection.shape[2:] != (6, dim)
+        ):
+            raise ValueError("LingBot timestep projection must have shape (batch, frames or tokens, 6, dim).")
         num_frames = timestep_projection.shape[1]
+        if num_frames == 0 or token_count % num_frames:
+            raise ValueError("LingBot timestep projection must align with hidden tokens.")
+        if self.self_attn.ulysses_world_size > 1 and num_frames != token_count:
+            raise ValueError("LingBot Ulysses requires one timestep projection per local token.")
+        # Without SP, broadcast per frame. With SP, each entry represents one token.
         tokens_per_frame = token_count // num_frames
         # Timestep, camera, and text remain separate conditioning paths.
         modulation = self.modulation.unsqueeze(1) + timestep_projection.float()
@@ -560,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(
@@ -635,13 +718,26 @@ class _LingBotHead(nn.Module):
         self,
         hidden_states: torch.Tensor,
         timestep_embedding: torch.Tensor,
+        *,
+        tokens_per_frame: int | None = None,
+        token_offset: int = 0,
     ) -> torch.Tensor:
         num_frames = timestep_embedding.shape[1]
-        tokens_per_frame = hidden_states.shape[1] // num_frames
         modulation = self.modulation.unsqueeze(1) + timestep_embedding.unsqueeze(2).float()
         shift, scale = modulation.chunk(2, dim=2)
-        normalized = self.norm(hidden_states.float()).unflatten(1, (num_frames, tokens_per_frame))
-        normalized = (normalized * (1 + scale) + shift).flatten(1, 2).to(hidden_states.dtype)
+        normalized = self.norm(hidden_states.float())
+        if tokens_per_frame is None:
+            normalized = normalized.unflatten(1, (num_frames, -1))
+            normalized = (normalized * (1 + scale) + shift).flatten(1, 2)
+        else:
+            # A sequence shard can begin/end inside a frame.
+            frames = (
+                torch.arange(hidden_states.shape[1], device=hidden_states.device) + token_offset
+            ) // tokens_per_frame
+            scale = scale.squeeze(2).index_select(1, frames)
+            shift = shift.squeeze(2).index_select(1, frames)
+            normalized = normalized * (1 + scale) + shift
+        normalized = normalized.to(hidden_states.dtype)
         return self.head(normalized)
 
 
@@ -658,7 +754,7 @@ def _sinusoidal_embedding(dim: int, timestep: torch.Tensor) -> torch.Tensor:
     return torch.cat((phase.cos(), phase.sin()), dim=1)
 
 
-def _rope_axis(max_seq_len: int, dim: int) -> tuple[torch.Tensor, torch.Tensor]:
+def _rope_axis(max_seq_len: int, dim: int, *, start: int = 0) -> tuple[torch.Tensor, torch.Tensor]:
     if dim == 0:
         empty = torch.empty(max_seq_len, 0, dtype=torch.float32)
         return empty, empty.clone()
@@ -668,16 +764,42 @@ def _rope_axis(max_seq_len: int, dim: int) -> tuple[torch.Tensor, torch.Tensor]:
         10000,
         torch.arange(0, dim, 2, dtype=torch.float64) / dim,
     )
-    phase = torch.outer(torch.arange(max_seq_len, dtype=torch.float64), frequencies)
+    phase = torch.outer(torch.arange(start, start + max_seq_len, dtype=torch.float64), frequencies)
     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."""
 
     _repeated_blocks = ["LingBotAttentionBlock"]
     packed_modules_mapping = {"qkv": ["q", "k", "v"]}
     _layerwise_offload_blocks_attrs = ["blocks"]
+    _sp_plan = {
+        "sp_prepare": {
+            0: SequenceParallelInput(split_dim=1, expected_dims=3, split_output=True),
+            1: SequenceParallelInput(split_dim=1, expected_dims=3, split_output=True),
+            2: SequenceParallelInput(split_dim=1, expected_dims=4, split_output=True),
+            3: SequenceParallelInput(split_dim=0, expected_dims=2, split_output=True),
+            4: SequenceParallelInput(split_dim=0, expected_dims=2, split_output=True),
+        },
+        "sp_output_gather": SequenceParallelOutput(gather_dim=1, expected_dims=3),
+    }
 
     def __init__(
         self,
@@ -768,6 +890,8 @@ class CausalLingBotWorldTransformer3DModel(nn.Module):
             stride=patch_size,
         )
         self.patch_embedding_wancamctrl = _LingBotCameraPatchEmbedding(6 * 8 * 8, dim, patch_size)
+        self.sp_prepare = _LingBotSPPrepare()
+        self.sp_output_gather = nn.Identity()
         self.c2ws_hidden_states_layer1 = ColumnParallelLinear(
             dim,
             dim,
@@ -819,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:
@@ -904,8 +1049,7 @@ class CausalLingBotWorldTransformer3DModel(nn.Module):
             self.config.local_attn_size if self.config.local_attn_size != -1 else self.config.sliding_window_num_frames
         )
         max_tokens = int(window_frames * post_patch_height * post_patch_width)
-        tp_size = get_tensor_model_parallel_world_size()
-        num_local_heads = self.config.num_attention_heads // tp_size
+        num_local_heads = self.blocks[0].self_attn.num_sp_heads
         return allocate_lingbot_cache(
             batch_size=batch_size,
             num_layers=self.config.num_layers,
@@ -926,23 +1070,29 @@ class CausalLingBotWorldTransformer3DModel(nn.Module):
         dtype: torch.dtype,
         device: torch.device,
     ) -> tuple[torch.Tensor, torch.Tensor]:
-        if start_frame + frames > self.config.rope_max_seq_len:
-            raise ValueError("Temporal RoPE positions exceed rope_max_seq_len.")
         if height > self.config.rope_max_seq_len or width > self.config.rope_max_seq_len:
             raise ValueError("Spatial RoPE positions exceed rope_max_seq_len.")
+        if start_frame + frames <= self._rope_temporal_cosine.shape[0]:
+            temporal_cosine = self._rope_temporal_cosine[start_frame : start_frame + frames]
+            temporal_sine = self._rope_temporal_sine[start_frame : start_frame + frames]
+        else:
+            # Keep absolute positions and checkpoint frequencies, computing only
+            # this block instead of growing a table for the whole session.
+            temporal_dim = self._rope_temporal_cosine.shape[1] * 2
+            temporal_cosine, temporal_sine = _rope_axis(frames, temporal_dim, start=start_frame)
+            temporal_cosine = temporal_cosine.to(self._rope_temporal_cosine)
+            temporal_sine = temporal_sine.to(self._rope_temporal_sine)
 
         def expand_axis(table: torch.Tensor, axis: str) -> torch.Tensor:
             if axis == "temporal":
-                return (
-                    table[start_frame : start_frame + frames].view(frames, 1, 1, -1).expand(frames, height, width, -1)
-                )
+                return table.view(frames, 1, 1, -1).expand(frames, height, width, -1)
             if axis == "height":
                 return table[:height].view(1, height, 1, -1).expand(frames, height, width, -1)
             return table[:width].view(1, 1, width, -1).expand(frames, height, width, -1)
 
         cosine = torch.cat(
             (
-                expand_axis(self._rope_temporal_cosine, "temporal"),
+                expand_axis(temporal_cosine, "temporal"),
                 expand_axis(self._rope_height_cosine, "height"),
                 expand_axis(self._rope_width_cosine, "width"),
             ),
@@ -950,7 +1100,7 @@ class CausalLingBotWorldTransformer3DModel(nn.Module):
         )
         sine = torch.cat(
             (
-                expand_axis(self._rope_temporal_sine, "temporal"),
+                expand_axis(temporal_sine, "temporal"),
                 expand_axis(self._rope_height_sine, "height"),
                 expand_axis(self._rope_width_sine, "width"),
             ),
@@ -1070,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.")
@@ -1138,15 +1289,51 @@ class CausalLingBotWorldTransformer3DModel(nn.Module):
                 query_len=hidden_states.shape[1],
             )
             cache.self_attention = [layer_context.to_layer_inputs() for layer_context in cache.self_attention]
+        sp_size = self.blocks[0].self_attn.ulysses_world_size
+        global_tokens = patched_frames * tokens_per_frame
+        hidden_dim = hidden_states.shape[-1]
+        rope_dim = rotary_emb[0].shape[-1]
+        if global_tokens % sp_size:
+            raise ValueError("LingBot Ulysses requires the token count to be divisible by its degree.")
+        hidden_states, camera_hidden_states, timestep_projection, cosine, sine = self.sp_prepare(
+            hidden_states,
+            camera_hidden_states,
+            timestep_projection,
+            rotary_emb,
+        )
+        if sp_size > 1:
+            local_tokens = global_tokens // sp_size
+            expected_hidden = (batch_size, local_tokens, hidden_dim)
+            if (
+                hidden_states.shape != expected_hidden
+                or camera_hidden_states.shape != expected_hidden
+                or timestep_projection.shape != (batch_size, local_tokens, 6, hidden_dim)
+                or cosine.shape != (local_tokens, rope_dim)
+                or sine.shape != (local_tokens, rope_dim)
+            ):
+                raise RuntimeError(
+                    "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,
@@ -1156,9 +1343,17 @@ class CausalLingBotWorldTransformer3DModel(nn.Module):
             )
             cache.cross_attention[index] = cross_cache
 
-        # Phase 4: map tokens to per-patch 16-channel flow values and restore
-        # [B, C, F, H, W] for the Pipeline's sampler update.
-        hidden_states = self.head(hidden_states, timestep_embedding)
+        # Phase 4: project local tokens before gathering the much narrower flow values.
+        hidden_states = self.head(
+            hidden_states,
+            timestep_embedding,
+            tokens_per_frame=tokens_per_frame if sp_size > 1 else None,
+            token_offset=get_sp_group().ulysses_rank * (global_tokens // sp_size) if sp_size > 1 else 0,
+        )
+        hidden_states = self.sp_output_gather(hidden_states)
+        projected_dim = self.config.out_channels * math.prod(self.config.patch_size)
+        if sp_size > 1 and hidden_states.shape != (batch_size, global_tokens, projected_dim):
+            raise RuntimeError("LingBot SP output hook did not gather the full projected token sequence.")
         return self._unpatchify(
             hidden_states,
             batch_size=batch_size,
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 87d3402d3..0009a2ecc 100644
--- a/vllm_omni/diffusion/models/magi2/modeling_magi2.py
+++ b/vllm_omni/diffusion/models/magi2/modeling_magi2.py
@@ -16,6 +16,7 @@ import os
 from collections.abc import Iterable
 from enum import IntEnum
 from functools import partial
+from typing import Any
 
 import torch
 import torch.nn as nn
@@ -28,6 +29,7 @@ from .configuration_magi2 import Magi2PreviewConfig
 from .layers import (
     ElementWiseFourierEmbed,
     MHCHandler,
+    MHCTensorTuple,
     ModalityDispatcher,
     MultiModalityRMSNorm,
     make_grouped_linear,
@@ -130,14 +132,12 @@ class Magi2Attention(nn.Module):
         start = self.tp_group.rank * self.num_heads_q
         return checkpoint_tensor[:, start : start + self.num_heads_q]
 
-    def forward(
+    def project(
         self,
         hidden_states: torch.Tensor,
         rope: torch.Tensor,
-        varlen_handler: VarlenHandler,
         modality_dispatcher: ModalityDispatcher,
-        cp_split_sizes: list[int] | torch.Tensor,
-    ) -> torch.Tensor:
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
         normalized = self.pre_norm(hidden_states, modality_dispatcher)
         gates = self.linear_g(normalized, modality_dispatcher)
         qkv = self.linear_qkv(normalized, modality_dispatcher)
@@ -159,8 +159,17 @@ class Magi2Attention(nn.Module):
         q = apply_rotary_emb(q, cos, sin).squeeze(0).to(self.config.params_dtype)
         k = apply_rotary_emb(k, cos, sin).squeeze(0).to(self.config.params_dtype)
         v = v.squeeze(0).to(self.config.params_dtype)
+        return q, k, v, gates
 
-        output = self.packed_attention(
+    def attend(
+        self,
+        q: torch.Tensor,
+        k: torch.Tensor,
+        v: torch.Tensor,
+        varlen_handler: VarlenHandler,
+        cp_split_sizes: list[int] | torch.Tensor,
+    ) -> torch.Tensor:
+        return self.packed_attention(
             q,
             k,
             v,
@@ -172,7 +181,14 @@ class Magi2Attention(nn.Module):
                 }
             ),
         )
-        output = modality_dispatcher.permute(output)
+
+    def output(
+        self,
+        attention: torch.Tensor,
+        gates: torch.Tensor,
+        modality_dispatcher: ModalityDispatcher,
+    ) -> torch.Tensor:
+        output = modality_dispatcher.permute(attention)
         output = output * torch.sigmoid(gates)
         output = output.reshape(-1, self.q_size).to(self.config.params_dtype)
         return self.linear_proj(output, modality_dispatcher)
@@ -303,12 +319,21 @@ class Magi2MultiHeadMoELayer(nn.Module):
             modality.contiguous(), dispatcher
         )
 
-    def forward(self, hidden_states: torch.Tensor, dispatcher: ModalityDispatcher) -> torch.Tensor:
+    def route_input(
+        self,
+        hidden_states: torch.Tensor,
+        dispatcher: ModalityDispatcher,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
         normalized = self.pre_norm(hidden_states, dispatcher)
-        routed = self.split_linear(normalized)
-        routed = self.moe_mlp(routed)
-        routed = self.merge_linear(routed)
-        return routed + self._shared_experts(normalized, dispatcher)
+        return normalized, self.split_linear(normalized)
+
+    def combine(
+        self,
+        normalized: torch.Tensor,
+        routed: torch.Tensor,
+        dispatcher: ModalityDispatcher,
+    ) -> torch.Tensor:
+        return self.merge_linear(routed) + self._shared_experts(normalized, dispatcher)
 
 
 class Magi2PreAdapter(nn.Module):
@@ -339,37 +364,28 @@ class Magi2PreAdapter(nn.Module):
     def forward(
         self,
         packed: torch.Tensor,
-        coords_mapping: torch.Tensor,
         video_indices: torch.Tensor,
         audio_indices: torch.Tensor,
         text_indices: torch.Tensor,
-    ) -> tuple[torch.Tensor, torch.Tensor]:
-        rope = self.rope(coords_mapping)
-        output = torch.zeros(
+    ) -> torch.Tensor:
+        # Every token belongs to exactly one modality, so the three copies
+        # below cover the whole buffer.  Embedding in fp32 and rounding each
+        # modality once matches the released cast at the block boundary.
+        output = torch.empty(
             packed.shape[0],
             self.adapter_dim,
-            dtype=torch.float32,
+            dtype=self.config.params_dtype,
             device=packed.device,
         )
-        if text_indices.numel():
-            output.index_copy_(
-                0,
-                text_indices,
-                self.text_embedder(packed.index_select(0, text_indices)[:, : self.config.text_in_channels].float()),
-            )
-        if audio_indices.numel():
-            output.index_copy_(
-                0,
-                audio_indices,
-                self.audio_embedder(packed.index_select(0, audio_indices)[:, : self.config.audio_in_channels].float()),
-            )
-        if video_indices.numel():
-            output.index_copy_(
-                0,
-                video_indices,
-                self.video_embedder(packed.index_select(0, video_indices)[:, : self.config.video_in_channels].float()),
-            )
-        return output, rope
+        for indices, embedder, in_channels in (
+            (text_indices, self.text_embedder, self.config.text_in_channels),
+            (audio_indices, self.audio_embedder, self.config.audio_in_channels),
+            (video_indices, self.video_embedder, self.config.video_in_channels),
+        ):
+            if indices.numel():
+                tokens = packed[:, :in_channels].index_select(0, indices).float()
+                output.index_copy_(0, indices, embedder(tokens).to(output.dtype))
+        return output
 
 
 class Magi2PostAdapter(nn.Module):
@@ -425,8 +441,10 @@ class Magi2TransformerLayer(nn.Module):
         self.mlp: nn.Module
         if layer_index in config.moe.layers:
             self.mlp = Magi2MultiHeadMoELayer(config)
+            self.region_methods = ("_attention_input", "_moe_input", "_moe_output")
         else:
             self.mlp = Magi2MLP(config, num_modality=num_modality)
+            self.region_methods = ("_attention_input", "_dense_output")
         self._init_mhc(num_modality)
 
     def _init_mhc(self, num_modality: int) -> None:
@@ -525,6 +543,74 @@ class Magi2TransformerLayer(nn.Module):
         )
         return self.mhc_handler.hyper_connect(streams, output, post, residual)
 
+    # The layer forward is split into compile regions around the two eager
+    # kernels: packed attention and the multi-head MoE.
+
+    def _attention_input(
+        self,
+        hidden_states: torch.Tensor,
+        rope: torch.Tensor,
+        modality_dispatcher: ModalityDispatcher,
+    ) -> tuple[torch.Tensor, MHCTensorTuple, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        streams = hidden_states.reshape(hidden_states.shape[0], self.config.mhc.num_streams, self.config.hidden_size)
+        attention_logits = self._branch_logits(streams, "attn", modality_dispatcher)
+        attention_input = self._branch_input(streams, "attn", attention_logits)
+        q, k, v, gates = self.attention.project(attention_input, rope, modality_dispatcher)
+        return streams, attention_logits, q, k, v, gates
+
+    def _mlp_input(
+        self,
+        streams: torch.Tensor,
+        attention: torch.Tensor,
+        gates: torch.Tensor,
+        attention_logits: MHCTensorTuple,
+        modality_dispatcher: ModalityDispatcher,
+    ) -> tuple[torch.Tensor, MHCTensorTuple, torch.Tensor]:
+        attention_output = self.attention.output(attention, gates, modality_dispatcher)
+        streams = self._connect(streams, attention_output, "attn", attention_logits)
+        mlp_logits = self._branch_logits(streams, "mlp", modality_dispatcher)
+        return streams, mlp_logits, self._branch_input(streams, "mlp", mlp_logits)
+
+    def _dense_output(
+        self,
+        streams: torch.Tensor,
+        attention: torch.Tensor,
+        gates: torch.Tensor,
+        attention_logits: MHCTensorTuple,
+        modality_dispatcher: ModalityDispatcher,
+    ) -> torch.Tensor:
+        streams, mlp_logits, mlp_input = self._mlp_input(
+            streams, attention, gates, attention_logits, modality_dispatcher
+        )
+        streams = self._connect(streams, self.mlp(mlp_input, modality_dispatcher), "mlp", mlp_logits)
+        return streams.reshape(streams.shape[0], -1)
+
+    def _moe_input(
+        self,
+        streams: torch.Tensor,
+        attention: torch.Tensor,
+        gates: torch.Tensor,
+        attention_logits: MHCTensorTuple,
+        modality_dispatcher: ModalityDispatcher,
+    ) -> tuple[torch.Tensor, MHCTensorTuple, torch.Tensor, torch.Tensor]:
+        streams, mlp_logits, mlp_input = self._mlp_input(
+            streams, attention, gates, attention_logits, modality_dispatcher
+        )
+        normalized, routed = self.mlp.route_input(mlp_input, modality_dispatcher)
+        return streams, mlp_logits, normalized, routed
+
+    def _moe_output(
+        self,
+        streams: torch.Tensor,
+        mlp_logits: MHCTensorTuple,
+        normalized: torch.Tensor,
+        routed: torch.Tensor,
+        modality_dispatcher: ModalityDispatcher,
+    ) -> torch.Tensor:
+        mlp_output = self.mlp.combine(normalized, routed, modality_dispatcher)
+        streams = self._connect(streams, mlp_output, "mlp", mlp_logits)
+        return streams.reshape(streams.shape[0], -1)
+
     def forward(
         self,
         hidden_states: torch.Tensor,
@@ -533,22 +619,15 @@ class Magi2TransformerLayer(nn.Module):
         modality_dispatcher: ModalityDispatcher,
         cp_split_sizes: list[int] | torch.Tensor,
     ) -> torch.Tensor:
-        streams = hidden_states.reshape(hidden_states.shape[0], self.config.mhc.num_streams, self.config.hidden_size)
-        attention_logits = self._branch_logits(streams, "attn", modality_dispatcher)
-        attention_input = self._branch_input(streams, "attn", attention_logits)
-        attention_output = self.attention(
-            attention_input,
-            rope,
-            varlen_handler,
-            modality_dispatcher,
-            cp_split_sizes,
+        streams, attention_logits, q, k, v, gates = self._attention_input(hidden_states, rope, modality_dispatcher)
+        attention = self.attention.attend(q, k, v, varlen_handler, cp_split_sizes)
+        if not isinstance(self.mlp, Magi2MultiHeadMoELayer):
+            return self._dense_output(streams, attention, gates, attention_logits, modality_dispatcher)
+        streams, mlp_logits, normalized, routed = self._moe_input(
+            streams, attention, gates, attention_logits, modality_dispatcher
         )
-        streams = self._connect(streams, attention_output, "attn", attention_logits)
-        mlp_logits = self._branch_logits(streams, "mlp", modality_dispatcher)
-        mlp_input = self._branch_input(streams, "mlp", mlp_logits)
-        mlp_output = self.mlp(mlp_input, modality_dispatcher)
-        streams = self._connect(streams, mlp_output, "mlp", mlp_logits)
-        return streams.reshape(streams.shape[0], -1)
+        routed = self.mlp.moe_mlp(routed)
+        return self._moe_output(streams, mlp_logits, normalized, routed, modality_dispatcher)
 
 
 class Magi2TransformerBlock(nn.Module):
@@ -570,7 +649,6 @@ class Magi2TransformerBlock(nn.Module):
         modality_dispatcher: ModalityDispatcher,
         cp_split_sizes: list[int] | torch.Tensor,
     ) -> torch.Tensor:
-        hidden_states = hidden_states.to(self.config.params_dtype)
         hidden_states = modality_dispatcher.permute(hidden_states)
         for layer in self.layers:
             hidden_states = layer(
@@ -592,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 = (
@@ -626,10 +702,19 @@ 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
 
+    def compile_regions(self, **compile_kwargs: Any) -> None:
+        """Compile the dense compute between the eager attention and MoE kernels."""
+
+        self.pre_adapter.forward = torch.compile(self.pre_adapter.forward, **compile_kwargs)
+        self.post_adapter.forward = torch.compile(self.post_adapter.forward, **compile_kwargs)
+        for layer in self.block.layers:
+            for name in layer.region_methods:
+                setattr(layer, name, torch.compile(getattr(layer, name), **compile_kwargs))
+
     def forward(
         self,
         x: torch.Tensor,
@@ -647,6 +732,7 @@ class Magi2PreviewTransformer(nn.Module):
         assert dispatcher.split_sizes is not None
         cp_split_sizes = dispatcher.split_sizes
 
+        rope = self.pre_adapter.rope(coords_mapping)
         time_mask = modality_mapping == int(Modality.TIME)
         modality_mapping = torch.where(time_mask, int(Modality.TEXT), modality_mapping)
         modality_dispatcher = ModalityDispatcher(modality_mapping, 3)
@@ -654,13 +740,7 @@ class Magi2PreviewTransformer(nn.Module):
         audio_indices = torch.nonzero(modality_mapping == int(Modality.AUDIO)).flatten()
         text_indices = torch.nonzero(modality_mapping == int(Modality.TEXT)).flatten()
 
-        hidden_states, rope = self.pre_adapter(
-            x,
-            coords_mapping,
-            video_indices,
-            audio_indices,
-            text_indices,
-        )
+        hidden_states = self.pre_adapter(x, video_indices, audio_indices, text_indices)
         if time_token_sequence is not None and time_token_sequence.shape[-1] > 0:
             hidden_states[:, : time_token_sequence.shape[-1]] = time_token_sequence.to(hidden_states.dtype)
         hidden_states = self.block(
diff --git a/vllm_omni/diffusion/models/magi2/pipeline_magi2.py b/vllm_omni/diffusion/models/magi2/pipeline_magi2.py
index c7c480876..910e0d074 100644
--- a/vllm_omni/diffusion/models/magi2/pipeline_magi2.py
+++ b/vllm_omni/diffusion/models/magi2/pipeline_magi2.py
@@ -695,6 +695,24 @@ class Magi2Pipeline(
 
         return self.video_decoder.module
 
+    def setup_compile(self) -> None:
+        """Compile the transformer regions; the attention and MoE kernels stay eager."""
+
+        granularity = self.od_config.diffusion_compile_granularity
+        if granularity != "regional":
+            logger.warning(
+                "MAGI-2 compiles the transformer regions itself; diffusion_compile_granularity=%r is ignored.",
+                granularity,
+            )
+
+        # The mHC connections chain bf16 ops that eager rounds after every op.
+        # Emulating those casts keeps the compiled rounding boundaries equal.
+        self.transformer.compile_regions(
+            fullgraph=True,
+            dynamic=self.od_config.diffusion_compile_dynamic,
+            options={"emulate_precision_casts": True},
+        )
+
     def load_weights(
         self,
         weights: Iterable[tuple[str, torch.Tensor]],
diff --git a/vllm_omni/diffusion/models/magi2/sampler_magi2.py b/vllm_omni/diffusion/models/magi2/sampler_magi2.py
index 994fdd3e4..35dd2dab9 100644
--- a/vllm_omni/diffusion/models/magi2/sampler_magi2.py
+++ b/vllm_omni/diffusion/models/magi2/sampler_magi2.py
@@ -308,29 +308,11 @@ class Magi2PreviewSampler(CFGParallelMixin):
         per_token_video_t = t_batch.view(-1, 1, 1, 1, 1).expand(cfg_batch, 1, video_t, video_h, video_w)
         per_token_audio_t = t_batch.view(-1, 1, 1).expand(cfg_batch, audio_t, 1)
 
-        audio_lengths = torch.full(
-            (cfg_batch,),
-            audio_latent_len,
-            device=latent.device,
-            dtype=torch.long,
-        )
-        text_lengths = torch.tensor(
-            [txt_feat_len] * batch_size + [null_txt_feat_len] * batch_size,
-            device=latent.device,
-            dtype=torch.long,
-        )
-        ref_audio_lengths = torch.full(
-            (cfg_batch,),
-            ref_audio_feat_len,
-            device=latent.device,
-            dtype=torch.long,
-        )
-        ref_video_lengths = torch.full(
-            (cfg_batch,),
-            ref_video_feat_len,
-            device=latent.device,
-            dtype=torch.long,
-        )
+        # Lengths stay host integers; the data proxy reads them as Python ints.
+        audio_lengths = [audio_latent_len] * cfg_batch
+        text_lengths = [txt_feat_len] * batch_size + [null_txt_feat_len] * batch_size
+        ref_audio_lengths = [ref_audio_feat_len] * cfg_batch
+        ref_video_lengths = [ref_video_feat_len] * cfg_batch
 
         return ModelInput(
             x_t=torch.cat((latent, latent), dim=0),
diff --git a/vllm_omni/diffusion/models/mammoth_moda2/mammothmoda2_dit_model.py b/vllm_omni/diffusion/models/mammoth_moda2/mammothmoda2_dit_model.py
index 000abe051..e2c086d4a 100644
--- a/vllm_omni/diffusion/models/mammoth_moda2/mammothmoda2_dit_model.py
+++ b/vllm_omni/diffusion/models/mammoth_moda2/mammothmoda2_dit_model.py
@@ -1,4 +1,5 @@
-import math
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
 import torch
 import torch.nn.functional as F
@@ -6,27 +7,14 @@ from diffusers.configuration_utils import ConfigMixin, register_to_config
 from diffusers.models.attention_processor import Attention
 from diffusers.models.embeddings import TimestepEmbedding, Timesteps
 from diffusers.models.modeling_utils import ModelMixin
-from einops import rearrange, repeat
+from einops import rearrange
 from torch import nn
 from transformers.models.qwen2.modeling_qwen2 import Qwen2RMSNorm
 
-from .rope_real import RotaryPosEmbedReal
+from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata
+from vllm_omni.diffusion.attention.layer import Attention as OmniAttention
 
-try:
-    from transformers.modeling_flash_attention_utils import (  # type: ignore
-        flash_attn_varlen_func,  # pyright: ignore[reportAttributeAccessIssue]
-        is_flash_attn_available,
-    )
-except Exception:  # pragma: no cover - best-effort compatibility
-    flash_attn_varlen_func = None  # type: ignore[assignment]
-
-    def is_flash_attn_available() -> bool:  # type: ignore[override]
-        return False
-
-
-from .rope_real import apply_real_rotary_emb
-
-_HAS_FLASH_ATTN_VARLEN = bool(is_flash_attn_available()) and flash_attn_varlen_func is not None
+from .rope_real import RotaryPosEmbedReal, apply_real_rotary_emb
 
 
 class LuminaRMSNormZero(nn.Module):
@@ -278,9 +266,14 @@ class SimpleQFormerImageRefiner(nn.Module):
 
 
 class AttnProcessor:
-    def __init__(self) -> None:
-        if not hasattr(F, "scaled_dot_product_attention"):
-            raise ImportError("AttnProcessor requires PyTorch 2.0+ (F.scaled_dot_product_attention).")
+    """Self-attention for the MammothModa2 DiT through the shared Omni attention layer.
+
+    The model-specific parts stay here: the projections, the per-head QK RMSNorm
+    and the interleaved real RoPE. The kernel, the padding mask and the
+    grouped-query heads are the shared backend's job, so K/V are handed over
+    with their native head count instead of being replicated to the query
+    head count first.
+    """
 
     def __call__(
         self,
@@ -289,118 +282,55 @@ class AttnProcessor:
         encoder_hidden_states: torch.Tensor,
         attention_mask: torch.Tensor | None = None,
         image_rotary_emb: torch.Tensor | None = None,
-        base_sequence_length: int | None = None,
     ) -> torch.Tensor:
         batch_size, sequence_length, _ = hidden_states.shape
 
-        # Get Query-Key-Value Pair
         query = attn.to_q(hidden_states)
         key = attn.to_k(encoder_hidden_states)
         value = attn.to_v(encoder_hidden_states)
 
-        query_dim = query.shape[-1]
-        inner_dim = key.shape[-1]
-        head_dim = query_dim // attn.heads
+        head_dim = query.shape[-1] // attn.heads
+        kv_heads = key.shape[-1] // head_dim
         dtype = query.dtype
 
-        # Get key-value heads
-        kv_heads = inner_dim // head_dim
+        if sequence_length == 0 or key.shape[1] == 0:
+            # The pipeline's default unconditional branch is a text stream with
+            # zero tokens (negative_prompt_embeds has no rows), so under CFG the
+            # context refiner attends over an empty sequence. SDPA returns an
+            # empty tensor for that; the flash-attention varlen fallback builds
+            # cu_seqlens with arange(step=seq_len) and rejects step 0. Nothing
+            # to attend to either way, so hand the projection an empty input.
+            empty = query.new_zeros(batch_size, sequence_length, attn.heads * head_dim)
+            return attn.to_out[1](attn.to_out[0](empty))
 
-        # Reshape tensors for attention computation
         query = query.view(batch_size, -1, attn.heads, head_dim)
         key = key.view(batch_size, -1, kv_heads, head_dim)
         value = value.view(batch_size, -1, kv_heads, head_dim)
 
-        # Apply Query-Key normalization
         if attn.norm_q is not None:
             query = attn.norm_q(query)
         if attn.norm_k is not None:
             key = attn.norm_k(key)
 
-        # Apply Rotary Position Embeddings
         if image_rotary_emb is not None:
             query = apply_real_rotary_emb(query, image_rotary_emb[0], image_rotary_emb[1])
             key = apply_real_rotary_emb(key, image_rotary_emb[0], image_rotary_emb[1])
 
         query, key = query.to(dtype), key.to(dtype)
 
-        # Calculate attention scale
-        if base_sequence_length is not None:
-            softmax_scale = math.sqrt(math.log(sequence_length, base_sequence_length)) * attn.scale
-        else:
-            softmax_scale = attn.scale
-
-        if _HAS_FLASH_ATTN_VARLEN and attention_mask is not None and hidden_states.is_cuda:
-            # Flash-Attn varlen expects packed tokens + cu_seqlens. Here we only need
-            # the self-attention case (q/k/v share the same padding mask).
+        if attention_mask is not None:
             attention_mask = attention_mask.to(torch.bool)
-            seqlens = attention_mask.sum(dim=-1, dtype=torch.int32)
-            indices = torch.nonzero(attention_mask.flatten(), as_tuple=False).flatten()
-            max_seqlen = int(seqlens.max().item())
-            cu_seqlens = F.pad(torch.cumsum(seqlens, dim=0, dtype=torch.int32), (1, 0))
 
-            query_states = query.reshape(batch_size * sequence_length, attn.heads, head_dim)[indices]
-            key_states = key.reshape(batch_size * sequence_length, kv_heads, head_dim)[indices]
-            value_states = value.reshape(batch_size * sequence_length, kv_heads, head_dim)[indices]
+        attn_metadata = AttentionMetadata(attn_mask=attention_mask) if attention_mask is not None else None
+        hidden_states = attn.omni_attn(query, key, value, attn_metadata)
 
-            if kv_heads < attn.heads:
-                key_states = repeat(key_states, "l h c -> l (h k) c", k=attn.heads // kv_heads)
-                value_states = repeat(value_states, "l h c -> l (h k) c", k=attn.heads // kv_heads)
+        if attention_mask is not None:
+            # Padded rows carry nothing downstream; keep them at zero as the
+            # previous varlen path did, since neither backend does it for us.
+            hidden_states = hidden_states * attention_mask[:, :, None, None]
 
-            attn_output_unpad = flash_attn_varlen_func(
-                query_states,
-                key_states,
-                value_states,
-                cu_seqlens_q=cu_seqlens,
-                cu_seqlens_k=cu_seqlens,
-                max_seqlen_q=max_seqlen,
-                max_seqlen_k=max_seqlen,
-                dropout_p=0.0,
-                causal=False,
-                softmax_scale=softmax_scale,
-            )
+        hidden_states = hidden_states.reshape(batch_size, sequence_length, attn.heads * head_dim).type_as(query)
 
-            out = torch.zeros(
-                (batch_size * sequence_length, attn.heads, head_dim),
-                device=attn_output_unpad.device,
-                dtype=attn_output_unpad.dtype,
-            )
-            out[indices] = attn_output_unpad
-            hidden_states = out.view(batch_size, sequence_length, attn.heads, head_dim).flatten(-2)
-            hidden_states = hidden_states.type_as(query)
-        else:
-            # PyTorch SDPA path.
-            attn_mask = None
-            if attention_mask is not None:
-                attention_mask = attention_mask.to(torch.bool)
-                attn_mask = attention_mask.view(batch_size, 1, 1, -1)
-
-            query = query.transpose(1, 2)  # [B, H, S, D]
-            key = key.transpose(1, 2)  # [B, H_kv, S, D]
-            value = value.transpose(1, 2)
-
-            if kv_heads < attn.heads:
-                key = key.repeat_interleave(attn.heads // kv_heads, dim=1)
-                value = value.repeat_interleave(attn.heads // kv_heads, dim=1)
-
-            hidden_states = F.scaled_dot_product_attention(
-                query,
-                key,
-                value,
-                attn_mask=attn_mask,
-                dropout_p=0.0,
-                is_causal=False,
-                scale=softmax_scale,
-            )
-
-            if attention_mask is not None:
-                # Keep padding tokens consistent with the flash-varlen path (zero output).
-                hidden_states = hidden_states * attention_mask[:, None, :, None]
-
-            hidden_states = hidden_states.transpose(1, 2).reshape(batch_size, -1, attn.heads * head_dim)
-            hidden_states = hidden_states.type_as(query)
-
-        # Apply output projection
         hidden_states = attn.to_out[0](hidden_states)
         hidden_states = attn.to_out[1](hidden_states)
 
@@ -441,6 +371,18 @@ class TransformerBlock(nn.Module):
         # 显式使用 transformers 的 Qwen2RMSNorm，避免依赖 diffusers 内部创建的 `RMSNorm` 再做递归替换。
         self.attn.norm_q = Qwen2RMSNorm(self.head_dim, eps=1e-5)
         self.attn.norm_k = Qwen2RMSNorm(self.head_dim, eps=1e-5)
+        # The kernel itself runs through the shared Omni attention layer: backend
+        # selection, padding-mask handling and native grouped-query heads live
+        # there. It owns no parameters, so checkpoint keys are unchanged. The
+        # diffusers Attention above is kept for its projections and QK norms.
+        self.attn.omni_attn = OmniAttention(
+            num_heads=num_attention_heads,
+            head_size=self.head_dim,
+            causal=False,
+            softmax_scale=self.attn.scale,
+            num_kv_heads=num_kv_heads,
+            allow_fp32_fallback=True,
+        )
 
         # Initialize feed-forward network
         self.feed_forward = LuminaFeedForward(
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 5298d5514..21977f488 100644
--- a/vllm_omni/diffusion/models/mammoth_moda2/pipeline_mammothmoda2_dit.py
+++ b/vllm_omni/diffusion/models/mammoth_moda2/pipeline_mammothmoda2_dit.py
@@ -1,19 +1,25 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 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
@@ -23,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).
@@ -36,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(
@@ -46,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:
@@ -109,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:
@@ -123,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(
@@ -191,47 +325,28 @@ class MammothModa2DiTPipeline(nn.Module, SupportsComponentDiscovery):
         text_mask = questions_mask & ~(visual_token_mask | gen_token_mask)
         image_mask = answers_mask & gen_token_mask
 
-        text_cond = full_hidden_states[text_mask].to(dtype=torch.float32).contiguous()
-        image_cond = full_hidden_states[image_mask].to(dtype=torch.float32).contiguous()
+        # Keep the transferred representation compact until the final device/dtype
+        # conversion in ``forward``.  The masks are dtype-independent, and an
+        # unconditional host-side float32 expansion here would otherwise double both
+        # the selected-condition staging footprint and BF16 H2D traffic.
+        text_cond = full_hidden_states[text_mask].contiguous()
+        image_cond = full_hidden_states[image_mask].contiguous()
         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.
@@ -241,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()
 
@@ -295,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],
         )
@@ -370,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,
@@ -391,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/attention/__init__.py b/vllm_omni/diffusion/models/minimax_h3/attention/__init__.py
new file mode 100644
index 000000000..4244ce4b4
--- /dev/null
+++ b/vllm_omni/diffusion/models/minimax_h3/attention/__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/diffusion/models/minimax_h3/attention/fastvideo_h3.py b/vllm_omni/diffusion/models/minimax_h3/attention/fastvideo_h3.py
new file mode 100644
index 000000000..35b87a58b
--- /dev/null
+++ b/vllm_omni/diffusion/models/minimax_h3/attention/fastvideo_h3.py
@@ -0,0 +1,209 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""MiniMax-H3 VSA prefix routing, tile layout, and learned compression gate."""
+
+from __future__ import annotations
+
+import functools
+import math
+
+import torch
+from vllm.logger import init_logger
+
+from vllm_omni.diffusion.attention.backends.abstract import AttentionMetadata
+from vllm_omni.diffusion.attention.backends.fastvideo_vsa import (
+    FastVideoVSAImpl,
+    _construct_variable_block_sizes,
+    _get_gate_compress,
+    _get_non_pad_index,
+    _get_tile_partition_indices,
+)
+from vllm_omni.diffusion.attention.ops.block_sparse import (
+    build_prefix_dense_block_map,
+    fastvideo_block_sparse_attn_bshd,
+    mean_pool_tiles,
+)
+
+logger = init_logger(__name__)
+
+
+@functools.lru_cache(maxsize=32)
+def _get_h3_tile_metadata(
+    prefix_segments: tuple[int, ...],
+    video_shape: tuple[int, int, int],
+    device: torch.device,
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, int, int]:
+    """Official FastVideo H3 geometry: pure prefix chunks + 3-D video tiles."""
+    block_size = (4, 4, 4)
+    block_elements = 64
+    prefix_len = sum(prefix_segments)
+    prefix_sizes: list[int] = []
+    for segment in prefix_segments:
+        full, remainder = divmod(segment, block_elements)
+        prefix_sizes.extend([block_elements] * full)
+        if remainder:
+            prefix_sizes.append(remainder)
+
+    video_indices = _get_tile_partition_indices(video_shape, block_size, device) + prefix_len
+    video_sizes = _construct_variable_block_sizes(video_shape, block_size, device)
+    partition = torch.cat([torch.arange(prefix_len, device=device, dtype=torch.long), video_indices])
+    sizes = torch.cat([torch.tensor(prefix_sizes, device=device, dtype=torch.int32), video_sizes.to(torch.int32)])
+    non_pad = _get_non_pad_index(sizes, block_elements)
+    untile = non_pad[torch.argsort(partition)]
+    total = prefix_len + math.prod(video_shape)
+    if int(sizes.sum()) != total or untile.numel() != total:
+        raise ValueError(
+            f"invalid H3 VSA geometry: prefix={prefix_segments}, video={video_shape}, "
+            f"sizes_sum={int(sizes.sum())}, total={total}"
+        )
+    return partition, sizes, non_pad, untile, len(prefix_sizes), int(video_sizes.numel())
+
+
+def _get_h3_layout(
+    attn_metadata: AttentionMetadata | None,
+) -> tuple[tuple[int, ...], tuple[int, int, int], int] | None:
+    if attn_metadata is None or attn_metadata.video_layout is None:
+        return None
+    prefix = attn_metadata.extra.get("vsa_h3_prefix_segments")
+    if not isinstance(prefix, (tuple, list)):
+        return None
+    target = next(
+        (span for span in reversed(attn_metadata.video_layout.video_spans) if span.role == "target"),
+        None,
+    )
+    if target is None:
+        return None
+    return tuple(int(x) for x in prefix if int(x) > 0), target.latent_grid, target.start
+
+
+class MiniMaxH3VSAImpl(FastVideoVSAImpl):
+    """Apply H3 tile64 routing after shared parallel attention dispatch."""
+
+    def _forward_h3(
+        self,
+        query: torch.Tensor,
+        key: torch.Tensor,
+        value: torch.Tensor,
+        attn_metadata: AttentionMetadata,
+    ) -> torch.Tensor:
+        layout = _get_h3_layout(attn_metadata)
+        if layout is None:
+            raise ValueError("incomplete VSA-H3 layout metadata")
+        prefix_segments, video_shape, target_start = layout
+        if sum(prefix_segments) != target_start:
+            raise ValueError(f"VSA-H3 prefix segments sum to {sum(prefix_segments)}, target starts at {target_start}")
+        expected = target_start + math.prod(video_shape)
+        if query.shape[1] != expected:
+            raise ValueError(f"VSA-H3 layout has {expected} rows but attention received {query.shape[1]}")
+        if query.dtype not in (torch.float16, torch.bfloat16):
+            raise ValueError(f"VSA-H3 requires fp16/bf16 tensors, got {query.dtype}")
+        gate = _get_gate_compress(attn_metadata)
+        if gate is not None:
+            # H3 pads the packed document to 64 rows, while VSA operates on
+            # the valid prefix. Validate/slice before launching attention so a
+            # metadata error can never trigger an unsafe dense fallback after
+            # an asynchronous custom kernel.
+            if gate.shape[0] != query.shape[0] or gate.shape[2:] != query.shape[2:] or gate.shape[1] < query.shape[1]:
+                raise ValueError(f"gate_compress shape {gate.shape} cannot cover query shape {query.shape}")
+            gate = gate[:, : query.shape[1]]
+
+        partition, sizes, non_pad, untile, prefix_blocks, video_blocks = _get_h3_tile_metadata(
+            prefix_segments, video_shape, query.device
+        )
+        logical_blocks = int(sizes.numel())
+        # The native sm100a kernel assigns pairs of query blocks to CTAs. Its
+        # contract requires an even block count; the synthetic partner is
+        # transport-only and is removed before returning.
+        pair_pad = logical_blocks % 2
+        kernel_blocks = logical_blocks + pair_pad
+        target_shape = (query.shape[0], kernel_blocks * 64, query.shape[2], query.shape[3])
+        q_tiled = torch.zeros(target_shape, device=query.device, dtype=query.dtype)
+        k_tiled = torch.zeros_like(q_tiled)
+        v_tiled = torch.zeros_like(q_tiled)
+        q_tiled[:, non_pad] = query[:, partition]
+        k_tiled[:, non_pad] = key[:, partition]
+        v_tiled[:, non_pad] = value[:, partition]
+
+        q_pool = mean_pool_tiles(q_tiled[:, : logical_blocks * 64], sizes, block_size=64)
+        k_pool = mean_pool_tiles(k_tiled[:, : logical_blocks * 64], sizes, block_size=64)
+        scores = torch.matmul(q_pool, k_pool.transpose(-2, -1)) * self.softmax_scale
+        block_map = build_prefix_dense_block_map(scores, prefix_blocks, video_blocks, self.topk)
+        kernel_sizes = sizes
+        if pair_pad:
+            block_map = torch.nn.functional.pad(block_map, (0, 1, 0, 1), value=False)
+            kernel_sizes = torch.nn.functional.pad(sizes, (0, 1), value=0)
+
+        logger.info_once(
+            "FASTVIDEO_VSA H3 routing: seq_len=%d, prefix_segments=%s, video_shape=%s, "
+            "prefix_blocks=%d, video_blocks=%d, topk=%d, kernel_blocks=%d",
+            query.shape[1],
+            prefix_segments,
+            video_shape,
+            prefix_blocks,
+            video_blocks,
+            min(self.topk, video_blocks),
+            kernel_blocks,
+        )
+        output = fastvideo_block_sparse_attn_bshd(
+            q_tiled.contiguous(),
+            k_tiled.contiguous(),
+            v_tiled.contiguous(),
+            block_map.contiguous(),
+            kernel_sizes.contiguous(),
+            logical_blocks,
+        )[:, : logical_blocks * 64]
+
+        if gate is not None:
+            gate_tiled = torch.zeros_like(q_tiled[:, : logical_blocks * 64])
+            gate_tiled[:, non_pad] = gate[:, partition]
+            v_pool = mean_pool_tiles(v_tiled[:, : logical_blocks * 64], sizes, block_size=64)
+            compressed = torch.matmul(torch.softmax(scores, dim=-1), v_pool)
+            compressed = compressed.permute(0, 2, 1, 3).to(output.dtype)
+            output = (
+                output.view(output.shape[0], logical_blocks, 64, output.shape[2], output.shape[3])
+                + compressed.unsqueeze(2)
+                * gate_tiled.view(gate_tiled.shape[0], logical_blocks, 64, gate_tiled.shape[2], gate_tiled.shape[3])
+            ).view_as(output)
+        return output[:, untile].contiguous()
+
+    def forward_cuda(
+        self,
+        query: torch.Tensor,
+        key: torch.Tensor,
+        value: torch.Tensor,
+        attn_metadata: AttentionMetadata | None = None,
+    ) -> torch.Tensor:
+        if _get_h3_layout(attn_metadata) is None:
+            return super().forward_cuda(query, key, value, attn_metadata)
+
+        original_query, original_key, original_value = query, key, value
+        original_seq_len = query.shape[1]
+        valid_seq_len = original_seq_len
+        if attn_metadata is not None and attn_metadata.packed_padding is not None:
+            valid_seq_len = attn_metadata.packed_padding.q_length
+            if attn_metadata.packed_padding.kv_length != valid_seq_len:
+                return self._fallback(
+                    original_query, original_key, original_value, attn_metadata, "packed Q/KV lengths must match"
+                )
+            query = query[:, :valid_seq_len]
+            key = key[:, :valid_seq_len]
+            value = value[:, :valid_seq_len]
+
+        try:
+            output = self._forward_h3(query, key, value, attn_metadata)
+            if valid_seq_len == original_seq_len:
+                return output
+            restored = torch.zeros_like(original_query)
+            restored[:, :valid_seq_len] = output
+            return restored
+        except Exception as exc:
+            # A CUDA fault poisons the process context; attempting SDPA
+            # afterwards obscures the original kernel failure and cannot
+            # recover the request.
+            if isinstance(exc, torch.AcceleratorError):
+                raise
+            if not self.fallback_on_error:
+                raise
+            return self._fallback(
+                original_query, original_key, original_value, attn_metadata, f"VSA-H3 kernel failed: {exc}"
+            )
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 3abc90476..5662a9641 100644
--- a/vllm_omni/diffusion/models/minimax_h3/minimax_h3_transformer.py
+++ b/vllm_omni/diffusion/models/minimax_h3/minimax_h3_transformer.py
@@ -33,24 +33,30 @@ from vllm_omni.diffusion.attention.backends.abstract import (
     VideoTokenLayout,
 )
 from vllm_omni.diffusion.attention.layer import Attention
-from vllm_omni.diffusion.attention.ops.minimax_h3_modulation import (
-    indexed_gate,
-    indexed_gate_rms_norm_scale_shift,
-    indexed_scale_shift_,
-    rms_norm_indexed_scale_shift,
-)
 from vllm_omni.diffusion.cache.cachedit import CacheDiTAdapterConfig
 from vllm_omni.diffusion.distributed.sp_plan import (
     SequenceParallelInput,
     SequenceParallelOutput,
 )
+from vllm_omni.diffusion.forward_context import (
+    get_forward_context,
+    is_forward_context_available,
+)
 from vllm_omni.diffusion.layers.activation import SiluAndMul
 from vllm_omni.diffusion.layers.fused_qk_norm_rope import fused_qk_norm_rope
+from vllm_omni.diffusion.layers.indexed_modulation import (
+    indexed_gate,
+    indexed_gate_rms_norm_scale_shift,
+    indexed_scale_shift_,
+    rms_norm_indexed_scale_shift,
+)
 from vllm_omni.diffusion.layers.norm import RMSNorm
 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,
@@ -67,6 +73,15 @@ logger = init_logger(__name__)
 # packing, and ``_run_packed_attention`` re-checks it per forward; a name-only
 # gate would let FLASH_ATTN's NPU/XPU code paths through even though those
 # variants would silently attend across request boundaries.
+def _ring_sequence_parallel_is_active(attention_layer: Attention) -> bool:
+    """Match :meth:`Attention._get_active_parallel_strategy` for Ring."""
+    if not getattr(attention_layer, "use_ring", False) or getattr(attention_layer, "skip_sequence_parallel", False):
+        return False
+    if is_forward_context_available() and not get_forward_context().sp_active:
+        return False
+    return True
+
+
 def _attention_isolates_packed_requests(attention_layer: Any) -> bool:
     """True if this attention layer keeps N-document packed boundaries.
 
@@ -78,7 +93,7 @@ def _attention_isolates_packed_requests(attention_layer: Any) -> bool:
     backend = getattr(attention_layer, "attn_backend", None)
     if backend is None or not backend.supports_multi_doc_packed_varlen():
         return False
-    return not getattr(attention_layer, "use_ring", False)
+    return not _ring_sequence_parallel_is_active(attention_layer)
 
 
 @dataclass
@@ -105,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:
@@ -381,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,
@@ -429,6 +459,8 @@ class MiniMaxH3Attention(nn.Module):
         self._gate_hidden_size = arch.hidden_size
         self._gate_quant_config = quant_config
         self._gate_prefix = f"{prefix}.to_gate_compress"
+        from .attention.fastvideo_h3 import MiniMaxH3VSAImpl
+
         self.attention = Attention(
             num_heads=self.num_heads,
             num_kv_heads=self.num_kv_heads,
@@ -441,6 +473,7 @@ class MiniMaxH3Attention(nn.Module):
             role_category=role_category,
             skip_sequence_parallel=skip_sequence_parallel,
             prefix=prefix,
+            impl_overrides={"FASTVIDEO_VSA": MiniMaxH3VSAImpl},
         )
 
     def enable_vsa_gate(self) -> None:
@@ -508,6 +541,7 @@ class MiniMaxH3Attention(nn.Module):
             )
         attn_mask = None
         mask_free_packed_padding = False
+        use_ring = _ring_sequence_parallel_is_active(self.attention)
         if num_requests > 1:
             # A step-mode batch packs one document per request, so its valid
             # rows are block-diagonal rather than a prefix: neither a KV prefix
@@ -534,12 +568,15 @@ class MiniMaxH3Attention(nn.Module):
             # supports_packed_mask_free: backend consumes the packed metadata
             # without ever reading attn_mask (CUDA packed varlen, NPU
             # npu_attn_varlen opt-in with its own fallback rebuild).
-            use_ring = getattr(self.attention, "use_ring", False)
             mask_free_packed_padding = not use_ring and self.attention.attn_backend.supports_packed_mask_free()
             no_mask = not use_ring and (
                 self.attention.attn_backend.supports_prefix_kv_slicing or mask_free_packed_padding
             )
-            if used < packed_total and not no_mask:
+            # Hybrid Ulysses reshards Q to one ring partition before the ring
+            # kernel runs, so a global [packed_total] mask cannot pass its
+            # query-length check. Ring consumes valid_kv_length directly and
+            # trims the circulated K/V blocks instead.
+            if used < packed_total and not no_mask and not use_ring:
                 attn_mask = torch.arange(packed_total, device=q.device)[None] < used
         metadata = AttentionMetadata(
             attn_mask=attn_mask,
@@ -563,11 +600,12 @@ class MiniMaxH3Attention(nn.Module):
                 # quadratic full_qk mask is never materialized. Ring attention
                 # is excluded: it keeps the aligned padding rows for its
                 # fixed-size P2P buffers and still needs the mask.
-                "npu_attn_varlen": not getattr(self.attention, "use_ring", False),
+                "npu_attn_varlen": not use_ring,
                 # fp16-range protection for the ascend_laser_attention kernel
                 # (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 {}),
@@ -1107,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
@@ -1191,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
@@ -1203,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:
@@ -1273,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(
@@ -1299,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/ops/vae/qk_norm_rope.py b/vllm_omni/diffusion/models/minimax_h3/ops/vae/qk_norm_rope.py
index 40b7069f6..f964c1577 100644
--- a/vllm_omni/diffusion/models/minimax_h3/ops/vae/qk_norm_rope.py
+++ b/vllm_omni/diffusion/models/minimax_h3/ops/vae/qk_norm_rope.py
@@ -11,18 +11,26 @@ if HAS_TRITON:
 
     @triton.jit
     def _qk_rms_norm_rope_exact_kernel(
-        x_ptr,
+        q_ptr,
+        k_ptr,
         cos_ptr,
         sin_ptr,
-        output_ptr,
-        x_stride_token,
-        x_stride_head,
-        x_stride_dim,
+        q_output_ptr,
+        k_output_ptr,
+        q_stride_token,
+        q_stride_head,
+        q_stride_dim,
+        k_stride_token,
+        k_stride_head,
+        k_stride_dim,
         rope_stride_token,
         rope_stride_dim,
-        output_stride_token,
-        output_stride_head,
-        output_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,
         num_heads: tl.constexpr,
         head_dim: tl.constexpr,
         rotary_dim: tl.constexpr,
@@ -31,12 +39,15 @@ if HAS_TRITON:
     ):
         token = tl.program_id(0)
         head_group = tl.program_id(1)
+        qk_domain = tl.program_id(2)
         heads = head_group * heads_per_program + tl.arange(0, heads_per_program)
         dims = tl.arange(0, head_dim)
         mask = heads[:, None] < num_heads
 
-        offsets = token * x_stride_token + heads[:, None] * x_stride_head + dims[None, :] * x_stride_dim
-        x = tl.load(x_ptr + offsets, mask=mask, other=0.0).to(tl.float32)
+        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
+        x_ptrs = tl.where(qk_domain == 0, q_ptr + q_offsets, k_ptr + k_offsets)
+        x = tl.load(x_ptrs, mask=mask, other=0.0).to(tl.float32)
         inv_rms = tl.rsqrt(tl.sum(x * x, axis=1) / head_dim + eps)
         normalized = (x * inv_rms[:, None]).to(tl.float16)
 
@@ -46,8 +57,10 @@ if HAS_TRITON:
             dims + rotary_half,
             tl.where(dims < rotary_dim, dims - rotary_half, dims),
         )
-        pair_offsets = token * x_stride_token + heads[:, None] * x_stride_head + pair_dims[None, :] * x_stride_dim
-        pair_x = tl.load(x_ptr + pair_offsets, mask=mask, other=0.0).to(tl.float32)
+        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_x_ptrs = tl.where(qk_domain == 0, q_ptr + q_pair_offsets, k_ptr + k_pair_offsets)
+        pair_x = tl.load(pair_x_ptrs, mask=mask, other=0.0).to(tl.float32)
         pair_normalized = (pair_x * inv_rms[:, None]).to(tl.float16)
 
         rope_mask = dims < rotary_dim
@@ -79,10 +92,18 @@ if HAS_TRITON:
         )
         output = tl.where(rope_mask[None, :], rotated, normalized)
 
-        output_offsets = (
-            token * output_stride_token + heads[:, None] * output_stride_head + dims[None, :] * output_stride_dim
+        q_output_offsets = (
+            token * q_output_stride_token + heads[:, None] * q_output_stride_head + dims[None, :] * q_output_stride_dim
         )
-        tl.store(output_ptr + output_offsets, output, mask=mask)
+        k_output_offsets = (
+            token * k_output_stride_token + heads[:, None] * k_output_stride_head + dims[None, :] * k_output_stride_dim
+        )
+        output_ptrs = tl.where(
+            qk_domain == 0,
+            q_output_ptr + q_output_offsets,
+            k_output_ptr + k_output_offsets,
+        )
+        tl.store(output_ptrs, output, mask=mask)
 
 
 def _supported_inputs(
@@ -143,11 +164,11 @@ def try_qk_norm_rope_exact(
     sin = sin.reshape(tokens, sin.shape[-1])
     q_output = torch.empty_like(q)
     k_output = torch.empty_like(k)
-    # This launch layout is part of the exactness contract on the validated
-    # SM90 and SM103 targets: changing the warp-to-row mapping changes the
-    # FP32 RMS reduction order.
+    # The first two launch dimensions are part of the exactness contract on
+    # the validated SM90 and SM103 targets: changing the warp-to-row mapping
+    # changes the FP32 RMS reduction order.
     heads_per_program = 8
-    grid = (tokens, triton.cdiv(heads, heads_per_program))
+    grid = (tokens, triton.cdiv(heads, heads_per_program), 2)
     launch_args = {
         "num_heads": heads,
         "head_dim": head_dim,
@@ -158,29 +179,22 @@ def try_qk_norm_rope_exact(
     }
     _qk_rms_norm_rope_exact_kernel[grid](
         q,
-        cos,
-        sin,
-        q_output,
-        q.stride(0),
-        q.stride(1),
-        q.stride(2),
-        cos.stride(0),
-        cos.stride(1),
-        q_output.stride(0),
-        q_output.stride(1),
-        q_output.stride(2),
-        **launch_args,
-    )
-    _qk_rms_norm_rope_exact_kernel[grid](
         k,
         cos,
         sin,
+        q_output,
         k_output,
+        q.stride(0),
+        q.stride(1),
+        q.stride(2),
         k.stride(0),
         k.stride(1),
         k.stride(2),
         cos.stride(0),
         cos.stride(1),
+        q_output.stride(0),
+        q_output.stride(1),
+        q_output.stride(2),
         k_output.stride(0),
         k_output.stride(1),
         k_output.stride(2),
diff --git a/vllm_omni/diffusion/models/minimax_h3/packed_sequence.py b/vllm_omni/diffusion/models/minimax_h3/packed_sequence.py
index 0dcbd19b8..49ad496b4 100644
--- a/vllm_omni/diffusion/models/minimax_h3/packed_sequence.py
+++ b/vllm_omni/diffusion/models/minimax_h3/packed_sequence.py
@@ -1,4 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """MiniMax H3 packed-sequence materialization for FL2VA and Ref2VA tasks.
 
 Layout: [text L | imgvid_cond C | audio A(=t*2ch) | video_target V | pad P].
@@ -13,11 +14,14 @@ Builder rules:
 
 from __future__ import annotations
 
+import math
 from collections.abc import Mapping, Sequence
 
 import numpy as np
 import torch
 
+from vllm_omni.errors import OmniClientError
+
 MINIMAX_H3_FL2VA_KEYFRAME_SIGNATURES: tuple[tuple[int, ...], ...] = (
     (0,),
     (-1,),
@@ -38,13 +42,42 @@ _INTERP = 32
 _T_GROUP = 5
 _FRAME_PER_TOKEN = (1, 4, 4, 4, 4)
 _FRAME_RESCALE = 5.0 / 3.0
-_SEQ_ALIGN = 64
+MINIMAX_H3_SEQ_ALIGN = 64
+"""Row alignment of the packed sequence.
+
+An explicit ``seq_len`` must be a multiple of this, so that pinning a length
+lands on a bucket the default rounding could also produce.
+"""
+
+MINIMAX_H3_MAX_PAD_SEQ_LEN = 1 << 20
+"""Ceiling for a request-pinned packed length.
+
+Every packed row costs a fixed number of bytes across the structural tensors
+built below, so an unbounded request value would size those allocations. The
+largest shape this pipeline is documented against -- 672x384 at 209 frames --
+packs about 16k rows, so this ceiling leaves roughly two orders of magnitude of
+headroom while keeping the structural tensors in the tens of megabytes.
+"""
 # MiniMax H3 packs video latents with a fixed [1, 2, 2] (t, h, w) patch.
 _PATCH_T = 1
 _PATCH_H = 2
 _PATCH_W = 2
 
 
+def _resolve_padded_seq_len(used: int, seq_len: int | None) -> int:
+    """Resolve the padded row count for a packed sequence.
+
+    Without an explicit ``seq_len`` the used rows are rounded up to the next
+    :data:`MINIMAX_H3_SEQ_ALIGN` boundary. An explicit value is honored as-is
+    and must cover the used rows.
+    """
+    if seq_len is None:
+        return ((used + MINIMAX_H3_SEQ_ALIGN - 1) // MINIMAX_H3_SEQ_ALIGN) * MINIMAX_H3_SEQ_ALIGN
+    if seq_len < used:
+        raise OmniClientError(f"seq_len {seq_len} < used rows {used}")
+    return seq_len
+
+
 def _keyframe_cond_frame_indices(
     *,
     include_keyframe_cond: bool,
@@ -124,10 +157,15 @@ def minimax_h3_packed_sequence(
     include_keyframe_cond: bool,
     keyframe_frame_indices: list[int] | tuple[int, ...] | None = None,
     frame_count: int | None = None,
+    seq_len: int | None = None,
 ) -> dict[str, object]:
     """Build the packed-sequence structural fields for one CFG branch.
 
-    The used length is padded up to a multiple of 64.
+    The used length is padded up to a multiple of
+    :data:`MINIMAX_H3_SEQ_ALIGN`, or to an explicit ``seq_len`` that covers the
+    used rows -- the same contract
+    :func:`minimax_h3_packed_sequence_ref2va_blocks` already offers. Pinning
+    the length keeps requests of different prompt lengths on one packed shape.
     """
     ph, pw = latent_h // _PATCH_H, latent_w // _PATCH_W
     frame_rows = ph * pw
@@ -143,7 +181,7 @@ def minimax_h3_packed_sequence(
     video_rows = latent_t * frame_rows
     audio_rows = audio_t * audio_channel
     used = text_len + cond_rows + audio_rows + video_rows
-    seq_len = ((used + _SEQ_ALIGN - 1) // _SEQ_ALIGN) * _SEQ_ALIGN
+    seq_len = _resolve_padded_seq_len(used, seq_len)
 
     text_sl = slice(0, text_len)
     cond_sl = slice(text_len, text_len + cond_rows)
@@ -308,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.
 
@@ -316,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")
 
@@ -346,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
@@ -376,10 +430,7 @@ def minimax_h3_packed_sequence_ref2va_blocks(
     audio_rows = audio_t * audio_channel
     ref_rows = ref_visual_rows + ref_audio_rows
     used = text_len + ref_rows + audio_rows + video_rows
-    if seq_len is None:
-        seq_len = ((used + _SEQ_ALIGN - 1) // _SEQ_ALIGN) * _SEQ_ALIGN
-    if seq_len < used:
-        raise ValueError(f"seq_len {seq_len} < used rows {used}")
+    seq_len = _resolve_padded_seq_len(used, seq_len)
 
     text_sl = slice(0, text_len)
     cursor = text_len
@@ -413,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(
@@ -451,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":
@@ -533,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
@@ -557,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 ff1f8a3e5..8fc1514ef 100644
--- a/vllm_omni/diffusion/models/minimax_h3/pipeline_minimax_h3.py
+++ b/vllm_omni/diffusion/models/minimax_h3/pipeline_minimax_h3.py
@@ -7,9 +7,9 @@ from __future__ import annotations
 import json
 import math
 import os
-import tempfile
 from collections.abc import Iterable, Mapping, Sequence
 from contextlib import contextmanager, nullcontext
+from dataclasses import fields, replace
 from itertools import groupby
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, ClassVar
@@ -18,7 +18,6 @@ import numpy as np
 import torch
 import torch.distributed as dist
 import torch.nn as nn
-from PIL import Image
 from transformers import Qwen2TokenizerFast, Qwen3VLProcessor
 from vllm.logger import init_logger
 from vllm.model_executor.layers.quantization.base_config import QuantizationConfig
@@ -29,10 +28,7 @@ from vllm_omni.diffusion.cache.cachedit import (
     RequestScopedCacheDiTRuntime,
 )
 from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
-from vllm_omni.diffusion.distributed.parallel_state import (
-    get_world_group,
-    init_world_group,
-)
+from vllm_omni.diffusion.distributed.parallel_state import get_world_group, init_world_group
 from vllm_omni.diffusion.distributed.utils import get_local_device
 from vllm_omni.diffusion.forward_context import DenoiseProgressMixin
 from vllm_omni.diffusion.model_loader.diffusers_loader import (
@@ -64,45 +60,32 @@ from vllm_omni.diffusion.profiler.diffusion_pipeline_profiler import (
     DiffusionPipelineProfilerMixin,
 )
 from vllm_omni.diffusion.sched.sigma_schedule import DMD2SigmaSchedule
+from vllm_omni.diffusion.utils.media_utils import normalize_preencode_batch_frames, normalize_video_codec_options
 from vllm_omni.diffusion.worker.request_batch import DiffusionRequestBatch
 from vllm_omni.errors import OmniClientError, client_error_from_metadata
 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 (
+    MiniMaxH3EncoderConditioning,
+    MiniMaxH3EncoderMediaConditioning,
+    MiniMaxH3EncoderMediaInput,
     MiniMaxH3TextConditioning,
 )
-from vllm_omni.model_executor.models.minimax_h3.preprocessing import (
-    load_minimax_h3_images as _load_images,
-)
-from vllm_omni.model_executor.models.minimax_h3.preprocessing import (
-    minimax_h3_multi_image_presentation,
-    minimax_h3_ref2va_presentation,
-    minimax_h3_ref2va_video_presentation,
-    minimax_h3_text_only_ids,
-)
-from vllm_omni.model_executor.models.minimax_h3.preprocessing import (
-    resolve_minimax_h3_aspect_ratio as _resolve_minimax_h3_aspect_ratio,
-)
-from vllm_omni.model_executor.models.minimax_h3.preprocessing import (
-    resolve_minimax_h3_output_canvas as _resolve_output_canvas,
-)
-from vllm_omni.model_executor.models.minimax_h3.preprocessing import (
-    resolve_minimax_h3_reference_image_shape as _reference_image_shape,
+from vllm_omni.model_executor.models.minimax_h3.encoder_processing import (
+    PreparedEncoderInputs,
+    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,
     deserialize_prepared_reference_videos,
-    load_audio_file,
-    load_video_audio,
-    load_video_frames,
-    prepare_reference_videos,
-    sample_reference_video_frames,
-    validate_reference_audio_files,
-    validate_reference_audio_waveforms,
 )
 from vllm_omni.platforms import current_omni_platform
 from vllm_omni.quantization import (
@@ -117,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,
@@ -125,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,6 +127,8 @@ from .npu.lora import (
     load_minimax_h3_native_lora,
 )
 from .packed_sequence import (
+    MINIMAX_H3_MAX_PAD_SEQ_LEN,
+    MINIMAX_H3_SEQ_ALIGN,
     minimax_h3_packed_sequence,
     minimax_h3_packed_sequence_ref2va_blocks,
 )
@@ -151,12 +144,13 @@ from .scheduling_minimax_h3_euler_ancestral import (
 )
 from .time_request import (
     MINIMAX_H3_SHAPE_PLANNER,
-    minimax_h3_align_frame_count,
     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
 
@@ -172,22 +166,6 @@ MINIMAX_H3_FPS = 24
 MINIMAX_H3_AUDIO_SAMPLE_RATE = 32000
 MINIMAX_H3_IMGVID_COND_TIMESTEP = 0.999
 MINIMAX_H3_AUDIO_REF_COND_TIMESTEP = 1.0
-MINIMAX_H3_OUTPUT_SHORT_EDGE = 768
-MINIMAX_H3_OUTPUT_MAX_PIXELS = 768 * 1344
-MINIMAX_H3_REFERENCE_IMAGE_SHORT_EDGE = 2048
-MINIMAX_H3_REFERENCE_IMAGE_MULTIPLE = 32
-MINIMAX_H3_SUPPORTED_ASPECT_RATIOS = {
-    "21:9": 21.0 / 9.0,
-    "16:9": 16.0 / 9.0,
-    "4:3": 4.0 / 3.0,
-    "1:1": 1.0,
-    "3:4": 3.0 / 4.0,
-    "9:16": 9.0 / 16.0,
-}
-MINIMAX_H3_MAX_REFERENCE_IMAGE_BYTES = 30 * 1024 * 1024
-MINIMAX_H3_REFERENCE_IMAGE_FORMATS = frozenset({"jpeg", "png", "webp", "heic", "heif"})
-MINIMAX_H3_MIN_OUTPUT_SECONDS = 4.0
-MINIMAX_H3_MAX_OUTPUT_SECONDS = 15.0
 MINIMAX_H3_DOWNLOAD_PATTERNS = [
     "FL2VA/**",
     "Ref2VA/model_index.json",
@@ -247,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]
         )
@@ -264,7 +246,6 @@ def _resolve_minimax_h3_model_root(
     )
 
 
-# Keys of ``_prepare_request_inputs`` that feed ``diffuse`` / ``_build_denoise_inputs``.
 _MINIMAX_H3_DENOISE_INPUT_KEYS = (
     "task",
     "text_embeddings",
@@ -287,6 +268,14 @@ _MINIMAX_H3_DENOISE_INPUT_KEYS = (
     "visual_condition_shapes",
     "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.
@@ -299,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]:
@@ -348,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"
@@ -367,6 +360,19 @@ def _minimax_h3_post_process(output, output_type: str = "np"):
     if not isinstance(output, tuple) or len(output) != 2:
         return output
     video, audio = output
+    if isinstance(video, (bytes, bytearray, memoryview)):
+        video = [video]
+    if isinstance(video, list) and all(isinstance(item, (bytes, bytearray, memoryview)) for item in video):
+        encoded_videos = [bytes(item) for item in video]
+    else:
+        encoded_videos = None
+    if encoded_videos is not None:
+        return {
+            "video": encoded_videos,
+            "audio": [None] * len(encoded_videos),
+            "audio_sample_rate": MINIMAX_H3_AUDIO_SAMPLE_RATE,
+            "fps": MINIMAX_H3_FPS,
+        }
     if video.dtype != torch.uint8 or video.ndim != 5 or video.shape[-1] not in (3, 4):
         # Float or channel-first frames would reach the muxer as a black or
         # banded video rather than as an error.
@@ -389,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:
@@ -410,112 +424,25 @@ def get_minimax_h3_post_process_func(
     return _minimax_h3_post_process
 
 
-def _align_multiple(value: float, multiple: int = 32) -> int:
-    return max(multiple, int(round(float(value) / multiple)) * multiple)
-
-
-def _load_image(value: Any) -> Image.Image:
-    images = _load_images(value)
-    if len(images) != 1:
-        raise OmniClientError(f"MiniMax H3 expected one image, got {len(images)}")
-    return images[0]
-
-
-def _load_audio(value: Any) -> tuple[torch.Tensor, int]:
-    if isinstance(value, (list, tuple)) and not (len(value) == 2 and isinstance(value[1], (int, np.integer))):
-        audios = _load_audios(value)
-        if len(audios) != 1:
-            raise OmniClientError(f"MiniMax H3 expected one audio, got {len(audios)}")
-        return audios[0]
-    if isinstance(value, (str, os.PathLike)):
-        return load_audio_file(str(value))
-    if isinstance(value, (list, tuple)) and len(value) == 2:
-        waveform, sample_rate = value
-        waveform = torch.as_tensor(waveform).float()
-        return waveform, int(sample_rate)
-    if isinstance(value, dict):
-        waveform = value.get("waveform", value.get("array"))
-        sample_rate = value.get("sample_rate", value.get("sampling_rate"))
-        if waveform is not None and sample_rate is not None:
-            return torch.as_tensor(waveform).float(), int(sample_rate)
-    raise OmniClientError("MiniMax H3 audio input must be a path, (waveform, sample_rate), or a waveform mapping")
-
-
-def _load_audios(value: Any) -> list[tuple[torch.Tensor, int]]:
-    if isinstance(value, (list, tuple)) and not (len(value) == 2 and isinstance(value[1], (int, np.integer))):
-        if not value:
-            raise OmniClientError("MiniMax H3 audio input must not be empty")
-        return [_load_audio(item) for item in value]
-    return [_load_audio(value)]
-
-
-def _as_int_list(value: Any, *, name: str) -> list[int]:
-    if isinstance(value, bool):
-        raise OmniClientError(f"{name} must be an integer or a list of integers")
-    if isinstance(value, (int, np.integer)):
-        return [int(value)]
-    if isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
-        result = list(value)
-        if not result:
-            raise OmniClientError(f"{name} must not be empty")
-        if any(isinstance(item, bool) or not isinstance(item, (int, np.integer)) for item in result):
-            raise OmniClientError(f"{name} must contain only integers")
-        return [int(item) for item in result]
-    raise OmniClientError(f"{name} must be an integer or a list of integers")
-
-
-def _resolve_fl2va_keyframe_indices(extra: Mapping[str, Any], image_count: int) -> list[int]:
-    target = extra.get("target")
-    target = target if isinstance(target, Mapping) else {}
-    raw = extra.get("frame_indices", extra.get("frame_index"))
-    if raw is None:
-        raw = target.get("frame_indices", target.get("frame_index"))
-    if raw is None:
-        raw_indices = [0] if image_count == 1 else [0, -1]
-    else:
-        raw_indices = _as_int_list(raw, name="frame_indices")
-    if len(raw_indices) != image_count:
-        raise OmniClientError(
-            f"MiniMax H3 FL2VA requires one frame index per image: got {raw_indices!r} for {image_count} image(s)"
-        )
-    if tuple(raw_indices) not in ((0,), (-1,), (0, -1)):
-        raise OmniClientError("MiniMax H3 FL2VA frame_indices must be [0], [-1], or [0, -1]")
-    return raw_indices
-
-
-def _reuse_prepared_reference_videos(
-    prepared: list[dict[str, Any]] | None,
+def _expose_padded_audio_tail(
+    source_audio_t: int,
     *,
-    expected_count: int,
-) -> list[dict[str, Any]] | None:
-    if prepared is None:
-        return None
-    if len(prepared) != expected_count:
-        raise OmniClientError("MiniMax H3 prepared-reference-video count does not match the request")
-    for item in prepared:
-        if not os.path.isfile(item["prepared_path"]):
-            raise OmniClientError(f"MiniMax H3 prepared reference video is unavailable: {item['prepared_path']}")
-    return prepared
-
-
-def _validate_ref2va_reference_counts(
-    image_count: int,
-    video_count: int,
-    audio_count: int,
-) -> None:
-    """Validate the official Ref2VA reference-count contract."""
-    if image_count < 0 or video_count < 0 or audio_count < 0:
-        raise OmniClientError("MiniMax H3 reference counts must be non-negative")
-    if image_count + video_count == 0:
-        raise OmniClientError("ref2va requires at least one image or video reference")
-    if image_count > 9:
-        raise OmniClientError("ref2va accepts at most 9 image references")
-    if video_count > 3:
-        raise OmniClientError("ref2va accepts at most 3 video references")
-    if audio_count > 3:
-        raise OmniClientError("ref2va accepts at most 3 standalone audio references")
-    if image_count + video_count + audio_count > 12:
-        raise OmniClientError("ref2va accepts at most 12 total references")
+    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:
@@ -529,21 +456,32 @@ def _resolve_minimax_h3_num_outputs(value: Any) -> int:
     return value
 
 
+def _resolve_pad_seq_len(value: object) -> int | None:
+    """Validate the optional packed-length pin from ``extra_args``.
+
+    The packer itself only needs a value that covers the used rows. A request
+    field needs two more guards: an unaligned value would silently open yet
+    another compiled shape, and an unbounded one would size every structural
+    tensor the packer allocates.
+    """
+    if value is None:
+        return None
+    if isinstance(value, bool) or not isinstance(value, (int, np.integer)):
+        raise OmniClientError("MiniMax H3 pad_seq_len must be an integer")
+    pinned = int(value)
+    if pinned <= 0:
+        raise OmniClientError(f"MiniMax H3 pad_seq_len must be positive, got {pinned}")
+    if pinned % MINIMAX_H3_SEQ_ALIGN:
+        raise OmniClientError(f"MiniMax H3 pad_seq_len must be a multiple of {MINIMAX_H3_SEQ_ALIGN}, got {pinned}")
+    if pinned > MINIMAX_H3_MAX_PAD_SEQ_LEN:
+        raise OmniClientError(f"MiniMax H3 pad_seq_len must be at most {MINIMAX_H3_MAX_PAD_SEQ_LEN}, got {pinned}")
+    return pinned
+
+
 def _minimax_h3_output_seeds(seed: int, num_outputs: int) -> list[int]:
     return [int(seed) + output_index for output_index in range(int(num_outputs))]
 
 
-def _validate_reference_image(image: Image.Image) -> None:
-    width, height = image.size
-    if min(width, height) < 256 or max(width, height) > 5760:
-        raise OmniClientError(
-            f"MiniMax H3 reference image dimensions must be in [256, 5760] pixels, got {width}x{height}"
-        )
-    ratio = width / height
-    if not 0.4 <= ratio <= 2.5:
-        raise OmniClientError(f"MiniMax H3 reference image aspect ratio must be in [0.4, 2.5], got {width}x{height}")
-
-
 def _dit_rank_world() -> tuple[Any, int, int]:
     if not dist.is_initialized():
         return None, 0, 1
@@ -677,10 +615,8 @@ class MiniMaxH3Pipeline(
         on_demand_component_paths=frozenset({"text_encoder", "video_vae", "audio_vae"}),
     )
     _PROFILER_TARGETS: ClassVar[list[str]] = [
-        "_prepare_reference_videos",
         "encode_prompt",
-        "_encode_visual_conditions",
-        "_encode_reference_audio_conditions",
+        "_encode_local_media",
         "diffuse",
         "decode",
         "video_vae.decode_latent",
@@ -695,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,
@@ -770,6 +707,18 @@ class MiniMaxH3Pipeline(
                 f"bound={len(bound_lora_names)}/{len(lora_model.loras)}, missing={missing[:5]}"
             )
 
+    def _active_turbo_spec(self, sampling: Any) -> TurboSpec | None:
+        """Return the spec of the Turbo adapter this request actually applies.
+
+        A recognized adapter at scale 0 contributes nothing, so it neither
+        constrains the task nor imposes its sampler contract.
+        """
+
+        lora_request = sampling.lora_request
+        if lora_request is None or math.isclose(0.0, float(sampling.lora_scale)):
+            return None
+        return self._turbo_lora_specs.get(lora_request.lora_int_id)
+
     def _has_active_native_lora(self, sampling: Any) -> bool:
         lora_request = sampling.lora_request
         return (
@@ -829,18 +778,6 @@ class MiniMaxH3Pipeline(
             return adapter_schedule
         return self._base_schedule_for_task(task)
 
-    def _active_turbo_spec(self, sampling: Any) -> TurboSpec | None:
-        """Return the spec of the Turbo adapter this request actually applies.
-
-        A recognized adapter at scale 0 contributes nothing, so it neither
-        constrains the task nor imposes its sampler contract.
-        """
-
-        lora_request = sampling.lora_request
-        if lora_request is None or math.isclose(0.0, float(sampling.lora_scale)):
-            return None
-        return self._turbo_lora_specs.get(lora_request.lora_int_id)
-
     def _validate_turbo_sampling(self, sampling: Any, spec: TurboSpec) -> None:
         """Hold a request to the contract of the artifact that is loaded.
 
@@ -896,11 +833,37 @@ class MiniMaxH3Pipeline(
         if int(self.parallel_config.cfg_parallel_size) != 1:
             raise ValueError("MiniMax-H3 is CFG-distilled and has no negative branch; cfg_parallel_size must be 1")
         self.device = get_local_device()
-        self.load_text_encoder = od_config.model_loaded["text_encoder"]
+        self.load_text_encoder = od_config.model_loaded.get("text_encoder", True)
+        self.load_vae_encoder = od_config.model_loaded.get("vae_encoder", True)
+        if self.load_vae_encoder is False and self.load_text_encoder is True:
+            raise ValueError(
+                "MiniMax H3 does not support local text encoding with external media conditioning; "
+                "set text_encoder=false or enable vae_encoder"
+            )
+        self._encoder_modules = ["text_encoder"] if self.load_text_encoder else []
+        self._PROFILER_TARGETS = list(type(self)._PROFILER_TARGETS)
+        encoder_block_attrs = dict(self._offload_plan.encoder_block_attrs)
+        if not self.load_text_encoder:
+            encoder_block_attrs.pop("text_encoder", None)
+        on_demand_component_paths = set(self._offload_plan.on_demand_component_paths)
+        if not self.load_text_encoder:
+            on_demand_component_paths.discard("text_encoder")
+        self._offload_plan = replace(
+            self._offload_plan,
+            encoder_block_attrs=encoder_block_attrs,
+            on_demand_component_paths=frozenset(on_demand_component_paths),
+        )
+        if not self.load_text_encoder:
+            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] = {}
@@ -910,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:
@@ -973,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)
@@ -1060,14 +1040,18 @@ 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,
+            trust_remote_code=od_config.trust_remote_code,
         )
         # Registry-side VAE patch-parallel discovery uses ``pipeline.vae``.
         self.vae = self.video_vae
@@ -1113,6 +1097,8 @@ class MiniMaxH3Pipeline(
                 raise ValueError(f"MiniMax-H3 weight source {prefix!r} is not contiguous")
             loaded_prefixes.add(prefix)
             component = getattr(self, prefix.removesuffix("."))
+            if component is None:
+                raise ValueError(f"MiniMax-H3 component {prefix.removesuffix('.')!r} is disabled in this deployment")
             stream = ((name[len(prefix) :], tensor) for name, tensor in grouped_weights)
             if prefix == "transformer." and self._fasth3 is not None:
                 # Fuse before the model shards anything, which is also the only
@@ -1137,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
@@ -1186,17 +1178,21 @@ class MiniMaxH3Pipeline(
     def _resolve_task(
         self,
         requested: str | None,
-        multi_modal_data: dict[str, Any],
+        multi_modal_data: dict[str, Any] | None = None,
         *,
+        audio_mode: str = "native",
         turbo_spec: TurboSpec | None = None,
         has_native_lora: bool = False,
     ) -> str:
+        multi_modal_data = multi_modal_data or {}
         if requested is None:
             # A Ref2VA-only startup has no FL2VA transformer; preserve its
             # 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"
@@ -1218,217 +1214,6 @@ class MiniMaxH3Pipeline(
             self._fasth3.check_task(task)
         return task
 
-    def _resolve_shape(
-        self,
-        task: str,
-        sampling: Any,
-        image: Image.Image | None,
-    ) -> tuple[int, int, int, int, int]:
-        fps = int(sampling.fps or MINIMAX_H3_FPS)
-        if fps != MINIMAX_H3_FPS:
-            raise OmniClientError(f"MiniMax H3 output fps is fixed at {MINIMAX_H3_FPS}")
-        extra = sampling.extra_args or {}
-        target = extra.get("target")
-        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 {}
-        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}")
-            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}")
-            requested_frames = int(round(duration * fps))
-        elif int(sampling.num_frames or 1) > 1:
-            requested_frames = int(sampling.num_frames)
-        else:
-            requested_frames = 124 if task == "ref2va" else 209
-            duration = requested_frames / fps
-        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}"
-            )
-        num_frames = minimax_h3_align_frame_count(requested_frames)
-
-        height = sampling.height
-        width = sampling.width
-        aspect_ratio = target.get("aspect_ratio", extra.get("aspect_ratio"))
-        raw_short_edge = target.get("short_edge", extra.get("short_edge", MINIMAX_H3_OUTPUT_SHORT_EDGE))
-        if isinstance(raw_short_edge, bool) or not isinstance(raw_short_edge, (int, np.integer)):
-            raise OmniClientError(
-                f"MiniMax H3 target.short_edge must be {MINIMAX_H3_OUTPUT_SHORT_EDGE}, got {raw_short_edge!r}"
-            )
-        short_edge = int(raw_short_edge)
-
-        aspect_ratio = _resolve_minimax_h3_aspect_ratio(
-            task,
-            aspect_ratio,
-            image,
-        )
-        if not 0.25 <= aspect_ratio <= 4.0:
-            raise OmniClientError(f"MiniMax H3 canvas aspect ratio must be in [1:4, 4:1], got {aspect_ratio}")
-
-        if height is None or width is None:
-            height, width = _resolve_output_canvas(aspect_ratio, short_edge)
-        height = int(height) // 32 * 32
-        width = int(width) // 32 * 32
-        if min(height, width) <= 0:
-            raise OmniClientError(f"invalid MiniMax H3 canvas {width}x{height}")
-        if width > 4 * height or height > 4 * width:
-            raise OmniClientError("MiniMax H3 canvas aspect ratio must be in [1:4, 4:1]")
-
-        latent_t = MINIMAX_H3_SHAPE_PLANNER.video_latent_t(num_frames)
-        audio_t = MINIMAX_H3_SHAPE_PLANNER.audio_latent_t(num_frames / fps)
-        return height, width, num_frames, latent_t, audio_t
-
-    def encode_prompt(
-        self,
-        *,
-        task: str,
-        prompt: str,
-        image: Image.Image | None = None,
-        images: list[Image.Image] | None = None,
-        prepared_videos: list[dict[str, Any]] | None = None,
-        condition_labels: list[tuple[str, int]] | None = None,
-    ) -> tuple[torch.Tensor, torch.Tensor]:
-        _, rank, _ = _dit_rank_world()
-        hidden = None
-        tags = None
-        ids = None
-        vision_kwargs: dict[str, torch.Tensor] = {}
-        images = list(images) if images is not None else ([image] if image is not None else [])
-        if rank == 0:
-            if task == "t2va":
-                ids = minimax_h3_text_only_ids(self.tokenizer, prompt)
-                tags = torch.ones(ids.shape[0], dtype=torch.long)
-                vision_kwargs = {}
-            else:
-                image_token_counts: list[int] = []
-                if images:
-                    vision = self.processor.image_processor(
-                        images=images,
-                        return_tensors="pt",
-                    )
-                    image_grid = vision["image_grid_thw"]
-                    merge = int(self.processor.image_processor.merge_size) ** 2
-                    image_token_counts = [int(grid.prod().item()) // merge for grid in image_grid]
-                    vision_kwargs.update(
-                        {
-                            "pixel_values": vision["pixel_values"],
-                            "image_grid_thw": image_grid,
-                        }
-                    )
-
-                video_block_counts: list[list[int]] = []
-                video_block_timestamps: list[list[float]] = []
-                if prepared_videos:
-                    videos = []
-                    sampled_videos = []
-                    for index, item in enumerate(prepared_videos):
-                        sampled = sample_reference_video_frames(item["prepared_path"])
-                        videos.append(np.stack(sampled["frames"]))
-                        sampled_videos.append(sampled)
-                    vision = self.processor.video_processor(
-                        videos=videos,
-                        do_sample_frames=False,
-                        return_tensors="pt",
-                    )
-                    video_grid = vision["video_grid_thw"]
-                    merge = int(self.processor.image_processor.merge_size) ** 2
-                    for index, sampled in enumerate(sampled_videos):
-                        blocks = int(video_grid[index, 0])
-                        per_block = int(video_grid[index, 1]) * int(video_grid[index, 2]) // merge
-                        timestamps = sampled["block_timestamps"]
-                        if len(timestamps) != blocks:
-                            raise ValueError(
-                                f"video block count mismatch: processor={blocks}, timestamps={len(timestamps)}"
-                            )
-                        video_block_counts.append([per_block] * blocks)
-                        video_block_timestamps.append(timestamps)
-                    vision_kwargs.update(
-                        {
-                            "pixel_values_videos": vision["pixel_values_videos"],
-                            "video_grid_thw": video_grid,
-                        }
-                    )
-
-                if not images and not prepared_videos:
-                    raise OmniClientError(f"{task} requires an image or video condition")
-                if condition_labels is None:
-                    condition_labels = []
-                    for image_index in range(1, len(images) + 1):
-                        condition_labels.append(("image", image_index))
-                    audio_index = 0
-                    for video_index, item in enumerate(prepared_videos or (), start=1):
-                        if item["input_has_audio"]:
-                            audio_index += 1
-                            condition_labels.append(("audio", audio_index))
-                        condition_labels.append(("video", video_index))
-
-                if task == "fl2va":
-                    if prepared_videos:
-                        raise OmniClientError("fl2va does not accept video conditions")
-                    ids, tags = minimax_h3_multi_image_presentation(
-                        self.tokenizer,
-                        prompt=prompt,
-                        image_token_counts=image_token_counts,
-                    )
-                elif prepared_videos:
-                    ids, tags = minimax_h3_ref2va_video_presentation(
-                        self.tokenizer,
-                        prompt=prompt,
-                        condition_labels=condition_labels,
-                        image_token_count=image_token_counts or None,
-                        video_block_token_counts=video_block_counts,
-                        video_block_timestamps=video_block_timestamps,
-                    )
-                else:
-                    ids, tags = minimax_h3_ref2va_presentation(
-                        self.tokenizer,
-                        prompt=prompt,
-                        condition_labels=condition_labels,
-                        image_token_count=image_token_counts or None,
-                    )
-
-            logger.info(
-                "MiniMax H3 %s Qwen presentation: %d tokens%s",
-                task,
-                int(ids.shape[0]),
-                (
-                    f", {len(images)} reference images"
-                    + (f", {len(prepared_videos)} reference videos" if prepared_videos else "")
-                    if images
-                    else (f", {len(prepared_videos)} reference videos" if prepared_videos else "")
-                ),
-            )
-
-        if rank < self.text_encoder_tp_size:
-            # Distribute the encode inputs from the DiT main rank to the other
-            # encoder TP ranks, then run the distributed encode on all of them.
-            ids = self._distribute_encode_inputs(ids, vision_kwargs)
-            hidden = self._encode_text_hidden(ids, vision_kwargs)
-
-        hidden = _broadcast_tensor(
-            hidden,
-            dtype=torch.bfloat16,
-            device=self.device,
-        )
-        tags = _broadcast_tensor(
-            tags,
-            dtype=torch.long,
-            device=self.device,
-        )
-        return hidden, tags
-
     def _build_text_encoder_group(self, text_encoder_tp_size: int) -> Any:
         """Create the encoder tensor-parallel process group.
 
@@ -1524,24 +1309,6 @@ class MiniMaxH3Pipeline(
             )
         return ids
 
-    def _prepare_reference_videos(
-        self,
-        values: Any,
-        *,
-        target_frame_count: int,
-        workdir: str,
-        start_time_seconds: Any = None,
-    ) -> list[dict[str, Any]] | None:
-        _, rank, _ = _dit_rank_world()
-        if rank != 0:
-            return None
-        return prepare_reference_videos(
-            values,
-            target_frame_count=target_frame_count,
-            workdir=workdir,
-            start_time_seconds=start_time_seconds,
-        )
-
     def _encode_text_hidden(
         self,
         input_ids: torch.Tensor,
@@ -1626,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
@@ -1660,6 +1436,11 @@ class MiniMaxH3Pipeline(
                             logger.exception("Failed to release retained allocator cache after offload failure")
                     raise
 
+    @staticmethod
+    def _is_output_owner_rank() -> bool:
+        """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],
@@ -1672,8 +1453,12 @@ class MiniMaxH3Pipeline(
         _, 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) if needs_video_vae else nullcontext()
+        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
@@ -1694,162 +1479,31 @@ class MiniMaxH3Pipeline(
                 )
                 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 _encode_audio_conditions_resident(
-        self,
-        audios: list[tuple[torch.Tensor, int]],
-        *,
-        max_duration_seconds: float | None = None,
-    ) -> tuple[torch.Tensor | None, list[int]]:
-        if not audios:
-            return None, []
-        if max_duration_seconds is not None:
-            max_duration_seconds = float(max_duration_seconds)
-            if max_duration_seconds <= 0:
-                raise ValueError("max_duration_seconds must be positive")
-        _, rank, _ = _dit_rank_world()
-        rows = None
-        lengths = torch.zeros(len(audios), dtype=torch.long, device=self.device)
-        if rank == 0:
-            bounded_audios = []
-            for waveform, sample_rate in audios:
-                if max_duration_seconds is not None:
-                    max_samples = int(round(max_duration_seconds * int(sample_rate)))
-                    waveform = waveform[..., :max_samples]
-                bounded_audios.append((waveform, sample_rate))
-            encoded = [self.audio_vae.encode_waveform(*audio) for audio in bounded_audios]
-            rows = torch.cat([item[0] for item in encoded])
-            lengths = torch.tensor(
-                [int(item[1]) for item in encoded],
-                dtype=torch.long,
-                device=self.device,
-            )
-        group, _, world_size = _dit_rank_world()
-        if world_size > 1:
-            dist.broadcast(lengths, src=0, group=group)
-        return (
-            _broadcast_tensor(rows, dtype=torch.float32, device=self.device),
-            [int(value) for value in lengths.tolist()],
-        )
+    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.
 
-    def _encode_video_conditions_resident(
-        self,
-        prepared_videos: list[dict[str, Any]] | None,
-        *,
-        count: int,
-    ) -> tuple[torch.Tensor, list[tuple[int, int, int]]]:
-        group, rank, world_size = _dit_rank_world()
-        distributed_encode = self.video_vae.is_distributed_enabled()
-        if distributed_encode:
-            # Native tiled encode uses collectives, so every VPP rank must
-            # enter each reference encode in the same input order.
-            prepared_videos_list = [prepared_videos]
-            dist.broadcast_object_list(
-                prepared_videos_list,
-                src=0,
-                group=group,
-                device=self.device,
-            )
-            prepared_videos = prepared_videos_list[0]
+        Model-level CPU offload makes the VAE hook evict the DiT before decode.
+        For a multi-output request, however, the next seed reloads the DiT while
+        the preceding decoded output would otherwise still occupy the device.
+        The reply rank performs the D2H copy early; ranks whose outputs are not
+        consumed retain only a metadata placeholder for the final concatenation.
 
-        rows = None
-        shapes = torch.zeros((count, 3), dtype=torch.long, device=self.device)
-        if rank == 0 or distributed_encode:
-            if prepared_videos is None or len(prepared_videos) != count:
-                raise ValueError("reference-video preparation is incomplete")
-            encoded = [
-                self.video_vae.encode_video(load_video_frames(item["prepared_path"])) for item in prepared_videos
-            ]
-            rows = torch.cat([item[0] for item in encoded])
-            shapes = torch.tensor(
-                [item[1] for item in encoded],
-                dtype=torch.long,
-                device=self.device,
-            )
-        if distributed_encode:
-            return (
-                rows.to(device=self.device, dtype=torch.float32),
-                [tuple(int(value) for value in item) for item in shapes.tolist()],
-            )
-
-        if world_size > 1:
-            dist.broadcast(shapes, src=0, group=group)
-        return (
-            _broadcast_tensor(rows, dtype=torch.float32, device=self.device),
-            [tuple(int(value) for value in item) for item in shapes.tolist()],
-        )
-
-    def _encode_video_audio_conditions_resident(
-        self,
-        prepared_videos: list[dict[str, Any]] | None,
-        *,
-        has_audio: list[bool],
-    ) -> tuple[torch.Tensor | None, list[int]]:
-        _, rank, _ = _dit_rank_world()
-        count = sum(has_audio)
-        if count == 0:
-            return None, []
-        rows = None
-        lengths = torch.zeros(count, dtype=torch.long, device=self.device)
-        if rank == 0:
-            if prepared_videos is None:
-                raise ValueError("rank 0 reference-video preparation is incomplete")
-            encoded = [
-                self.audio_vae.encode_waveform(
-                    *load_video_audio(
-                        item["original_path"],
-                        start_time_seconds=float(item.get("start_time_seconds", 0.0)),
-                        duration_seconds=item.get(
-                            "audio_duration_seconds",
-                            item.get("duration_seconds"),
-                        ),
-                    )
-                )
-                for item in prepared_videos
-                if item["input_has_audio"]
-            ]
-            rows = torch.cat([item[0] for item in encoded])
-            lengths = torch.tensor(
-                [item[1] for item in encoded],
-                dtype=torch.long,
-                device=self.device,
-            )
-        group, _, world_size = _dit_rank_world()
-        if world_size > 1:
-            dist.broadcast(lengths, src=0, group=group)
-        return (
-            _broadcast_tensor(rows, dtype=torch.float32, device=self.device),
-            [int(value) for value in lengths.tolist()],
-        )
-
-    def _encode_reference_audio_conditions(
-        self,
-        prepared_videos: list[dict[str, Any]] | None,
-        *,
-        has_audio: list[bool],
-        standalone_audios: list[tuple[torch.Tensor, int]],
-        max_duration_seconds: float,
-    ) -> tuple[torch.Tensor | None, list[int], torch.Tensor | None, list[int]]:
-        # Embedded and standalone audio are consecutive direct Audio-VAE
-        # calls. Keep the component resident across both paths.
-        needs_audio_vae = any(has_audio) or bool(standalone_audios)
-        audio_vae_context = self._component_on_device(self.audio_vae) if needs_audio_vae else nullcontext()
-        with audio_vae_context:
-            embedded_condition, embedded_lengths = self._encode_video_audio_conditions_resident(
-                prepared_videos,
-                has_audio=has_audio,
-            )
-            external_condition, external_lengths = self._encode_audio_conditions_resident(
-                standalone_audios,
-                max_duration_seconds=max_duration_seconds,
-            )
-        return (
-            embedded_condition,
-            embedded_lengths,
-            external_condition,
-            external_lengths,
-        )
+        Call this on the tensor that is actually returned to the engine. Audio is
+        released inside ``decode``; video is released by the callers of ``decode``
+        only after ``_prepare_minimax_h3_video_output`` has quantized it, so the
+        early D2H copy carries ``uint8`` frames rather than the decoded floats.
+        """
+        if not getattr(self, "_model_cpu_offload_modules", None):
+            return tensor
+        if self._is_output_owner_rank():
+            return tensor.cpu()
+        return torch.empty(tensor.shape, dtype=tensor.dtype, device="meta")
 
     def _initial_noise(
         self,
@@ -1918,6 +1572,16 @@ class MiniMaxH3Pipeline(
         visual_condition_shapes: list[tuple[int, int, int]] | None = None,
         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.
 
@@ -1947,6 +1611,9 @@ class MiniMaxH3Pipeline(
                 latent_w=latent_w,
                 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(
@@ -1958,7 +1625,19 @@ class MiniMaxH3Pipeline(
                 include_keyframe_cond=task == "fl2va",
                 keyframe_frame_indices=keyframe_frame_indices if task == "fl2va" else None,
                 frame_count=num_frames if task == "fl2va" else None,
+                seq_len=pad_seq_len,
             )
+        # Report the effective shape at info level exactly when a request pins
+        # it, so a deployment can confirm the pin landed without raising the
+        # log level for every request.
+        log = logger.info if pad_seq_len is not None else logger.debug
+        log(
+            "MiniMax H3 packed sequence: task=%s pad_seq_len=%s used=%d seq_len=%d",
+            task,
+            pad_seq_len,
+            int(packed["cu_seqlens"][1]),
+            int(packed["seq_len"]),
+        )
 
         tags = packed["token_tags"].clone()
         tags[packed["text_pos"]] = text_tags.cpu()
@@ -1992,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
@@ -2013,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,
@@ -2037,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(
@@ -2094,6 +1817,16 @@ class MiniMaxH3Pipeline(
         visual_condition_shapes: list[tuple[int, int, int]] | None = None,
         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,
@@ -2117,6 +1850,16 @@ class MiniMaxH3Pipeline(
             visual_condition_shapes=visual_condition_shapes,
             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)
@@ -2134,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(),
                 )
 
@@ -2147,6 +1892,81 @@ class MiniMaxH3Pipeline(
             audio_t=audio_t,
         )
 
+    def decode_to_mp4(
+        self,
+        video_latent: torch.Tensor,
+        audio_latent: torch.Tensor,
+        *,
+        height: int,
+        width: int,
+        max_pending: int = 2,
+        batch_frames: int = 17,
+        video_codec_options: dict[str, str] | None = None,
+    ) -> 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. 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.
+
+        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]
+
+        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 _release_stage_cache(self) -> None:
+        """Return idle allocator pages to the device at stage boundaries.
+
+        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,
         video_latent: torch.Tensor,
@@ -2155,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,
@@ -2165,6 +1989,7 @@ class MiniMaxH3Pipeline(
         video = video[..., :height, :width].contiguous()
         with self._component_on_device(self.audio_vae):
             audio = self.audio_vae.decode_latent(audio_latent)
+        audio = self._offload_model_cpu_stage_output(audio)
         return video, audio
 
     @staticmethod
@@ -2185,13 +2010,16 @@ class MiniMaxH3Pipeline(
         if isinstance(raw_prompt, str):
             return None
         additional_information = raw_prompt.get("additional_information") or {}
-        text_encoder_output = additional_information.get("text_encoder_output")
-        if text_encoder_output is None:
+        encoder_output = additional_information.get("encoder_output")
+        if encoder_output is None:
             return None
-        if not isinstance(text_encoder_output, Mapping):
-            raise OmniClientError("text_encoder_output must be a mapping")
+        if not isinstance(encoder_output, Mapping):
+            raise OmniClientError("MiniMax H3 encoder output must be a mapping")
         try:
-            return MiniMaxH3TextConditioning.from_payload(text_encoder_output)
+            if "hidden_states" in encoder_output and "token_tags" in encoder_output:
+                return MiniMaxH3TextConditioning.from_payload(encoder_output)
+            conditioning = MiniMaxH3EncoderConditioning.from_omni_payload(encoder_output)
+            return MiniMaxH3TextConditioning(conditioning.hidden_states, conditioning.token_tags)
         except ValueError as exc:
             raise OmniClientError(str(exc)) from exc
 
@@ -2212,29 +2040,293 @@ class MiniMaxH3Pipeline(
             raise OmniClientError(str(exc)) from exc
         return videos
 
-    def _prepare_request_inputs(
-        self,
-        *,
-        prompt: str,
-        multi_modal_data: dict[str, Any],
-        sampling: Any,
-        text_conditioning: MiniMaxH3TextConditioning | None = None,
-        prepared_reference_videos: list[dict[str, Any]] | None = None,
-    ) -> dict[str, Any]:
-        """Resolve the task and output shape, then run every request-level encode.
+    def encode_prompt(self, prepared: PreparedEncoderInputs | None) -> tuple[torch.Tensor, torch.Tensor]:
+        _, rank, _ = _dit_rank_world()
+        ids = tags = hidden = None
+        vision_kwargs: dict[str, torch.Tensor] = {}
+        error = None
+        if rank == 0:
+            try:
+                if prepared is None:
+                    raise ValueError("rank 0 must prepare MiniMax H3 text inputs")
+                if prepared.images:
+                    vision = self.processor.image_processor(images=prepared.images, return_tensors="pt")
+                    vision_kwargs.update(
+                        pixel_values=vision["pixel_values"],
+                        image_grid_thw=vision["image_grid_thw"],
+                    )
+                if prepared.qwen_videos:
+                    vision = self.processor.video_processor(
+                        videos=[frames for frames, _ in prepared.qwen_videos],
+                        do_sample_frames=False,
+                        return_tensors="pt",
+                    )
+                    vision_kwargs.update(
+                        pixel_values_videos=vision["pixel_values_videos"],
+                        video_grid_thw=vision["video_grid_thw"],
+                    )
+                ids, tags = build_minimax_h3_presentation(
+                    self.tokenizer,
+                    prompt=prepared.prompt,
+                    task=prepared.media.task,
+                    condition_labels=prepared.condition_labels,
+                    image_grid_thw=vision_kwargs.get("image_grid_thw"),
+                    video_grid_thw=vision_kwargs.get("video_grid_thw"),
+                    video_timestamps=prepared.video_timestamps,
+                    merge_size=int(self.processor.image_processor.merge_size),
+                )
+            except Exception as exc:
+                error = exc
+        _broadcast_rank0_exception(error)
+        if rank < self.text_encoder_tp_size:
+            ids = self._distribute_encode_inputs(ids, vision_kwargs)
+            hidden = self._encode_text_hidden(ids, vision_kwargs)
+        return (
+            _broadcast_tensor(hidden, dtype=torch.bfloat16, device=self.device),
+            _broadcast_tensor(tags, dtype=torch.long, device=self.device),
+        )
 
-        Shared by request-mode :meth:`forward` and step-mode
-        :meth:`prepare_encode`; the returned mapping feeds :meth:`diffuse` and
-        :meth:`_build_denoise_inputs` unchanged.
+    def _distribute_media_inputs(self, media: MiniMaxH3EncoderMediaInput | None) -> MiniMaxH3EncoderMediaInput:
+        group, rank, world_size = _dit_rank_world()
+        if world_size == 1:
+            assert media is not None
+            return media
+        tensors = media.to_mm_tensors() if media is not None else []
+        header = [(media.to_metadata(), [value.dtype for value in tensors])] if media is not None else [None]
+        dist.broadcast_object_list(header, src=0, group=group)
+        metadata, dtypes = header[0]
+        received = []
+        for index, dtype in enumerate(dtypes):
+            value = _broadcast_tensor(tensors[index] if rank == 0 else None, dtype=dtype, device=self.device)
+            if rank != 0:
+                received.append(value.cpu())
+            del value
+        if rank == 0:
+            assert media is not None
+            return media
+        return MiniMaxH3EncoderMediaInput.from_mm_tensors(received, metadata)
+
+    def _broadcast_media_conditioning(
+        self, conditioning: MiniMaxH3EncoderMediaConditioning | None
+    ) -> MiniMaxH3EncoderMediaConditioning:
+        group, rank, world_size = _dit_rank_world()
+        if world_size == 1:
+            assert conditioning is not None
+            return conditioning
+        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
+            metadata = {
+                item.name: getattr(conditioning, item.name)
+                for item in fields(conditioning)
+                if item.name not in tensor_names
+            }
+            dtypes = {
+                name: value.dtype if (value := getattr(conditioning, name)) is not None else None
+                for name in tensor_names
+            }
+            header[0] = (metadata, dtypes)
+        dist.broadcast_object_list(header, src=0, group=group)
+        metadata, dtypes = header[0]
+        tensors = {}
+        for name, dtype in dtypes.items():
+            source = getattr(conditioning, name) if rank == 0 else None
+            tensors[name] = _broadcast_tensor(source, dtype=dtype, device=self.device) if dtype is not None else None
+        return MiniMaxH3EncoderMediaConditioning(**metadata, **tensors)
+
+    def _encode_local_media(self, media: MiniMaxH3EncoderMediaInput | None) -> MiniMaxH3EncoderMediaConditioning:
+        group, rank, world_size = _dit_rank_world()
+        distributed_video = self.video_vae.is_distributed_enabled()
+        if distributed_video:
+            media = self._distribute_media_inputs(media)
+        conditioning = None
+        error = None
+        try:
+            if rank == 0 or distributed_video:
+                assert media is not None
+                conditioning = encode_media(
+                    media,
+                    video_vae=self.video_vae,
+                    audio_vae=self.audio_vae,
+                    emit_conditioning=rank == 0,
+                    component_scope=self._component_on_device,
+                )
+        except ValueError as exc:
+            error = OmniClientError(str(exc))
+        except Exception as exc:
+            error = exc
+        if world_size > 1:
+            # All participants finish the codec phase before any latent broadcast.
+            errors = [None] * world_size
+            info = (str(error), isinstance(error, OmniClientError)) if error is not None else None
+            dist.all_gather_object(errors, info, group=group)
+            for info in errors:
+                if info is not None:
+                    if error is not None:
+                        raise error
+                    message, is_client_error = info
+                    raise OmniClientError(message) if is_client_error else RuntimeError(message)
+        elif error is not None:
+            raise error
+        return self._broadcast_media_conditioning(conditioning)
+
+    def _prepare_local_conditioning(
+        self,
+        raw_prompt: Any,
+        sampling: Any,
+        *,
+        require_external_text: bool = False,
+    ) -> 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.
         """
-        quality = sampling.quality
-        logger.debug("MiniMax H3 request quality=%s", quality)
+        group, rank, world_size = _dit_rank_world()
+        prompts = (sampling.extra_args or {}).get("continuation_prompts")
+        prepared = text_conditioning = None
+        error = None
+        if rank == 0:
+            try:
+                _, multi_modal_data = self._extract_prompt(raw_prompt)
+                turbo_spec = self._active_turbo_spec(sampling)
+                has_native_lora = self._has_active_native_lora(sampling)
+                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,
+                )
+                if turbo_spec is not None:
+                    self._validate_turbo_sampling(sampling, turbo_spec)
+                if has_native_lora:
+                    self._validate_native_sampling(sampling, task=task)
+                text_conditioning = self._extract_text_conditioning(raw_prompt)
+                if require_external_text and text_conditioning is None:
+                    raise OmniClientError(
+                        "MiniMax H3 diffusion stage requires text encoder conditioning when text_encoder is not loaded"
+                    )
+                prepared = prepare_encoder_inputs(
+                    raw_prompt,
+                    sampling,
+                    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)
+        reuse_text = [text_conditioning is not None]
+        if world_size > 1:
+            dist.broadcast_object_list(reuse_text, src=0, group=group)
+        if reuse_text[0]:
+            hidden = _broadcast_tensor(
+                text_conditioning.hidden_states if rank == 0 else None,
+                dtype=torch.bfloat16,
+                device=self.device,
+            )
+            tags = _broadcast_tensor(
+                text_conditioning.token_tags if rank == 0 else None, dtype=torch.long, device=self.device
+            )
+        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), window_text
+
+    def _prepare_request_inputs(self, raw_prompt: Any, sampling: Any) -> dict[str, Any]:
+        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=not self.load_text_encoder,
+            )
+        else:
+            conditioning = self._extract_encoder_conditioning(raw_prompt)
+        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:
+        if isinstance(prompt, list):
+            prompt = prompt[0] if prompt else None
+        additional_information = prompt.get("additional_information") if isinstance(prompt, Mapping) else None
+        payload = additional_information.get("encoder_output") if isinstance(additional_information, Mapping) else None
+        if not isinstance(payload, Mapping) or not payload:
+            raise OmniClientError("MiniMax H3 diffusion stage requires encoder conditioning from the encoder stage")
+        try:
+            return MiniMaxH3EncoderConditioning.from_omni_payload(payload)
+        except ValueError as exc:
+            raise OmniClientError(str(exc)) from exc
+
+    def _prepare_encoder_conditioning_inputs(
+        self,
+        conditioning: MiniMaxH3EncoderConditioning,
+        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(
+                f"MiniMax H3 encoder task {conditioning.task!r} does not match diffusion request {requested_task!r}"
+            )
         turbo_spec = self._active_turbo_spec(sampling)
         has_native_lora = self._has_active_native_lora(sampling)
         task = self._resolve_task(
-            extra.get("task"),
-            multi_modal_data,
+            conditioning.task,
             turbo_spec=turbo_spec,
             has_native_lora=has_native_lora,
         )
@@ -2242,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,
@@ -2249,256 +2346,135 @@ class MiniMaxH3Pipeline(
                 audio_shift=self.default_audio_shift,
             )
 
-        raw_image = multi_modal_data.get("image")
-        raw_videos = multi_modal_data.get("video")
-        raw_audio = multi_modal_data.get("audio")
-        images = _load_images(raw_image) if raw_image is not None else []
-        video_values = list(raw_videos) if isinstance(raw_videos, (list, tuple)) else raw_videos
-        audio_values = list(raw_audio) if isinstance(raw_audio, (list, tuple)) else raw_audio
-
-        if task == "t2va" and (images or raw_videos is not None or raw_audio is not None):
-            raise OmniClientError("t2va does not accept image, video, or audio conditions")
-        if task == "fl2va":
-            if not images:
-                raise OmniClientError("fl2va requires multi_modal_data.image")
-            if len(images) > 2:
-                raise OmniClientError("fl2va accepts at most first and last images")
-            if raw_videos is not None or raw_audio is not None:
-                raise OmniClientError("fl2va accepts image keyframes only")
-        if task == "ref2va":
-            video_count = (
-                len(video_values) if isinstance(video_values, (list, tuple)) else int(video_values is not None)
+        if conditioning.height % 32 or conditioning.width % 32:
+            raise OmniClientError(
+                f"MiniMax H3 encoder canvas must be divisible by 32, got {conditioning.width}x{conditioning.height}"
             )
-            audio_is_waveform_pair = (
-                isinstance(raw_audio, (list, tuple))
-                and len(raw_audio) == 2
-                and isinstance(raw_audio[1], (int, np.integer))
+        expected_latent_t = MINIMAX_H3_SHAPE_PLANNER.video_latent_t(conditioning.num_frames)
+        expected_audio_t = MINIMAX_H3_SHAPE_PLANNER.audio_latent_t(conditioning.num_frames / MINIMAX_H3_FPS)
+        if (conditioning.latent_t, conditioning.audio_t) != (expected_latent_t, expected_audio_t):
+            raise OmniClientError(
+                "MiniMax H3 encoder latent shape does not match its output frame count: "
+                f"got ({conditioning.latent_t}, {conditioning.audio_t}), expected "
+                f"({expected_latent_t}, {expected_audio_t})"
             )
-            audio_count = (
-                len(audio_values)
-                if isinstance(audio_values, (list, tuple)) and not audio_is_waveform_pair
-                else int(raw_audio is not None)
-            )
-            _validate_ref2va_reference_counts(len(images), video_count, audio_count)
-        elif raw_videos is not None:
-            raise OmniClientError(f"{task} does not accept a video condition")
 
-        image = images[0] if images else None
-        height, width, num_frames, latent_t, audio_t = self._resolve_shape(task, sampling, image)
-        if task == "fl2va":
-            for item in images:
-                _validate_reference_image(item)
-            prepared_images = [item.resize((width, height), Image.Resampling.LANCZOS) for item in images]
-            keyframe_frame_indices = _resolve_fl2va_keyframe_indices(extra, len(images))
-        elif task == "ref2va":
-            prepared_images = []
-            for item in images:
-                ref_width, ref_height = _reference_image_shape(item)
-                prepared_images.append(item.resize((ref_width, ref_height), Image.Resampling.LANCZOS))
-            keyframe_frame_indices = None
-        else:
-            prepared_images = []
-            keyframe_frame_indices = None
+        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
 
-        visual_condition = None
-        visual_shape = None
-        visual_shapes = None
-        audio_condition = None
-        ref_audio_t = None
-        audio_lengths = None
-        ref_blocks = None
-        with tempfile.TemporaryDirectory(prefix="minimax_h3_ref2va_") as workdir:
-            prepared_videos = None
-            has_audio: list[bool] = []
-            video_count = 0
-            if raw_videos is not None:
-                video_count = len(raw_videos) if isinstance(raw_videos, (list, tuple)) else 1
-                # File-based reference-video prep runs only on rank 0; other
-                # ranks return None without touching disk. If rank 0 raises
-                # (e.g. invalid file, unsupported codec) it must not exit
-                # ``prepare_encode`` before the downstream broadcasts below --
-                # non-zero ranks would then deadlock on them forever. Capture
-                # the exception here and let every rank agree on the outcome
-                # before starting any subsequent collective.
-                prep_error: Exception | None = None
-                try:
-                    _, rank, _ = _dit_rank_world()
-                    if prepared_reference_videos is not None:
-                        if rank == 0:
-                            prepared_videos = _reuse_prepared_reference_videos(
-                                prepared_reference_videos,
-                                expected_count=video_count,
-                            )
-                    else:
-                        prepared_videos = self._prepare_reference_videos(
-                            raw_videos,
-                            target_frame_count=num_frames,
-                            workdir=workdir,
-                            start_time_seconds=extra.get("start_time_seconds"),
-                        )
-                except Exception as exc:
-                    prep_error = exc
-                _broadcast_rank0_exception(prep_error)
-                has_audio_tensor = torch.zeros(
-                    video_count,
-                    dtype=torch.long,
-                    device=self.device,
+        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,
                 )
-                _, rank, world_size = _dit_rank_world()
-                if rank == 0:
-                    has_audio_tensor = torch.tensor(
-                        [int(item["input_has_audio"]) for item in prepared_videos or []],
-                        dtype=torch.long,
-                        device=self.device,
-                    )
-                if world_size > 1:
-                    dist.broadcast(
-                        has_audio_tensor,
-                        src=0,
-                        group=get_world_group().device_group,
-                    )
-                has_audio = [bool(value) for value in has_audio_tensor.tolist()]
+                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
 
-            if raw_audio is not None:
-                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)
-            condition_labels: list[tuple[str, int]] = []
-            for image_index in range(1, len(prepared_images) + 1):
-                condition_labels.append(("image", image_index))
-            audio_index = 0
-            for video_index, item in enumerate(prepared_videos or (), start=1):
-                if item["input_has_audio"]:
-                    audio_index += 1
-                    condition_labels.append(("audio", audio_index))
-                condition_labels.append(("video", video_index))
-            for _ in standalone_audios:
-                audio_index += 1
-                condition_labels.append(("audio", audio_index))
-
-            if text_conditioning is not None:
-                text_embeddings = text_conditioning.hidden_states.to(
-                    device=self.device,
-                    dtype=torch.bfloat16,
-                )
-                text_tags = text_conditioning.token_tags.to(
-                    device=self.device,
-                    dtype=torch.long,
-                )
-            elif getattr(self, "text_encoder", None) is not None:
-                text_embeddings, text_tags = self.encode_prompt(
-                    task=task,
-                    prompt=prompt,
-                    images=prepared_images,
-                    prepared_videos=prepared_videos,
-                    condition_labels=condition_labels if task == "ref2va" else None,
-                )
-            else:
-                raise OmniClientError(
-                    "MiniMax H3 diffusion stage requires text_encoder_output when text_encoder is not loaded"
-                )
-
-            # ``prepared_videos`` is intentionally ``None`` on non-zero DiT
-            # ranks; the distributed video encoder broadcasts the prepared
-            # metadata inside ``_encode_visual_conditions``.  Use the global
-            # video count here so video + standalone-audio Ref2VA requests do
-            # not look like audio-only requests on those ranks.
-            if video_count or prepared_images:
-                visual_condition, visual_shapes = self._encode_visual_conditions(
-                    prepared_images,
-                    prepared_videos,
-                    video_count=video_count,
-                )
-                (
-                    embedded_audio_condition,
-                    embedded_audio_lengths,
-                    external_audio_condition,
-                    external_audio_lengths,
-                ) = self._encode_reference_audio_conditions(
-                    prepared_videos,
-                    has_audio=has_audio,
-                    standalone_audios=standalone_audios,
-                    max_duration_seconds=float(num_frames) / float(sampling.fps or MINIMAX_H3_FPS),
-                )
-                audio_parts = [
-                    item for item in (embedded_audio_condition, external_audio_condition) if item is not None
-                ]
-                audio_condition = torch.cat(audio_parts) if audio_parts else None
-                audio_lengths = embedded_audio_lengths + external_audio_lengths
-                ref_blocks = []
-                image_shapes = visual_shapes[: len(prepared_images)]
-                video_shapes = visual_shapes[len(prepared_images) :]
-                for shape in image_shapes:
-                    ref_blocks.append(
-                        {
-                            "kind": "image",
-                            "latent_h": shape[1],
-                            "latent_w": shape[2],
-                        }
-                    )
-                audio_iterator = iter(embedded_audio_lengths)
-                for shape, contributes_audio in zip(video_shapes, has_audio, strict=True):
-                    ref_audio = next(audio_iterator) if contributes_audio else 0
-                    ref_blocks.append(
-                        {
-                            "kind": "video_audio" if ref_audio else "video",
-                            "ref_audio_t": ref_audio,
-                            "latent_t": shape[0],
-                            "latent_h": shape[1],
-                            "latent_w": shape[2],
-                        }
-                    )
-                for ref_audio_t in external_audio_lengths:
-                    ref_blocks.append({"kind": "audio", "ref_audio_t": ref_audio_t})
-            elif standalone_audios:
-                raise OmniClientError("standalone audio references require a Ref2VA visual reference")
-
-            if visual_shapes and len(visual_shapes) == 1:
-                visual_shape = visual_shapes[0]
-            if audio_lengths:
-                if any(length < 80 or length > 600 for length in audio_lengths):
-                    raise OmniClientError("MiniMax H3 audio references must each be between 2 and 15 seconds")
-                if sum(audio_lengths) > 600:
-                    raise OmniClientError("MiniMax H3 audio references must be at most 15 seconds in total")
-                if len(audio_lengths) == 1:
-                    ref_audio_t = audio_lengths[0]
-
-        seed = int(sampling.seed if sampling.seed is not None else 42)
         base_schedule, num_steps = self._resolve_sigma_positions(task, sampling)
-        video_shift = float(extra.get("flow_shift", self.default_video_shift))
-        audio_shift = float(extra.get("audio_flow_shift", self.default_audio_shift))
         quality_plan = self._quality_policy.resolve(
-            quality=quality,
+            quality=sampling.quality,
             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)
-        num_outputs = _resolve_minimax_h3_num_outputs(sampling.num_outputs_per_prompt)
         return {
+            "continuation": continuation,
             "task": task,
-            "height": height,
-            "width": width,
-            "num_frames": num_frames,
-            "latent_t": latent_t,
-            "latent_h": height // 16,
-            "latent_w": width // 16,
-            "audio_t": audio_t,
-            "text_embeddings": text_embeddings,
-            "text_tags": text_tags,
-            "visual_condition": visual_condition,
-            "visual_condition_shape": visual_shape,
-            "audio_condition": audio_condition,
-            "ref_audio_t": ref_audio_t,
-            "ref_blocks": ref_blocks,
+            "height": conditioning.height,
+            "width": conditioning.width,
+            "num_frames": conditioning.num_frames,
+            "latent_t": conditioning.latent_t,
+            "latent_h": conditioning.height // 16,
+            "latent_w": conditioning.width // 16,
+            "audio_t": conditioning.audio_t,
+            "text_embeddings": conditioning.hidden_states.to(device=self.device, dtype=torch.bfloat16),
+            "text_tags": conditioning.token_tags.to(device=self.device, dtype=torch.long),
+            "visual_condition": (
+                conditioning.visual_condition.to(device=self.device)
+                if conditioning.visual_condition is not None
+                else None
+            ),
+            "visual_condition_shape": visual_shapes[0] if visual_shapes and len(visual_shapes) == 1 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,
-            "keyframe_frame_indices": keyframe_frame_indices,
-            "seed": seed,
+            "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),
             "num_steps": num_steps,
-            "video_shift": video_shift,
-            "audio_shift": audio_shift,
+            "video_shift": float(extra.get("flow_shift", self.default_video_shift)),
+            "audio_shift": float(extra.get("audio_flow_shift", self.default_audio_shift)),
             "base_schedule": base_schedule,
-            "num_outputs": num_outputs,
+            "num_outputs": _resolve_minimax_h3_num_outputs(sampling.num_outputs_per_prompt),
+            "preencode_mp4": bool(extra.get("preencode_mp4", False)),
+            "preencode_batch_frames": (
+                normalize_preencode_batch_frames(extra.get("preencode_batch_frames", 17))
+                if extra.get("preencode_mp4", False)
+                else 17
+            ),
+            "video_codec_options": normalize_video_codec_options(
+                extra.get("video_codec_options", {"preset": "ultrafast", "threads": "0"})
+                if extra.get("preencode_mp4", False)
+                else None
+            ),
+            **latent_edit,
         }
 
     @staticmethod
@@ -2510,31 +2486,65 @@ class MiniMaxH3Pipeline(
     def forward(self, request: DiffusionRequestBatch) -> DiffusionOutput:
         if len(request.prompts) != 1:
             raise OmniClientError("MiniMax H3 supports one request at a time")
-        raw_prompt = request.prompts[0]
-        prompt, multi_modal_data = self._extract_prompt(raw_prompt)
         context = self._prepare_request_inputs(
-            prompt=prompt,
-            multi_modal_data=multi_modal_data,
-            sampling=request.sampling_params,
-            text_conditioning=self._extract_text_conditioning(raw_prompt),
-            prepared_reference_videos=self._extract_prepared_reference_videos(raw_prompt),
+            request.prompts[0],
+            request.sampling_params,
         )
         denoise_kwargs = self._denoise_kwargs(context)
         num_outputs = context["num_outputs"]
         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})
-            video, audio = self.decode(
-                video_latent,
-                audio_latent,
-                height=context["height"],
-                width=context["width"],
-            )
-            videos.append(_prepare_minimax_h3_video_output(video))
-            audios.append(audio)
-        video = videos[0] if len(videos) == 1 else torch.cat(videos, dim=0)
-        audio = audios[0] if len(audios) == 1 else torch.cat(audios, dim=0)
+            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(
+                        video_latent,
+                        audio_latent,
+                        height=context["height"],
+                        width=context["width"],
+                        video_codec_options=context["video_codec_options"],
+                        batch_frames=context["preencode_batch_frames"],
+                    )
+                )
+                audios.append(None)
+            else:
+                video, audio = self.decode(
+                    video_latent,
+                    audio_latent,
+                    height=context["height"],
+                    width=context["width"],
+                )
+                # Rebind rather than append the expression: the local would
+                # otherwise keep the decoded frames' device storage alive for the
+                # rest of the iteration, and the next seed's diffuse() -- the DiT
+                # reload this release exists to make room for -- runs before the
+                # 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
+            audio = None
+        else:
+            video = videos[0] if len(videos) == 1 else torch.cat(videos, dim=0)
+            audio = audios[0] if len(audios) == 1 else torch.cat(audios, dim=0)
         return DiffusionOutput(
             output=(video, audio),
             post_process_func=get_minimax_h3_post_process_func(self.od_config),
@@ -2601,13 +2611,9 @@ class MiniMaxH3Pipeline(
                 "co-batched requests would reuse incompatible cache state. Drop --step-execution "
                 "or omit quality=high."
             )
-        prompt, multi_modal_data = self._extract_prompt(state.prompt)
         context = self._prepare_request_inputs(
-            prompt=prompt,
-            multi_modal_data=multi_modal_data,
-            sampling=state.sampling,
-            text_conditioning=self._extract_text_conditioning(state.prompt),
-            prepared_reference_videos=self._extract_prepared_reference_videos(state.prompt),
+            state.prompt,
+            state.sampling,
         )
         inputs = self._build_denoise_inputs(**self._denoise_kwargs(context))
 
@@ -2652,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"],
@@ -2659,6 +2667,9 @@ class MiniMaxH3Pipeline(
                     "latent_h": context["latent_h"],
                     "latent_w": context["latent_w"],
                     "audio_t": context["audio_t"],
+                    "preencode_mp4": context.get("preencode_mp4", False),
+                    "preencode_batch_frames": context.get("preencode_batch_frames", 17),
+                    "video_codec_options": context.get("video_codec_options"),
                 },
             }
         )
@@ -2682,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
@@ -2733,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)
@@ -2748,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",
@@ -2781,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,
@@ -2797,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,
@@ -2809,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
 
@@ -2830,13 +2889,25 @@ class MiniMaxH3Pipeline(
             latent_w=shape["latent_w"],
             audio_t=shape["audio_t"],
         )
-        video, audio = self.decode(
-            video_latent,
-            audio_latent,
-            height=shape["height"],
-            width=shape["width"],
-        )
-        video = _prepare_minimax_h3_video_output(video)
+        if shape.get("preencode_mp4", False):
+            video = self.decode_to_mp4(
+                video_latent,
+                audio_latent,
+                height=shape["height"],
+                width=shape["width"],
+                video_codec_options=shape.get("video_codec_options"),
+                batch_frames=shape.get("preencode_batch_frames", 17),
+            )
+            audio = None
+        else:
+            video, audio = self.decode(
+                video_latent,
+                audio_latent,
+                height=shape["height"],
+                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 ca8359904..ed28029bb 100644
--- a/vllm_omni/diffusion/models/minimax_h3/vae.py
+++ b/vllm_omni/diffusion/models/minimax_h3/vae.py
@@ -6,17 +6,21 @@ 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
 from PIL import Image
+from safetensors import safe_open
 from transformers.dynamic_module_utils import get_class_from_dynamic_module
 from vllm.logger import init_logger
+from vllm.utils.torch_utils import set_default_torch_dtype
 
 from vllm_omni.diffusion.distributed.autoencoders.distributed_vae_executor import (
     DistributedVaeMixin,
@@ -31,11 +35,15 @@ from vllm_omni.diffusion.offloader.module_residency import (
 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__)
 
@@ -61,6 +69,11 @@ def _minimax_h3_keyframe_encode_context(
         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"))
@@ -75,11 +88,23 @@ def _load_component_config(component_path: str) -> dict[str, Any]:
 def _load_remote_component(
     component_path: str,
     config: dict[str, Any],
+    *,
+    trust_remote_code: bool,
 ) -> nn.Module:
     auto_map = config.get("auto_map") or {}
     class_reference = auto_map.get("AutoModel")
     if not isinstance(class_reference, str):
         raise ValueError(f"{component_path}/config.json must define auto_map.AutoModel")
+    if not trust_remote_code:
+        raise ValueError(
+            f"Loading {component_path} executes the modeling code shipped with "
+            f"the checkpoint (auto_map.AutoModel = {class_reference}). Pass "
+            "--trust-remote-code (or trust_remote_code=True) to allow it."
+        )
+    # ``trust_remote_code`` is checked here rather than forwarded to
+    # ``get_class_from_dynamic_module``: that helper takes no such argument and
+    # would silently absorb it into ``**kwargs``, so forwarding it would read
+    # like a gate while executing the remote code unconditionally.
     component_cls = get_class_from_dynamic_module(
         class_reference,
         component_path,
@@ -94,6 +119,121 @@ def _load_remote_component(
         return component_cls.from_pretrained(component_path)
 
 
+def _check_trust_remote_code(
+    component_path: str,
+    config: dict[str, Any],
+    trust_remote_code: bool,
+) -> None:
+    """Apply the remote-code gate before either full or encoder-only loading."""
+
+    class_reference = (config.get("auto_map") or {}).get("AutoModel")
+    if isinstance(class_reference, str) and not trust_remote_code:
+        raise ValueError(
+            f"Loading {component_path} executes the modeling code shipped with "
+            f"the checkpoint (auto_map.AutoModel = {class_reference}). Pass "
+            "--trust-remote-code (or trust_remote_code=True) to allow it."
+        )
+
+
+def _load_selected_state_dict(
+    model: nn.Module,
+    weights_path: Path,
+    prefixes: tuple[str, ...],
+) -> None:
+    with safe_open(str(weights_path), framework="pt", device="cpu") as checkpoint:
+        selected = sorted(name for name in checkpoint.keys() if name.startswith(prefixes))
+        if not selected:
+            raise ValueError(f"{weights_path}: no VAE weights match prefixes {prefixes!r}")
+        state_dict = {name: checkpoint.get_tensor(name) for name in selected}
+    model.load_state_dict(state_dict, strict=True)
+
+
+def _remove_modules(model: nn.Module, names: tuple[str, ...]) -> None:
+    for name in names:
+        if not isinstance(getattr(model, name, None), nn.Module):
+            raise ValueError(f"MiniMax H3 VAE model has no module {name!r}")
+        delattr(model, name)
+
+
+def _load_video_vae_encoder(
+    component_path: str,
+    config: dict[str, Any],
+) -> nn.Module:
+    class_reference = (config.get("auto_map") or {}).get("AutoModel")
+    if not isinstance(class_reference, str):
+        raise ValueError(f"{component_path}/config.json must define auto_map.AutoModel")
+    component_cls = get_class_from_dynamic_module(class_reference, component_path)
+    component_module = importlib.import_module(component_cls.__module__)
+    source_classes = getattr(component_module, "_SOURCE_CLASSES", None)
+    source_class_name = config.get("source_class_name")
+    if not isinstance(source_classes, dict) or source_class_name not in source_classes:
+        raise ValueError(f"unsupported MiniMax H3 video VAE source class {source_class_name!r}")
+    if bool(config["vae_parallel_tiling"]):
+        ensure_parallel_state = getattr(component_module, "_ensure_vae_parallel_state", None)
+        if not callable(ensure_parallel_state):
+            raise ValueError("MiniMax H3 video VAE remote module does not expose its parallel-state initializer")
+        ensure_parallel_state()
+
+    source_path = Path(component_path) / str(config["source_path"])
+    weights_path = source_path / str(config["source_safetensors_path"])
+    load_kwargs = {
+        "clip_length": int(config["vae_clip_length"]),
+        "token_drop": int(config["vae_token_drop"]),
+        "encoder_tiling": int(config["vae_encoder_tiling"]),
+        "decoder_tiling": int(config["vae_decoder_tiling"]),
+        "parallel_tiling": int(config["vae_parallel_tiling"]),
+        "tile_size": int(config["vae_tile_size"]),
+        "tile_overlap_min": int(config["vae_tile_overlap_min"]),
+        "encoder_parallel": int(config["vae_encoder_parallel"]),
+        "decoder_parallel": int(config["vae_decoder_parallel"]),
+        "chunk_dim": int(config["vae_chunk_dim"]),
+    }
+    source_cls = source_classes[source_class_name]
+    source_config = source_cls.load_config(str(source_path))
+    with set_default_torch_dtype(torch.float32), torch.device("cpu"):
+        model, _unused = source_cls.from_config(source_config, return_unused_kwargs=True, **load_kwargs)
+    _remove_modules(model, ("decoder", "post_quant_conv"))
+    _load_selected_state_dict(model, weights_path, ("encoder.", "quant_conv."))
+    model.eval()
+    return component_cls(model)
+
+
+def _load_audio_vae_encoder(
+    component_path: str,
+    config: dict[str, Any],
+) -> nn.Module:
+    class_reference = (config.get("auto_map") or {}).get("AutoModel")
+    if not isinstance(class_reference, str):
+        raise ValueError(f"{component_path}/config.json must define auto_map.AutoModel")
+    component_cls = get_class_from_dynamic_module(class_reference, component_path)
+    component_module = importlib.import_module(component_cls.__module__)
+    load_yaml = getattr(component_module, "_load_yaml", None)
+    model_cls = getattr(component_module, "DacAudioVAE", None)
+    if not callable(load_yaml) or not isinstance(model_cls, type):
+        raise ValueError("MiniMax H3 audio VAE remote module does not expose its source loader")
+
+    component_dir = Path(component_path)
+    audio_config = load_yaml(component_dir / str(config["source_config_path"]))
+    metadata_path = component_dir / str(config["source_metadata_path"])
+    metadata_doc = json.loads(metadata_path.read_text(encoding="utf-8"))
+    metadata = metadata_doc["metadata"]["kwargs"]
+    with set_default_torch_dtype(torch.float32), torch.device("cpu"):
+        model = model_cls(
+            encoder_rates=metadata["encoder_rates"],
+            decoder_rates=metadata["decoder_rates"],
+            attn_proj=metadata["attn_proj"],
+            decoder_type=metadata["decoder_type"],
+            decoder_dim=audio_config["model_config"]["decoder_dim"],
+            vae_latent_channels=audio_config["model_config"]["vae_latent_channels"],
+            sample_rate=metadata["sample_rate"],
+        )
+    _remove_modules(model, ("decoder", "dec_in_proj", "logs_proj"))
+    weights_path = component_dir / str(config["source_safetensors_path"])
+    _load_selected_state_dict(model, weights_path, ("encoder.", "pre_block.", "mean_proj."))
+    model.eval()
+    return component_cls(model)
+
+
 class _AudioVAEDeterminismContext(AbstractContextManager):
     def __enter__(self):
         backends = torch.backends
@@ -135,6 +275,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."""
 
@@ -144,14 +327,24 @@ class MiniMaxH3VideoVAE(nn.Module, DistributedVaeMixin):
         *,
         device: torch.device,
         load_device: torch.device | None = None,
+        encode_only: bool = False,
+        decode_only: bool = False,
+        trust_remote_code: bool = False,
     ) -> None:
         super().__init__()
         self._device_target = device
+        self.encode_only = bool(encode_only)
+        self.decode_only = bool(decode_only)
+        if self.encode_only and self.decode_only:
+            raise ValueError("MiniMax H3 video VAE cannot be both encode-only and decode-only")
         self.config_dict = _load_component_config(component_path)
-        self.remote = _load_remote_component(
-            component_path,
-            self.config_dict,
-        )
+        _check_trust_remote_code(component_path, self.config_dict, trust_remote_code)
+        if self.encode_only:
+            self.remote = _load_video_vae_encoder(component_path, self.config_dict)
+        else:
+            self.remote = _load_remote_component(component_path, self.config_dict, trust_remote_code=trust_remote_code)
+            if self.decode_only:
+                _remove_modules(self.remote.model, ("encoder", "quant_conv"))
         # Match the reference loader contract before installing inference-only
         # decoder fast paths. Keyframe encoding remains FP32; decoder Linear
         # weights may be materialized in FP16 because reference decode casts
@@ -164,49 +357,126 @@ 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
         self.device_module = torch.get_device_module()
+        self._tile_gather_workspace: torch.Tensor | None = None
+        self._tile_gather_stats = {"hits": 0, "allocs": 0, "workspace_bytes": 0}
+        self._checkpoint_tile_gather = None
+        if self._tile_gather_reuse_enabled():
+            self._install_persistent_tile_gather()
+
+    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._stager is not 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,
         parallel_size: int,
         mode: str = "tile",
+        process_group: dist.ProcessGroup | None = None,
     ) -> None:
         if mode != "tile":
             raise ValueError(f"MiniMax H3 VAE supports its native tile parallel mode only, got {mode!r}")
-        group = get_world_group().device_group
+        group = process_group if process_group is not None else get_world_group().device_group
         world_size = dist.get_world_size(group)
         rank = dist.get_rank(group)
         parallel_size = int(parallel_size)
@@ -241,6 +511,145 @@ class MiniMaxH3VideoVAE(nn.Module, DistributedVaeMixin):
         parallel_module = importlib.import_module(f"{package}.parallel")
         return parallel_module.get_parallel_state()
 
+    def _tile_gather_reuse_enabled(self) -> bool:
+        """Whether this device needs the tiled-VAE gather address kept stable.
+
+        XPU only. The accumulation this guards against is an XCCL-side
+        registration that is kept for every distinct receive-buffer address and
+        never reclaimed; no other backend in tree does that, so everywhere else
+        the checkpoint's own method is left in place and behaviour is unchanged.
+        The stable address comes from one grow-only byte workspace, so what the
+        adapter holds resident is one buffer for the largest geometry it has
+        seen rather than one per geometry.
+        """
+
+        return self._device_target.type == "xpu"
+
+    def _install_persistent_tile_gather(self) -> None:
+        """Route the checkpoint's tiled-VAE gather through a bounded workspace.
+
+        The checkpoint's ``_all_gather_tiled_results`` allocates its gather
+        output afresh on every call. Model-level offload calls ``empty_cache()``
+        once per request, so the next request's output lands on a new device
+        address; XCCL registers a non-reclaimable resource per new receive
+        address, and the registrations accumulate until the card is full. The
+        replacement below keeps a single byte workspace alive on this adapter
+        and carves every gather out of its front, so the address the collective
+        writes to is the same one every request.
+
+        The workspace only ever grows: a geometry that fits in the current
+        block reuses it as is, and a larger one replaces the block, which
+        drops the previous allocation before allocating its own. Resident
+        memory is therefore bounded by one buffer for the largest geometry the
+        adapter has seen, not by one buffer per distinct geometry.
+
+        The override is bound on the checkpoint *instance*, not its class: the
+        class is remote code shared by every component loaded from the same
+        checkpoint, and only this adapter knows the device it runs on.
+        """
+
+        self._checkpoint_tile_gather = self.model._all_gather_tiled_results
+        self.model._all_gather_tiled_results = self._persistent_tile_gather
+        logger.info(
+            "[H3_VAE_GATHER] persistent tile gather installed device=%s",
+            self._device_target.type,
+        )
+
+    def _persistent_tile_gather(
+        self,
+        tasks: list[torch.Tensor],
+        num_tiles: int,
+    ) -> list[torch.Tensor]:
+        """Equal-shape replacement for the checkpoint's tiled-result gather.
+
+        Contract kept identical to the checkpoint's method: return a list of
+        ``num_tiles`` tensors in global tile order, and raise on an empty local
+        share so a rank that owns no tile cannot silently skip the collective.
+
+        Tile ownership is round-robin (``range(sp_rank, num_tiles, sp_size)``),
+        so every rank can compute every other rank's task count from
+        ``num_tiles`` and ``sp_size`` alone. That makes the per-rank payloads
+        equal once the leading task dimension is padded to ``max_tasks``, which
+        is what lets a single ``all_gather_into_tensor`` into a stable buffer
+        replace the variable-shape gather.
+
+        The landing buffer is a view onto the front of one byte workspace that
+        this adapter keeps alive and only ever grows, so its address stays
+        stable across requests while resident memory stays bounded by the
+        largest geometry seen rather than growing per geometry. A byte
+        workspace is dtype-agnostic, so mixed-precision requests share it too.
+
+        Returned tiles are cloned out of the buffer: the buffer is overwritten
+        by the next call and callers hold the tiles past that point.
+        """
+
+        state = self._native_parallel_state()
+        group = state["sp_process_group"]
+        sp_size = int(state["sp_size"])
+        sp_rank = int(state["sp_rank"])
+
+        if not tasks:
+            raise ValueError(f"Found empty tasks on sp rank {sp_rank}")
+
+        max_tasks = -(-num_tiles // sp_size)
+        if len(tasks) > max_tasks:
+            raise ValueError(
+                f"sp rank {sp_rank} holds {len(tasks)} tiles but round-robin "
+                f"ownership of {num_tiles} tiles across {sp_size} ranks allows "
+                f"at most {max_tasks}"
+            )
+        if len(tasks) == max_tasks:
+            stacked = torch.stack(tasks, dim=0)
+        else:
+            # Pad the leading (task) dimension only. The padded slots belong to
+            # ranks whose share is short by construction, and the unpacking loop
+            # below never reads them back.
+            stacked = tasks[0].new_empty((max_tasks, *tasks[0].shape))
+            torch.stack(tasks, dim=0, out=stacked[: len(tasks)])
+            stacked[len(tasks) :].zero_()
+
+        need_bytes = sp_size * stacked.numel() * stacked.element_size()
+        workspace = self._tile_gather_workspace
+        if workspace is None or workspace.device != stacked.device or workspace.numel() < need_bytes:
+            # Drop the previous block before allocating its replacement so the
+            # two are never resident at once; only one workspace is ever held.
+            workspace = None
+            self._tile_gather_workspace = None
+            workspace = torch.empty(need_bytes, dtype=torch.uint8, device=stacked.device)
+            self._tile_gather_workspace = workspace
+            self._tile_gather_stats["allocs"] += 1
+            self._tile_gather_stats["workspace_bytes"] = need_bytes
+            reuse = "alloc"
+        else:
+            self._tile_gather_stats["hits"] += 1
+            reuse = "hit"
+        buffer = workspace[:need_bytes].view(stacked.dtype).view(sp_size, *stacked.shape)
+        # Quantities, not just presence: a line that only says "installed"
+        # cannot distinguish a buffer that is being reused from one that is
+        # reallocated every request, which is the whole failure being fixed.
+        # Debug level, because this fires once per decoder tile batch (12 times
+        # per request on the canonical 1344x768 geometry) and the one-shot
+        # "installed" line above is what an operator needs at info level.
+        logger.debug(
+            "[H3_VAE_GATHER] reuse=%s shape=%s/%s need_mib=%.2f workspace_mib=%.2f buf_ptr=0x%x hits=%d allocs=%d",
+            reuse,
+            tuple(stacked.shape),
+            stacked.dtype,
+            need_bytes / (1024.0 * 1024.0),
+            self._tile_gather_stats["workspace_bytes"] / (1024.0 * 1024.0),
+            workspace.data_ptr(),
+            self._tile_gather_stats["hits"],
+            self._tile_gather_stats["allocs"],
+        )
+        dist.all_gather_into_tensor(buffer, stacked, group=group)
+
+        results: list[torch.Tensor] = [None] * num_tiles  # type: ignore[list-item]
+        for rank in range(sp_size):
+            num_rank_tasks = -(-(num_tiles - rank) // sp_size)
+            for k in range(num_rank_tasks):
+                results[k * sp_size + rank] = buffer[rank][k].clone()
+        return results
+
     def _decoder_tile_count(self, latent: torch.Tensor) -> int:
         """Number of decoder tiles the checkpoint will split ``latent`` into.
 
@@ -254,15 +663,40 @@ class MiniMaxH3VideoVAE(nn.Module, DistributedVaeMixin):
         cols, _, _ = self.model.split_tiles(int(latent.shape[-1]) * ratio, True)
         return len(rows) * len(cols)
 
+    def _encoder_tile_count(self, height: int, width: int) -> int:
+        processor = getattr(self.model, "processor", None)
+        align = getattr(processor, "_align_to_total_patch_size", None)
+        if callable(align):
+            height, width = align(int(height), int(width))
+        rows, _, _ = self.model.split_tiles(int(height), False)
+        cols, _, _ = self.model.split_tiles(int(width), False)
+        return len(rows) * len(cols)
+
+    def _encoder_tiling_context(
+        self,
+        height: int,
+        width: int,
+    ) -> AbstractContextManager:
+        parallel_size = int(getattr(self, "parallel_size", 1))
+        if parallel_size <= 1:
+            return nullcontext()
+        num_tiles = self._encoder_tile_count(height, width)
+        if num_tiles >= parallel_size:
+            return nullcontext()
+        logger.warning_once(
+            "MiniMax-H3 VAE encode splits a %dx%d input into %d tile(s) but "
+            "the tile group has %d ranks; encoding rank-locally for this "
+            "shape instead, which avoids ranks without tiles hanging the "
+            "collective.",
+            width,
+            height,
+            num_tiles,
+            parallel_size,
+        )
+        return self._rank_local_tiling()
+
     @contextmanager
     def _rank_local_tiling(self) -> Iterator[None]:
-        """Run one decode with tiling kept on this rank, then restore the group.
-
-        Used only when there are fewer tiles than ranks. Every rank then decodes
-        every tile, which is slower than sharing the work but is correct and
-        involves no collective.
-        """
-
         state = self._native_parallel_state()
         saved_state = dict(state)
         saved_tiling = self.model.parallel_tiling
@@ -290,15 +724,24 @@ class MiniMaxH3VideoVAE(nn.Module, DistributedVaeMixin):
 
     @torch.inference_mode()
     def encode_image(self, image: Image.Image) -> torch.Tensor:
+        if getattr(self, "decode_only", False):
+            raise RuntimeError("MiniMax H3 decode-only video VAE cannot encode images")
         previous_parallel = self.model.parallel_tiling
-        self.model.parallel_tiling = False
+        if int(getattr(self, "parallel_size", 1)) <= 1:
+            self.model.parallel_tiling = False
         parameter = next(self.parameters())
         previous_dtype = parameter.dtype
         if previous_dtype != torch.float32:
             self.to(torch.float32)
         devices = [parameter.device] if parameter.device.type != "cpu" else []
         try:
-            with torch.random.fork_rng(devices=devices, device_type=parameter.device.type):
+            with (
+                self._encoder_tiling_context(image.height, image.width),
+                torch.random.fork_rng(
+                    devices=devices,
+                    device_type=parameter.device.type,
+                ),
+            ):
                 torch.default_generator.manual_seed(MINIMAX_H3_KEYFRAME_ENCODE_SEED)
                 for device in devices:
                     with self.device_module.device(device):
@@ -332,22 +775,128 @@ 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,
         frames: Any,
     ) -> tuple[torch.Tensor, tuple[int, int, int]]:
+        if getattr(self, "decode_only", False):
+            raise RuntimeError("MiniMax H3 decode-only video VAE cannot encode videos")
         parameter = next(self.parameters())
         previous_dtype = parameter.dtype
         if previous_dtype != torch.float32:
             self.to(torch.float32)
         devices = [parameter.device] if parameter.device.type != "cpu" else []
+        shape = getattr(frames, "shape", None)
+        if int(getattr(self, "parallel_size", 1)) > 1:
+            if shape is None or len(shape) != 4:
+                raise ValueError("parallel MiniMax H3 video encode requires a rank-4 frame array")
+            if int(shape[-1]) in {1, 3, 4}:
+                frame_height, frame_width = int(shape[-3]), int(shape[-2])
+            else:
+                frame_height, frame_width = int(shape[-2]), int(shape[-1])
+            tiling_context = self._encoder_tiling_context(frame_height, frame_width)
+        else:
+            tiling_context = nullcontext()
         try:
-            with torch.random.fork_rng(devices=devices, device_type=parameter.device.type):
+            with tiling_context, torch.random.fork_rng(devices=devices, device_type=parameter.device.type):
                 torch.default_generator.manual_seed(MINIMAX_H3_KEYFRAME_ENCODE_SEED)
                 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,
@@ -403,9 +952,16 @@ class MiniMaxH3VideoVAE(nn.Module, DistributedVaeMixin):
 
     @torch.inference_mode()
     def decode_latent(self, latent: torch.Tensor) -> torch.Tensor:
+        if getattr(self, "encode_only", False):
+            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"])
@@ -422,7 +978,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.
@@ -440,6 +996,8 @@ class MiniMaxH3VideoVAE(nn.Module, DistributedVaeMixin):
         the complete decode path. After a callback failure, the remaining
         chunks are decoded and discarded before the exception is re-raised.
         """
+        if getattr(self, "encode_only", False):
+            raise RuntimeError("MiniMax H3 encode-only video VAE cannot decode latents")
         if not callable(on_chunk):
             raise TypeError("on_chunk must be callable")
         if not callable(getattr(self.model, "_adaptive_decode", None)):
@@ -456,6 +1014,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__(
@@ -464,14 +1049,24 @@ class MiniMaxH3AudioVAE(nn.Module):
         *,
         device: torch.device,
         load_device: torch.device | None = None,
+        encode_only: bool = False,
+        decode_only: bool = False,
+        trust_remote_code: bool = False,
     ) -> None:
         super().__init__()
         self._device_target = device
+        self.encode_only = bool(encode_only)
+        self.decode_only = bool(decode_only)
+        if self.encode_only and self.decode_only:
+            raise ValueError("MiniMax H3 audio VAE cannot be both encode-only and decode-only")
         self.config_dict = _load_component_config(component_path)
-        self.remote = _load_remote_component(
-            component_path,
-            self.config_dict,
-        )
+        _check_trust_remote_code(component_path, self.config_dict, trust_remote_code)
+        if self.encode_only:
+            self.remote = _load_audio_vae_encoder(component_path, self.config_dict)
+        else:
+            self.remote = _load_remote_component(component_path, self.config_dict, trust_remote_code=trust_remote_code)
+            if self.decode_only:
+                _remove_modules(self.remote.model, ("encoder", "pre_block", "mean_proj"))
         # The checkpoint's audio VAE contract is FP32 for both reference
         # encoding and waveform decoding.
         initial_device = load_device or device
@@ -514,6 +1109,8 @@ class MiniMaxH3AudioVAE(nn.Module):
         waveform: torch.Tensor,
         sample_rate: int,
     ) -> tuple[torch.Tensor, int]:
+        if getattr(self, "decode_only", False):
+            raise RuntimeError("MiniMax H3 decode-only audio VAE cannot encode waveforms")
         import torchaudio
 
         waveform = waveform.float()
@@ -559,6 +1156,8 @@ class MiniMaxH3AudioVAE(nn.Module):
 
     @torch.inference_mode()
     def decode_latent(self, latent: torch.Tensor) -> torch.Tensor:
+        if getattr(self, "encode_only", False):
+            raise RuntimeError("MiniMax H3 encode-only audio VAE cannot decode latents")
         channels = int(self.config_dict["latent_channels"])
         mean = torch.tensor(
             self.config_dict["latents_mean"],
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/pipeline_qwen_image_edit.py b/vllm_omni/diffusion/models/qwen_image/pipeline_qwen_image_edit.py
index 34e5733fd..a9b7ef95a 100644
--- a/vllm_omni/diffusion/models/qwen_image/pipeline_qwen_image_edit.py
+++ b/vllm_omni/diffusion/models/qwen_image/pipeline_qwen_image_edit.py
@@ -374,51 +374,6 @@ class QwenImageEditPipeline(
 
         return split_result
 
-    def _get_qwen_prompt_embeds(
-        self,
-        prompt: str | list[str] = None,
-        image: torch.Tensor | None = None,
-        dtype: torch.dtype | None = None,
-    ):
-        dtype = dtype or self.text_encoder.dtype
-
-        prompt = [prompt] if isinstance(prompt, str) else prompt
-
-        template = self.prompt_template_encode
-        drop_idx = self.prompt_template_encode_start_idx
-        txt = [template.format(e) for e in prompt]
-
-        model_inputs = self.processor(
-            text=txt,
-            images=image,
-            padding=True,
-            return_tensors="pt",
-        ).to(self.device)
-
-        outputs = self.text_encoder(
-            input_ids=model_inputs.input_ids,
-            attention_mask=model_inputs.attention_mask,
-            pixel_values=model_inputs.pixel_values,
-            image_grid_thw=model_inputs.image_grid_thw,
-            output_hidden_states=True,
-        )
-
-        hidden_states = outputs.hidden_states[-1]
-        split_hidden_states = self._extract_masked_hidden(hidden_states, model_inputs.attention_mask)
-        split_hidden_states = [e[drop_idx:] for e in split_hidden_states]
-        attn_mask_list = [torch.ones(e.size(0), dtype=torch.long, device=e.device) for e in split_hidden_states]
-        max_seq_len = max([e.size(0) for e in split_hidden_states])
-        prompt_embeds = torch.stack(
-            [torch.cat([u, u.new_zeros(max_seq_len - u.size(0), u.size(1))]) for u in split_hidden_states]
-        )
-        encoder_attention_mask = torch.stack(
-            [torch.cat([u, u.new_zeros(max_seq_len - u.size(0))]) for u in attn_mask_list]
-        )
-
-        prompt_embeds = prompt_embeds.to(dtype=dtype, device=self.device)
-
-        return prompt_embeds, encoder_attention_mask
-
     def _get_qwen_prompt_embeds(
         self,
         prompt: str | list[str] = None,
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 696728b90..cb1adbb61 100644
--- a/vllm_omni/diffusion/models/qwen_image/qwen_image_transformer.py
+++ b/vllm_omni/diffusion/models/qwen_image/qwen_image_transformer.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
 
@@ -45,20 +45,61 @@ from vllm_omni.diffusion.distributed.sp_plan import (
 )
 from vllm_omni.diffusion.forward_context import get_forward_context
 from vllm_omni.diffusion.layers.adalayernorm import AdaLayerNorm
+from vllm_omni.diffusion.layers.fused_qk_norm_rope import (
+    _fused_cuda_supported,
+    fused_qk_norm_rope,
+)
+from vllm_omni.diffusion.layers.qwen_select01_modulation import (
+    can_use_qwen_select01_triton,
+    fused_layernorm_select01,
+    fused_residual_layernorm_select01,
+    select01_modulation_native,
+)
 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.
+def _qwen_image_qk_norm_rope(
+    q: torch.Tensor,
+    k: torch.Tensor,
+    norm_q: nn.Module,
+    norm_k: nn.Module,
+    freqs: torch.Tensor,
+    rope: RotaryEmbedding,
+    eps: float,
+    *,
+    use_fused: bool = True,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    head_dim = q.shape[-1]
+    rotary_dim = freqs.shape[-1] * 2
+    if use_fused and _fused_cuda_supported(q, k, head_dim, rotary_dim, interleaved=True):
+        batch, seq_len, num_heads, _ = q.shape
+        num_kv_heads = k.shape[2]
+        rope_table = torch.cat((freqs.real, freqs.imag), dim=-1)
+        rope_table = rope_table.unsqueeze(0).expand(batch, -1, -1).reshape(batch * seq_len, rotary_dim)
+        fused_q, fused_k = fused_qk_norm_rope(
+            q.reshape(batch * seq_len, num_heads, head_dim),
+            k.reshape(batch * seq_len, num_kv_heads, head_dim),
+            norm_q.weight,
+            norm_k.weight,
+            rope_table,
+            eps,
+            interleaved=True,
+        )
+        return (
+            fused_q.reshape(batch, seq_len, num_heads, head_dim),
+            fused_k.reshape(batch, seq_len, num_kv_heads, head_dim),
+        )
 
-    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)
+    # 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)
+    cos = torch.real(freqs).to(q.dtype)
+    sin = torch.imag(freqs).to(q.dtype)
+    return rope(q, cos, sin), rope(k, cos, sin)
 
 
 def _normalize_qwen_image_weight_name(name: str) -> str:
@@ -648,28 +689,25 @@ class QwenImageCrossAttention(nn.Module):
         txt_key = txt_key.unflatten(-1, (self.add_kv_num_heads, self.head_dim))
         txt_value = txt_value.unflatten(-1, (self.add_kv_num_heads, self.head_dim))
 
-        img_query = self.norm_q(img_query)
-        img_key = self.norm_k(img_key)
-        txt_query = self.norm_added_q(txt_query)
-        txt_key = self.norm_added_k(txt_key)
-
-        if img_query.device.type == "cuda":
-            img_query = _apply_qwen_image_rotary_emb(img_query, vid_freqs)
-            img_key = _apply_qwen_image_rotary_emb(img_key, vid_freqs)
-            txt_query = _apply_qwen_image_rotary_emb(txt_query, txt_freqs)
-            txt_key = _apply_qwen_image_rotary_emb(txt_key, txt_freqs)
-        else:
-            # Retain the platform-specific kernels on other accelerators,
-            # which may not support complex tensors.
-            img_cos = torch.real(vid_freqs).to(img_query.dtype)
-            img_sin = torch.imag(vid_freqs).to(img_query.dtype)
-            txt_cos = torch.real(txt_freqs).to(txt_query.dtype)
-            txt_sin = torch.imag(txt_freqs).to(txt_query.dtype)
-
-            img_query = self.rope(img_query, img_cos, img_sin)
-            img_key = self.rope(img_key, img_cos, img_sin)
-            txt_query = self.rope(txt_query, txt_cos, txt_sin)
-            txt_key = self.rope(txt_key, txt_cos, txt_sin)
+        img_query, img_key = _qwen_image_qk_norm_rope(
+            img_query,
+            img_key,
+            self.norm_q,
+            self.norm_k,
+            vid_freqs,
+            self.rope,
+            self.eps,
+            use_fused=self.qk_norm,
+        )
+        txt_query, txt_key = _qwen_image_qk_norm_rope(
+            txt_query,
+            txt_key,
+            self.norm_added_q,
+            self.norm_added_k,
+            txt_freqs,
+            self.rope,
+            self.eps,
+        )
 
         seq_len_txt = encoder_hidden_states.shape[1]
         joint_query = torch.cat([txt_query, img_query], dim=1)
@@ -807,41 +845,11 @@ class QwenImageTransformerBlock(nn.Module):
 
         self.zero_cond_t = zero_cond_t
 
-    def _modulate(self, mod_params, index=None):
+    def _modulate(self, mod_params):
         """Apply modulation to input tensor"""
         # shift: b d, scale: b d, gate: b d
         shift, scale, gate = mod_params.chunk(3, dim=-1)
-
-        if index is not None:
-            # Assuming mod_params batch dim is 2*actual_batch (chunked into 2 parts)
-            # So shift, scale, gate have shape [2*actual_batch, d]
-            actual_batch = shift.size(0) // 2
-            shift_0, shift_1 = shift[:actual_batch], shift[actual_batch:]  # each: [actual_batch, d]
-            scale_0, scale_1 = scale[:actual_batch], scale[actual_batch:]
-            gate_0, gate_1 = gate[:actual_batch], gate[actual_batch:]
-
-            # index: [b, l] where b is actual batch size
-            # Expand to [b, l, 1] to match feature dimension
-            index_expanded = index.unsqueeze(-1)  # [b, l, 1]
-
-            # Expand chunks to [b, 1, d] then broadcast to [b, l, d]
-            shift_0_exp = shift_0.unsqueeze(1)  # [b, 1, d]
-            shift_1_exp = shift_1.unsqueeze(1)  # [b, 1, d]
-            scale_0_exp = scale_0.unsqueeze(1)
-            scale_1_exp = scale_1.unsqueeze(1)
-            gate_0_exp = gate_0.unsqueeze(1)
-            gate_1_exp = gate_1.unsqueeze(1)
-
-            # Use torch.where to select based on index
-            shift_result = torch.where(index_expanded == 0, shift_0_exp, shift_1_exp)
-            scale_result = torch.where(index_expanded == 0, scale_0_exp, scale_1_exp)
-            gate_result = torch.where(index_expanded == 0, gate_0_exp, gate_1_exp)
-        else:
-            shift_result = shift.unsqueeze(1)
-            scale_result = scale.unsqueeze(1)
-            gate_result = gate.unsqueeze(1)
-
-        return scale_result, shift_result, gate_result
+        return scale.unsqueeze(1), shift.unsqueeze(1), gate.unsqueeze(1)
 
     def forward(
         self,
@@ -867,8 +875,22 @@ class QwenImageTransformerBlock(nn.Module):
         txt_mod1, txt_mod2 = txt_mod_params.chunk(2, dim=-1)  # Each [B, 3*dim]
 
         # Process image stream - norm1 + modulation
-        img_scale1, img_shift1, img_gate1 = self._modulate(img_mod1, modulate_index)
-        img_modulated = self.img_norm1(hidden_states, img_scale1, img_shift1)
+        use_fused_select01 = modulate_index is not None and can_use_qwen_select01_triton(hidden_states)
+        if use_fused_select01:
+            img_modulated, img_gate1 = fused_layernorm_select01(
+                hidden_states,
+                img_mod1,
+                modulate_index,
+                self.img_norm1.eps,
+                self.img_norm1.layernorm.weight,
+                self.img_norm1.layernorm.bias,
+            )
+        elif modulate_index is not None:
+            img_scale1, img_shift1, img_gate1 = select01_modulation_native(img_mod1, modulate_index)
+            img_modulated = self.img_norm1(hidden_states, img_scale1, img_shift1)
+        else:
+            img_scale1, img_shift1, img_gate1 = self._modulate(img_mod1)
+            img_modulated = self.img_norm1(hidden_states, img_scale1, img_shift1)
 
         # Process text stream - norm1 + modulation
         txt_scale1, txt_shift1, txt_gate1 = self._modulate(txt_mod1)
@@ -893,12 +915,29 @@ class QwenImageTransformerBlock(nn.Module):
         img_attn_output, txt_attn_output = attn_output
 
         # Apply attention gates and add residual (like in Megatron)
-        hidden_states = hidden_states + img_gate1 * img_attn_output
+        hidden_states_before_attn = hidden_states
+        if not use_fused_select01:
+            hidden_states = hidden_states + img_gate1 * img_attn_output
         encoder_hidden_states = encoder_hidden_states + txt_gate1 * txt_attn_output
 
         # Process image stream - norm2 + MLP
-        img_scale2, img_shift2, img_gate2 = self._modulate(img_mod2, modulate_index)
-        img_modulated2 = self.img_norm2(hidden_states, img_scale2, img_shift2)
+        if use_fused_select01:
+            img_modulated2, hidden_states, img_gate2 = fused_residual_layernorm_select01(
+                img_attn_output,
+                hidden_states_before_attn,
+                img_gate1,
+                img_mod2,
+                modulate_index,
+                self.img_norm2.eps,
+                self.img_norm2.layernorm.weight,
+                self.img_norm2.layernorm.bias,
+            )
+        elif modulate_index is not None:
+            img_scale2, img_shift2, img_gate2 = select01_modulation_native(img_mod2, modulate_index)
+            img_modulated2 = self.img_norm2(hidden_states, img_scale2, img_shift2)
+        else:
+            img_scale2, img_shift2, img_gate2 = self._modulate(img_mod2)
+            img_modulated2 = self.img_norm2(hidden_states, img_scale2, img_shift2)
 
         img_mlp_output = self.img_mlp(img_modulated2)
         hidden_states = hidden_states + img_gate2 * img_mlp_output
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 c9ef325c4..a971806b0 100644
--- a/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2.py
+++ b/vllm_omni/diffusion/models/wan2_2/pipeline_wan2_2.py
@@ -26,18 +26,34 @@ from vllm_omni.diffusion.distributed.pipeline_parallel import AsyncLatents, Pipe
 from vllm_omni.diffusion.distributed.utils import get_local_device
 from vllm_omni.diffusion.forward_context import DenoiseProgressMixin
 from vllm_omni.diffusion.lora.loader import WanLoraLoaderMixin
+from vllm_omni.diffusion.media import (
+    DiffusionMediaOutput,
+    VideoMediaOutput,
+    VideoTensorEncoding,
+    VideoTensorLayout,
+    VideoTensorSpec,
+    VideoValueRange,
+)
 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.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
@@ -51,9 +67,11 @@ FASTWAN_DMD_SCHEDULER_SHIFT = 8.0
 
 def build_wan_scheduler(sample_solver: str, flow_shift: float) -> Any:
     if sample_solver == "unipc":
+        # Keep native Wan's unshifted training endpoints; set_timesteps applies
+        # the requested shift to the interpolated inference sigmas.
         return FlowUniPCMultistepScheduler(
             num_train_timesteps=1000,
-            shift=flow_shift,
+            shift=1.0,
             prediction_type="flow_prediction",
         )
     if sample_solver == "euler":
@@ -169,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 = {}
@@ -206,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:
@@ -235,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(
@@ -450,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
 
@@ -494,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):
@@ -670,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
 
@@ -766,7 +820,10 @@ class Wan22Pipeline(
                 self._sample_solver = sample_solver
                 self._flow_shift = flow_shift
 
-            self.scheduler.set_timesteps(num_steps, device=device)
+            if sample_solver == "unipc":
+                self.scheduler.set_timesteps(num_steps, device=device, shift=flow_shift)
+            else:
+                self.scheduler.set_timesteps(num_steps, device=device)
             timesteps = self.scheduler.timesteps
         self._num_timesteps = len(timesteps)
         boundary_timestep = None
@@ -907,6 +964,7 @@ class Wan22Pipeline(
 
         if DEBUG_PERF:
             _t_decode_start = time.perf_counter()
+        media = None
         if output_type == "latent":
             output = latents
         else:
@@ -920,7 +978,36 @@ class Wan22Pipeline(
                 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:
+                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()
@@ -947,6 +1034,7 @@ class Wan22Pipeline(
         return split_diffusion_output_by_request(
             DiffusionOutput(
                 output=output,
+                media=media,
                 stage_durations=self.stage_durations if hasattr(self, "stage_durations") else None,
             ),
             req,
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 908a35020..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
 
@@ -629,7 +630,10 @@ class Wan22I2VPipeline(
             self._flow_shift = flow_shift
 
         # Timesteps
-        self.scheduler.set_timesteps(num_steps, device=device)
+        if sample_solver == "unipc":
+            self.scheduler.set_timesteps(num_steps, device=device, shift=flow_shift)
+        else:
+            self.scheduler.set_timesteps(num_steps, device=device)
         timesteps = self.scheduler.timesteps
         self._num_timesteps = len(timesteps)
 
@@ -745,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 ea99e065f..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
 
@@ -545,10 +559,10 @@ class Wan22S2VPipeline(
             self._init_original_format(model_path, dtype)
 
         # -- Scheduler --
-        flow_shift = od_config.flow_shift if od_config.flow_shift is not None else 3.0  # S2V default
+        self._flow_shift = od_config.flow_shift if od_config.flow_shift is not None else 3.0  # S2V default
         self.scheduler = FlowUniPCMultistepScheduler(
             num_train_timesteps=1000,
-            shift=flow_shift,
+            shift=1.0,
             prediction_type="flow_prediction",
         )
 
@@ -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)
-            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 0d48dffb5..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,
@@ -690,7 +697,10 @@ class Wan22VACEPipeline(Wan22Pipeline, SupportImageInput):
         )
 
         # Set up scheduler
-        self.scheduler.set_timesteps(num_inference_steps, device=device)
+        if self._sample_solver == "unipc":
+            self.scheduler.set_timesteps(num_inference_steps, device=device, shift=self._flow_shift)
+        else:
+            self.scheduler.set_timesteps(num_inference_steps, device=device)
         timesteps = self.scheduler.timesteps
         self._num_timesteps = len(timesteps)
 
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/models/z_image/z_image_transformer.py b/vllm_omni/diffusion/models/z_image/z_image_transformer.py
index 1399eb0f0..f25c01fca 100644
--- a/vllm_omni/diffusion/models/z_image/z_image_transformer.py
+++ b/vllm_omni/diffusion/models/z_image/z_image_transformer.py
@@ -612,6 +612,15 @@ class ZImageTransformer2DModel(CachedTransformer):
         Note: Our "Sequence Parallelism" (SP) corresponds to "Context Parallelism" (CP) in diffusers.
     """
 
+    # Fused projections and their checkpoint shard names (mirrors
+    # stacked_params_mapping in load_weights). ``w13`` is the Z-Image FFN
+    # fusion of ``w1``/``w3``; declared here so quantized-checkpoint adapters
+    # can resolve shard keys without a framework-level default entry.
+    packed_modules_mapping = {
+        "to_qkv": ["to_q", "to_k", "to_v"],
+        "w13": ["w1", "w3"],
+    }
+
     _repeated_blocks = ["ZImageTransformerBlock"]
     _layerwise_offload_blocks_attrs = ["layers"]
 
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/layerwise_backend.py b/vllm_omni/diffusion/offloader/layerwise_backend.py
index a1e594f8b..e9f8cf5be 100644
--- a/vllm_omni/diffusion/offloader/layerwise_backend.py
+++ b/vllm_omni/diffusion/offloader/layerwise_backend.py
@@ -14,11 +14,6 @@ from vllm_omni.diffusion.hooks import HookRegistry, ModelHook
 from vllm_omni.platforms import current_omni_platform
 
 from .base import OffloadBackend, OffloadConfig, run_cleanup_steps
-from .block_discovery import (
-    get_blocks_attr_names,
-    get_blocks_from_dit,
-    set_blocks_attr_names,
-)
 from .component_utils import (
     clear_encoder_layerwise_state,
     iter_streamable_dits,
@@ -26,7 +21,6 @@ from .component_utils import (
     prepare_pipeline_components,
     set_encoder_layerwise_state,
 )
-from .config import DIT_COMPONENT
 from .plan_resolver import ResolvedComponent, resolve_offload_plan
 from .tensor_utils import (
     clear_block_storage,
@@ -433,9 +427,8 @@ class LayerWiseOffloadBackend(OffloadBackend):
             return
 
         resolved = resolve_offload_plan(pipeline, self.config)
-        if not resolved.dits and self.config.offloads(DIT_COMPONENT):
-            # An explicit selection already failed while resolving.
-            logger.warning("No DiT/transformer modules found for selected DiT layerwise offload")
+        if resolved.skip_reason is not None:
+            logger.warning("%s", resolved.skip_reason)
             return
 
         def enable_encoder_blocks(component: ResolvedComponent) -> bool:
@@ -458,15 +451,6 @@ class LayerWiseOffloadBackend(OffloadBackend):
             enable_encoder_blocks=enable_encoder_blocks,
         )
 
-        if not self.config.offloads(DIT_COMPONENT):
-            self.enabled = bool(self._encoder_modules or self._staged_components)
-            if not self.enabled:
-                raise ValueError(
-                    "None of the selected layerwise offload components have "
-                    "a model-declared streamable or on-demand plan"
-                )
-            return
-
         logger.info("Applying layer-wise offloading on %s", [component.path for component in resolved.dits])
 
         # Apply block-wise offloading hook for each of the blocks in DiT model(s)
@@ -475,22 +459,9 @@ class LayerWiseOffloadBackend(OffloadBackend):
             dit_module = component.module
             blocks = list(stack.blocks)
 
-            # Move non-block modules to GPU (they stay resident)
-            for name, m in dit_module.named_children():
-                if name not in stack.attrs:
-                    m.to(self.device)
-                    logger.debug(f"Moved {name} to device {self.device}")
-                else:
-                    logger.debug(f"Skipped blocks module {name}")
-
-            # Move top-level params/buffers to GPU (dit_module's own, not sub-modules)
-            for param in dit_module._parameters.values():
-                if param is not None:
-                    param.data = param.data.to(self.device, non_blocking=True)
-
-            for buffer in dit_module._buffers.values():
-                if buffer is not None:
-                    buffer.data = buffer.data.to(self.device, non_blocking=True)
+            # Place the remainder by resolved block tensor identity, just as
+            # for encoders. Attribute aliases must not move streamed weights.
+            move_non_block_state_to_device(dit_module, (stack.blocks,), self.device)
 
             block_hooks = _install_layerwise_hook_group(
                 blocks,
@@ -550,8 +521,3 @@ class LayerWiseOffloadBackend(OffloadBackend):
 
     def disable(self) -> None:
         self._disable(restore_weights=True)
-
-    # Compatibility aliases for existing model integrations.
-    get_blocks_attr_names = staticmethod(get_blocks_attr_names)
-    set_blocks_attr_names = staticmethod(set_blocks_attr_names)
-    get_blocks_from_dit = staticmethod(get_blocks_from_dit)
diff --git a/vllm_omni/diffusion/offloader/plan_resolver.py b/vllm_omni/diffusion/offloader/plan_resolver.py
index b2e951b4e..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,17 +90,33 @@ 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
+    # the strategy that honors it.
+    skip_reason: str | None = None
 
     @property
     def components(self) -> tuple[ResolvedComponent, ...]:
         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.
@@ -112,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,
@@ -248,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)
@@ -302,8 +407,11 @@ 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
+            else None
+        ),
     )
     _validate_unique_ownership(resolved)
     return resolved
@@ -312,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/offloader/sequential_backend.py b/vllm_omni/diffusion/offloader/sequential_backend.py
index 3dc32320b..55a225256 100644
--- a/vllm_omni/diffusion/offloader/sequential_backend.py
+++ b/vllm_omni/diffusion/offloader/sequential_backend.py
@@ -13,7 +13,6 @@ from vllm_omni.diffusion.hooks import HookRegistry, ModelHook
 from vllm_omni.platforms import current_omni_platform
 
 from .base import OffloadBackend, OffloadConfig, SupportsModelCpuOffload
-from .config import DIT_COMPONENT
 from .module_residency import PinnedModuleStager
 from .plan_resolver import resolve_offload_plan
 
@@ -385,6 +384,7 @@ class ModelLevelOffloadBackend(OffloadBackend):
         encoders = [component.module for component in resolved.encoders]
         vaes = [component.module for component in resolved.vaes]
         residents = [component.module for component in resolved.residents]
+        selected_dits = [component.module for component in resolved.dits if component.selected]
         selected_encoders = [component.module for component in resolved.encoders if component.selected]
 
         all_modules = [*dits, *encoders, *vaes, *residents]
@@ -412,7 +412,7 @@ class ModelLevelOffloadBackend(OffloadBackend):
                 device=self.device,
                 pin_memory=self.config.pin_cpu_memory,
                 use_hsdp=self.config.use_hsdp,
-                offload_dit_modules=(dits if self.config.offloads(DIT_COMPONENT) else ()),
+                offload_dit_modules=selected_dits,
                 offload_encoder_modules=selected_encoders,
                 # Fixed DiT staging keeps decode-graph weight pointers valid;
                 # other platforms keep plain move semantics.
diff --git a/vllm_omni/diffusion/output_formatter.py b/vllm_omni/diffusion/output_formatter.py
index 62c2330d5..4074806e1 100644
--- a/vllm_omni/diffusion/output_formatter.py
+++ b/vllm_omni/diffusion/output_formatter.py
@@ -5,7 +5,7 @@ from __future__ import annotations
 
 from collections.abc import Mapping
 from dataclasses import dataclass, field
-from typing import TypeGuard, cast
+from typing import Any, TypeGuard, cast
 
 from vllm_omni.diffusion.data import DiffusionOutput, OmniDiffusionConfig
 from vllm_omni.diffusion.io_support import get_diffusion_output_type, supports_audio_output
@@ -106,6 +106,7 @@ def format_empty_diffusion_outputs(
     request: OmniDiffusionRequest,
     *,
     finished: bool = True,
+    custom_output: dict[str, Any] | None = None,
 ) -> list[OmniRequestOutput]:
     return [
         OmniRequestOutput.from_diffusion(
@@ -114,6 +115,7 @@ def format_empty_diffusion_outputs(
             prompt=request.prompt,
             metrics={},
             latents=None,
+            custom_output=custom_output,
             finished=finished,
         )
     ]
diff --git a/vllm_omni/diffusion/postprocess/device_reduction.py b/vllm_omni/diffusion/postprocess/device_reduction.py
new file mode 100644
index 000000000..ec4ef895f
--- /dev/null
+++ b/vllm_omni/diffusion/postprocess/device_reduction.py
@@ -0,0 +1,152 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Device-side reduction of decoded video tensors to uint8 frames."""
+
+from __future__ import annotations
+
+from dataclasses import replace
+
+import torch
+from vllm.logger import init_logger
+
+from vllm_omni.diffusion.data import OmniDiffusionConfig
+from vllm_omni.diffusion.media import (
+    DiffusionMediaOutput,
+    FloatVideoConsumer,
+    VideoMediaOutput,
+    VideoTensorEncoding,
+    VideoTensorLayout,
+    VideoTensorSpec,
+    VideoTransportConstraints,
+    VideoValueRange,
+    ensure_request_owned_tensor,
+)
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+from vllm_omni.platforms import current_omni_platform
+
+# VaeImageProcessor.denormalize: (x * 0.5 + 0.5).clamp(0, 1)
+_DENORM_SCALE = 0.5
+_DENORM_SHIFT = 0.5
+
+logger = init_logger(__name__)
+
+
+def _request_float_consumers(
+    sampling_params: OmniDiffusionSamplingParams | None,
+) -> frozenset[FloatVideoConsumer]:
+    if sampling_params is not None and sampling_params.enable_frame_interpolation:
+        return frozenset({FloatVideoConsumer.FRAME_INTERPOLATION})
+    return frozenset()
+
+
+def _request_supports_uint8_frames(sampling_params: OmniDiffusionSamplingParams | None) -> bool:
+    return sampling_params is None or (sampling_params.output_type or "np") == "np"
+
+
+def _prepare_float_media_for_transport(
+    media: DiffusionMediaOutput,
+    video: VideoMediaOutput,
+) -> DiffusionMediaOutput:
+    prepared = replace(
+        media,
+        video=video.with_tensor(ensure_request_owned_tensor(video.tensor)),
+        prepared_for_transport=True,
+    )
+    prepared.validate()
+    return prepared
+
+
+def prepare_diffusion_media_for_transport(
+    media: DiffusionMediaOutput,
+    *,
+    od_config: OmniDiffusionConfig,
+    sampling_params: OmniDiffusionSamplingParams | None = None,
+) -> DiffusionMediaOutput:
+    """Validate and prepare one request-local media output before D2H."""
+    media.validate()
+    if media.prepared_for_transport:
+        # Only the model runner prepares media, exactly once, on media the
+        # pipeline emits unprepared. Accepting pre-prepared media here would let
+        # a pipeline forge runner-owned state and skip request policy (e.g. a
+        # forged uint8 payload silently bypasses frame interpolation).
+        raise ValueError(
+            "Media reached transport preparation already prepared; pipelines must "
+            "emit unprepared media so request policy is applied by the runner"
+        )
+    if media.video.spec.encoding is not VideoTensorEncoding.NORMALIZED_FLOAT:
+        raise ValueError("Pipelines must emit unprepared media as NORMALIZED_FLOAT video")
+
+    video = media.video
+    constraints = VideoTransportConstraints(
+        pending_float_consumers=(video.constraints.pending_float_consumers | _request_float_consumers(sampling_params))
+    )
+    constrained_video = replace(video, constraints=constraints)
+
+    enabled = od_config.video_output_transport.enable_device_postprocess
+    output_supported = _request_supports_uint8_frames(sampling_params)
+    if not enabled or constraints.pending_float_consumers or not output_supported:
+        if not enabled:
+            reason = "disabled"
+        elif constraints.pending_float_consumers:
+            reason = ",".join(sorted(consumer.value for consumer in constraints.pending_float_consumers))
+        else:
+            reason = "unsupported_presentation"
+        logger.debug("Device video preparation kept normalized float: reason=%s", reason)
+        return _prepare_float_media_for_transport(media, constrained_video)
+
+    try:
+        frames = reduce_video_to_uint8_frames(
+            constrained_video.tensor,
+            do_denormalize=constrained_video.spec.value_range is VideoValueRange.NEGATIVE_ONE_TO_ONE,
+        )
+    except torch.OutOfMemoryError:
+        logger.warning("Device video preparation ran out of memory; using normalized float transport")
+    else:
+        prepared_video = replace(
+            constrained_video,
+            tensor=frames,
+            spec=VideoTensorSpec(
+                layout=VideoTensorLayout.BTHWC,
+                encoding=VideoTensorEncoding.UINT8_FRAMES,
+                value_range=VideoValueRange.ZERO_TO_255,
+            ),
+            constraints=VideoTransportConstraints(),
+        )
+        prepared = replace(media, video=prepared_video, prepared_for_transport=True)
+        prepared.validate()
+        logger.debug(
+            "Device video preparation converted normalized float to uint8: shape=%s",
+            tuple(frames.shape),
+        )
+        return prepared
+
+    # Leave the exception handler before allocator cleanup and fallback
+    # construction. A late conversion OOM otherwise keeps the helper traceback
+    # (and its live float32 intermediates) reachable while the fallback may need
+    # to clone a non-compact request view.
+    current_omni_platform.empty_cache()
+    current_omni_platform.synchronize()
+    return _prepare_float_media_for_transport(media, constrained_video)
+
+
+def reduce_video_to_uint8_frames(video: torch.Tensor, *, do_denormalize: bool = True) -> torch.Tensor:
+    """Reduce a decoded ``[B, C, F, H, W]`` video to uint8 ``[B, F, H, W, C]`` frames.
+
+    Runs denormalize/clamp/permute/round on the input's device so the following
+    D2H copy carries uint8 instead of float. The result matches
+    ``VideoProcessor.postprocess_video(output_type="np")`` then the ``*255``
+    rounding done in the API server. Pass ``do_denormalize=False`` for VAEs that
+    already emit ``[0, 1]``.
+    """
+    if video.dim() != 5:
+        raise ValueError(f"expected a [B, C, F, H, W] video tensor, got shape {tuple(video.shape)}")
+
+    # Match the numpy path, which promotes to float before scaling.
+    frames = video.to(torch.float32)
+    if do_denormalize:
+        frames = frames.mul(_DENORM_SCALE).add(_DENORM_SHIFT).clamp_(0.0, 1.0)
+    else:
+        frames = frames.clamp(0.0, 1.0)
+    frames = frames.permute(0, 2, 3, 4, 1)
+    frames = frames.mul_(255.0).round_().clamp_(0.0, 255.0).to(torch.uint8)
+    return frames.contiguous()
diff --git a/vllm_omni/diffusion/postprocess/media.py b/vllm_omni/diffusion/postprocess/media.py
new file mode 100644
index 000000000..fd2564434
--- /dev/null
+++ b/vllm_omni/diffusion/postprocess/media.py
@@ -0,0 +1,92 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from __future__ import annotations
+
+from dataclasses import replace
+
+from vllm_omni.diffusion.media import (
+    DiffusionMediaOutput,
+    FloatVideoConsumer,
+    VideoTensorEncoding,
+    VideoTensorLayout,
+    VideoTransportConstraints,
+    VideoValueRange,
+)
+from vllm_omni.diffusion.postprocess.rife_interpolator import interpolate_video_tensor
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+
+def finalize_diffusion_media(
+    media: DiffusionMediaOutput,
+    *,
+    sampling_params: OmniDiffusionSamplingParams,
+) -> dict[str, object]:
+    """Finalize typed video media without invoking a model postprocessor."""
+    media.validate()
+    if not media.prepared_for_transport:
+        raise ValueError("Diffusion media reached the engine before transport preparation")
+
+    video = media.video
+    metadata: dict[str, object] = {}
+    consumers = video.constraints.pending_float_consumers
+    if FloatVideoConsumer.FRAME_INTERPOLATION in consumers:
+        if video.spec.encoding is not VideoTensorEncoding.NORMALIZED_FLOAT:
+            raise ValueError("Frame interpolation requires NORMALIZED_FLOAT video")
+        # RIFE guesses [0,1] vs [-1,1] from the tensor's min/max, so relying on
+        # the sample content misclassifies both an all-nonnegative [-1,1] clip
+        # (read as [0,1]) and a [0,1] clip whose single bf16 value overshoots 1
+        # (read as [-1,1]). Always map to unit range per the declared spec and
+        # clamp to [0,1] before RIFE, then restore the declared range so
+        # downstream denormalization is correct regardless of the sample.
+        to_negative_one = video.spec.value_range is VideoValueRange.NEGATIVE_ONE_TO_ONE
+        if to_negative_one:
+            interp_input = video.tensor.mul(0.5).add(0.5).clamp_(0.0, 1.0)
+        else:
+            interp_input = video.tensor.clamp(0.0, 1.0)
+        interpolated, multiplier = interpolate_video_tensor(
+            interp_input,
+            exp=sampling_params.frame_interpolation_exp,
+            scale=sampling_params.frame_interpolation_scale,
+            model_path=sampling_params.frame_interpolation_model_path,
+        )
+        if to_negative_one:
+            interpolated = interpolated.mul(2.0).sub(1.0)
+        consumers = consumers - {FloatVideoConsumer.FRAME_INTERPOLATION}
+        video = replace(
+            video,
+            tensor=interpolated,
+            constraints=VideoTransportConstraints(pending_float_consumers=frozenset(consumers)),
+        )
+        metadata["video"] = {"video_fps_multiplier": multiplier}
+
+    if consumers:
+        names = sorted(consumer.value for consumer in consumers)
+        raise ValueError(f"Video has pending float consumers at finalization: {names}")
+
+    output_type = getattr(sampling_params, "output_type", None) or "np"
+    if output_type == "latent":
+        raise ValueError("Latent output cannot be finalized from VideoMediaOutput")
+
+    if video.spec.encoding is VideoTensorEncoding.UINT8_FRAMES:
+        if video.spec.layout is not VideoTensorLayout.BTHWC:
+            raise ValueError("UINT8_FRAMES video must use BTHWC layout")
+        if output_type != "np":
+            raise ValueError(f"UINT8_FRAMES finalization does not support output_type={output_type!r}")
+        frames = video.tensor.detach().cpu().numpy()
+    else:
+        if video.spec.layout is not VideoTensorLayout.BCTHW:
+            raise ValueError("NORMALIZED_FLOAT video must use BCTHW layout")
+        from diffusers.video_processor import VideoProcessor
+
+        do_denormalize = video.spec.value_range is VideoValueRange.NEGATIVE_ONE_TO_ONE
+        frames = VideoProcessor(vae_scale_factor=8).postprocess_video(
+            video.tensor,
+            output_type=output_type,
+            do_denormalize=[do_denormalize] * video.tensor.shape[2],
+        )
+
+    return {
+        "payload": {"video": frames},
+        "metadata": metadata,
+    }
diff --git a/vllm_omni/diffusion/registry.py b/vllm_omni/diffusion/registry.py
index c4f923444..6c2ed3571 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": (
@@ -61,6 +74,11 @@ _DIFFUSION_MODELS = {
         "pipeline_ovis_image",
         "OvisImagePipeline",
     ),
+    "MammothModa2DiTPipeline": (
+        "mammoth_moda2",
+        "pipeline_mammothmoda2_dit",
+        "MammothModa2DiTPipeline",
+    ),
     "WanPipeline": (
         "wan2_2",
         "pipeline_wan2_2",
@@ -121,6 +139,11 @@ _DIFFUSION_MODELS = {
         "pipeline_minimax_h3",
         "MiniMaxH3Pipeline",
     ),
+    "AuKPipeline": (
+        "auk",
+        "pipeline_auk",
+        "AuKPipeline",
+    ),
     "StableAudioPipeline": (
         "stable_audio",
         "pipeline_stable_audio",
@@ -206,6 +229,11 @@ _DIFFUSION_MODELS = {
         "pipeline_pi0",
         "Pi0Pipeline",
     ),
+    "Pi05Pipeline": (
+        "pi05",
+        "pipeline_pi05",
+        "Pi05Pipeline",
+    ),
     "LongCatImageEditPipeline": (
         "longcat_image",
         "pipeline_longcat_image_edit",
@@ -351,6 +379,11 @@ _DIFFUSION_MODELS = {
         "pipeline_dreamzero",
         "DreamZeroPipeline",
     ),
+    "AnimaPipeline": (
+        "anima",
+        "pipeline_anima",
+        "AnimaPipeline",
+    ),
     "StableDiffusionXLPipeline": (
         "sdxl",
         "pipeline_sdxl",
@@ -377,11 +410,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",
     # Qwen-Image 2.1's transformer carries its own prefix KV cache (keyed by CFG
     # branch) across denoising steps, which conflicts with cache_dit / tea_cache
@@ -557,12 +592,14 @@ _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",
     "QwenImage21Pipeline": "get_qwen_image_21_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",
@@ -577,6 +614,7 @@ _DIFFUSION_POST_PROCESS_FUNCS = {
     "LTX2I2VDMD2Pipeline": "get_ltx2_post_process_func",
     "MiniMaxH3Pipeline": "get_minimax_h3_post_process_func",
     "MiniMaxH3ModularPipeline": "get_minimax_h3_post_process_func",
+    "AuKPipeline": "get_auk_post_process_func",
     "StableAudioPipeline": "get_stable_audio_post_process_func",
     "WanImageToVideoPipeline": "get_wan22_i2v_post_process_func",
     "WanS2VPipeline": "get_wan22_s2v_post_process_func",
@@ -590,6 +628,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 f90f843a5..3e1dffb57 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 3b5f515ef..5f27f43a9 100644
--- a/vllm_omni/diffusion/sched/step_scheduler.py
+++ b/vllm_omni/diffusion/sched/step_scheduler.py
@@ -78,7 +78,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/stage_diffusion_proc.py b/vllm_omni/diffusion/stage_diffusion_proc.py
index aedb730e3..220158f1f 100644
--- a/vllm_omni/diffusion/stage_diffusion_proc.py
+++ b/vllm_omni/diffusion/stage_diffusion_proc.py
@@ -13,7 +13,7 @@ import asyncio
 import contextlib
 import multiprocessing.connection
 import signal
-from collections.abc import AsyncGenerator
+from collections.abc import AsyncGenerator, Awaitable, Callable
 from concurrent.futures import ThreadPoolExecutor
 from types import SimpleNamespace
 from typing import TYPE_CHECKING, Any
@@ -33,7 +33,10 @@ from vllm.v1.engine.utils import (
 )
 from vllm.v1.utils import shutdown
 
-from vllm_omni.diffusion.data import DiffusionRequestAbortedError
+from vllm_omni.diffusion.data import (
+    DiffusionRequestAbortedError,
+    is_diffusion_request_started_output,
+)
 from vllm_omni.diffusion.diffusion_engine import DiffusionEngine
 from vllm_omni.diffusion.request import OmniDiffusionRequest
 from vllm_omni.distributed.omni_connectors.utils.serialization import (
@@ -163,6 +166,7 @@ class StageDiffusionProc:
         prompt: Any,
         sampling_params_dict: dict,
         kv_sender_info: dict[str, Any] | None = None,
+        on_request_started: Callable[[OmniRequestOutput], Awaitable[None]] | None = None,
         kv_transfer_params: dict[str, Any] | None = None,
     ) -> OmniRequestOutput:
         """Build a diffusion request and consume DiffusionEngine.step_streaming() to completion."""
@@ -180,7 +184,13 @@ class StageDiffusionProc:
         # return the final output.
         result = None
         async for results in self._engine.step_streaming(request):
-            result = results[0]
+            output = results[0]
+            if is_diffusion_request_started_output(output) and on_request_started is not None:
+                if not output.request_id:
+                    output.request_id = request_id
+                await on_request_started(output)
+                continue
+            result = output
         if result is None:
             raise RuntimeError("Diffusion execution finished without output.")
         if not result.request_id:
@@ -354,11 +364,16 @@ class StageDiffusionProc:
             """Process a single diffusion request and send the response."""
             try:
                 if not self._od_config.streaming_output:
+
+                    async def _send_request_started(output: OmniRequestOutput) -> None:
+                        await response_socket.send(encoder.encode({"type": "result", "output": output}))
+
                     result = await self._process_request(
                         request_id,
                         prompt,
                         sampling_params_dict,
                         kv_sender_info=kv_sender_info,
+                        on_request_started=_send_request_started,
                         kv_transfer_params=kv_transfer_params,
                     )
                     await response_socket.send(encoder.encode({"type": "result", "output": result}))
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 615df090f..a53359cc8 100644
--- a/vllm_omni/diffusion/utils/media_utils.py
+++ b/vllm_omni/diffusion/utils/media_utils.py
@@ -7,16 +7,57 @@ from __future__ import annotations
 import io
 import queue
 import threading
-from collections.abc import Iterable
+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:
+        raise ValueError("preencode_batch_frames must be a positive integer")
+    return value
+
+
+def normalize_video_codec_options(value: Any) -> dict[str, str] | None:
+    """Coerce a request's ``video_codec_options`` into PyAV's str->str contract.
+
+    The value reaches a worker straight from ``extra_params``, so reject a
+    non-mapping here rather than letting it fail inside the encoder after the
+    decode has already run.
+    """
+    if value is None:
+        return None
+    if not isinstance(value, Mapping):
+        raise ValueError("video_codec_options must be a JSON object of encoder option names to values")
+    return {str(key): str(item) for key, item in value.items()}
+
+
 def _validate_video_chunk(chunk: np.ndarray, *, width: int, height: int) -> None:
     """Validate a ``(T, H, W, 3)`` uint8 RGB chunk against a session's frame size."""
     if chunk.ndim != 4 or chunk.shape[-1] != 3:
@@ -30,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`.
     """
 
@@ -64,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,
@@ -79,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)
@@ -86,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)
@@ -109,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:
@@ -144,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()
 
@@ -233,6 +306,18 @@ class FragmentedMP4Muxer:
         return chunk
 
 
+def count_mp4_frames(video_bytes: bytes) -> int | None:
+    """Read an MP4's frame count from its sample table, without decoding it."""
+    if not video_bytes:
+        return None
+    try:
+        with cast(Any, av.open(io.BytesIO(video_bytes), format="mp4")) as container:
+            frames = int(container.streams.video[0].frames)
+    except Exception:
+        return None
+    return frames or None
+
+
 def finalize_streaming_video_bytes(
     video_bytes: bytes,
     *,
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 5fb9ce16b..49cb9452c 100644
--- a/vllm_omni/diffusion/worker/diffusion_model_runner.py
+++ b/vllm_omni/diffusion/worker/diffusion_model_runner.py
@@ -25,7 +25,7 @@ from vllm.utils.mem_utils import DeviceMemoryProfiler, GiB_bytes
 from vllm.v1.kv_cache_interface import KVCacheConfig, KVCacheSpec
 
 from vllm_omni.diffusion.attention.layer import Attention
-from vllm_omni.diffusion.cache.cachedit import cache_summary
+from vllm_omni.diffusion.cache.cachedit import CacheDiTBackend, cache_summary
 from vllm_omni.diffusion.cache.prompt_embed_cache import (
     install_prompt_embed_cache,
     resolve_prompt_embed_cache_config,
@@ -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,
@@ -53,6 +54,7 @@ from vllm_omni.diffusion.models.interface import (
 )
 from vllm_omni.diffusion.offloader import enable_offload_backend
 from vllm_omni.diffusion.offloader.config import TEXT_ENCODER_COMPONENT, resolve_offload
+from vllm_omni.diffusion.postprocess.device_reduction import prepare_diffusion_media_for_transport
 from vllm_omni.diffusion.registry import _NO_CACHE_ACCELERATION
 from vllm_omni.diffusion.request import OmniDiffusionRequest
 from vllm_omni.diffusion.sched.interface import (
@@ -192,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
         )
@@ -412,7 +420,7 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
                 # may explicitly adopt the enabled Cache-DiT backend and then
                 # own all later request-boundary enable/disable transitions.
                 self.cache_backend.enable(self.pipeline)
-                if str(self.od_config.cache_backend).lower() == "cache_dit" and adopt_request_scoped_cache_dit(
+                if isinstance(self.cache_backend, CacheDiTBackend) and adopt_request_scoped_cache_dit(
                     self.pipeline,
                     self.cache_backend,
                 ):
@@ -474,6 +482,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)
@@ -486,7 +504,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:
@@ -523,8 +541,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(
@@ -609,6 +628,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.
@@ -666,12 +688,13 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
             num_inference_steps = getattr(self.pipeline, "default_num_inference_steps", None)
         if num_inference_steps is None and od_config.cache_backend in (
             "tea_cache",
+            "sea_cache",
             "step_cache",
         ):
             # When num_inference_steps is None, some pipelines defer to their
-            # own defaults. TeaCache refresh ignores this value; step_cache
-            # refresh is a no-op because per-chunk state resets in the denoise
-            # loop. Use the pipeline default when available to keep refresh
+            # own defaults. These backends use refresh to reset request state;
+            # runtime step metadata is either unused or resolved in the
+            # pipeline. Use the pipeline default when available to keep refresh
             # behavior aligned with single-request execution.
             num_inference_steps = getattr(self.pipeline, "num_inference_steps", 0) or 0
 
@@ -684,6 +707,21 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
                 od_config.cache_backend,
             )
 
+    def _prepare_output_for_transport(
+        self,
+        output: DiffusionOutput,
+        sampling_params: OmniDiffusionSamplingParams,
+    ) -> DiffusionOutput:
+        if output.media is not None:
+            if output.output is not None:
+                raise ValueError("DiffusionOutput cannot contain both media and legacy output")
+            output.media = prepare_diffusion_media_for_transport(
+                output.media,
+                od_config=self.od_config,
+                sampling_params=sampling_params,
+            )
+        return output
+
     def _runner_output_from_outputs(
         self,
         reqs: list[OmniDiffusionRequest],
@@ -757,6 +795,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
@@ -778,6 +818,11 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
                         allow_single_output=allow_single_output,
                         pipeline_name=type(self.pipeline).__name__,
                     )
+                with record_function("prepare_output_for_transport"):
+                    outputs = [
+                        self._prepare_output_for_transport(output, req.sampling_params)
+                        for req, output in zip(reqs, outputs, strict=True)
+                    ]
 
             if is_primary and outputs and record_output_peak_memory:
                 batch_peak_memory_mb = self._sample_peak_memory_mb()
@@ -1000,13 +1045,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)
 
@@ -1029,34 +1079,19 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
         new_request_ids: list[str],
     ) -> tuple[list[StepRequestState], InputBatch | None, list[RunnerOutput]]:
         # process new reqs
+        pipeline = self.pipeline
+        assert pipeline is not None, "Model not loaded. Call load_model() first."
         prepared_states: list[StepRequestState] = []
         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(self.pipeline)
-                    # encode
-                    self.pipeline.prepare_encode(state)
-                    merge_stage_durations(
-                        state,
-                        consume_pipeline_stage_durations(self.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(
@@ -1076,6 +1111,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)
 
@@ -1230,6 +1300,8 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
         use_hsdp = self.od_config.parallel_config.use_hsdp
         grad_context = torch.no_grad() if use_hsdp else torch.inference_mode()
         with grad_context:
+            pipeline = self.pipeline
+            assert pipeline is not None, "Model not loaded. Call load_model() first."
             had_active_states = bool(self.state_cache)
             states, new_request_ids = self._update_states(scheduler_output)
             is_primary = not torch.distributed.is_initialized() or torch.distributed.get_rank() == 0
@@ -1244,7 +1316,7 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
             states, input_batch, runner_output_list = self._prepare_batch_inputs(states, new_request_ids)
             if input_batch is None:
                 return BatchRunnerOutput.from_list(runner_output_list)
-            attn_metadata = {}
+            attn_metadata: dict[str, Any] = {}
 
             kv_backend = getattr(self, "diffusion_kv_backend", None)
             paged_kv_runtime = kv_backend if getattr(kv_backend, "paged_attention_adapter", None) is not None else None
@@ -1255,16 +1327,16 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
                 paged_kv_runtime=paged_kv_runtime,
                 in_diffusion_kv_memory_profile=in_diffusion_kv_memory_profile,
             ):
-                clear_pipeline_stage_durations(self.pipeline)
-                noise_pred = self.pipeline.denoise_step(input_batch, states=states)
-                denoise_stage_durations = consume_pipeline_stage_durations(self.pipeline)
+                clear_pipeline_stage_durations(pipeline)
+                noise_pred = pipeline.denoise_step(input_batch, states=states)
+                denoise_stage_durations = consume_pipeline_stage_durations(pipeline)
                 for state in states:
                     merge_stage_durations(
                         state,
                         denoise_stage_durations,
                     )
 
-                pipeline_interrupted = getattr(self.pipeline, "interrupt", False)
+                pipeline_interrupted = getattr(pipeline, "interrupt", False)
                 if noise_pred is None and pipeline_interrupted:
                     for state in states:
                         runner_output_list.append(
@@ -1279,9 +1351,11 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
                 else:
                     offset = 0
                     for req in states:
+                        if req.latents is None:
+                            raise RuntimeError(f"Stepwise request {req.request_id} has no latent state.")
                         row_num = req.latents.shape[0]
                         try:
-                            self.pipeline.step_scheduler(
+                            pipeline.step_scheduler(
                                 req, noise_pred[offset : offset + row_num] if noise_pred is not None else None
                             )
                             if self.od_config.streaming_output:
@@ -1290,17 +1364,18 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
                                 should_decode = req.denoise_completed
 
                             if should_decode:
-                                clear_pipeline_stage_durations(self.pipeline)
-                                result = self.pipeline.post_decode(req)
+                                clear_pipeline_stage_durations(pipeline)
+                                result = pipeline.post_decode(req)
                                 if result is not None:
+                                    result = self._prepare_output_for_transport(result, req.sampling)
                                     self._attach_stepwise_metadata(
                                         req,
                                         result,
                                     )
                                     # After consuming this chunk's interaction metadata, apply pending interactions and
                                     # prepare the next chunk (prepare_next_chunk may be a no-op---depending on pipeline)
-                                    if supports_interaction_apply(self.pipeline) and not req.request_denoise_completed:
-                                        pipe = cast(SupportsInteractionApply, self.pipeline)
+                                    if supports_interaction_apply(pipeline) and not req.request_denoise_completed:
+                                        pipe = cast(SupportsInteractionApply, pipeline)
                                         pipe.apply_interaction_at_chunk_boundary(req)
                                         pipe.prepare_next_chunk(req)
                             else:
@@ -1352,12 +1427,12 @@ class DiffusionModelRunner(OmniConnectorModelRunnerMixin):
                     for runner_output in runner_output_list:
                         if runner_output.result is None:
                             continue
-                        state = states_by_id.get(runner_output.request_id)
-                        if state is None:
+                        matched_state = states_by_id.get(runner_output.request_id)
+                        if matched_state is None:
                             continue
                         runner_output.result.peak_memory_mb = max(
                             runner_output.result.peak_memory_mb,
-                            state.peak_memory_mb,
+                            matched_state.peak_memory_mb,
                         )
 
                 terminal_request_ids = [
@@ -1379,47 +1454,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 4443353a0..4eadf33db 100644
--- a/vllm_omni/diffusion/worker/diffusion_worker.py
+++ b/vllm_omni/diffusion/worker/diffusion_worker.py
@@ -59,12 +59,17 @@ 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,
 )
 from vllm_omni.diffusion.forward_context import set_forward_context
-from vllm_omni.diffusion.ipc import DIFFUSION_RPC_RESULT_ENVELOPE, pack_diffusion_output_shm
+from vllm_omni.diffusion.ipc import (
+    DIFFUSION_RPC_RESULT_ENVELOPE,
+    pack_diffusion_output_shm,
+    payload_carries_typed_media,
+)
 from vllm_omni.diffusion.lora.manager import DiffusionLoRAManager, LoRABackend
 from vllm_omni.diffusion.registry import get_diffusion_ir_op_priority_func
 from vllm_omni.diffusion.request import OmniDiffusionRequest
@@ -112,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
 
 
@@ -442,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)),
@@ -463,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(
@@ -530,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
@@ -786,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()
 
@@ -1131,7 +1155,15 @@ class WorkerProc:
         # Sync path (original, or async fallback).
         try:
             pack_diffusion_output_shm(output)
+        except (TypeError, ValueError):
+            raise
         except Exception as e:
+            # Typed media that fails to pack is left unprepared/on device (the
+            # pack is failure-atomic and does not mutate it), so enqueueing it
+            # would ship a broken payload. Re-raise memory/packing failures here
+            # instead of swallowing them for typed media.
+            if payload_carries_typed_media(output):
+                raise
             if hasattr(output, "output"):
                 logger.warning("SHM pack failed for model output: %s", e)
         self._enqueue_result(output)
@@ -1242,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)
@@ -1556,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:
@@ -1593,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/diffusion/worker/request_batch.py b/vllm_omni/diffusion/worker/request_batch.py
index 079a213db..d5f1d5585 100644
--- a/vllm_omni/diffusion/worker/request_batch.py
+++ b/vllm_omni/diffusion/worker/request_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
 """Request-level batch abstraction for diffusion runner."""
 
 from __future__ import annotations
@@ -12,6 +12,7 @@ import numpy as np
 import torch
 
 from vllm_omni.diffusion.data import DiffusionOutput
+from vllm_omni.diffusion.media import DiffusionMediaOutput, slice_diffusion_media_output
 from vllm_omni.diffusion.request import OmniDiffusionRequest
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams, OmniPromptType
 
@@ -35,6 +36,18 @@ def split_diffusion_output_by_request(
     """Split a batched DiffusionOutput into one output per request."""
     if num_outputs_per_prompt <= 0:
         raise ValueError(f"num_outputs_per_prompt must be positive, got {num_outputs_per_prompt}.")
+    if result.media is not None and result.output is not None:
+        raise ValueError("DiffusionOutput cannot contain both media and legacy output")
+    if result.media is not None and not isinstance(result.media, DiffusionMediaOutput):
+        raise TypeError(f"DiffusionOutput.media must be DiffusionMediaOutput, got {type(result.media).__name__}")
+    if result.media is not None:
+        expected_batch = req.num_reqs * num_outputs_per_prompt
+        actual_batch = result.media.video.tensor.shape[0]
+        if actual_batch != expected_batch:
+            raise ValueError(
+                f"Video media batch dimension must equal request_count * num_outputs_per_prompt "
+                f"({expected_batch}), got {actual_batch}"
+            )
 
     return [
         DiffusionOutput(
@@ -43,6 +56,15 @@ def split_diffusion_output_by_request(
                 idx * num_outputs_per_prompt,
                 (idx + 1) * num_outputs_per_prompt,
             ),
+            media=(
+                slice_diffusion_media_output(
+                    result.media,
+                    idx * num_outputs_per_prompt,
+                    (idx + 1) * num_outputs_per_prompt,
+                )
+                if result.media is not None
+                else None
+            ),
             error=result.error,
             finished=result.finished,
             stage_durations=result.stage_durations,
diff --git a/vllm_omni/distributed/__init__.py b/vllm_omni/distributed/__init__.py
index 3506f02f6..40374cd6d 100644
--- a/vllm_omni/distributed/__init__.py
+++ b/vllm_omni/distributed/__init__.py
@@ -7,6 +7,7 @@ from .omni_connectors import (
     MooncakeStoreConnector,
     MooncakeTransferEngineConnector,
     MoriTransferEngineConnector,
+    NixlConnector,
     OmniConnectorBase,
     OmniConnectorFactory,
     OmniTransferConfig,
@@ -27,6 +28,7 @@ __all__ = [
     "MooncakeStoreConnector",
     "MooncakeTransferEngineConnector",
     "MoriTransferEngineConnector",
+    "NixlConnector",
     "SharedMemoryConnector",
     "YuanrongConnector",
     "YuanrongTransferEngineConnector",
diff --git a/vllm_omni/distributed/omni_connectors/__init__.py b/vllm_omni/distributed/omni_connectors/__init__.py
index 0cee596bb..e46142b2a 100644
--- a/vllm_omni/distributed/omni_connectors/__init__.py
+++ b/vllm_omni/distributed/omni_connectors/__init__.py
@@ -22,6 +22,11 @@ try:
     from .connectors.mori_transfer_engine_connector import MoriTransferEngineConnector
 except ImportError:
     MoriTransferEngineConnector = None  # RDMA deps (msgspec/zmq/mori) not installed
+
+try:
+    from .connectors.nixl_connector import NixlConnector
+except ImportError:
+    NixlConnector = None  # NIXL deps not installed
 from .factory import OmniConnectorFactory
 from .utils.config import ConnectorSpec, OmniTransferConfig
 from .utils.initialization import (
@@ -50,6 +55,7 @@ __all__ = [
     "MooncakeStoreConnector",
     "MooncakeTransferEngineConnector",
     "MoriTransferEngineConnector",
+    "NixlConnector",
     "SharedMemoryConnector",
     "YuanrongConnector",
     "YuanrongTransferEngineConnector",
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/nixl_connector.py b/vllm_omni/distributed/omni_connectors/connectors/nixl_connector.py
new file mode 100644
index 000000000..7dda744f6
--- /dev/null
+++ b/vllm_omni/distributed/omni_connectors/connectors/nixl_connector.py
@@ -0,0 +1,1044 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from __future__ import annotations
+
+import math
+import os
+import socket
+import sys
+import threading
+import time
+import uuid
+from dataclasses import dataclass, field
+from typing import Any
+
+import msgspec
+import torch
+import zmq
+
+from ..utils.logging import get_connector_logger
+from .base import OmniConnectorBase
+
+logger = get_connector_logger(__name__)
+
+_SCHEMA_VERSION = 1
+_KIND_TENSORS = "tensors"
+_KIND_STRUCTURED = "structured"
+_KIND_OBJECT = "object"
+_INIT_AGENT = "NIXL_INIT_AGENT"
+_TENSOR_MARKER = "__nixl_tensor_index__"
+_TUPLE_MARKER = "__nixl_tuple__"
+
+# Handshake control-plane messages. Consumers claim connector-managed payloads
+# before READ, even with out-of-band metadata, and acknowledge completion here.
+_GET_META_MSG = b"nixl_get_meta"
+_XFER_DONE_MSG = b"nixl_xfer_done"
+_META_NOT_FOUND = b"nixl_meta_not_found"
+_ACK = b"nixl_ack"
+
+# NIXL has no remote READ cancellation primitive. A closed producer with an
+# abandoned claim must keep both its agent and allocations alive until process
+# exit; dropping the last Python reference is not a safe cancellation policy.
+_RETAINED_PRODUCERS: set[Any] = set()
+
+
+@dataclass
+class _DeferredTransfer:
+    tensors: list[torch.Tensor]
+    registrations: list[Any] = field(default_factory=list)
+    dlists: list[Any] = field(default_factory=list)
+    handles: list[Any] = field(default_factory=list)
+    remote_agent: Any = None
+    source_key: str | None = None
+    source_metadata: dict[str, Any] | None = None
+
+
+@dataclass
+class _PendingPayload:
+    tensors: list[torch.Tensor]
+    registrations: list[Any]
+    deadline: float
+    generation: str = field(default_factory=lambda: uuid.uuid4().hex)
+    claims: set[str] = field(default_factory=set)
+
+
+class NixlConnector(OmniConnectorBase):
+    """OmniConnector backed by vLLM's native NIXL wrapper.
+
+    This connector intentionally depends on vLLM's optional NIXL integration
+    (``vllm.distributed.nixl_utils``). It transfers raw tensor payloads
+    directly through NIXL READ operations. Non-tensor Python
+    payloads are serialized with OmniSerializer, packed into a uint8 CPU tensor,
+    and moved through the same NIXL path.
+
+    A NIXL READ needs the producer's agent metadata and memory descriptors,
+    which ``put`` returns to its caller. Consumers use the ZMQ control plane to
+    claim connector-managed payloads before READ and acknowledge completion,
+    including when metadata is forwarded directly. Producers without a fixed
+    ``zmq_port`` use an ephemeral listener advertised in that metadata. Callers
+    passing ``metadata=None`` need a configured or request-specific producer
+    endpoint to fetch and claim metadata by key.
+    """
+
+    supports_raw_data: bool = True
+
+    def __init__(self, config: dict[str, Any]):
+        self.config = dict(config or {})
+        self.stage_id = int(self.config.get("stage_id", 0))
+        self._closed = True
+        self._registered_descs: list[Any] = []
+        self._pending: dict[str, _PendingPayload] = {}
+        self._published: dict[str, dict[str, Any]] = {}
+        self._state_lock = threading.RLock()
+        self._remote_agents: list[str] = []
+        self._metrics: dict[str, int] = {
+            "puts": 0,
+            "gets": 0,
+            "errors": 0,
+            "bytes_transferred": 0,
+        }
+
+        from vllm.distributed.nixl_utils import NixlWrapper, nixl_agent_config
+
+        if NixlWrapper is None:
+            raise RuntimeError("NIXL is not available. Install the optional nixl/rixl package to use NixlConnector.")
+
+        backends = self.config.get("backends", ["UCX"])
+        self._backends = list(backends) if isinstance(backends, (list, tuple)) else [str(backends)]
+        if nixl_agent_config is None:
+            agent_config = None
+        else:
+            from nixl import nixl_thread_sync_t
+
+            config_module = sys.modules.get(nixl_agent_config.__module__)
+            sync_type = getattr(config_module, "nixl_thread_sync_t", nixl_thread_sync_t)
+            sync_mode = sync_type.NIXL_THREAD_SYNC_STRICT
+            non_ucx_backends = [backend for backend in self._backends if backend != "UCX"]
+            if non_ucx_backends:
+                agent_config = nixl_agent_config(
+                    backends=self._backends,
+                    capture_telemetry=False,
+                    sync_mode=sync_mode,
+                )
+            else:
+                num_threads = int(self.config.get("num_threads", 4))
+                agent_config = nixl_agent_config(
+                    num_threads=num_threads,
+                    capture_telemetry=False,
+                    sync_mode=sync_mode,
+                )
+
+        self._agent = NixlWrapper(str(self.config.get("agent_name", uuid.uuid4())), agent_config)
+        self._receive_device = self._parse_device(self.config.get("receive_device"))
+        self._default_memory_type = self.config.get("memory_type")
+        # The lease bounds how long a ``put`` payload stays registered while it
+        # waits to be read. A consumer stage may legitimately queue for a long
+        # time (e.g. video diffusion with concurrency above the replica count),
+        # so the default must be far larger than any plausible queueing delay.
+        # The environment variables intentionally take precedence over the
+        # deployment YAML, which ships a fixed 300s lease that is too short for
+        # long-queueing pipelines and cannot be overridden per deployment.
+        self._lease_seconds = float(
+            os.environ.get("VLLM_OMNI_NIXL_LEASE_S") or self.config.get("lease_seconds", 3600.0)
+        )
+        self._transfer_timeout_s = float(
+            os.environ.get("VLLM_OMNI_NIXL_XFER_TIMEOUT_S") or self.config.get("transfer_timeout_s", 300.0)
+        )
+        self._poll_interval_s = float(self.config.get("poll_interval_s", 0.001))
+        self._closed = False
+        self._init_handshake()
+        self._lease_wakeup = threading.Event()
+        self._lease_thread: threading.Thread | None = None
+        if self._serving_handshake:
+            self._lease_thread = threading.Thread(
+                target=self._lease_reaper_loop,
+                name="nixl-lease-reaper",
+                daemon=True,
+            )
+            self._lease_thread.start()
+        self._transfer_wakeup = threading.Event()
+        self._deferred_transfers: list[_DeferredTransfer] = []
+        self._transfer_thread: threading.Thread | None = None
+        if self._role != "sender":
+            self._transfer_thread = threading.Thread(
+                target=self._transfer_reaper_loop,
+                name="nixl-transfer-reaper",
+                daemon=True,
+            )
+            self._transfer_thread.start()
+
+    def _init_handshake(self) -> None:
+        """Set up the ZMQ metadata and payload-ownership control plane.
+
+        Producers listen on a configured or ephemeral port, including for
+        directly forwarded metadata. Receive-only connectors dial the producer;
+        intermediate stages can also listen for their outgoing payloads.
+        """
+        role = self.config.get("role")
+        self._role = str(role).lower() if role else None
+        # Even out-of-band metadata needs an atomic claim before READ. An
+        # ephemeral listener supplies that ownership channel when no fixed
+        # data-plane metadata port was configured.
+        self._zmq_port = self.config.get("zmq_port", 0 if self._role != "receiver" else None)
+        self._sender_host = self.config.get("sender_host")
+        self._sender_zmq_port = self.config.get("sender_zmq_port")
+        self._handshake_timeout_ms = int(self.config.get("handshake_timeout_ms", 5000))
+        self._metadata_query_timeout_ms = int(
+            self.config.get("metadata_query_timeout_ms", min(self._handshake_timeout_ms, 10))
+        )
+        self._handshake_max_wait_s = float(self.config.get("handshake_max_wait_s", 60.0))
+        self._handshake_retry_s = float(self.config.get("handshake_retry_s", 0.05))
+        self._zmq_ctx: zmq.Context | None = None
+        self._req_local = threading.local()
+        self._listener_thread: threading.Thread | None = None
+        self._listener_ready = threading.Event()
+        self._stop_event = threading.Event()
+        self._bind_error: BaseException | None = None
+        self.host: str | None = None
+        self._serving_handshake = False
+
+        self._handshake_enabled = self._zmq_port is not None or self._sender_host is not None
+        if not self._handshake_enabled:
+            return
+
+        self._zmq_ctx = zmq.Context()
+        # A receiver only dials out, so it never needs a port of its own.
+        if self._zmq_port is None:
+            return
+
+        host_value = str(self.config.get("host", "auto"))
+        self.host = (
+            self._get_local_ip()
+            if host_value.lower() == "auto" or host_value in {"", "*", "0.0.0.0", "::"}
+            else host_value
+        )
+        self._zmq_port = int(self._zmq_port)
+        self._listener_thread = threading.Thread(
+            target=self._handshake_listener_loop, name="nixl-handshake", daemon=True
+        )
+        self._listener_thread.start()
+        self._listener_ready.wait(timeout=5.0)
+        if self._bind_error is not None:
+            raise RuntimeError(
+                f"NixlConnector failed to bind handshake socket on {self.host}:{self._zmq_port}"
+            ) from self._bind_error
+        self._serving_handshake = True
+        logger.info("NixlConnector handshake listener bound on %s:%s", self.host, self._zmq_port)
+
+    def put(
+        self,
+        from_stage: str,
+        to_stage: str,
+        put_key: str,
+        data: Any,
+    ) -> tuple[bool, int, dict[str, Any] | None]:
+        if self._closed or getattr(self, "_closing", False):
+            raise RuntimeError("Cannot put data: NixlConnector is closed")
+
+        try:
+            self._cleanup_expired_pending()
+            kind = _KIND_TENSORS
+            if self._is_tensor_payload(data):
+                tensors, tensor_specs = self._normalize_tensor_payload(data)
+            elif self._contains_tensor(data):
+                skeleton, payload_tensors = self._extract_tensor_leaves(data)
+                header = self.serialize_obj(skeleton)
+                header_tensor = torch.frombuffer(header, dtype=torch.uint8).clone().contiguous()
+                tensors, tensor_specs = self._normalize_tensor_payload([header_tensor, *payload_tensors])
+                kind = _KIND_STRUCTURED
+            else:
+                payload = self.serialize_obj(data)
+                tensor = torch.frombuffer(payload, dtype=torch.uint8).clone().contiguous()
+                tensors, tensor_specs = self._normalize_tensor_payload(tensor)
+                kind = _KIND_OBJECT
+
+            grouped_tensors: dict[str, list[tuple[int, torch.Tensor]]] = {}
+            for tensor_index, tensor in enumerate(tensors):
+                # Preserve spec/skeleton slots, but never register empty DMA regions.
+                if tensor.numel() == 0:
+                    continue
+                memory_type = self._resolve_memory_type(tensor)
+                grouped_tensors.setdefault(memory_type, []).append((tensor_index, tensor))
+
+            descriptor_groups = []
+            registered_descs = []
+            try:
+                for memory_type, indexed_tensors in grouped_tensors.items():
+                    tensor_indices = [tensor_index for tensor_index, _ in indexed_tensors]
+                    regions = [self._tensor_region(tensor) for _, tensor in indexed_tensors]
+                    reg_descs = self._agent.get_reg_descs(regions, memory_type)
+                    self._agent.register_memory(reg_descs, backends=self._backends)
+                    registered_descs.append(reg_descs)
+                    descriptor_groups.append(
+                        {
+                            "memory_type": memory_type,
+                            "tensor_indices": tensor_indices,
+                            "regions": regions,
+                        }
+                    )
+            except Exception:
+                for reg_descs in registered_descs:
+                    self._safe_call(self._agent.deregister_memory, reg_descs)
+                raise
+            with self._state_lock:
+                self._registered_descs.extend(registered_descs)
+
+            size = sum(spec["size"] for spec in tensor_specs)
+            metadata = {
+                "schema_version": _SCHEMA_VERSION,
+                "kind": kind,
+                "agent_metadata": self._agent.get_agent_metadata(),
+                "descriptor_groups": descriptor_groups,
+                "tensor_specs": tensor_specs,
+                "size": size,
+            }
+            if self._serving_handshake:
+                metadata["sender_host"] = self.host
+                metadata["sender_zmq_port"] = self._zmq_port
+            with self._state_lock:
+                previous = self._pending.get(put_key)
+                if previous is not None and previous.claims:
+                    for descs in registered_descs:
+                        self._safe_call(self._agent.deregister_memory, descs)
+                        self._registered_descs.remove(descs)
+                    raise RuntimeError(f"Cannot replace claimed NIXL payload {put_key}")
+                previous = self._take_pending(put_key)
+                if previous is not None:
+                    self._release_pending(previous)
+                pending = _PendingPayload(
+                    tensors=tensors,
+                    registrations=registered_descs,
+                    deadline=time.monotonic() + self._lease_seconds,
+                )
+                metadata["generation"] = pending.generation
+                self._pending[put_key] = pending
+                if self._serving_handshake:
+                    self._published[put_key] = metadata
+            self._lease_wakeup.set()
+            self._metrics["puts"] += 1
+            self._metrics["bytes_transferred"] += size
+            logger.debug("NixlConnector put %s->%s key=%s size=%d", from_stage, to_stage, put_key, size)
+            return True, size, metadata
+        except Exception:
+            self._metrics["errors"] += 1
+            logger.error("NixlConnector put failed for %s", put_key, exc_info=True)
+            return False, 0, None
+
+    def get(
+        self,
+        from_stage: str,
+        to_stage: str,
+        get_key: str,
+        metadata: dict[str, Any] | None = None,
+    ) -> tuple[Any, int] | None:
+        if self._closed or getattr(self, "_closing", False):
+            raise RuntimeError("Cannot get data: NixlConnector is closed")
+
+        remote_agent = None
+        local_reg_descs_list = []
+        dlist_handles = []
+        xfer_handles = []
+        source_metadata = None
+        try:
+            metadata = self._resolve_metadata(get_key, metadata)
+            if not isinstance(metadata, dict) or metadata.get("schema_version") != _SCHEMA_VERSION:
+                logger.error("NixlConnector get has invalid metadata for %s", get_key)
+                return None
+
+            source_metadata = metadata
+
+            tensor_specs = metadata.get("tensor_specs")
+            if not isinstance(tensor_specs, list):
+                raise RuntimeError(f"Invalid NIXL metadata for {get_key}: missing tensor_specs")
+            descriptor_groups = self._validated_descriptor_groups(metadata, tensor_specs)
+
+            local_tensors = [self._allocate_tensor_from_spec(spec, metadata.get("kind")) for spec in tensor_specs]
+            if descriptor_groups:
+                remote_agent = self._agent.add_remote_agent(metadata["agent_metadata"])
+                self._remote_agents.append(remote_agent)
+            for descriptor_group in descriptor_groups:
+                remote_memory_type = descriptor_group["memory_type"]
+                indexed_regions = list(
+                    zip(descriptor_group["tensor_indices"], descriptor_group["regions"], strict=True)
+                )
+                local_groups: dict[str, list[tuple[int, Any]]] = {}
+                for tensor_index, remote_region in indexed_regions:
+                    local_memory_type = self._resolve_memory_type(local_tensors[tensor_index])
+                    local_groups.setdefault(local_memory_type, []).append((tensor_index, remote_region))
+
+                for local_memory_type, entries in local_groups.items():
+                    group_tensors = [local_tensors[tensor_index] for tensor_index, _ in entries]
+                    local_regions = [self._tensor_region(tensor) for tensor in group_tensors]
+                    local_reg_descs = self._agent.get_reg_descs(local_regions, local_memory_type)
+                    self._agent.register_memory(local_reg_descs, backends=self._backends)
+                    local_reg_descs_list.append(local_reg_descs)
+
+                    remote_regions = [tuple(region)[:3] for _, region in entries]
+                    remote_descs = self._agent.get_xfer_descs(remote_regions, remote_memory_type)
+                    local_descs = self._agent.get_xfer_descs(
+                        [tuple(region)[:3] for region in local_regions], local_memory_type
+                    )
+                    remote_dlist = self._agent.prep_xfer_dlist(remote_agent, remote_descs)
+                    local_dlist = self._agent.prep_xfer_dlist(_INIT_AGENT, local_descs)
+                    dlist_handles.extend([local_dlist, remote_dlist])
+
+                    desc_ids = list(range(len(entries)))
+                    xfer_handle = self._agent.make_prepped_xfer(
+                        "READ",
+                        local_dlist,
+                        desc_ids,
+                        remote_dlist,
+                        desc_ids,
+                    )
+                    xfer_handles.append(xfer_handle)
+                    self._agent.transfer(xfer_handle)
+
+            for xfer_handle in xfer_handles:
+                self._wait_for_transfer(xfer_handle, get_key)
+            for xfer_handle in xfer_handles:
+                self._agent.release_xfer_handle(xfer_handle)
+            xfer_handles.clear()
+
+            size = int(metadata.get("size", sum(spec.get("size", 0) for spec in tensor_specs)))
+            if metadata.get("kind") == _KIND_OBJECT:
+                raw = local_tensors[0].detach().cpu().contiguous().view(torch.uint8).numpy().tobytes()
+                payload = self.deserialize_obj(raw)
+            elif metadata.get("kind") == _KIND_STRUCTURED:
+                raw = local_tensors[0].detach().cpu().contiguous().view(torch.uint8).numpy().tobytes()
+                skeleton = self.deserialize_obj(raw)
+                payload = self._restore_tensor_leaves(skeleton, local_tensors[1:])
+            else:
+                payload = local_tensors[0] if len(local_tensors) == 1 else local_tensors
+            self._metrics["gets"] += 1
+            self._metrics["bytes_transferred"] += size
+            logger.debug("NixlConnector get %s->%s key=%s size=%d", from_stage, to_stage, get_key, size)
+            return payload, size
+        except Exception:
+            if xfer_handles and self._transfers_may_be_active(xfer_handles):
+                self._defer_transfer(
+                    _DeferredTransfer(
+                        tensors=local_tensors,
+                        registrations=local_reg_descs_list,
+                        dlists=dlist_handles,
+                        handles=xfer_handles,
+                        remote_agent=remote_agent,
+                        source_key=get_key,
+                        source_metadata=source_metadata,
+                    )
+                )
+                local_tensors = []
+                local_reg_descs_list = []
+                dlist_handles = []
+                xfer_handles = []
+                remote_agent = None
+                source_metadata = None
+            self._metrics["errors"] += 1
+            logger.error("NixlConnector get failed for %s", get_key, exc_info=True)
+            return None
+        finally:
+            for xfer_handle in xfer_handles:
+                self._safe_call(self._agent.release_xfer_handle, xfer_handle)
+            for dlist_handle in dlist_handles:
+                self._safe_call(self._agent.release_dlist_handle, dlist_handle)
+            if remote_agent is not None:
+                self._safe_call(self._agent.remove_remote_agent, remote_agent)
+                if remote_agent in self._remote_agents:
+                    self._remote_agents.remove(remote_agent)
+            for local_reg_descs in local_reg_descs_list:
+                self._safe_call(self._agent.deregister_memory, local_reg_descs)
+            if source_metadata is not None:
+                self._notify_transfer_done(get_key, source_metadata)
+
+    def cleanup(self, request_id: str) -> None:
+        pending = self._take_pending(request_id)
+        if pending is None:
+            return
+        self._release_pending(pending)
+
+    def _release_pending(self, pending: _PendingPayload) -> None:
+        for reg_descs in pending.registrations:
+            self._safe_call(self._agent.deregister_memory, reg_descs)
+            with self._state_lock:
+                if reg_descs in self._registered_descs:
+                    self._registered_descs.remove(reg_descs)
+
+    def _take_pending(self, request_id: str, expected: _PendingPayload | None = None) -> _PendingPayload | None:
+        with self._state_lock:
+            pending = self._pending.get(request_id)
+            if pending is None or (expected is not None and pending is not expected):
+                return None
+            if pending.claims:
+                return None
+            self._published.pop(request_id, None)
+            return self._pending.pop(request_id)
+
+    def close(self) -> None:
+        if self._closed:
+            return
+        self._closed = True
+        # Stop accepting puts/gets, but keep serving completion ACKs for outstanding
+        # remote READs. A later close() call can finish teardown once drained.
+        for request_id in list(self._pending):
+            self.cleanup(request_id)
+        with self._state_lock:
+            if any(pending.claims for pending in self._pending.values()):
+                _RETAINED_PRODUCERS.add(self)
+                self._closed = False
+                self._closing = True
+                logger.warning("NIXL close deferred: remote READ claims still own source allocations")
+                return
+        _RETAINED_PRODUCERS.discard(self)
+        self._stop_event.set()
+        self._lease_wakeup.set()
+        self._transfer_wakeup.set()
+        if self._listener_thread is not None:
+            self._listener_thread.join(timeout=5.0)
+            self._listener_thread = None
+        if self._lease_thread is not None:
+            self._lease_thread.join(timeout=5.0)
+            self._lease_thread = None
+        if self._transfer_thread is not None:
+            self._transfer_thread.join(timeout=5.0)
+            self._transfer_thread = None
+        while self._deferred_transfers:
+            self._reap_deferred_transfers()
+            if self._deferred_transfers:
+                time.sleep(max(self._poll_interval_s, 0.01))
+        if self._zmq_ctx is not None:
+            # destroy() rather than term(): REQ sockets live in thread-local
+            # caches this thread cannot reach, and term() blocks until every
+            # socket in the context is closed.
+            self._safe_call(self._zmq_ctx.destroy, 0)
+            self._zmq_ctx = None
+        for request_id in list(self._pending):
+            self.cleanup(request_id)
+        deferred_agents = {
+            transfer.remote_agent for transfer in self._deferred_transfers if transfer.remote_agent is not None
+        }
+        for agent_name in [agent for agent in self._remote_agents if agent not in deferred_agents]:
+            self._safe_call(self._agent.remove_remote_agent, agent_name)
+            self._remote_agents.remove(agent_name)
+        for reg_descs in list(self._registered_descs):
+            self._safe_call(self._agent.deregister_memory, reg_descs)
+        self._registered_descs.clear()
+
+    def health(self) -> dict[str, Any]:
+        return {
+            "status": "unhealthy" if self._closed else "healthy",
+            "pending_requests": len(self._pending),
+            **self._metrics,
+        }
+
+    def get_connection_info(self) -> dict[str, Any]:
+        """Endpoint a consumer needs to reach this producer's handshake socket."""
+        return {"host": self.host, "zmq_port": self._zmq_port}
+
+    def update_sender_info(self, sender_host: str, sender_zmq_port: int) -> None:
+        """Register the producer handshake endpoint on the consumer side.
+
+        Used when the endpoint is only known after both stages have started and
+        therefore cannot be baked into the connector config.
+        """
+        self._sender_host = sender_host
+        self._sender_zmq_port = int(sender_zmq_port)
+        if self._zmq_ctx is None:
+            self._zmq_ctx = zmq.Context()
+            self._handshake_enabled = True
+
+    @staticmethod
+    def _metadata_endpoint(metadata: dict[str, Any] | None) -> tuple[str, int] | None:
+        if not isinstance(metadata, dict):
+            return None
+        host = metadata.get("sender_host")
+        port = metadata.get("sender_zmq_port")
+        if not host or not port:
+            host = metadata.get("source_host")
+            port = metadata.get("source_port")
+        if not host or not port:
+            return None
+        return str(host), int(port)
+
+    def _resolve_metadata(self, get_key: str, metadata: dict[str, Any] | None) -> dict[str, Any] | None:
+        """Return complete NIXL transfer metadata for ``get_key``.
+
+        Connector-managed metadata, including directly forwarded ``put`` results,
+        requires a handshake claim at the supplied or configured producer endpoint.
+        Only legacy externally owned metadata without a generation bypasses it.
+        """
+        direct = isinstance(metadata, dict) and metadata.get("schema_version") == _SCHEMA_VERSION
+        if direct and "generation" not in metadata:
+            # Legacy externally owned metadata has no connector-managed lease.
+            return metadata
+
+        endpoint = self._metadata_endpoint(metadata)
+        if endpoint is None and self._sender_host and self._sender_zmq_port:
+            endpoint = (str(self._sender_host), int(self._sender_zmq_port))
+        if endpoint is None:
+            logger.error(
+                "NixlConnector get(%s) received no usable metadata and no producer handshake "
+                "endpoint is configured. Set sender_host/sender_zmq_port on the consumer, "
+                "pass source_host/source_port for the producer rank, or forward the metadata "
+                "returned by put().",
+                get_key,
+            )
+            return None
+        if self._zmq_ctx is None:
+            with self._state_lock:
+                if self._zmq_ctx is None:
+                    self._zmq_ctx = zmq.Context()
+
+        if direct:
+            return self._query_metadata_at(get_key, *endpoint, generation=metadata["generation"])
+        return self._query_metadata_at(get_key, *endpoint)
+
+    def _query_metadata_at(
+        self, get_key: str, host: str, port: int, *, generation: str | None = None
+    ) -> dict[str, Any] | None:
+        """Fetch transfer metadata for ``get_key`` from a producer's ROUTER socket.
+
+        Each call performs one bounded query so a missing key cannot starve
+        other requests in the shared receive loop. The caller retries later.
+        """
+        zmq_addr = f"tcp://{host}:{port}"
+        request = _GET_META_MSG + msgspec.msgpack.encode(
+            {"key": get_key, "generation": generation, "claim_id": uuid.uuid4().hex}
+        )
+        sock = self._get_req_socket(zmq_addr, self._metadata_query_timeout_ms)
+        try:
+            sock.send(request)
+            reply = sock.recv()
+        except Exception:
+            self._invalidate_req_socket(zmq_addr)
+            logger.debug("NixlConnector handshake query to %s failed for %s", zmq_addr, get_key, exc_info=True)
+            return None
+        if reply == _META_NOT_FOUND:
+            return None
+        return msgspec.msgpack.decode(reply)
+
+    def _notify_transfer_done(self, get_key: str, metadata: dict[str, Any]) -> None:
+        """Tell the producer its buffer is drained so it can deregister now.
+
+        Without this the producer would hold the registration until the lease
+        expires, which for long-lived stages means unbounded growth.
+        """
+        endpoint = self._metadata_endpoint(metadata)
+        if endpoint is None or self._zmq_ctx is None:
+            return
+        host, port = endpoint
+        zmq_addr = f"tcp://{host}:{port}"
+        sock = self._get_req_socket(zmq_addr)
+        try:
+            sock.send(
+                _XFER_DONE_MSG
+                + msgspec.msgpack.encode(
+                    {"key": get_key, "generation": metadata.get("generation"), "claim_id": metadata.get("claim_id")}
+                )
+            )
+            sock.recv()
+        except Exception:
+            self._invalidate_req_socket(zmq_addr)
+            logger.debug("NixlConnector failed to notify completion for %s", get_key, exc_info=True)
+
+    def _handshake_listener_loop(self) -> None:
+        router = self._zmq_ctx.socket(zmq.ROUTER)
+        try:
+            if self._zmq_port == 0:
+                self._zmq_port = router.bind_to_random_port(f"tcp://{self.host}")
+            else:
+                router.bind(f"tcp://{self.host}:{self._zmq_port}")
+        except zmq.ZMQError as exc:
+            logger.error("NixlConnector handshake bind failed on %s:%s: %s", self.host, self._zmq_port, exc)
+            self._bind_error = exc
+            self._listener_ready.set()
+            router.close(linger=0)
+            return
+        self._listener_ready.set()
+
+        poller = zmq.Poller()
+        poller.register(router, zmq.POLLIN)
+        try:
+            while not self._stop_event.is_set():
+                try:
+                    if not dict(poller.poll(500)):
+                        self._cleanup_expired_pending()
+                        continue
+                    identity, _, payload = router.recv_multipart()
+                    router.send_multipart([identity, b"", self._handle_handshake_message(payload)])
+                except zmq.ContextTerminated:
+                    break
+                except Exception:
+                    logger.debug("NixlConnector handshake listener error", exc_info=True)
+        finally:
+            self._safe_call(router.close, 0)
+
+    def _handle_handshake_message(self, payload: bytes) -> bytes:
+        if payload.startswith(_GET_META_MSG):
+            request = msgspec.msgpack.decode(payload[len(_GET_META_MSG) :])
+            key = request.get("key")
+            claim = request.get("claim_id")
+            with self._state_lock:
+                pending = self._pending.get(key)
+                metadata = self._published.get(key)
+                if (
+                    pending is None
+                    or metadata is None
+                    or not claim
+                    or request.get("generation") not in (None, pending.generation)
+                    or (not pending.claims and time.monotonic() >= pending.deadline)
+                    or self._closed
+                    or getattr(self, "_closing", False)
+                ):
+                    return _META_NOT_FOUND
+                # Publish ownership before descriptors can leave this lock.
+                # Failed/lost replies retain the claim conservatively.
+                reply = msgspec.msgpack.encode({**metadata, "claim_id": claim})
+                pending.claims.add(claim)
+                return reply
+        if payload.startswith(_XFER_DONE_MSG):
+            request = msgspec.msgpack.decode(payload[len(_XFER_DONE_MSG) :])
+            key = request.get("key")
+            with self._state_lock:
+                pending = self._pending.get(key)
+                if (
+                    pending is not None
+                    and request.get("generation") == pending.generation
+                    and request.get("claim_id") in pending.claims
+                ):
+                    pending.claims.remove(request["claim_id"])
+                    self.cleanup(key)
+            return _ACK
+        logger.warning("NixlConnector handshake received an unknown message")
+        return _META_NOT_FOUND
+
+    def _get_req_socket(self, zmq_addr: str, timeout_ms: int | None = None) -> zmq.Socket:
+        """Return a thread-local REQ socket so concurrent calls never interleave."""
+        cache: dict[str, zmq.Socket] | None = getattr(self._req_local, "cache", None)
+        if cache is None:
+            cache = {}
+            self._req_local.cache = cache
+        sock = cache.get(zmq_addr)
+        if sock is None:
+            sock = self._zmq_ctx.socket(zmq.REQ)
+            sock.connect(zmq_addr)
+            cache[zmq_addr] = sock
+        timeout_ms = self._handshake_timeout_ms if timeout_ms is None else timeout_ms
+        sock.setsockopt(zmq.SNDTIMEO, timeout_ms)
+        sock.setsockopt(zmq.RCVTIMEO, timeout_ms)
+        return sock
+
+    def _invalidate_req_socket(self, zmq_addr: str) -> None:
+        cache: dict[str, zmq.Socket] | None = getattr(self._req_local, "cache", None)
+        if cache is None:
+            return
+        sock = cache.pop(zmq_addr, None)
+        if sock is not None:
+            self._safe_call(sock.close, 0)
+
+    @staticmethod
+    def _get_local_ip() -> str:
+        """Resolve the externally routable local address for the handshake bind."""
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as probe:
+                probe.connect(("8.8.8.8", 80))
+                return probe.getsockname()[0]
+        except Exception:
+            try:
+                return socket.gethostbyname(socket.gethostname())
+            except Exception:
+                logger.warning("NixlConnector could not resolve a local IP; binding loopback")
+                return "127.0.0.1"
+
+    def _wait_for_transfer(self, handle: int, request_id: str) -> None:
+        deadline = time.monotonic() + self._transfer_timeout_s
+        while True:
+            state = self._agent.check_xfer_state(handle)
+            if state == "DONE":
+                return
+            if state != "PROC":
+                raise RuntimeError(f"NIXL transfer for {request_id} failed with state={state}")
+            if time.monotonic() >= deadline:
+                raise TimeoutError(f"NIXL transfer for {request_id} timed out")
+            time.sleep(self._poll_interval_s)
+
+    def _transfers_may_be_active(self, handles: list[Any]) -> bool:
+        try:
+            return any(self._agent.check_xfer_state(handle) not in {"DONE", "ERR"} for handle in handles)
+        except Exception:
+            return True
+
+    def _cleanup_expired_pending(self) -> None:
+        now = time.monotonic()
+        with self._state_lock:
+            expired = [
+                (key, pending, sum(t.numel() * t.element_size() for t in pending.tensors))
+                for key, pending in self._pending.items()
+                if not pending.claims and now >= pending.deadline
+            ]
+        for request_id, pending, size in expired:
+            logger.warning(
+                "NixlConnector lease expired for request %s after %.0fs; its %d bytes are "
+                "unclaimed and can safely be reclaimed.",
+                request_id,
+                self._lease_seconds,
+                size,
+            )
+            claimed = self._take_pending(request_id, expected=pending)
+            if claimed is not None:
+                self._release_pending(claimed)
+
+    def _lease_reaper_loop(self) -> None:
+        while not self._stop_event.is_set():
+            now = time.monotonic()
+            with self._state_lock:
+                next_deadline = min(
+                    (pending.deadline for pending in self._pending.values() if not pending.claims), default=None
+                )
+            if next_deadline is None:
+                timeout = None
+            else:
+                timeout = max(0.0, next_deadline - now)
+            self._lease_wakeup.wait(timeout=timeout)
+            self._lease_wakeup.clear()
+            if not self._stop_event.is_set():
+                self._cleanup_expired_pending()
+
+    def _defer_transfer(self, transfer: _DeferredTransfer) -> None:
+        with self._state_lock:
+            self._deferred_transfers.append(transfer)
+        self._transfer_wakeup.set()
+
+    def _transfer_reaper_loop(self) -> None:
+        while not self._stop_event.is_set():
+            self._transfer_wakeup.wait(timeout=max(self._poll_interval_s, 0.01))
+            self._transfer_wakeup.clear()
+            self._reap_deferred_transfers()
+
+    def _reap_deferred_transfers(self) -> None:
+        with self._state_lock:
+            transfers = list(self._deferred_transfers)
+        for transfer in transfers:
+            try:
+                states = [self._agent.check_xfer_state(handle) for handle in transfer.handles]
+            except Exception:
+                logger.debug("Failed to poll deferred NIXL transfer", exc_info=True)
+                continue
+            if any(state not in {"DONE", "ERR"} for state in states):
+                continue
+            self._release_deferred_transfer(transfer)
+            if (
+                not transfer.handles
+                and not transfer.dlists
+                and not transfer.registrations
+                and transfer.remote_agent is None
+            ):
+                transfer.tensors.clear()
+                if transfer.source_metadata is not None:
+                    self._notify_transfer_done(transfer.source_key, transfer.source_metadata)
+                    transfer.source_metadata = None
+                with self._state_lock:
+                    if transfer in self._deferred_transfers:
+                        self._deferred_transfers.remove(transfer)
+
+    def _release_deferred_transfer(self, transfer: _DeferredTransfer) -> None:
+        transfer.handles = self._release_owned_resources(self._agent.release_xfer_handle, transfer.handles)
+        transfer.dlists = self._release_owned_resources(self._agent.release_dlist_handle, transfer.dlists)
+        if transfer.remote_agent is not None:
+            try:
+                self._agent.remove_remote_agent(transfer.remote_agent)
+            except Exception:
+                logger.debug("Failed to remove deferred NIXL remote agent", exc_info=True)
+            else:
+                if transfer.remote_agent in self._remote_agents:
+                    self._remote_agents.remove(transfer.remote_agent)
+                transfer.remote_agent = None
+        transfer.registrations = self._release_owned_resources(self._agent.deregister_memory, transfer.registrations)
+
+    @staticmethod
+    def _release_owned_resources(release: Any, resources: list[Any]) -> list[Any]:
+        remaining = []
+        for resource in resources:
+            try:
+                release(resource)
+            except Exception:
+                logger.debug("Failed to release deferred NIXL resource", exc_info=True)
+                remaining.append(resource)
+        return remaining
+
+    def _resolve_memory_type(self, tensor: torch.Tensor) -> str:
+        if self._default_memory_type is not None:
+            return str(self._default_memory_type)
+        if tensor.device.type == "cpu":
+            return "DRAM"
+        return "VRAM"
+
+    @staticmethod
+    def _validated_descriptor_groups(
+        metadata: dict[str, Any], tensor_specs: list[dict[str, Any]]
+    ) -> list[dict[str, Any]]:
+        # Derive emptiness from shape/dtype rather than the advertised size.
+        sizes = []
+        for spec in tensor_specs:
+            if not isinstance(spec, dict):
+                raise RuntimeError("Invalid NIXL metadata: tensor spec must be a mapping")
+            shape = spec.get("shape")
+            if not isinstance(shape, list) or any(type(dim) is not int or dim < 0 for dim in shape):
+                raise RuntimeError("Invalid NIXL metadata: invalid tensor shape")
+            dtype = getattr(torch, str(spec.get("dtype", "")).removeprefix("torch."), None)
+            if not isinstance(dtype, torch.dtype):
+                raise RuntimeError("Invalid NIXL metadata: invalid tensor dtype")
+            size = math.prod(shape) * dtype.itemsize
+            if type(spec.get("size")) is not int or spec["size"] != size:
+                raise RuntimeError("Invalid NIXL metadata: tensor size does not match shape/dtype")
+            sizes.append(size)
+        groups = metadata.get("descriptor_groups")
+        if not isinstance(groups, list):
+            raise RuntimeError("Invalid NIXL metadata: missing descriptor_groups")
+
+        seen_indices = []
+        for group in groups:
+            if not isinstance(group, dict):
+                raise RuntimeError("Invalid NIXL metadata: descriptor group must be a mapping")
+            indices = group.get("tensor_indices")
+            regions = group.get("regions")
+            if not isinstance(indices, list) or not isinstance(regions, list) or len(indices) != len(regions):
+                raise RuntimeError("Invalid NIXL metadata: tensor_indices and regions must have equal lengths")
+            if not indices:
+                raise RuntimeError("Invalid NIXL metadata: empty descriptor group")
+            if not group.get("memory_type"):
+                raise RuntimeError("Invalid NIXL metadata: descriptor group is missing memory_type")
+            if any(type(index) is not int or not 0 <= index < len(sizes) for index in indices):
+                raise RuntimeError("Invalid NIXL metadata: tensor indices must form an exact partition")
+            for index, region in zip(indices, regions, strict=True):
+                if (
+                    not isinstance(region, (list, tuple))
+                    or len(region) not in (3, 4)
+                    or type(region[0]) is not int
+                    or region[0] <= 0
+                    or type(region[1]) is not int
+                    or region[1] <= 0
+                    or region[1] != sizes[index]
+                    or type(region[2]) is not int
+                    or region[2] < 0
+                ):
+                    raise RuntimeError("Invalid NIXL metadata: invalid tensor region or byte size")
+            seen_indices.extend(indices)
+
+        if sorted(seen_indices) != [index for index, size in enumerate(sizes) if size > 0]:
+            raise RuntimeError("Invalid NIXL metadata: tensor indices must form an exact partition")
+        return groups
+
+    @staticmethod
+    def _tensor_region(tensor: torch.Tensor) -> tuple[int, int, int, str]:
+        device_id = max(tensor.get_device(), 0) if tensor.device.type != "cpu" else 0
+        return (tensor.data_ptr(), tensor.numel() * tensor.element_size(), device_id, "")
+
+    @staticmethod
+    def _is_tensor_payload(payload: Any) -> bool:
+        return isinstance(payload, torch.Tensor) or (
+            isinstance(payload, (list, tuple))
+            and bool(payload)
+            and all(isinstance(item, torch.Tensor) for item in payload)
+        )
+
+    @classmethod
+    def _contains_tensor(cls, payload: Any) -> bool:
+        if isinstance(payload, torch.Tensor):
+            return True
+        if isinstance(payload, msgspec.Struct):
+            payload = msgspec.structs.asdict(payload)
+        if isinstance(payload, dict):
+            return any(cls._contains_tensor(value) for value in payload.values())
+        if isinstance(payload, (list, tuple)):
+            return any(cls._contains_tensor(value) for value in payload)
+        return False
+
+    @classmethod
+    def _extract_tensor_leaves(cls, payload: Any) -> tuple[Any, list[torch.Tensor]]:
+        tensors: list[torch.Tensor] = []
+
+        def visit(value: Any) -> Any:
+            if isinstance(value, torch.Tensor):
+                index = len(tensors)
+                tensors.append(value)
+                return {_TENSOR_MARKER: index}
+            if isinstance(value, msgspec.Struct):
+                value = msgspec.structs.asdict(value)
+            if isinstance(value, dict):
+                return {key: visit(item) for key, item in value.items()}
+            if isinstance(value, list):
+                return [visit(item) for item in value]
+            if isinstance(value, tuple):
+                return {_TUPLE_MARKER: [visit(item) for item in value]}
+            return value
+
+        return visit(payload), tensors
+
+    @classmethod
+    def _restore_tensor_leaves(cls, skeleton: Any, tensors: list[torch.Tensor]) -> Any:
+        if isinstance(skeleton, dict):
+            if set(skeleton) == {_TENSOR_MARKER}:
+                return tensors[int(skeleton[_TENSOR_MARKER])]
+            if set(skeleton) == {_TUPLE_MARKER}:
+                return tuple(cls._restore_tensor_leaves(item, tensors) for item in skeleton[_TUPLE_MARKER])
+            return {key: cls._restore_tensor_leaves(value, tensors) for key, value in skeleton.items()}
+        if isinstance(skeleton, list):
+            return [cls._restore_tensor_leaves(item, tensors) for item in skeleton]
+        return skeleton
+
+    @staticmethod
+    def _normalize_tensor_payload(payload: Any) -> tuple[list[torch.Tensor], list[dict[str, Any]]]:
+        tensors = [payload] if isinstance(payload, torch.Tensor) else list(payload)
+        normalized: list[torch.Tensor] = []
+        specs: list[dict[str, Any]] = []
+        for tensor in tensors:
+            contiguous = tensor.detach().contiguous()
+            normalized.append(contiguous)
+            specs.append(
+                {
+                    "shape": list(contiguous.shape),
+                    "dtype": str(contiguous.dtype),
+                    "device": str(contiguous.device),
+                    "size": contiguous.numel() * contiguous.element_size(),
+                }
+            )
+        return normalized, specs
+
+    def _allocate_tensor_from_spec(self, spec: dict[str, Any], kind: str | None) -> torch.Tensor:
+        shape = spec.get("shape")
+        if not isinstance(shape, list):
+            raise RuntimeError(f"Invalid NIXL tensor shape: {shape!r}")
+        dtype_name = str(spec.get("dtype", "")).removeprefix("torch.")
+        dtype = getattr(torch, dtype_name, None)
+        if dtype is None:
+            raise RuntimeError(f"Unsupported NIXL tensor dtype: {spec.get('dtype')!r}")
+        device = torch.device("cpu") if kind == _KIND_OBJECT else self._resolve_receive_device(spec.get("device"))
+        return torch.empty(tuple(int(dim) for dim in shape), dtype=dtype, device=device)
+
+    def _resolve_receive_device(self, spec_device: Any) -> torch.device:
+        if self._receive_device is not None:
+            return self._receive_device
+        device = self._parse_device(spec_device)
+        if device is None or device.type == "cpu":
+            return torch.device("cpu")
+        # The producer's device index is meaningless in this process, so keep
+        # only its type and land the buffer on this stage's own card.
+        backend = getattr(torch, device.type, None)
+        index = backend.current_device() if hasattr(backend, "current_device") else 0
+        return torch.device(device.type, index)
+
+    @staticmethod
+    def _parse_device(device_like: Any) -> torch.device | None:
+        if device_like is None:
+            return None
+        try:
+            return torch.device(device_like)
+        except Exception as exc:
+            raise RuntimeError(f"Invalid NIXL receive device: {device_like!r}") from exc
+
+    @staticmethod
+    def _safe_call(func: Any, *args: Any) -> None:
+        try:
+            func(*args)
+        except Exception:
+            logger.debug("Ignoring NIXL cleanup failure", exc_info=True)
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/factory.py b/vllm_omni/distributed/omni_connectors/factory.py
index c49da1c6c..66dbca079 100644
--- a/vllm_omni/distributed/omni_connectors/factory.py
+++ b/vllm_omni/distributed/omni_connectors/factory.py
@@ -125,6 +125,17 @@ def _create_mori_transfer_engine_connector(config: dict[str, Any]) -> OmniConnec
     return MoriTransferEngineConnector(config)
 
 
+def _create_nixl_connector(config: dict[str, Any]) -> OmniConnectorBase:
+    try:
+        from .connectors.nixl_connector import NixlConnector
+    except ImportError:
+        import sys
+
+        sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
+        from omni_connectors.connectors.nixl_connector import NixlConnector
+    return NixlConnector(config)
+
+
 # Register connectors
 OmniConnectorFactory.register_connector("MooncakeStoreConnector", _create_mooncake_store_connector)
 OmniConnectorFactory.register_connector("MooncakeTransferEngineConnector", _create_mooncake_transfer_engine_connector)
@@ -132,5 +143,6 @@ OmniConnectorFactory.register_connector("SharedMemoryConnector", _create_shm_con
 OmniConnectorFactory.register_connector("YuanrongConnector", _create_yuanrong_connector)
 OmniConnectorFactory.register_connector("YuanrongTransferEngineConnector", _create_yuanrong_transfer_engine_connector)
 OmniConnectorFactory.register_connector("MoriTransferEngineConnector", _create_mori_transfer_engine_connector)
+OmniConnectorFactory.register_connector("NixlConnector", _create_nixl_connector)
 # Backward-compatible aliases – will be removed in the future
 OmniConnectorFactory.register_connector("MooncakeConnector", _create_mooncake_store_connector)
diff --git a/vllm_omni/distributed/omni_connectors/kv_transfer_manager.py b/vllm_omni/distributed/omni_connectors/kv_transfer_manager.py
index 6b83349f2..6ab0b36a2 100644
--- a/vllm_omni/distributed/omni_connectors/kv_transfer_manager.py
+++ b/vllm_omni/distributed/omni_connectors/kv_transfer_manager.py
@@ -564,6 +564,13 @@ class OmniKVTransferManager:
                             # the wrong process. Explicit sender_* YAML values
                             # are still preserved for standalone connector use.
 
+                    if c_type == "NixlConnector" and c_extra.get("role") == "receiver":
+                        # This manager receives on the shared incoming edge;
+                        # its YAML zmq_port belongs to the producer. NIXL treats
+                        # an explicit zmq_port as a local listener, even for a
+                        # receiver. Keep only the request-scoped sender_* endpoint.
+                        c_extra.pop("zmq_port", None)
+
                     logger.info(
                         "Initializing OmniConnector type=%s role=%s",
                         c_type,
@@ -922,7 +929,9 @@ class OmniKVTransferManager:
         The base host/port are also stored so that the receive path can
         construct per-rank metadata for heterogeneous TP scenarios.
         """
-        if not self.config.need_recv_cache:
+        # A stage can sit on the receiving end of a payload-only edge, where the
+        # sender endpoint still has to be applied even though no KV is expected.
+        if not self.config.need_recv_cache and (self.config.connector_config or {}).get("role") != "receiver":
             return
 
         actual_info = self._resolve_sender_info(sender_info, sender_stage_id=sender_stage_id)
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 25515cfaf..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
@@ -182,14 +189,19 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
         from_stage: str,
         to_stage: str,
         connector_get_key: str,
+        metadata: dict[str, Any] | None = None,
     ) -> Any:
         """Receive one ordinary non-KV stage payload on the local leader rank only."""
         tp_group = self._get_local_tp_group()
         if tp_group is None or getattr(tp_group, "world_size", 1) <= 1:
-            return connector.get(from_stage, to_stage, connector_get_key)
+            if metadata is None:
+                return connector.get(from_stage, to_stage, connector_get_key)
+            return connector.get(from_stage, to_stage, connector_get_key, metadata)
         if not self.is_data_transfer_rank():
             return None
-        return connector.get(from_stage, to_stage, connector_get_key)
+        if metadata is None:
+            return connector.get(from_stage, to_stage, connector_get_key)
+        return connector.get(from_stage, to_stage, connector_get_key, metadata)
 
     def _recv_full_payload_result(
         self,
@@ -197,6 +209,7 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
         from_stage: str,
         to_stage: str,
         connector_get_key: str,
+        metadata: dict[str, Any] | None = None,
     ) -> Any:
         """Receive one full-payload transfer on the local leader rank only."""
         return self._recv_ordinary_stage_result(
@@ -204,6 +217,7 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
             from_stage,
             to_stage,
             connector_get_key,
+            metadata,
         )
 
     def _recv_async_chunk_result(
@@ -212,6 +226,7 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
         from_stage: str,
         to_stage: str,
         connector_get_key: str,
+        metadata: dict[str, Any] | None = None,
     ) -> Any:
         """Receive one ordinary async chunk on the local leader rank only."""
         return self._recv_ordinary_stage_result(
@@ -219,6 +234,7 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
             from_stage,
             to_stage,
             connector_get_key,
+            metadata,
         )
 
     @staticmethod
@@ -318,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:
@@ -493,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
@@ -547,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
@@ -575,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 "
@@ -739,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,
@@ -840,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.
 
@@ -854,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.
@@ -865,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,
@@ -877,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
@@ -929,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)
@@ -960,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(
@@ -992,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:
@@ -1027,6 +1003,14 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
         chunk_id = self._get_req_chunk[req_id]
         external_req_id = self._request_ids_mapping.get(req_id, req_id)
         connector_get_key = f"{external_req_id}_{target_stage_id}_{chunk_id}"
+        request = self._pending_load_reqs.get(req_id)
+        sender_info = getattr(request, "payload_sender_info", None)
+        metadata = None
+        if isinstance(sender_info, dict):
+            host = sender_info.get("host")
+            port = sender_info.get("zmq_port")
+            if host and port:
+                metadata = {"source_host": str(host), "source_port": int(port)}
 
         if self._async_chunk:
             result = self._recv_async_chunk_result(
@@ -1034,6 +1018,7 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
                 str(target_stage_id),
                 str(self._stage_id),
                 connector_get_key,
+                metadata,
             )
         else:
             result = self._recv_full_payload_result(
@@ -1041,6 +1026,7 @@ class _OmniConnectorPayloadTransportMixin(_OmniConnectorRuntimeMixin):
                 str(target_stage_id),
                 str(self._stage_id),
                 connector_get_key,
+                metadata,
             )
 
         if result is None:
@@ -1066,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)
@@ -1134,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
 
@@ -1142,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(
@@ -1164,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:
@@ -1214,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(
@@ -1231,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"]),
@@ -1250,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:
@@ -1268,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)
@@ -1280,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)
@@ -1319,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 275a2c0af..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
@@ -19,6 +20,9 @@ from vllm_omni.distributed.omni_connectors.utils.config import (
     ConnectorSpec,
     get_stage_connector_role,
 )
+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")
 
@@ -67,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."""
 
@@ -164,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",
@@ -186,7 +213,11 @@ class _OmniConnectorRuntimeMixin:
                 getattr(topology, "target_tp_size", None),
                 getattr(topology, "local_rank", None),
             )
-            if all(isinstance(value, int) for value in effective_mapping):
+            if (
+                isinstance(effective_mapping[0], int)
+                and isinstance(effective_mapping[1], int)
+                and isinstance(effective_mapping[2], int)
+            ):
                 rank_cfg = {
                     "from_tp": effective_mapping[0],
                     "to_tp": effective_mapping[1],
@@ -223,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()
@@ -241,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.
@@ -264,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()
 
@@ -358,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)
@@ -378,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)
@@ -521,7 +562,15 @@ class _OmniConnectorRuntimeMixin:
         elif not isinstance(extra, dict):
             raise RuntimeError(f"Invalid extra config for connector {name}: expected dict, got {type(extra).__name__}")
 
-        spec = ConnectorSpec(name=name, extra=extra)
+        stage_id = int(getattr(model_config, "stage_id", extra.get("stage_id", 0)))
+        role = extra.get("role")
+        spec = resolve_connector_spec(
+            ConnectorSpec(name=name, extra=extra),
+            stage_id=stage_id,
+            role=str(role) if role is not None else None,
+            local_rank=get_local_tp_rank(),
+            replica_id=get_omni_replica_id(),
+        )
         try:
             return OmniConnectorFactory.create_connector(spec)
         except Exception as exc:
@@ -580,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
@@ -612,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:
@@ -620,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:
@@ -1059,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 d71d55bf1..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
@@ -20,6 +20,8 @@ from vllm_omni.data_entry_keys import MetaStruct, OmniPayloadStruct, unflatten_p
 from ..adapter import construct_next_stage_streaming_input_prompt
 from ..factory import OmniConnectorFactory
 from ..utils.config import ConnectorSpec, stage_receives_chunks
+from ..utils.initialization import resolve_connector_spec
+from ..utils.kv_utils import get_local_tp_rank, get_omni_replica_id
 from ..utils.logging import get_connector_logger
 from .base import OmniTransferAdapterBase
 
@@ -32,15 +34,35 @@ class _SenderGeneration:
     def __init__(self) -> None:
         self.in_flight = False
         self.cancelled = False
+        # A request-terminal chunk is queued but not yet on the wire. The
+        # downstream stage has no other way to learn the stream ended -- it
+        # polls the connector and parks in WAITING_FOR_CHUNK until a chunk
+        # carrying ``finished`` arrives -- so cleanup must not discard it.
+        # See vllm-project/vllm-omni#6670.
+        self.terminal_pending = False
+        # ``cleanup_sender`` asked to reclaim this generation while the fence
+        # was up. The terminal task owes that cleanup once it is done with the
+        # connector -- on every exit path, including a failed or raising put.
+        self.cleanup_deferred = False
 
 
 class _LoadEntry:
     """Identify one receiver registration across queue and I/O boundaries."""
 
-    __slots__ = ("request",)
+    __slots__ = ("request", "source_metadata")
 
     def __init__(self, request: Request) -> None:
         self.request = request
+        sender_info = getattr(request, "payload_sender_info", None)
+        self.source_metadata = None
+        if isinstance(sender_info, dict):
+            host = sender_info.get("host")
+            port = sender_info.get("zmq_port")
+            if host and port:
+                self.source_metadata = {
+                    "source_host": str(host),
+                    "source_port": int(port),
+                }
 
     @property
     def request_id(self) -> str:
@@ -251,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
@@ -270,11 +294,20 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
                 "extra": getattr(connector_config, "extra", {}),
             }
 
-        connector_specs = ConnectorSpec(
+        connector_spec = ConnectorSpec(
             name=connector_config.get("name", "SharedMemoryConnector"),
             extra=connector_config.get("extra", {}),
         )
-        return OmniConnectorFactory.create_connector(connector_specs)
+        stage_id = int(getattr(model_config, "stage_id", connector_spec.extra.get("stage_id", 0)))
+        role = connector_spec.extra.get("role")
+        resolved_spec = resolve_connector_spec(
+            connector_spec,
+            stage_id=stage_id,
+            role=str(role) if role is not None else None,
+            local_rank=get_local_tp_rank(),
+            replica_id=get_omni_replica_id(),
+        )
+        return OmniConnectorFactory.create_connector(resolved_spec)
 
     def load_async(self, request: Request):
         """Register a request for asynchronous chunk retrieval.
@@ -321,6 +354,17 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
         self._processor_accepts_step_tokens[processor] = accepts
         return accepts
 
+    def has_active_sender(self, external_req_id: str) -> bool:
+        """Whether this request owns a sender, including work still queued.
+
+        ``save_async`` registers the generation before the background thread
+        can send its first chunk. Chunk counters are initialized later and
+        cannot determine whether a prewarmed receiver needs a terminal.
+        """
+        with self._sender_state_lock:
+            sender_token = self._sender_tokens.get(external_req_id)
+            return sender_token is not None and not sender_token.cancelled
+
     def save_async(
         self,
         multimodal_output: dict[str, Any] | None = None,
@@ -329,6 +373,7 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
         new_token_ids: Iterable[int] | None = None,
         confirmed_num_computed_tokens: int | None = None,
         segment_generation: int | None = None,
+        force_request_finished: bool = False,
     ):
         """Build and enqueue one chunk for asynchronous sending.
 
@@ -352,8 +397,14 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
                 before a streaming transition can mutate ``request``
             segment_generation: generation captured before a resumable stop
                 can apply a queued update to the mutable request
+            force_request_finished: send this chunk as the request terminal
+                even though ``request`` is not in a finished status yet. The
+                scheduler needs this when it ends a *parked* streaming session:
+                the terminal has to be enqueued before ``finish_requests``,
+                because ``finish_requests`` skips requests that already report
+                ``is_finished()``. See ``_finish_parked_streaming_session``.
         """
-        is_finished = request.is_finished() and not request.resumable
+        is_finished = force_request_finished or (request.is_finished() and not request.resumable)
         if not hasattr(self, "_segment_generation"):
             self._segment_generation = defaultdict(int)
         external_req_id = request.external_req_id
@@ -414,6 +465,10 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
                     self._sender_tokens[external_req_id] = sender_token
                 task["sender_token"] = sender_token
                 self._pending_save_reqs.append(task)
+                if is_finished:
+                    # Fence this generation against cleanup until the terminal
+                    # chunk has been handed to the connector (#6670).
+                    sender_token.terminal_pending = True
                 if is_segment_finished:
                     # The queued FIFO item now owns the old segment. Start the next
                     # segment's deduplication watermark before the worker sends it.
@@ -452,6 +507,7 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
                 str(target_stage_id),
                 str(stage_id),
                 connector_get_key,
+                entry.source_metadata,
             )
         except Exception as e:
             logger.error(f"SharedMemoryConnector get failed for req {connector_get_key}: {e}")
@@ -624,32 +680,71 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
         if sender_token is None:
             self._send_single_request_for_generation(task)
             return
+        is_terminal_task = bool(task.get("is_finished"))
         with self._sender_state_lock:
             is_current = self._sender_tokens.get(external_req_id) is sender_token
-            if is_current and not sender_token.cancelled:
+            # ``cancelled`` does not veto a terminal chunk. It is the
+            # downstream stage's only end-of-stream signal, so dropping it
+            # leaves that stage parked in WAITING_FOR_CHUNK until the input
+            # deadline -- the hang this fence exists to prevent (#6670).
+            # Losing ownership of the external id still vetoes: the state the
+            # chunk describes then belongs to a different generation.
+            if is_current and (is_terminal_task or not sender_token.cancelled):
                 sender_token.in_flight = True
             else:
                 is_current = False
         if not is_current:
             logger.debug("Discarding stale queued chunk for aborted request %s", external_req_id)
+            if is_terminal_task:
+                self._release_terminal_fence(external_req_id, sender_token)
             return
         try:
             self._send_single_request_for_generation(task, sender_token)
         finally:
+            if is_terminal_task:
+                # Drop the fence and run the cleanup it deferred, whether the
+                # put succeeded, reported failure, or raised. Until this runs,
+                # the block below must not reclaim the generation either.
+                self._release_terminal_fence(external_req_id, sender_token)
             with self._sender_state_lock:
                 if self._sender_tokens.get(external_req_id) is sender_token:
                     sender_token.in_flight = False
-                    if sender_token.cancelled:
+                    if sender_token.cancelled and not sender_token.terminal_pending:
                         self._sender_tokens.pop(external_req_id, None)
                         self._clear_sender_state_locked(external_req_id)
 
+    def _release_terminal_fence(self, external_req_id: str, sender_token: _SenderGeneration) -> None:
+        """Drop the terminal fence and run the cleanup it deferred.
+
+        Called on every exit path of a terminal task. ``cleanup_sender``
+        cannot reclaim a generation whose terminal chunk is still queued, so
+        it records the request on the token instead; without this the only
+        path that ever replayed it was a *successful* put, and a connector
+        failure leaked the whole per-request sender state (#6670).
+        """
+        with self._sender_state_lock:
+            sender_token.terminal_pending = False
+            deferred = sender_token.cleanup_deferred
+            sender_token.cleanup_deferred = False
+            # A generation that no longer owns the external id was already
+            # reclaimed by whoever replaced it; cleaning now would clear the
+            # successor's state.
+            still_current = self._sender_tokens.get(external_req_id) is sender_token
+        if deferred and still_current:
+            self.cleanup_sender(external_req_id)
+
     def _sender_generation_is_active(
         self,
         external_req_id: str,
         sender_token: _SenderGeneration,
+        *,
+        is_terminal: bool = False,
     ) -> bool:
         with self._sender_state_lock:
-            return self._sender_tokens.get(external_req_id) is sender_token and not sender_token.cancelled
+            if self._sender_tokens.get(external_req_id) is not sender_token:
+                return False
+            # Terminal chunks outlive cancellation -- see _send_single_request.
+            return is_terminal or not sender_token.cancelled
 
     def _send_single_request_for_generation(
         self,
@@ -712,7 +807,9 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
         if payload_data.meta.is_segment_finished is None:
             payload_data.meta.is_segment_finished = torch.tensor(is_segment_finished, dtype=torch.bool)
 
-        if sender_token is not None and not self._sender_generation_is_active(external_req_id, sender_token):
+        if sender_token is not None and not self._sender_generation_is_active(
+            external_req_id, sender_token, is_terminal=is_finished
+        ):
             logger.debug("Skipping cancelled chunk for request %s before connector put", external_req_id)
             return
 
@@ -723,16 +820,25 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
             data=payload_data,
         )
 
-        if sender_token is not None and not self._sender_generation_is_active(external_req_id, sender_token):
-            # cleanup_sender() may cancel this generation while put() is
-            # blocked. Do not let that stale completion recreate state for a
-            # request whose cleanup is already in progress.
-            logger.debug("Ignoring completed put for cancelled request %s", external_req_id)
-            return
+        with self._sender_state_lock:
+            if sender_token is not None:
+                still_current = self._sender_tokens.get(external_req_id) is sender_token
+                retiring_without_terminal = sender_token.cancelled and not (
+                    is_finished or sender_token.terminal_pending
+                )
+                if not still_current or retiring_without_terminal:
+                    logger.debug("Ignoring completed put for retired request %s", external_req_id)
+                    return
+            if success:
+                # A receiver may already have consumed this key while put was
+                # in flight. Even if cleanup retired this generation, its
+                # pending terminal must use the next key. Check ownership and
+                # advance counters under the same lock so a stale completion
+                # cannot modify a successor's state.
+                self.put_req_chunk[external_req_id] += 1
+                self.ramp_chunk_count[external_req_id] += 1
 
         if success:
-            self.put_req_chunk[external_req_id] += 1
-            self.ramp_chunk_count[external_req_id] += 1
             logger.debug(f"[Stage-{stage_id}] Sent {connector_put_key}")
             # Sender uses struct attr access here; the receive path in
             # `_load_one_request` / `_update_request_payload` reads dict keys.
@@ -774,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)
@@ -862,6 +969,18 @@ class OmniChunkTransferAdapter(OmniTransferAdapterBase):
             if sender_token is None:
                 self._clear_sender_state_locked(external_req_id)
                 return
+            if sender_token.terminal_pending:
+                # A request-terminal chunk is still queued. Reclaiming the
+                # state now would drop it, and the downstream stage would sit
+                # in WAITING_FOR_CHUNK until VLLM_OMNI_INPUT_WAIT_TIMEOUT_S
+                # with no way to know the stream ended (#6670). Retire the
+                # generation anyway -- ``save_async`` rejects new chunks on
+                # ``cancelled``, which is what keeps a request reusing this
+                # external id from joining a generation that is going away --
+                # and hand the reclaim to the terminal task.
+                sender_token.cancelled = True
+                sender_token.cleanup_deferred = True
+                return
             sender_token.cancelled = True
             if sender_token.in_flight:
                 # The sender's finally block is the first point where no
@@ -876,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 1a6d395c2..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
@@ -13,6 +13,7 @@ TRANSFER_ENGINE_CONNECTOR_NAMES = frozenset(
         "MooncakeTransferEngineConnector",
         "MoriTransferEngineConnector",
         "YuanrongTransferEngineConnector",
+        "NixlConnector",
     }
 )
 
@@ -32,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/distributed/omni_connectors/utils/initialization.py b/vllm_omni/distributed/omni_connectors/utils/initialization.py
index bbbda44e3..d0139b59a 100644
--- a/vllm_omni/distributed/omni_connectors/utils/initialization.py
+++ b/vllm_omni/distributed/omni_connectors/utils/initialization.py
@@ -4,9 +4,10 @@
 """Utilities for OmniConnector configuration and validation."""
 
 import json
+import os
 import warnings
 from pathlib import Path
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Literal
 
 from ..factory import OmniConnectorFactory
 from .config import TRANSFER_ENGINE_CONNECTOR_NAMES, ConnectorSpec, OmniTransferConfig
@@ -38,6 +39,91 @@ KV_RANK_PORT_STRIDE = 16
 # comfortably sized block per replica for TP-rank and stage offsets.
 KV_REPLICA_PORT_STRIDE = 1024
 
+REQUEST_FORWARDING_PORT_OFFSET = 0
+ORCHESTRATOR_PORT_OFFSET = 200
+
+ConnectorPurpose = Literal["request_forwarding", "kv_transfer", "orchestrator"]
+
+
+def compute_connector_zmq_port(
+    base_port: int,
+    *,
+    purpose: ConnectorPurpose,
+    from_stage: int,
+    local_rank: int = 0,
+    replica_id: int = 0,
+) -> int:
+    """Return a collision-free connector endpoint for an edge and worker."""
+    purpose_offsets = {
+        "request_forwarding": REQUEST_FORWARDING_PORT_OFFSET,
+        "kv_transfer": KV_TRANSFER_PORT_OFFSET,
+        "orchestrator": ORCHESTRATOR_PORT_OFFSET,
+    }
+    if purpose not in purpose_offsets:
+        raise ValueError(f"Unsupported connector purpose: {purpose}")
+    if not 0 <= from_stage < KV_RANK_PORT_STRIDE:
+        raise ValueError(f"from_stage must be in [0, {KV_RANK_PORT_STRIDE}), got {from_stage}")
+    if local_rank < 0:
+        raise ValueError(f"local_rank must be non-negative, got {local_rank}")
+    if replica_id < 0:
+        raise ValueError(f"replica_id must be non-negative, got {replica_id}")
+
+    port = (
+        base_port
+        + purpose_offsets[purpose]
+        + replica_id * KV_REPLICA_PORT_STRIDE
+        + local_rank * KV_RANK_PORT_STRIDE
+        + from_stage
+    )
+    if not 1 <= port <= 65535:
+        raise ValueError(f"Resolved connector port must be in [1, 65535], got {port}")
+    return port
+
+
+def resolve_connector_spec(
+    spec: ConnectorSpec,
+    *,
+    stage_id: int,
+    role: str | None,
+    purpose: ConnectorPurpose = "request_forwarding",
+    local_rank: int = 0,
+    replica_id: int = 0,
+) -> ConnectorSpec:
+    """Copy and resolve a connector spec for one stage worker."""
+    extra = dict(spec.extra or {})
+    extra["stage_id"] = stage_id
+    if role is not None:
+        extra["role"] = role
+    if spec.name not in TRANSFER_ENGINE_CONNECTOR_NAMES:
+        return ConnectorSpec(name=spec.name, extra=extra)
+
+    resolved_port = None
+    if role != "receiver" or "sender_zmq_port" not in extra:
+        resolved_port = compute_connector_zmq_port(
+            expand_env_int(extra.get("zmq_port", 50051), "zmq_port"),
+            purpose=purpose,
+            from_stage=int(extra.get("from_stage", stage_id)),
+            local_rank=local_rank,
+            replica_id=replica_id,
+        )
+    if role == "receiver":
+        extra.setdefault("sender_host", extra.get("host", "127.0.0.1"))
+        extra.setdefault("sender_zmq_port", resolved_port)
+        extra.pop("zmq_port", None)
+        outgoing = extra.get("outgoing")
+        if spec.name == "NixlConnector" and isinstance(outgoing, dict):
+            extra["zmq_port"] = compute_connector_zmq_port(
+                expand_env_int(outgoing.get("zmq_port", 50051), "zmq_port"),
+                purpose=purpose,
+                from_stage=int(outgoing.get("from_stage", stage_id)),
+                local_rank=local_rank,
+                replica_id=replica_id,
+            )
+            extra["host"] = outgoing.get("host", "auto")
+    else:
+        extra["zmq_port"] = resolved_port
+    return ConnectorSpec(name=spec.name, extra=extra)
+
 
 def initialize_connectors_from_config(
     config_path: str | Path | None = None,
@@ -82,52 +168,40 @@ def create_connectors_from_config(
     Returns:
         A dictionary of connectors.
     """
-    purpose_port_offsets = {
-        "request_forwarding": 0,
-        "kv_transfer": KV_TRANSFER_PORT_OFFSET,
-    }
-    port_offset = purpose_port_offsets.get(purpose, 0)
-    orchestrator_port_offset = 200
-
     connectors = {}
     for edge_key, connector_spec in connectors_config.items():
         from_stage, to_stage = edge_key
         try:
             if connector_spec.name in TRANSFER_ENGINE_CONNECTOR_NAMES:
                 extra = dict(connector_spec.extra) if connector_spec.extra else {}
-                base_port = expand_env_int(extra.get("zmq_port", 50051), "zmq_port")
                 try:
-                    stage_offset = int(from_stage)
-                except (TypeError, ValueError):
-                    stage_offset = 0
-
-                local_rank = 0 if str(caller_stage_id) == "orchestrator" else get_connector_local_rank()
-                if str(caller_stage_id) == "orchestrator":
-                    rank0_port = base_port + orchestrator_port_offset + stage_offset
-                else:
-                    rank0_port = base_port + port_offset + stage_offset
-                adjusted_port = rank0_port + local_rank * KV_RANK_PORT_STRIDE
-                extra["zmq_port"] = adjusted_port
+                    from_stage_id = int(from_stage)
+                except (TypeError, ValueError) as exc:
+                    raise ValueError(f"Transfer-engine stage id must be an integer, got {from_stage!r}") from exc
 
+                is_orchestrator = str(caller_stage_id) == "orchestrator"
+                local_rank = 0 if is_orchestrator else get_connector_local_rank()
+                resolved_purpose: ConnectorPurpose = "orchestrator" if is_orchestrator else purpose  # type: ignore[assignment]
                 if is_sender is not None:
-                    extra["role"] = "sender" if is_sender else "receiver"
-                    if not is_sender:
-                        extra.setdefault("sender_host", extra.get("host", "127.0.0.1"))
-                        extra.setdefault("sender_zmq_port", adjusted_port)
-                elif caller_stage_id is not None:
-                    caller_str = str(caller_stage_id)
-                    if caller_str == from_stage:
-                        extra["role"] = "sender"
-                    elif caller_str == to_stage:
-                        extra["role"] = "receiver"
-                        extra.setdefault("sender_host", extra.get("host", "127.0.0.1"))
-                        extra.setdefault("sender_zmq_port", adjusted_port)
-                    else:
-                        extra["role"] = "sender"
+                    role = "sender" if is_sender else "receiver"
+                elif caller_stage_id is not None and str(caller_stage_id) == to_stage:
+                    role = "receiver"
+                elif caller_stage_id is not None and str(caller_stage_id) == from_stage:
+                    role = "sender"
                 else:
-                    extra["role"] = extra.get("role", "auto")
-
-                connector = OmniConnectorFactory.create_connector(ConnectorSpec(name=connector_spec.name, extra=extra))
+                    role = str(extra.get("role", "auto"))
+                extra["from_stage"] = from_stage_id
+                extra["to_stage"] = int(to_stage)
+                replica_id = max(int(os.environ.get("VLLM_OMNI_REPLICA_ID", "0")), 0)
+                resolved_spec = resolve_connector_spec(
+                    ConnectorSpec(name=connector_spec.name, extra=extra),
+                    stage_id=int(caller_stage_id) if str(caller_stage_id).isdigit() else from_stage_id,
+                    role=role,
+                    purpose=resolved_purpose,
+                    local_rank=local_rank,
+                    replica_id=replica_id,
+                )
+                connector = OmniConnectorFactory.create_connector(resolved_spec)
             else:
                 connector = OmniConnectorFactory.create_connector(connector_spec)
             connectors[edge_key] = connector
@@ -174,12 +248,16 @@ def get_connectors_config_for_stage(transfer_config: OmniTransferConfig | None,
             # Incoming edge → this stage is the receiver
             extra = dict(spec.extra) if spec.extra else {}
             extra.setdefault("role", "receiver")
+            extra["from_stage"] = int(from_stage)
+            extra["to_stage"] = int(to_stage)
             stage_connectors_config[f"from_stage_{from_stage}"] = {"spec": {"name": spec.name, "extra": extra}}
         elif from_stage == target_stage and target_stage == "0":
             # Outgoing edge for stage 0 — included for async_chunk spec
             # extraction (omni_stage.py), NOT for connector instantiation.
             extra = dict(spec.extra) if spec.extra else {}
             extra.setdefault("role", "sender")
+            extra["from_stage"] = int(from_stage)
+            extra["to_stage"] = int(to_stage)
             stage_connectors_config[f"to_stage_{to_stage}"] = {"spec": {"name": spec.name, "extra": extra}}
 
     return stage_connectors_config
diff --git a/vllm_omni/distributed/omni_connectors/utils/kv_utils.py b/vllm_omni/distributed/omni_connectors/utils/kv_utils.py
index b7f51460c..4be32ba7e 100644
--- a/vllm_omni/distributed/omni_connectors/utils/kv_utils.py
+++ b/vllm_omni/distributed/omni_connectors/utils/kv_utils.py
@@ -16,7 +16,7 @@ from vllm.distributed.parallel_state import (
 )
 from vllm.logger import init_logger
 
-from .initialization import KV_RANK_PORT_STRIDE, KV_REPLICA_PORT_STRIDE, KV_TRANSFER_PORT_OFFSET
+from .initialization import compute_connector_zmq_port
 
 logger = init_logger(__name__)
 
@@ -123,12 +123,12 @@ def kv_zmq_port(
 
     """
     replica = get_omni_replica_id() if replica_id is None else max(int(replica_id), 0)
-    return (
-        base_port
-        + KV_TRANSFER_PORT_OFFSET
-        + replica * KV_REPLICA_PORT_STRIDE
-        + local_rank * KV_RANK_PORT_STRIDE
-        + from_stage
+    return compute_connector_zmq_port(
+        base_port,
+        purpose="kv_transfer",
+        from_stage=from_stage,
+        local_rank=local_rank,
+        replica_id=replica,
     )
 
 
diff --git a/vllm_omni/engine/__init__.py b/vllm_omni/engine/__init__.py
index e72ce9fed..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.
 """
@@ -79,6 +82,7 @@ class OmniEngineCoreRequest(EngineCoreRequest):
     # GPUModelRunner.model_intermediate_buffer instead of using the deprecated
     # additional_information request transport.
     model_intermediate_buffer: dict[str, Any] | None = None
+    payload_sender_info: dict[str, Any] | None = None
 
     @classmethod
     def from_request(
@@ -88,6 +92,7 @@ class OmniEngineCoreRequest(EngineCoreRequest):
         prompt_embeds: torch.Tensor | None = None,
         additional_information: AdditionalInformationPayload | None = None,
         model_intermediate_buffer: dict[str, Any] | None = None,
+        payload_sender_info: dict[str, Any] | None = None,
     ) -> "OmniEngineCoreRequest":
         """Clone an EngineCoreRequest into an OmniEngineCoreRequest with optional payload overrides."""
 
@@ -97,6 +102,8 @@ class OmniEngineCoreRequest(EngineCoreRequest):
             additional_information = getattr(request, "additional_information", None)
         if model_intermediate_buffer is None:
             model_intermediate_buffer = getattr(request, "model_intermediate_buffer", None)
+        if payload_sender_info is None:
+            payload_sender_info = getattr(request, "payload_sender_info", None)
 
         return cls(
             request_id=request.request_id,
@@ -121,6 +128,7 @@ class OmniEngineCoreRequest(EngineCoreRequest):
             abort_immediately=request.abort_immediately,
             additional_information=additional_information,
             model_intermediate_buffer=model_intermediate_buffer,
+            payload_sender_info=payload_sender_info,
         )
 
 
@@ -129,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 44bd9058c..939b19d50 100644
--- a/vllm_omni/engine/arg_utils.py
+++ b/vllm_omni/engine/arg_utils.py
@@ -54,6 +54,9 @@ def _register_omni_hf_configs() -> None:
     try:
         from transformers import AutoConfig
 
+        from vllm_omni.model_executor.models.breeze_tts_2.configuration_breeze_tts_2 import (
+            BreezeTTS2Config,
+        )
         from vllm_omni.model_executor.models.indextts2.configuration_indextts2 import (
             IndexTTS2Config,
             IndexTTS25Config,
@@ -105,6 +108,7 @@ def _register_omni_hf_configs() -> None:
         ("glm_tts", GLMTTSConfig),
         ("omnivoice", OmniVoiceConfig),
         ("voxcpm2", VoxCPM2Config),
+        ("breeze", BreezeTTS2Config),
     ]:
         try:
             AutoConfig.register(model_type, config_cls)
@@ -177,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
@@ -195,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.
@@ -419,6 +426,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,
@@ -426,6 +435,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,
@@ -566,11 +576,13 @@ class OrchestratorArgs:
     diffusion_compile_dynamic: bool | None = None
     cache_backend: str = "none"
     cache_config: str | None = None
+    video_output_transport: dict[str, object] | None = None
     enable_cache_dit_summary: bool = False
     step_execution: bool = False
     vae_use_slicing: bool = False
     vae_use_tiling: bool = False
     enable_multithread_weight_load: bool = True
+    enable_broadcast_weight_load: bool = False
     num_weight_load_threads: int = 4
     diffusion_offload_config: dict[str, Any] | None = None
     # Compatibility aliases for existing callers and model-specific stage
diff --git a/vllm_omni/engine/async_omni_engine.py b/vllm_omni/engine/async_omni_engine.py
index 6850e6b29..3469d8fee 100644
--- a/vllm_omni/engine/async_omni_engine.py
+++ b/vllm_omni/engine/async_omni_engine.py
@@ -1,498 +1,45 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
-"""
-Async Omni Engine for vLLM-Omni multi-stage runtime.
-
-AsyncOmniEngine in the caller's thread is a thin proxy that communicates
-with the Orchestrator (running in a background thread) via janus queues.
-"""
+"""AsyncOmniEngine: the turn-based engine (add_request / streaming updates / CFG companions / interaction)."""
 
 from __future__ import annotations
 
-import asyncio
-import concurrent.futures
 import copy
-import queue
 import shutil
-import threading
 import time
-import uuid
-import weakref
 from collections.abc import Mapping, Sequence
 from typing import Any, Literal, cast
 
-import janus
-from vllm import envs as vllm_envs
 from vllm.inputs import PromptType
 from vllm.logger import init_logger
 from vllm.v1.engine import EngineCoreRequest
-from vllm.v1.engine.input_processor import InputProcessor
 
-from vllm_omni.config.config_factory import StageConfigFactory
-from vllm_omni.config.resolver import OmniConfigResolution, resolve_omni_config
-from vllm_omni.config.stage_config import (
-    DuplexSessionRuntimeConfig,
-    PipelineConfig,
-    load_deploy_config,
-)
 from vllm_omni.data_entry_keys import REQUEST_ARTIFACT_DIRS_KEY, TRANSFORM_OWNED_META_KEYS
 from vllm_omni.engine import OmniEngineCoreRequest
 from vllm_omni.engine.async_engine_utils import (
-    SHUTDOWN_ENQUEUE_TIMEOUT_S,
-    SHUTDOWN_JOIN_TIMEOUT_S,
     apply_omni_final_stage_metadata,
-    enqueue_orchestrator_shutdown,
     inject_global_id,
-    is_abort_transport_shutdown,
-    is_janus_sync_queue_shutdown,
-    shutdown_runtime_after_orchestrator,
     upgrade_to_omni_request,
-    weak_shutdown_async_omni_engine,
-)
-from vllm_omni.engine.duplex.control_client import DuplexControlClient
-from vllm_omni.engine.duplex.lease import DuplexLeaseActivity
-from vllm_omni.engine.duplex.messages import DuplexFence
-from vllm_omni.engine.duplex.runtime import (
-    load_duplex_runtime_extension,
-    validate_duplex_runtime_extension,
 )
 from vllm_omni.engine.messages import (
-    AbortRequestMessage,
-    AbortResultMessage,
     AddCompanionRequestMessage,
-    CollectiveRPCRequestMessage,
-    CollectiveRPCResultMessage,
-    EngineQueueMessage,
-    ErrorMessage,
     InteractionMessage,
-    OutputMessage,
     StageSubmissionMessage,
 )
-from vllm_omni.engine.orchestrator import Orchestrator
-from vllm_omni.engine.rpc_result_router import CorrelatedRpcClient
+from vllm_omni.engine.omni_engine_base import OmniEngineBase, StageRuntimeInfo
+from vllm_omni.engine.orchestrator import Orchestrator, OrchestratorBase
 from vllm_omni.engine.serialization import deserialize_additional_information
-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 (
-    StageRuntimeInfo,
-    create_stage_runtime,
-)
-from vllm_omni.entrypoints.pd_utils import PDDisaggregationMixin
-from vllm_omni.entrypoints.utils import parse_stage_overrides
 from vllm_omni.inputs.data import OmniInteractionPrompt, OmniSamplingParams
-from vllm_omni.metrics.prometheus import OmniRequestCounter
 
 logger = init_logger(__name__)
 
-_STARTUP_POLL_INTERVAL_S = 1.0
-_REQUEST_QUEUE_MAXSIZE = 256
-_ConfigResolutionResult = OmniConfigResolution | tuple[str | None, list[Any], str | None]
 
+class AsyncOmniEngine(OmniEngineBase):
+    """Turn-based engine used by ``Omni`` / ``AsyncOmni``."""
 
-def load_and_resolve_stage_configs(
-    model: str,
-    kwargs: dict[str, Any],
-    *,
-    trust_remote_code: bool | None,
-    deploy_config_path: str | None,
-    stage_overrides: Mapping[str, Mapping[str, Any]] | None,
-    strategy_config_path: str | None,
-) -> OmniConfigResolution:
-    """Compatibility seam delegating to the single config resolver."""
-    return resolve_omni_config(
-        model,
-        trust_remote_code=trust_remote_code,
-        cli_overrides=kwargs,
-        deploy_config_path=deploy_config_path,
-        stage_overrides=stage_overrides,
-        strategy_config_path=strategy_config_path,
-    )
-
-
-class AsyncOmniEngine:
-    """Thin proxy that launches an Orchestrator in a background thread.
-
-    All stage clients, input/output processors, and stage-to-stage transfer
-    logic live inside the Orchestrator coroutine (running in its own thread
-    with a dedicated asyncio event loop). This class communicates with it
-    via janus queues (sync side for callers, async side for orchestrator).
-
-    Args:
-        model: Model name or path
-        init_timeout: Total timeout waiting for orchestrator startup (seconds).
-        stage_init_timeout: Timeout for stage initialization (seconds)
-        **kwargs: Additional arguments
-    """
-
-    # Class-level defaults so tests that bypass __init__ via object.__new__
-    # don't AttributeError when stage-init / forward paths touch these attrs.
-    _log_stats: bool = False
-    _coordinator_runtime: Any = None
-    _transfer_emitter: Any = None
-    _prom_metrics: Any = None
-    _enable_orch_monitor: bool = False
-    # Lazily created by get_output_blocking_async().
-    _output_drain_executor: concurrent.futures.ThreadPoolExecutor | None = None
-
-    def __init__(
-        self,
-        model: str,
-        stage_init_timeout: int = 300,
-        init_timeout: int = 600,
-        single_stage_mode: bool = False,
-        transfer_emitter: Any = None,
-        prom_metrics: Any = None,
-        log_stats: bool = False,
-        tokenizer: str | None = None,
-        trust_remote_code: bool | None = None,
-        **kwargs: Any,
-    ) -> None:
-        self.model = model
-        self.tokenizer = tokenizer
-        # Cached by get_diffusion_od_config().
-        self._diffusion_od_config_view: Any = None
-        startup_timeout = int(init_timeout)
-        # Forwarded into Orchestrator so its _forward_to_next_stage path can
-        # emit per-edge transfer_tx_s / transfer_size_bytes histograms.
-        # Optional: when None, Orchestrator silently skips TX emit (existing
-        # RX path still works via OrchestratorAggregator).
-        self._transfer_emitter = transfer_emitter
-        self._prom_metrics = prom_metrics
-        # Drives upstream EngineCore + scheduler stats production. When False
-        # the engine skips SchedulerStats / IterationStats; the per-(stage,
-        # replica) vllm:* wrap stays registered but reads zero. Respects the
-        # --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))
-
-        logger.info(f"[AsyncOmniEngine] Initializing with model {model}")
-
-        # ------------------------------------------------------------------ #
-        # Single-stage mode detection                                        #
-        # ------------------------------------------------------------------ #
-        # Single-stage mode is enabled when the caller explicitly passes      #
-        # single_stage_mode=True, or when a stage_id is provided in the args. #
-        _stage_id_kwarg = kwargs.get("stage_id")
-        if isinstance(_stage_id_kwarg, int) and not single_stage_mode:
-            single_stage_mode = True
-
-        self.single_stage_mode: bool = single_stage_mode
-        self._single_stage_id_filter: int | None = (
-            int(_stage_id_kwarg) if single_stage_mode and isinstance(_stage_id_kwarg, int) else None
-        )
-        self._omni_master_address: str | None = kwargs.get("omni_master_address")
-        self._omni_master_port: int | None = kwargs.get("omni_master_port")
-
-        # New omni-coordinator flags. Consumed only in single_stage_mode.
-        # ``omni_dp_size_local`` is process-local: each invocation (head and
-        # every headless) launches that many replicas for its own stage.
-        self._omni_dp_size_local: int = int(kwargs.get("omni_dp_size_local") or 1)
-        if self._omni_dp_size_local < 1:
-            raise ValueError(f"--omni-dp-size-local must be >= 1, got {self._omni_dp_size_local}")
-        self._omni_lb_policy: str = str(kwargs.get("omni_lb_policy") or "random")
-        self._omni_heartbeat_timeout: float = float(kwargs.get("omni_heartbeat_timeout") or 30.0)
-        if self._omni_heartbeat_timeout <= 0:
-            raise ValueError(f"--omni-heartbeat-timeout must be > 0, got {self._omni_heartbeat_timeout}")
-        # Concurrent same-device stage init (admission + SH/EX phase locks).
-        # Sourced from the parallel_stage_init orchestrator/CLI arg (config,
-        # not an env var); default False preserves serial init.
-        self._parallel_stage_init: bool = bool(kwargs.get("parallel_stage_init") or False)
-
-        if single_stage_mode:
-            logger.info(
-                "[AsyncOmniEngine] Single-stage mode enabled (stage_id_filter=%s, master=%s:%s)",
-                self._single_stage_id_filter,
-                self._omni_master_address,
-                self._omni_master_port,
-            )
-
-        # Keep the historical tuple return from _resolve_stage_configs while
-        # retaining the richer resolver result for pipeline-wide settings.
-        # Overrides of that private seam fall back to the factory below.
-        deploy_config_path = kwargs.get("deploy_config")
-        self._config_resolution: OmniConfigResolution | None = None
-        self.config_path, self.stage_configs = self._resolve_stage_configs(
-            model,
-            kwargs,
-            trust_remote_code=trust_remote_code,
-        )
-        if self._config_resolution is None:
-            pipeline_config = StageConfigFactory.get_pipeline_config(
-                model=model,
-                trust_remote_code=bool(trust_remote_code),
-                deploy_config_path=deploy_config_path,
-            )
-            self._set_pipeline_runtime_config(pipeline_config, self.config_path)
-        else:
-            self._set_pipeline_runtime_config(
-                self._config_resolution.pipeline_config,
-                self._config_resolution.config_path,
-            )
-
-        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.stage_pools: list[StagePool] = []
-        self.stage_clients: list[StageClient] = []  # logical-stage view for external readers
-        self.input_processor: InputProcessor | None = None
-        self.prompt_transform_func: Any | None = None
-        self.prompt_expand_func: Any | None = None
-        self.supported_tasks: tuple[str, ...] = ("generate",)
-        self.default_sampling_params_list: list[OmniSamplingParams] = []
-        self.stage_metadata: list[StageRuntimeInfo] = []
-        # Janus queues are constructed eagerly here (not deferred to the
-        # orchestrator thread) so the master server's ROUTER thread always
-        # sees a non-None ``self.request_queue`` when on_register fires.
-        # ``async_q`` lazily binds to whatever event loop first awaits on
-        # it (the orchestrator loop), so cross-thread use stays correct.
-        self.request_queue: janus.Queue[EngineQueueMessage] = janus.Queue(maxsize=_REQUEST_QUEUE_MAXSIZE)
-        self.output_queue: janus.Queue[EngineQueueMessage] = janus.Queue()
-        self.rpc_output_queue: janus.Queue[EngineQueueMessage] = janus.Queue()
-        self._shutdown_called = False
-        self._weak_finalizer: weakref.finalize | None = None
-        self._correlated_rpc_client: CorrelatedRpcClient | None = None
-        self._duplex_control_client: DuplexControlClient | None = None
-        self._running_counter = OmniRequestCounter()
-        self._engines_waiting_counter = OmniRequestCounter()
-
-        logger.info(f"[AsyncOmniEngine] Launching Orchestrator thread with {self.num_stages} stages")
-
-        # Launch orchestrator background thread
-        startup_future: concurrent.futures.Future = concurrent.futures.Future()
-
-        self.orchestrator_thread = threading.Thread(
-            target=self._bootstrap_orchestrator,
-            args=(
-                stage_init_timeout,
-                startup_future,
-            ),
-            daemon=True,
-            name="orchestrator",
-        )
-        self.orchestrator_thread.start()
-        self._wait_for_orchestrator_init(startup_future, startup_timeout)
-        self._correlated_rpc_client = CorrelatedRpcClient(
-            self.request_queue.sync_q,
-            self.rpc_output_queue.sync_q,
-        )
-
-        # Stage runtime fields are assigned directly on self by the bootstrap thread.
-        self._weak_finalizer = weakref.finalize(
-            self,
-            weak_shutdown_async_omni_engine,
-            self.orchestrator_thread,
-            self.request_queue,
-            self.output_queue,
-            self.rpc_output_queue,
-            self._correlated_rpc_client,
-        )
-
-        logger.info(f"[AsyncOmniEngine] Orchestrator ready with {self.num_stages} stages")
-
-    def get_diffusion_od_config(self) -> Any:
-        """Expose the diffusion ``model_class_name`` to client-side model-extras.
-
-        The worker holds the full config; here we just resolve the pipeline class
-        name from the model config (cached). ``model_class_name`` may be ``None``.
-        """
-        if self._diffusion_od_config_view is None:
-            from types import SimpleNamespace
-
-            from vllm_omni.diffusion.data import resolve_model_class_name
-            from vllm_omni.diffusion.model_metadata import get_diffusion_model_metadata
-
-            model_class_name = resolve_model_class_name(self.model)
-            metadata = get_diffusion_model_metadata(model_class_name)
-            self._diffusion_od_config_view = SimpleNamespace(
-                model_class_name=model_class_name,
-                supports_multimodal_inputs=metadata.supports_multimodal_inputs,
-                max_multimodal_image_inputs=metadata.max_multimodal_image_inputs,
-                supports_mixed_reference_inputs=metadata.supports_mixed_reference_inputs,
-            )
-        return self._diffusion_od_config_view
-
-    def _initialize_stages(self, stage_init_timeout: int) -> None:
-        """Initialize stage clients/processors via StageRuntime and assign to self."""
-        self._runtime = create_stage_runtime(
-            stage_configs=self.stage_configs,
-            model=self.model,
-            config_path=self.config_path,
-            single_stage_mode=self.single_stage_mode,
-            stage_init_timeout=stage_init_timeout,
-            async_chunk=self.async_chunk,
-            tokenizer=self.tokenizer,
-            parallel_stage_init=self._parallel_stage_init,
-            single_stage_id_filter=self._single_stage_id_filter,
-            omni_master_address=self._omni_master_address,
-            omni_master_port=self._omni_master_port,
-            omni_dp_size_local=self._omni_dp_size_local,
-            omni_heartbeat_timeout=self._omni_heartbeat_timeout,
-            omni_lb_policy=self._omni_lb_policy,
-            request_queue=self.request_queue,
-            log_stats=self._log_stats,
-        )
-        self._runtime.initialize()
-
-        self.num_stages = len(self.stage_configs)
-        self.stage_pools = self._runtime.stage_pools
-        self.stage_clients = [
-            cast(StageClient, pool.stage_client) for pool in self.stage_pools if pool.stage_client is not None
-        ]
-        self.stage_vllm_configs = [pool.stage_vllm_config for pool in self.stage_pools]
-        self.output_processors = [pool.output_processor for pool in self.stage_pools]
-        self.input_processor = (
-            build_stage0_input_processor(self.stage_vllm_configs[0])
-            if self.stage_vllm_configs and self.stage_vllm_configs[0] is not None
-            else None
-        )
-        self.prompt_transform_func = (
-            getattr(self.stage_clients[0], "prompt_transform_func", None) if self.stage_clients else None
-        )
-        self.prompt_expand_func = next(
-            (
-                getattr(client, "prompt_expand_func", None)
-                for client in self.stage_clients
-                if getattr(client, "prompt_expand_func", None) is not None
-            ),
-            None,
-        )
-        self.default_sampling_params_list = [client.default_sampling_params for client in self.stage_clients]
-        self.stage_metadata = [
-            StageRuntimeInfo(
-                final_output=client.final_output,
-                final_output_type=client.final_output_type,
-                stage_type=client.stage_type,
-                model_stage=getattr(client, "model_stage", None),
-            )
-            for client in self.stage_clients
-        ]
-        supported_tasks: set[str] = set()
-        if any(getattr(client, "is_comprehension", False) for client in self.stage_clients):
-            supported_tasks.add("generate")
-        if any(meta.final_output_type == "audio" for meta in self.stage_metadata):
-            supported_tasks.add("speech")
-        self.supported_tasks = tuple(supported_tasks) if supported_tasks else ("generate",)
-
-    def _bootstrap_orchestrator(
-        self,
-        stage_init_timeout: int,
-        startup_future: concurrent.futures.Future,
-    ) -> None:
-        """Create loop, initialize stages, then run Orchestrator."""
-
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-
-        async def _run_orchestrator() -> None:
-            self._initialize_stages(stage_init_timeout)
-
-            pd_config = self._detect_pd_config()
-
-            membership_controller = self._runtime.create_membership_controller()
-            duplex_runtime_extension = None
-            if self._duplex_control_enabled:
-                duplex_runtime_extension = load_duplex_runtime_extension(
-                    getattr(self, "_duplex_runtime_extension_path", None)
-                )
-                if duplex_runtime_extension is not None:
-                    stage_clients = []
-                    for pool in self.stage_pools:
-                        assert pool.stage_client is not None
-                        stage_clients.append(pool.stage_client)
-                    validate_duplex_runtime_extension(
-                        duplex_runtime_extension,
-                        sampling_defaults=tuple(client.default_sampling_params for client in stage_clients),
-                    )
-
-            orchestrator = Orchestrator(
-                request_async_queue=self.request_queue.async_q,
-                output_async_queue=self.output_queue.async_q,
-                rpc_async_queue=self.rpc_output_queue.async_q,
-                stage_pools=self.stage_pools,
-                async_chunk=self.async_chunk,
-                pd_config=pd_config,
-                membership_controller=membership_controller,
-                running_counter=self._running_counter,
-                engines_waiting_counter=self._engines_waiting_counter,
-                transfer_emitter=self._transfer_emitter,
-                prom_metrics=self._prom_metrics,
-                log_stats=self._log_stats,
-                enable_orch_monitor=self._enable_orch_monitor,
-                duplex_runtime_extension=duplex_runtime_extension,
-                enable_duplex_control=self._duplex_control_enabled,
-                duplex_session_config=self.duplex_session_config,
-            )
-            if not startup_future.done():
-                startup_future.set_result(asyncio.get_running_loop())
-            await orchestrator.run()
-
-        try:
-            loop.run_until_complete(_run_orchestrator())
-        except Exception as e:
-            if not startup_future.done():
-                wrapped = RuntimeError(f"Orchestrator initialization failed: {e}")
-                wrapped.__cause__ = e
-                startup_future.set_exception(wrapped)
-            logger.exception("[AsyncOmniEngine] Orchestrator thread crashed")
-            error_text = str(e) or "Orchestrator thread crashed"
-            try:
-                error_msg = ErrorMessage(error=error_text, fatal=True)
-                if self.output_queue is not None:
-                    self.output_queue.sync_q.put_nowait(error_msg)
-                if self.rpc_output_queue is not None:
-                    self.rpc_output_queue.sync_q.put_nowait(error_msg)
-            except Exception:
-                pass
-            raise
-        finally:
-            try:
-                pending = [task for task in asyncio.all_tasks(loop) if not task.done()]
-                for task in pending:
-                    task.cancel()
-                if pending:
-                    loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
-                loop.run_until_complete(loop.shutdown_asyncgens())
-                if hasattr(loop, "shutdown_default_executor"):
-                    loop.run_until_complete(loop.shutdown_default_executor())
-            except Exception:
-                logger.exception("[AsyncOmniEngine] Failed during orchestrator loop cleanup")
-            finally:
-                asyncio.set_event_loop(None)
-                loop.close()
-
-    def _wait_for_orchestrator_init(self, startup_future: concurrent.futures.Future, startup_timeout: int) -> None:
-        """
-        Wait for orchestrator startup future to return ready. Raises exception on any failures to the init process.
-        """
-        deadline = time.monotonic() + startup_timeout
-        while True:
-            remaining = deadline - time.monotonic()
-            if remaining <= 0:
-                logger.warning(
-                    "[AsyncOmniEngine] Orchestrator startup timed out after %ss. "
-                    "Multi-stage deployments that initialize stages sequentially on one device "
-                    "or load checkpoints from slow storage may need larger --init-timeout and "
-                    "--stage-init-timeout values.",
-                    startup_timeout,
-                )
-                self._try_shutdown("[AsyncOmniEngine] Failed to cleanup after orchestrator startup timeout")
-                raise TimeoutError(f"Orchestrator did not become ready within {startup_timeout}s")
-            try:
-                startup_future.result(
-                    timeout=min(remaining, _STARTUP_POLL_INTERVAL_S),
-                )
-                break
-            except concurrent.futures.TimeoutError:
-                if not self.orchestrator_thread.is_alive():
-                    self._try_shutdown("[AsyncOmniEngine] Failed to cleanup after orchestrator startup failure")
-                    if startup_future.done():
-                        startup_future.result()  # re-raises the real exception
-                    raise RuntimeError("Orchestrator thread died during startup")
-            except Exception:
-                self._try_shutdown("[AsyncOmniEngine] Failed to cleanup after orchestrator startup failure")
-                raise
+    def _create_orchestrator(self, **orchestrator_kwargs: Any) -> OrchestratorBase:
+        return Orchestrator(**orchestrator_kwargs)
 
     # ---- request helpers ----
 
@@ -918,158 +465,6 @@ class AsyncOmniEngine:
             len(companions),
         )
 
-    def _detect_pd_config(self) -> dict[str, Any] | None:
-        """Detect PD (Prefill-Decode) disaggregation config from stage_configs.
-        Returns a dict with 'pd_pair' and 'bootstrap_addr', or None.
-        """
-        pd_pair = PDDisaggregationMixin.detect_pd_separation_from_stage_configs(self.stage_configs)
-        if pd_pair is None:
-            return None
-        prefill_idx, decode_idx = pd_pair
-
-        # Extract bootstrap address from prefill stage engine_args
-        bootstrap_addr: str | None = None
-        try:
-            prefill_cfg = self.stage_configs[prefill_idx]
-            ea = getattr(prefill_cfg, "engine_args", None)
-            kv_cfg = getattr(ea, "kv_transfer_config", None) if ea is not None else None
-            if kv_cfg is not None:
-                port = vllm_envs.VLLM_MOONCAKE_BOOTSTRAP_PORT
-                kv_ip = getattr(kv_cfg, "kv_ip", None) or "127.0.0.1"
-                bootstrap_addr = f"http://{kv_ip}:{port}"
-        except Exception as exc:
-            logger.warning("[AsyncOmniEngine] Could not extract PD bootstrap address: %s", exc)
-
-        logger.info(
-            "[AsyncOmniEngine] PD disaggregation detected: prefill=stage-%d, decode=stage-%d, bootstrap=%s",
-            prefill_idx,
-            decode_idx,
-            bootstrap_addr,
-        )
-        prefill_engine_id: str | None = None
-        try:
-            prefill_client = self.stage_clients[prefill_idx]
-            kv_cfg = getattr(getattr(prefill_client, "vllm_config", None), "kv_transfer_config", None)
-            prefill_engine_id = getattr(kv_cfg, "engine_id", None)
-        except Exception as exc:
-            logger.warning("[AsyncOmniEngine] Could not extract prefill engine_id: %s", exc)
-
-        return {
-            "pd_pair": (prefill_idx, decode_idx),
-            "bootstrap_addr": bootstrap_addr,
-            "prefill_engine_id": prefill_engine_id,
-        }
-
-    def _apply_strategy_lb_policy(self, derived: str | None, kwargs: dict[str, Any]) -> None:
-        """Apply a strategy-derived ``omni_lb_policy`` to the engine.
-
-        Precedence: an explicit ``--omni-lb-policy`` always wins. ``"random"`` is
-        the engine default and is treated as "unset" (indistinguishable from no
-        flag), so a strategy value overrides it. If the user explicitly passed a
-        non-default policy that conflicts with the strategy-derived one, raise so
-        the mismatch is not silently ignored.
-        """
-        if not derived:
-            return
-        explicit = kwargs.get("omni_lb_policy")
-        user_set = explicit is not None and str(explicit) != "random"
-        if user_set:
-            if str(explicit) != str(derived):
-                raise ValueError(
-                    f"Conflicting load-balancer policy: --omni-lb-policy={explicit!r} was given "
-                    f"but the composable-parallel strategy derived omni_lb_policy={derived!r}. "
-                    "Drop --omni-lb-policy to use the strategy value, or make them match."
-                )
-            return
-        if self._omni_lb_policy != str(derived):
-            logger.info(
-                "[composable_parallel] applying strategy-derived omni_lb_policy=%r (was %r).",
-                derived,
-                self._omni_lb_policy,
-            )
-            self._omni_lb_policy = str(derived)
-
-    @staticmethod
-    def _create_default_diffusion_stage_cfg(kwargs: dict[str, Any]) -> list[dict[str, Any]]:
-        """Compatibility seam for the factory-owned diffusion fallback."""
-        return StageConfigFactory.create_default_diffusion(kwargs)
-
-    def _set_pipeline_runtime_config(
-        self,
-        pipeline_config: PipelineConfig | None,
-        config_path: str | None,
-    ) -> None:
-        """Initialize engine-wide settings resolved from pipeline metadata."""
-        self.endpoint_restrictions = pipeline_config.endpoint_restrictions if pipeline_config is not None else ()
-        self._duplex_runtime_extension_path = (
-            pipeline_config.duplex_runtime_extension if pipeline_config is not None else None
-        )
-        self.duplex_serving_adapter_path = (
-            pipeline_config.duplex_serving_adapter if pipeline_config is not None else None
-        )
-        self._duplex_control_enabled = bool(pipeline_config and pipeline_config.duplex_control_enabled)
-        self.duplex_session_config = DuplexSessionRuntimeConfig()
-        if config_path is not None:
-            self.duplex_session_config = load_deploy_config(config_path).duplex_session
-
-    def _resolve_stage_configs(
-        self,
-        model: str,
-        kwargs: dict[str, Any],
-        *,
-        trust_remote_code: bool | None,
-    ) -> 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
-
-        resolution = cast(
-            _ConfigResolutionResult,
-            load_and_resolve_stage_configs(
-                model,
-                kwargs,
-                trust_remote_code=trust_remote_code,
-                deploy_config_path=deploy_config_path,
-                stage_overrides=stage_overrides,
-                strategy_config_path=strategy_config_path,
-            ),
-        )
-        if isinstance(resolution, OmniConfigResolution):
-            self._config_resolution = resolution
-            config_path = resolution.config_path
-            stage_configs = list(resolution.stage_configs)
-            strategy_lb_policy = resolution.omni_lb_policy
-        else:
-            # Compatibility for overrides of the historical tuple-returning
-            # seam. Production always receives OmniConfigResolution above.
-            config_path, stage_configs, strategy_lb_policy = resolution
-
-        # A strategy.yaml may derive a pipeline-wide load-balancer policy. It is
-        # an orchestrator-level knob (read once at construction), so apply it here
-        # rather than as a per-stage config field.
-        self._apply_strategy_lb_policy(strategy_lb_policy, kwargs)
-
-        return cast(str, config_path), stage_configs
-
-    # ==================== Public API ====================
-
     def add_request(
         self,
         request_id: str,
@@ -1241,390 +636,6 @@ class AsyncOmniEngine:
             resumable=resumable,
         )
 
-    def open_duplex_session(
-        self,
-        session_id: str,
-        *,
-        session_mode: str = "duplex",
-        capabilities: dict[str, object] | None = None,
-        session_config: dict[str, object] | None = None,
-        runtime_config: dict[str, object] | None = None,
-        fence: DuplexFence,
-        timeout: float | None = 10.0,
-    ) -> dict[str, object]:
-        """Open an engine-level duplex session."""
-        return self._get_duplex_control_client().open(
-            session_id,
-            session_mode=session_mode,
-            capabilities=capabilities,
-            session_config=session_config,
-            runtime_config=runtime_config,
-            fence=fence,
-            timeout=timeout,
-        )
-
-    async def open_duplex_session_async(
-        self,
-        session_id: str,
-        *,
-        session_mode: str = "duplex",
-        capabilities: dict[str, object] | None = None,
-        session_config: dict[str, object] | None = None,
-        runtime_config: dict[str, object] | None = None,
-        fence: DuplexFence,
-        timeout: float | None = 10.0,
-    ) -> dict[str, object]:
-        """Async wrapper for opening an engine-level duplex session."""
-        loop = asyncio.get_running_loop()
-        return await loop.run_in_executor(
-            None,
-            lambda: self.open_duplex_session(
-                session_id,
-                session_mode=session_mode,
-                capabilities=capabilities,
-                session_config=session_config,
-                runtime_config=runtime_config,
-                fence=fence,
-                timeout=timeout,
-            ),
-        )
-
-    def append_duplex_input(
-        self,
-        session_id: str,
-        *,
-        mode: str,
-        payload: object,
-        operation_id: str | None = None,
-        final: bool = False,
-        expected_epoch: int | None = None,
-        fence: DuplexFence,
-        timeout: float | None = 10.0,
-    ) -> dict[str, object]:
-        """Append input to an engine-level duplex session."""
-        return self._get_duplex_control_client().append(
-            session_id,
-            mode=mode,
-            payload=payload,
-            operation_id=operation_id,
-            final=final,
-            expected_epoch=expected_epoch,
-            fence=fence,
-            timeout=timeout,
-        )
-
-    async def append_duplex_input_async(
-        self,
-        session_id: str,
-        *,
-        mode: str,
-        payload: object,
-        operation_id: str | None = None,
-        final: bool = False,
-        expected_epoch: int | None = None,
-        fence: DuplexFence,
-        timeout: float | None = 10.0,
-    ) -> dict[str, object]:
-        """Async wrapper for appending duplex input."""
-        loop = asyncio.get_running_loop()
-        return await loop.run_in_executor(
-            None,
-            lambda: self.append_duplex_input(
-                session_id,
-                mode=mode,
-                payload=payload,
-                operation_id=operation_id,
-                final=final,
-                expected_epoch=expected_epoch,
-                fence=fence,
-                timeout=timeout,
-            ),
-        )
-
-    def signal_duplex_turn(
-        self,
-        session_id: str,
-        *,
-        event: str,
-        fence: DuplexFence,
-        next_fence: DuplexFence | None = None,
-        session_config: dict[str, object] | None = None,
-        runtime_config: dict[str, object] | None = None,
-        timeout: float | None = 10.0,
-    ) -> dict[str, object]:
-        """Signal an engine-level duplex turn."""
-        return self._get_duplex_control_client().signal(
-            session_id,
-            event=event,
-            fence=fence,
-            next_fence=next_fence,
-            session_config=session_config,
-            runtime_config=runtime_config,
-            timeout=timeout,
-        )
-
-    async def signal_duplex_turn_async(
-        self,
-        session_id: str,
-        *,
-        event: str,
-        fence: DuplexFence,
-        next_fence: DuplexFence | None = None,
-        session_config: dict[str, object] | None = None,
-        runtime_config: dict[str, object] | None = None,
-        timeout: float | None = 10.0,
-    ) -> dict[str, object]:
-        """Async wrapper for signaling a duplex turn."""
-        loop = asyncio.get_running_loop()
-        return await loop.run_in_executor(
-            None,
-            lambda: self.signal_duplex_turn(
-                session_id,
-                event=event,
-                fence=fence,
-                next_fence=next_fence,
-                session_config=session_config,
-                runtime_config=runtime_config,
-                timeout=timeout,
-            ),
-        )
-
-    def close_duplex_session(
-        self,
-        session_id: str,
-        *,
-        reason: str = "client_close",
-        fence: DuplexFence,
-        timeout: float | None = 10.0,
-    ) -> dict[str, object]:
-        """Close an engine-level duplex session."""
-        return self._get_duplex_control_client().close(
-            session_id,
-            reason=reason,
-            fence=fence,
-            timeout=timeout,
-        )
-
-    def touch_duplex_session(
-        self,
-        session_id: str,
-        *,
-        fence: DuplexFence,
-        activity: DuplexLeaseActivity,
-        timeout: float | None = 10.0,
-    ) -> dict[str, object]:
-        return self._get_duplex_control_client().touch(
-            session_id,
-            fence=fence,
-            activity=activity,
-            timeout=timeout,
-        )
-
-    async def touch_duplex_session_async(
-        self,
-        session_id: str,
-        *,
-        fence: DuplexFence,
-        activity: DuplexLeaseActivity,
-        timeout: float | None = 10.0,
-    ) -> dict[str, object]:
-        loop = asyncio.get_running_loop()
-        return await loop.run_in_executor(
-            None,
-            lambda: self.touch_duplex_session(
-                session_id,
-                fence=fence,
-                activity=activity,
-                timeout=timeout,
-            ),
-        )
-
-    def resume_duplex_session(
-        self,
-        session_id: str,
-        *,
-        fence: DuplexFence,
-        expected_lease_generation: int,
-        timeout: float | None = 10.0,
-    ) -> dict[str, object]:
-        return self._get_duplex_control_client().resume(
-            session_id,
-            fence=fence,
-            expected_lease_generation=expected_lease_generation,
-            timeout=timeout,
-        )
-
-    async def resume_duplex_session_async(
-        self,
-        session_id: str,
-        *,
-        fence: DuplexFence,
-        expected_lease_generation: int,
-        timeout: float | None = 10.0,
-    ) -> dict[str, object]:
-        loop = asyncio.get_running_loop()
-        return await loop.run_in_executor(
-            None,
-            lambda: self.resume_duplex_session(
-                session_id,
-                fence=fence,
-                expected_lease_generation=expected_lease_generation,
-                timeout=timeout,
-            ),
-        )
-
-    def _get_duplex_control_client(self) -> DuplexControlClient:
-        client = getattr(self, "_duplex_control_client", None)
-        if client is None:
-            transport = getattr(self, "_correlated_rpc_client", None)
-            if transport is None:
-                raise RuntimeError("correlated RPC client is not initialized")
-            client = DuplexControlClient(
-                transport,
-                control_id_factory=lambda: uuid.uuid4().hex,
-            )
-            self._duplex_control_client = client
-        return client
-
-    async def close_duplex_session_async(
-        self,
-        session_id: str,
-        *,
-        reason: str = "client_close",
-        fence: DuplexFence,
-        timeout: float | None = 10.0,
-    ) -> dict[str, object]:
-        """Async wrapper for closing an engine-level duplex session."""
-        loop = asyncio.get_running_loop()
-        return await loop.run_in_executor(
-            None,
-            lambda: self.close_duplex_session(session_id, reason=reason, fence=fence, timeout=timeout),
-        )
-
-    def try_get_output(self, timeout: float = 0.001) -> EngineQueueMessage | None:
-        """Read one output message from the Orchestrator output queue."""
-        try:
-            return self.output_queue.sync_q.get(timeout=timeout)
-        except queue.Empty:
-            if not self.is_alive():
-                raise RuntimeError("Orchestrator died unexpectedly. See logs above.")
-            return None
-
-    async def try_get_output_async(self) -> EngineQueueMessage | None:
-        """Async read from the Orchestrator output queue."""
-        try:
-            return self.output_queue.sync_q.get_nowait()
-        except queue.Empty:
-            if not self.is_alive():
-                raise RuntimeError("Orchestrator died unexpectedly. See logs above.")
-            return None
-
-    async def get_output_blocking_async(self, timeout: float = 1.0) -> EngineQueueMessage | None:
-        """Blocking-wait read from the Orchestrator output queue.
-
-        Waits up to ``timeout`` seconds in a dedicated drain thread for the
-        next message (condition-variable wakeup instead of a poll cadence);
-        returns ``None`` on timeout so the caller keeps its liveness check,
-        mirroring ``try_get_output_async``'s contract. Used by the serving
-        final-output drain when ``VLLM_OMNI_EVENT_DRIVEN_ORCH`` is on.
-        """
-        executor = self._output_drain_executor
-        if executor is None:
-            executor = concurrent.futures.ThreadPoolExecutor(
-                max_workers=1,
-                thread_name_prefix="omni-output-drain",
-            )
-            self._output_drain_executor = executor
-
-        sync_q = self.output_queue.sync_q
-
-        def _drain_get() -> EngineQueueMessage | None:
-            # Exceptions are swallowed to a None sentinel: the queue may be
-            # closed mid-shutdown, and an exception left on an executor future
-            # after task cancellation would warn as never-retrieved.
-            try:
-                return sync_q.get(timeout=timeout)
-            except queue.Empty:
-                return None
-            except Exception:
-                return None
-
-        loop = asyncio.get_running_loop()
-        msg = await loop.run_in_executor(executor, _drain_get)
-        if msg is None and not self.is_alive():
-            raise RuntimeError("Orchestrator died unexpectedly. See logs above.")
-        return msg
-
-    def get_stage_metadata(self, stage_id: int) -> StageRuntimeInfo:
-        """Get cached metadata for a stage."""
-        return self.stage_metadata[stage_id]
-
-    def abort(self, request_ids: list[str]) -> None:
-        """Fire-and-forget abort: enqueue and return without waiting.
-
-        Prefer :meth:`abort_async` when the caller needs acknowledgment that
-        stage aborts, binding release, and orchestrator request cleanup finished.
-        """
-        if not request_ids or getattr(self, "_shutdown_called", False):
-            return
-        if self.request_queue is None:
-            raise RuntimeError("request_queue is not initialized")
-        try:
-            self.request_queue.sync_q.put(AbortRequestMessage(request_ids=request_ids))
-        except Exception as exc:
-            if getattr(self, "_shutdown_called", False) and is_janus_sync_queue_shutdown(exc):
-                return
-            raise
-
-    async def abort_async(
-        self,
-        request_ids: list[str],
-        timeout: float | None = None,
-    ) -> list[OutputMessage]:
-        """Abort requests and wait for orchestrator acknowledgment.
-
-        Unlike :meth:`abort`, this generates an ``rpc_id``, correlates the
-        :class:`AbortResultMessage` via :class:`CorrelatedRpcClient`, and
-        raises if the orchestrator reports failure or times out.
-
-        Returns:
-            Final-stage AR abort ``OutputMessage`` list carrying partial
-            tokens generated before abort (empty for diffusion / no OP state).
-        """
-        if not request_ids or getattr(self, "_shutdown_called", False):
-            return []
-        if self.request_queue is None:
-            raise RuntimeError("request_queue is not initialized")
-        transport = self._correlated_rpc_client
-        if transport is None:
-            raise RuntimeError("correlated RPC client is not initialized")
-
-        rpc_id = uuid.uuid4().hex
-        msg = AbortRequestMessage(request_ids=request_ids, rpc_id=rpc_id)
-
-        def _wait() -> AbortResultMessage:
-            result_msg = transport.execute(
-                ("abort", rpc_id),
-                msg,
-                timeout=timeout,
-                timeout_message=f"abort timed out after {timeout} seconds",
-                block_on_submit=True,
-            )
-            if not isinstance(result_msg, AbortResultMessage):
-                raise RuntimeError(f"unexpected abort result type: {type(result_msg).__name__}")
-            return result_msg
-
-        loop = asyncio.get_running_loop()
-        try:
-            result_msg = await loop.run_in_executor(None, _wait)
-        except Exception as exc:
-            if getattr(self, "_shutdown_called", False) and is_abort_transport_shutdown(exc):
-                return []
-            raise
-        if not result_msg.success:
-            raise RuntimeError(result_msg.error or "abort failed")
-        return list(result_msg.abort_outputs or [])
-
     def submit_interaction(
         self,
         request_id: str,
@@ -1649,166 +660,6 @@ class AsyncOmniEngine:
         """Async interaction API."""
         self.submit_interaction(request_id, interaction)
 
-    def collective_rpc(
-        self,
-        method: str,
-        timeout: float | None = None,
-        args: tuple[Any, ...] = (),
-        kwargs: dict[str, Any] | None = None,
-        stage_ids: list[int] | None = None,
-    ) -> list[Any]:
-        """Send a control RPC to the Orchestrator and wait for aggregated results.
 
-        This uses a dedicated RPC output queue so control-plane messages do not
-        race with the normal request output polling loop.
-        """
-        rpc_id = uuid.uuid4().hex
-        msg = CollectiveRPCRequestMessage(
-            rpc_id=rpc_id,
-            method=method,
-            timeout=timeout,
-            args=tuple(args),
-            kwargs=kwargs or {},
-            stage_ids=stage_ids,
-        )
-
-        transport = self._correlated_rpc_client
-        if transport is None:
-            raise RuntimeError("correlated RPC client is not initialized")
-        result_msg = transport.execute(
-            ("collective", rpc_id),
-            msg,
-            timeout=timeout,
-            timeout_message=f"collective_rpc timed out after {timeout} seconds",
-            block_on_submit=True,
-        )
-        if not isinstance(result_msg, CollectiveRPCResultMessage):
-            raise RuntimeError(f"unexpected collective RPC result type: {type(result_msg).__name__}")
-        return list(result_msg.results)
-
-    async def collective_rpc_async(
-        self,
-        method: str,
-        timeout: float | None = None,
-        args: tuple[Any, ...] = (),
-        kwargs: dict[str, Any] | None = None,
-        stage_ids: list[int] | None = None,
-    ) -> list[Any]:
-        """Async wrapper around collective_rpc()."""
-        loop = asyncio.get_running_loop()
-        return await loop.run_in_executor(
-            None,
-            lambda: self.collective_rpc(
-                method=method,
-                timeout=timeout,
-                args=args,
-                kwargs=kwargs,
-                stage_ids=stage_ids,
-            ),
-        )
-
-    def is_alive(self) -> bool:
-        """Whether the orchestrator thread is alive."""
-        return bool(self.orchestrator_thread.is_alive())
-
-    def shutdown(self) -> None:
-        """Send shutdown message and wait for the Orchestrator thread to exit."""
-        if getattr(self, "_shutdown_called", False):
-            return
-        self._shutdown_called = True
-        finalizer = getattr(self, "_weak_finalizer", None)
-        if finalizer is not None and finalizer.alive:
-            finalizer.detach()
-
-        logger.info("[AsyncOmniEngine] Shutting down Orchestrator")
-        request_queue_closed = False
-        shutdown_enqueued = enqueue_orchestrator_shutdown(
-            self.request_queue,
-            timeout=SHUTDOWN_ENQUEUE_TIMEOUT_S,
-        )
-        if self.request_queue is not None and not shutdown_enqueued:
-            logger.error(
-                "[AsyncOmniEngine] Failed to enqueue orchestrator shutdown; "
-                "closing the request queue to wake the request handler"
-            )
-            try:
-                self.request_queue.close()
-                request_queue_closed = True
-            except Exception:
-                logger.exception("[AsyncOmniEngine] Failed to close the request queue")
-
-        if self._correlated_rpc_client is not None:
-            try:
-                self._correlated_rpc_client.close()
-            except Exception:
-                logger.exception("[AsyncOmniEngine] Failed to close correlated RPC client")
-
-        orchestrator_stopped = False
-        try:
-            if self.is_alive():
-                self.orchestrator_thread.join(timeout=SHUTDOWN_JOIN_TIMEOUT_S)
-            orchestrator_stopped = not self.is_alive()
-            if not orchestrator_stopped:
-                logger.error(
-                    "[AsyncOmniEngine] Orchestrator did not stop within %.1f seconds; continuing cleanup",
-                    SHUTDOWN_JOIN_TIMEOUT_S,
-                )
-        except Exception:
-            logger.exception("[AsyncOmniEngine] Failed to join Orchestrator thread")
-
-        for q in (self.request_queue, self.output_queue, self.rpc_output_queue):
-            try:
-                if not (q is self.request_queue and request_queue_closed):
-                    q.close()
-            except Exception:
-                pass
-
-        if self._output_drain_executor is not None:
-            # Any in-flight blocking get bails out within its ≤1 s timeout
-            # (or immediately via the queue close above), so don't wait.
-            self._output_drain_executor.shutdown(wait=False)
-            self._output_drain_executor = None
-
-        if hasattr(self, "_runtime") and self._runtime is not None and orchestrator_stopped:
-            try:
-                self._runtime.shutdown()
-            except Exception:
-                logger.exception("[AsyncOmniEngine] Failed to shutdown StageRuntime")
-        elif hasattr(self, "_runtime") and self._runtime is not None:
-            logger.warning("[AsyncOmniEngine] Deferring StageRuntime shutdown until the Orchestrator exits")
-            threading.Thread(
-                target=shutdown_runtime_after_orchestrator,
-                args=(self.orchestrator_thread, self._runtime),
-                daemon=True,
-                name="omni-stage-runtime-shutdown",
-            ).start()
-
-        # ── Release CuMem allocator memory pool ──────────────────────────────
-        # When enable_sleep_mode is in use, the CuMem (CUDA Virtual Memory
-        # Management) allocator holds model weights in a singleton memory pool
-        # that lives in the parent process.  Killing the engine-core subprocess
-        # does NOT release this pool — the weights stay resident on the GPU
-        # and can cause CUDA OOM for subsequent engine instances (especially
-        # large models like BAGEL-7B-MoT whose weights alone consume ~134 GiB).
-        #
-        # CuMemAllocator.sleep() is NOT idempotent — calling it on already-
-        # slept entries causes CUDA_ERROR_INVALID_VALUE at cumem_allocator
-        # cuMemRelease (double-free of the memory handle).  Use release_pools()
-        # instead, which is the designed cleanup path: it drops MemPool refs
-        # and lets the destructor/free path handle asleep entries correctly
-        # (returns a null handle so the C extension skips unmap/release).
-        try:
-            from vllm.device_allocator.cumem import CuMemAllocator, cumem_available
-
-            if cumem_available:
-                allocator = CuMemAllocator.get_instance()
-                allocator.release_pools()
-                logger.debug("[AsyncOmniEngine] Released CuMem memory pool during shutdown")
-        except Exception:
-            pass
-
-    def _try_shutdown(self, *args, **kwargs) -> None:
-        try:
-            self.shutdown()
-        except Exception:
-            logger.exception(*args, **kwargs)
+# ``StageRuntimeInfo`` moved to ``omni_engine_base``; keep the historical import path.
+__all__ = ["AsyncOmniEngine", "StageRuntimeInfo"]
diff --git a/vllm_omni/engine/duplex/__init__.py b/vllm_omni/engine/duplex/__init__.py
index bd5ae0b3f..533e31e23 100644
--- a/vllm_omni/engine/duplex/__init__.py
+++ b/vllm_omni/engine/duplex/__init__.py
@@ -1,4 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
-"""Engine-side helpers for the full-duplex runtime."""
+"""Engine-resident full-duplex sessions: typed commands/events, the merged session
+state, the per-session runner, the session manager and the model plugin contract."""
diff --git a/vllm_omni/engine/duplex/audio.py b/vllm_omni/engine/duplex/audio.py
new file mode 100644
index 000000000..2d46e8edb
--- /dev/null
+++ b/vllm_omni/engine/duplex/audio.py
@@ -0,0 +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
+
+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,
+)
+
+__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
new file mode 100644
index 000000000..19674948c
--- /dev/null
+++ b/vllm_omni/engine/duplex/commands.py
@@ -0,0 +1,306 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""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`.
+
+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, 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.protocol.duplex import RealtimeInputDefaults
+
+
+class DuplexCommandError(RealtimeProtocolError):
+    """A client payload could not be turned into a duplex command.
+
+    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(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] = ""
+
+    def payload(self) -> dict[str, object]:
+        """Render the session-internal mailbox dictionary."""
+        data: dict[str, object] = {"type": self.type}
+        for f in fields(self):
+            if f.name == "event_id":
+                if self.event_id is not None:
+                    data["realtime_event_id"] = self.event_id
+                continue
+            value = getattr(self, f.name)
+            if value is None:
+                continue
+            if isinstance(value, tuple):
+                value = list(value)
+            elif isinstance(value, Mapping):
+                value = dict(value)
+            data[f.name] = value
+        return data
+
+
+# ---- GA commands ----
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+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"
+
+    def payload(self) -> dict[str, object]:
+        data = DuplexCommand.payload(self)
+        hints = data.pop("hints", None)
+        if isinstance(hints, Mapping):
+            # Hints are raw wire values; the typed fields went through
+            # ``build_append_audio``'s normalization, so they have to win. An
+            # unset typed field is simply absent here (``payload`` skips None),
+            # which is what lets a hint still carry it. Merging the other way
+            # round let a client's ``"is_speech": 0`` override the computed
+            # ``bool | None`` and silently miss the runner's silent-commit path.
+            merged: dict[str, object] = dict(hints)
+            merged.update(data)
+            data = merged
+        data["audio"] = base64.b64encode(self.audio).decode("ascii")
+        if not data.get("video_frames"):
+            data.pop("video_frames", None)
+        return data
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class Commit(DuplexCommand, _duplex_wire.Commit):
+    type: ClassVar[str] = "input_audio_buffer.commit"
+
+    def payload(self) -> dict[str, object]:
+        data = DuplexCommand.payload(self)
+        if self.create_response is not None:
+            data["response_create"] = data.pop("create_response")
+        return data
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+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"
+
+    def payload(self) -> dict[str, object]:
+        data = DuplexCommand.payload(self)
+        options = data.pop("options", None)
+        if isinstance(options, Mapping):
+            data["response"] = dict(options)
+        return data
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CancelResponse(DuplexCommand, _duplex_wire.CancelResponse):
+    type: ClassVar[str] = "response.cancel"
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CreateItem(DuplexCommand, _duplex_wire.CreateItem):
+    type: ClassVar[str] = "turn.signal"
+
+    def payload(self) -> dict[str, object]:
+        data = DuplexCommand.payload(self)
+        data["event"] = "conversation.item.create"
+        payload: dict[str, object] = {"item": dict(data.pop("item"))}
+        previous = data.pop("previous_item_id", None)
+        if previous is not None:
+            payload["previous_item_id"] = previous
+        data["payload"] = payload
+        return data
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class DeleteItem(DuplexCommand, _duplex_wire.DeleteItem):
+    type: ClassVar[str] = "turn.signal"
+
+    def payload(self) -> dict[str, object]:
+        data = DuplexCommand.payload(self)
+        data["event"] = "conversation.item.delete"
+        data["payload"] = {"item_id": data.pop("item_id")}
+        return data
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class TruncateItem(DuplexCommand, _duplex_wire.TruncateItem):
+    type: ClassVar[str] = "turn.signal"
+
+    def payload(self) -> dict[str, object]:
+        data = DuplexCommand.payload(self)
+        data["event"] = "conversation.item.truncate"
+        data["payload"] = {
+            "item_id": data.pop("item_id"),
+            "audio_end_ms": data.pop("audio_end_ms"),
+            "content_index": data.pop("content_index", 0),
+        }
+        return data
+
+
+# ---- duplex extension commands ----
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+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"
+
+
+REALTIME_COMMAND_TYPES: frozenset[str] = frozenset(
+    {
+        "input_audio_buffer.append",
+        "input_audio_buffer.commit",
+        "input_audio_buffer.clear",
+        "output_audio_buffer.clear",
+        "response.create",
+        "response.cancel",
+        "conversation.item.create",
+        "conversation.item.delete",
+        "conversation.item.truncate",
+        "session.update",
+        "playback.ack",
+        "session.heartbeat",
+        "session.close",
+        "turn.signal",
+        "input.text.append",
+        "input.cancel",
+        "barge_in",
+    }
+)
+
+
+def command_from_realtime(
+    payload: Mapping[str, object],
+    *,
+    defaults: RealtimeInputDefaults | None = None,
+) -> DuplexCommand:
+    """Translate one OpenAI Realtime client event into a command.
+
+    Envelope concerns (``event_id`` acknowledgements, resume bookkeeping) are
+    handled by the transport; this function only validates and maps the
+    payload shape. ``defaults`` carries the audio format / sample rate / VAD
+    defaults the session declared, so every transport decodes an append the
+    same way. Raises :class:`DuplexCommandError` for malformed or unsupported
+    payloads.
+    """
+    from vllm_omni.engine.duplex.realtime_commands import translate_realtime_command
+
+    return translate_realtime_command(payload, defaults=defaults)
+
+
+__all__ = [
+    "AckPlayback",
+    "AppendAudio",
+    "AppendText",
+    "BargeIn",
+    "CancelInput",
+    "CancelResponse",
+    "ClearInput",
+    "ClearOutputAudio",
+    "CloseSession",
+    "Commit",
+    "CreateItem",
+    "CreateResponse",
+    "DeleteItem",
+    "DuplexCommand",
+    "DuplexCommandError",
+    "Heartbeat",
+    "REALTIME_COMMAND_TYPES",
+    "RealtimeCommand",
+    "SignalTurn",
+    "TruncateItem",
+    "UpdateSession",
+    "command_from_realtime",
+]
diff --git a/vllm_omni/engine/duplex/config.py b/vllm_omni/engine/duplex/config.py
new file mode 100644
index 000000000..f343a5233
--- /dev/null
+++ b/vllm_omni/engine/duplex/config.py
@@ -0,0 +1,834 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Session configuration, capabilities and value types of the duplex session model.
+
+These classes are the typed half of the public contract: ``DuplexOmni``
+accepts a ``DuplexSessionConfig`` (or the equivalent OpenAI Realtime
+``session`` object via :meth:`DuplexSessionConfig.from_realtime`) and reports
+``DuplexCapabilities``. They used to live in ``entrypoints/duplex/protocol.py``.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, cast
+
+
+class DuplexConfigError(ValueError):
+    """A Realtime session/response object was rejected while mapping it onto the duplex config."""
+
+    def __init__(self, message: str, *, code: str = "bad_event", param: str | None = None) -> None:
+        super().__init__(message)
+        self.code = code
+        self.param = param
+
+
+class DuplexOverlapPolicy(str, Enum):
+    LISTEN_ONLY = "listen_only"
+    BARGE_IN_ON_SPEECH = "barge_in_on_speech"
+
+
+class DuplexPlaybackCommitPolicy(str, Enum):
+    COMMIT_ALL_ON_DONE = "commit_all_on_done"
+    ACK_ONLY = "ack_only"
+
+
+class DuplexSessionState(str, Enum):
+    OPEN = "open"
+    CLOSING = "closing"
+    CLOSED = "closed"
+
+
+class DuplexTurnState(str, Enum):
+    IDLE = "idle"
+    USER_SPEAKING = "user_speaking"
+    USER_COMMITTED = "user_committed"
+    ASSISTANT_GENERATING = "assistant_generating"
+    ASSISTANT_PLAYING = "assistant_playing"
+    BARGE_IN = "barge_in"
+
+
+class DuplexTurnEventType(str, Enum):
+    USER_STARTED = "user_started"
+    USER_COMMITTED = "user_committed"
+    ASSISTANT_STARTED = "assistant_started"
+    ASSISTANT_DONE = "assistant_done"
+    BARGE_IN = "barge_in"
+    PLAYBACK_ACK = "playback_ack"
+    TIMEOUT = "timeout"
+    CLOSE = "close"
+
+
+@dataclass
+class DuplexCapabilities:
+    """Runtime/model capabilities exposed by the duplex serving protocol.
+
+    These are intentionally explicit so the serving layer does not assume all
+    duplex models support the same input append, rollback, or turn policy.
+    ``supports_core_kv_lease`` is reserved for scheduler-owned KV lifecycle;
+    model-owned decoder/TTS state must use ``supports_model_internal_state``.
+    ``supports_core_resumable_request`` means the scheduler can resume the
+    same request id across streaming updates, but it is not a KV lease by
+    itself. Realtime support means this endpoint can speak the native Realtime
+    event schema for the supported audio duplex paths while keeping model- or
+    scheduler-specific limits explicit in the capability payload.
+    """
+
+    supports_session_adapter: bool = True
+    supports_model_native_turn_policy: bool = False
+    supports_external_turn_signal: bool = True
+    supports_client_commit: bool = True
+    supports_barge_in: bool = True
+    supports_playback_ack: bool = True
+    supports_input_append: bool = False
+    supports_replace_latest_chunk: bool = True
+    supports_reencode_context: bool = True
+    supports_rollback_to_checkpoint: bool = False
+    supports_turn_commit_only: bool = True
+    supports_kv_lease: bool = False
+    supports_core_kv_lease: bool = False
+    supports_model_internal_state: bool = False
+    supports_stage_resumption: bool = False
+    supports_scheduler_native_append: bool = False
+    supports_core_resumable_request: bool = False
+    supports_stage_connector_handoff: bool = False
+    supports_independent_io_streams: bool = False
+    supports_realtime_endpoint: bool = False
+    supports_multi_session: bool = False
+    supports_multi_session_same_replica: bool = False
+    supports_session_lease: bool = False
+    supports_session_resume: bool = False
+    session_admission_mode: str = "serving_managed"
+    supports_audio_truncate: bool = False
+    #: Whether this model can serve ``/v1/chat/completions`` on a duplex
+    #: session. That needs one thing the protocol cannot assume: the model
+    #: honours ``DuplexSessionConfig.initial_user_text``, so a turn can be
+    #: seeded from text. A model-native model decides to speak from the audio
+    #: it hears, and silence is its signal *not* to take a turn, so without
+    #: 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
+    requires_native_stage_role: bool = False
+    adapter_patterns: list[str] = field(default_factory=lambda: ["chunk_group_append"])
+    signal_sources: list[str] = field(default_factory=lambda: ["client_event", "server_policy", "model_native"])
+    stage_handoff_transport: str | None = None
+    chunk_period_ms: int | None = 1000
+    target_barge_in_latency_ms: int | None = 1000
+
+    def as_dict(self) -> dict[str, object]:
+        return {
+            "supports_session_adapter": self.supports_session_adapter,
+            "supports_model_native_turn_policy": self.supports_model_native_turn_policy,
+            "supports_external_turn_signal": self.supports_external_turn_signal,
+            "supports_client_commit": self.supports_client_commit,
+            "supports_barge_in": self.supports_barge_in,
+            "supports_playback_ack": self.supports_playback_ack,
+            "supports_input_append": self.supports_input_append,
+            "supports_replace_latest_chunk": self.supports_replace_latest_chunk,
+            "supports_reencode_context": self.supports_reencode_context,
+            "supports_rollback_to_checkpoint": self.supports_rollback_to_checkpoint,
+            "supports_turn_commit_only": self.supports_turn_commit_only,
+            "supports_kv_lease": self.supports_kv_lease,
+            "supports_core_kv_lease": self.supports_core_kv_lease,
+            "supports_model_internal_state": self.supports_model_internal_state,
+            "supports_stage_resumption": self.supports_stage_resumption,
+            "supports_scheduler_native_append": self.supports_scheduler_native_append,
+            "supports_core_resumable_request": self.supports_core_resumable_request,
+            "supports_stage_connector_handoff": self.supports_stage_connector_handoff,
+            "supports_independent_io_streams": self.supports_independent_io_streams,
+            "supports_realtime_endpoint": self.supports_realtime_endpoint,
+            "supports_multi_session": self.supports_multi_session,
+            "supports_multi_session_same_replica": self.supports_multi_session_same_replica,
+            "supports_session_lease": self.supports_session_lease,
+            "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,
+            "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,
+            "stage_handoff_transport": self.stage_handoff_transport,
+            "chunk_period_ms": self.chunk_period_ms,
+            "target_barge_in_latency_ms": self.target_barge_in_latency_ms,
+        }
+
+
+@dataclass
+class DuplexPlaybackCursor:
+    generated_ms: int = 0
+    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)))
+        if committed_ms is None:
+            committed_ms = self.played_ms
+        self.committed_ms = max(self.committed_ms, max(0, int(committed_ms)))
+
+    def truncate_committed(self, committed_ms: int) -> None:
+        self.committed_ms = max(0, min(max(self.sent_ms, self.generated_ms), int(committed_ms)))
+
+    def as_dict(self) -> dict[str, int]:
+        return {
+            "generated_ms": self.generated_ms,
+            "sent_ms": self.sent_ms,
+            "played_ms": self.played_ms,
+            "committed_ms": self.committed_ms,
+        }
+
+    def snapshot(self) -> DuplexPlaybackView:
+        return DuplexPlaybackView(
+            **self.as_dict(),
+            text_requires_complete_audio=self.text_requires_complete_audio,
+            audio_complete=self.audio_complete,
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class DuplexPlaybackView:
+    generated_ms: int = 0
+    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 {
+            "generated_ms": self.generated_ms,
+            "sent_ms": self.sent_ms,
+            "played_ms": self.played_ms,
+            "committed_ms": self.committed_ms,
+        }
+
+
+@dataclass
+class DuplexAudioChunk:
+    data: str
+    format: str = "wav"
+    sample_rate_hz: int | None = None
+
+
+@dataclass
+class DuplexSessionConfig:
+    model: str | None = None
+    modalities: list[str] = field(default_factory=lambda: ["text", "audio"])
+    instructions: str | None = None
+    #: Text the session treats as the user's opening turn. A caller that cannot
+    #: reach the model by speech (an HTTP request, a batch job) puts its prompt
+    #: here; ``supports_text_only_turn`` says whether the model can answer it.
+    initial_user_text: str | None = None
+    voice: str | None = None
+    ref_audio: str | None = None
+    response_format: str = "wav"
+    temperature: float | None = None
+    max_tokens: int | None = None
+    speed: float | None = None
+    use_tts_template: bool = True
+    idle_timeout_s: float = 300.0
+    overlap_policy: str = DuplexOverlapPolicy.LISTEN_ONLY.value
+    overlap_short_ack_ms: int = 700
+    overlap_barge_in_ms: int = 1200
+    overlap_silence_rms: float = 0.003
+    playback_commit_policy: str = DuplexPlaybackCommitPolicy.COMMIT_ALL_ON_DONE.value
+    extra_body: dict[str, object] = field(default_factory=dict)
+
+    def as_dict(self) -> dict[str, object]:
+        return {
+            "model": self.model,
+            "modalities": list(self.modalities),
+            "instructions": self.instructions,
+            "initial_user_text": self.initial_user_text,
+            "voice": self.voice,
+            "ref_audio": self.ref_audio,
+            "response_format": self.response_format,
+            "temperature": self.temperature,
+            "max_tokens": self.max_tokens,
+            "speed": self.speed,
+            "use_tts_template": self.use_tts_template,
+            "idle_timeout_s": self.idle_timeout_s,
+            "overlap_policy": self.overlap_policy,
+            "overlap_short_ack_ms": self.overlap_short_ack_ms,
+            "overlap_barge_in_ms": self.overlap_barge_in_ms,
+            "overlap_silence_rms": self.overlap_silence_rms,
+            "playback_commit_policy": self.playback_commit_policy,
+            "extra_body": dict(self.extra_body),
+        }
+
+    def normalized(self) -> DuplexSessionConfig:
+        """Apply the clamps / defaults ``from_event`` applies to a wire object (typed configs skip them)."""
+        return DuplexSessionConfig.from_event({"session": self.as_dict()})
+
+    @classmethod
+    def from_event(cls, event: dict[str, object]) -> DuplexSessionConfig:
+        payload = event.get("session")
+        if isinstance(payload, dict):
+            source = payload
+        else:
+            source = event
+
+        config = cls()
+        if isinstance(source.get("model"), str):
+            config.model = source["model"]
+        if isinstance(source.get("instructions"), str):
+            config.instructions = source["instructions"]
+        if isinstance(source.get("initial_user_text"), str):
+            config.initial_user_text = source["initial_user_text"]
+        if isinstance(source.get("voice"), str):
+            config.voice = source["voice"]
+        if isinstance(source.get("ref_audio"), str):
+            config.ref_audio = source["ref_audio"]
+        if isinstance(source.get("response_format"), str):
+            config.response_format = source["response_format"]
+        if isinstance(source.get("use_tts_template"), bool):
+            config.use_tts_template = bool(source["use_tts_template"])
+        if isinstance(source.get("temperature"), int | float):
+            config.temperature = float(source["temperature"])
+        if isinstance(source.get("max_tokens"), int):
+            config.max_tokens = int(source["max_tokens"])
+        if isinstance(source.get("speed"), int | float):
+            config.speed = float(source["speed"])
+        if isinstance(source.get("idle_timeout_s"), int | float):
+            config.idle_timeout_s = float(source["idle_timeout_s"])
+        if isinstance(source.get("overlap_policy"), str):
+            config.overlap_policy = cls._normalize_overlap_policy(source["overlap_policy"])
+        if isinstance(source.get("overlap_short_ack_ms"), int | float):
+            config.overlap_short_ack_ms = max(0, int(source["overlap_short_ack_ms"]))
+        if isinstance(source.get("overlap_barge_in_ms"), int | float):
+            config.overlap_barge_in_ms = max(0, int(source["overlap_barge_in_ms"]))
+        if isinstance(source.get("overlap_silence_rms"), int | float):
+            config.overlap_silence_rms = max(0.0, float(source["overlap_silence_rms"]))
+        if isinstance(source.get("playback_commit_policy"), str):
+            config.playback_commit_policy = cls._normalize_playback_commit_policy(source["playback_commit_policy"])
+        if isinstance(source.get("modalities"), list) and all(isinstance(x, str) for x in source["modalities"]):
+            config.modalities = list(source["modalities"])
+        if isinstance(source.get("extra_body"), dict):
+            config.extra_body = dict(source["extra_body"])
+            extra = config.extra_body
+            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
+    def from_realtime(
+        cls,
+        session_payload: Mapping[str, object],
+        *,
+        model: str | None = None,
+    ) -> DuplexSessionConfig:
+        """Build a config from an OpenAI Realtime ``session`` object (session.update / open_session).
+
+        Applies the wire defaults, validates audio formats and turn detection
+        (raising :class:`DuplexConfigError` with the same codes the Realtime
+        translator used), fills ``turn_detection`` defaults / derives
+        ``overlap_policy``, and stores the Realtime-only fields under the
+        ``realtime_*`` keys of ``extra_body`` exactly like the old
+        ``_session_create_from_realtime``.
+        """
+        from vllm_omni.engine.duplex.realtime_commands import (
+            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_session_payload,
+        )
+
+        payload: dict[str, object] = dict(session_payload)
+        # 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))
+
+        audio_config = payload.get("audio")
+        audio_input = audio_config.get("input") if isinstance(audio_config, dict) else None
+        audio_output = audio_config.get("output") if isinstance(audio_config, dict) else None
+        extra_body_payload = payload.get("extra_body")
+        extra_body: dict[str, object] = dict(extra_body_payload) if isinstance(extra_body_payload, dict) else {}
+        extra_body["realtime_session_payload"] = json_safe_realtime_payload(payload)
+        if isinstance(payload.get("tools"), list):
+            extra_body["realtime_tools"] = payload["tools"]
+        if isinstance(payload.get("tool_choice"), str | dict):
+            extra_body["realtime_tool_choice"] = payload["tool_choice"]
+        metadata = payload.get("metadata")
+        if isinstance(metadata, dict):
+            extra_body["realtime_metadata"] = dict(metadata)
+        include = payload.get("include")
+        if isinstance(include, list):
+            extra_body["realtime_include"] = list(include)
+        prompt = payload.get("prompt")
+        if isinstance(prompt, dict):
+            extra_body["realtime_prompt"] = dict(prompt)
+        transcription = input_audio_transcription_config(payload)
+        if isinstance(transcription, dict):
+            extra_body["realtime_input_audio_transcription"] = dict(transcription)
+        noise_reduction = payload.get("input_audio_noise_reduction")
+        if isinstance(noise_reduction, dict):
+            extra_body["realtime_input_audio_noise_reduction"] = dict(noise_reduction)
+        audio_noise_reduction = audio_input.get("noise_reduction") if isinstance(audio_input, dict) else None
+        if isinstance(audio_noise_reduction, dict):
+            extra_body["realtime_input_audio_noise_reduction"] = dict(audio_noise_reduction)
+        if isinstance(audio_config, dict):
+            extra_body["realtime_audio"] = dict(audio_config)
+        if isinstance(payload.get("tracing"), str | dict):
+            extra_body["realtime_tracing"] = payload["tracing"]
+        if isinstance(payload.get("turn_detection"), dict):
+            extra_body["realtime_turn_detection"] = dict(cast("Mapping[str, object]", payload["turn_detection"]))
+        elif "turn_detection" in payload and payload.get("turn_detection") is None:
+            extra_body["realtime_turn_detection"] = None
+        extra_body.setdefault("realtime_output_audio_format", defaults.output_audio_format)
+        voice = payload.get("voice")
+        if not isinstance(voice, str) and isinstance(audio_output, dict):
+            voice = audio_output.get("voice")
+        speed = payload.get("speed")
+        if not isinstance(speed, int | float) and isinstance(audio_output, dict):
+            speed = audio_output.get("speed")
+        resolved_model = payload.get("model") if isinstance(payload.get("model"), str) else model
+        session: dict[str, object] = {
+            "model": resolved_model,
+            "modalities": payload.get("modalities") or payload.get("output_modalities") or ["text", "audio"],
+            "instructions": payload.get("instructions"),
+            # Not a Realtime field, but a session one: a client that cannot
+            # reach the model by speech seeds its opening turn here. Without
+            # this a websocket client could only use the older
+            # ``extra_body.duplex_initial_user_text`` spelling.
+            "initial_user_text": payload.get("initial_user_text"),
+            "voice": voice,
+            "ref_audio": payload.get("ref_audio"),
+            "response_format": duplex_response_format(defaults.output_audio_format),
+            "temperature": payload.get("temperature"),
+            "max_tokens": realtime_max_output_tokens(
+                payload.get("max_response_output_tokens")
+                or payload.get("max_output_tokens")
+                or payload.get("max_tokens")
+            ),
+            "speed": speed,
+            "idle_timeout_s": payload.get("idle_timeout_s") or 300.0,
+            **realtime_overlap_fields(payload),
+            "extra_body": extra_body,
+        }
+        return cls.from_event({"session": session})
+
+    def apply_realtime_update(
+        self,
+        patch: Mapping[str, object],
+        *,
+        session_id: str | None = None,
+        audio_started: bool = False,
+    ) -> None:
+        """Apply a Realtime ``session.update`` patch in place.
+
+        Raises :class:`DuplexConfigError` (``code`` in ``model_update_unsupported``,
+        ``voice_update_after_audio_unsupported``, ``ref_audio_update_unsupported``)
+        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 duplex_response_format
+        from vllm_omni.protocol.duplex import (
+            REALTIME_OUTPUT_AUDIO_FORMATS,
+            input_audio_transcription_config,
+            json_safe_realtime_payload,
+            parse_realtime_audio_format,
+            realtime_max_output_tokens,
+        )
+
+        # Any: the patch is read with ``isinstance(payload.get(...))`` guards and consumed
+        # through ``payload[...]``; typing the values ``object`` would need a cast per read.
+        payload: dict[str, Any] = dict(patch)
+        model = payload.get("model")
+        audio_config = payload.get("audio")
+        audio_input = audio_config.get("input") if isinstance(audio_config, dict) else None
+        audio_output = audio_config.get("output") if isinstance(audio_config, dict) else None
+        voice = payload.get("voice")
+        if not isinstance(voice, str) and isinstance(audio_output, dict):
+            voice = audio_output.get("voice")
+        if isinstance(model, str) and self.model is not None and model != self.model:
+            raise DuplexConfigError(
+                "session.update cannot change model for an open realtime duplex session",
+                code="model_update_unsupported",
+            )
+        if isinstance(model, str) and self.model is None:
+            self.model = model
+        if isinstance(voice, str) and audio_started:
+            raise DuplexConfigError(
+                "session.update cannot change voice after audio output has started",
+                code="voice_update_after_audio_unsupported",
+            )
+        if isinstance(payload.get("ref_audio"), str):
+            raise DuplexConfigError(
+                "session.update cannot change ref_audio after the session is open", code="ref_audio_update_unsupported"
+            )
+        if isinstance(payload.get("instructions"), str):
+            self.instructions = str(payload["instructions"])
+        elif "instructions" in payload and payload.get("instructions") is None:
+            self.instructions = None
+        if isinstance(voice, str):
+            self.voice = str(voice)
+        elif "voice" in payload and payload.get("voice") is None:
+            self.voice = None
+        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:
+            self.response_format = duplex_response_format(response_format)
+        if isinstance(payload.get("temperature"), int | float):
+            self.temperature = float(payload["temperature"])
+        speed = payload.get("speed")
+        if not isinstance(speed, int | float) and isinstance(audio_output, dict):
+            speed = audio_output.get("speed")
+        if isinstance(speed, int | float):
+            self.speed = float(speed)
+        max_tokens = (
+            payload.get("max_response_output_tokens")
+            if "max_response_output_tokens" in payload
+            else payload.get("max_output_tokens")
+            if "max_output_tokens" in payload
+            else payload.get("max_tokens")
+        )
+        if "max_response_output_tokens" in payload or "max_output_tokens" in payload or "max_tokens" in payload:
+            self.max_tokens = realtime_max_output_tokens(max_tokens)
+        if isinstance(payload.get("overlap_policy"), str):
+            self.overlap_policy = self._normalize_overlap_policy(str(payload["overlap_policy"]))
+        if isinstance(payload.get("overlap_short_ack_ms"), int | float):
+            self.overlap_short_ack_ms = max(0, int(payload["overlap_short_ack_ms"]))
+        if isinstance(payload.get("overlap_barge_in_ms"), int | float):
+            self.overlap_barge_in_ms = max(0, int(payload["overlap_barge_in_ms"]))
+        if isinstance(payload.get("overlap_silence_rms"), int | float):
+            self.overlap_silence_rms = max(0.0, float(payload["overlap_silence_rms"]))
+        if isinstance(payload.get("playback_commit_policy"), str):
+            self.playback_commit_policy = self._normalize_playback_commit_policy(str(payload["playback_commit_policy"]))
+        modalities = payload.get("modalities") or payload.get("output_modalities")
+        if isinstance(modalities, list) and all(isinstance(item, str) for item in modalities):
+            self.modalities = list(modalities)
+        if isinstance(payload.get("extra_body"), dict):
+            self.extra_body.update(payload["extra_body"])
+            extra = payload["extra_body"]
+            if isinstance(extra.get("overlap_policy"), str):
+                self.overlap_policy = self._normalize_overlap_policy(str(extra["overlap_policy"]))
+            if isinstance(extra.get("playback_commit_policy"), str):
+                self.playback_commit_policy = self._normalize_playback_commit_policy(
+                    str(extra["playback_commit_policy"])
+                )
+        if isinstance(payload.get("tools"), list):
+            self.extra_body["realtime_tools"] = payload["tools"]
+        elif "tools" in payload and payload.get("tools") is None:
+            self.extra_body.pop("realtime_tools", None)
+        if isinstance(payload.get("tool_choice"), str | dict):
+            self.extra_body["realtime_tool_choice"] = payload["tool_choice"]
+        elif "tool_choice" in payload and payload.get("tool_choice") is None:
+            self.extra_body.pop("realtime_tool_choice", None)
+        if isinstance(payload.get("metadata"), dict):
+            self.extra_body["realtime_metadata"] = dict(payload["metadata"])
+        elif "metadata" in payload and payload.get("metadata") is None:
+            self.extra_body.pop("realtime_metadata", None)
+        if isinstance(payload.get("include"), list):
+            self.extra_body["realtime_include"] = list(payload["include"])
+        elif "include" in payload and payload.get("include") is None:
+            self.extra_body.pop("realtime_include", None)
+        if isinstance(payload.get("prompt"), dict):
+            self.extra_body["realtime_prompt"] = dict(payload["prompt"])
+        elif "prompt" in payload and payload.get("prompt") is None:
+            self.extra_body.pop("realtime_prompt", None)
+        transcription = input_audio_transcription_config(payload)
+        if isinstance(transcription, dict):
+            self.extra_body["realtime_input_audio_transcription"] = dict(transcription)
+        elif "input_audio_transcription" in payload and payload.get("input_audio_transcription") is None:
+            self.extra_body.pop("realtime_input_audio_transcription", None)
+        if isinstance(payload.get("input_audio_noise_reduction"), dict):
+            self.extra_body["realtime_input_audio_noise_reduction"] = dict(payload["input_audio_noise_reduction"])
+        elif "input_audio_noise_reduction" in payload and payload.get("input_audio_noise_reduction") is None:
+            self.extra_body.pop("realtime_input_audio_noise_reduction", None)
+        if isinstance(audio_input, dict) and isinstance(audio_input.get("noise_reduction"), dict):
+            self.extra_body["realtime_input_audio_noise_reduction"] = dict(audio_input["noise_reduction"])
+        elif isinstance(audio_input, dict) and audio_input.get("noise_reduction") is None:
+            self.extra_body.pop("realtime_input_audio_noise_reduction", None)
+        if isinstance(payload.get("audio"), dict):
+            self.extra_body["realtime_audio"] = dict(payload["audio"])
+        elif "audio" in payload and payload.get("audio") is None:
+            self.extra_body.pop("realtime_audio", None)
+        if isinstance(payload.get("tracing"), str | dict):
+            self.extra_body["realtime_tracing"] = payload["tracing"]
+        elif "tracing" in payload and payload.get("tracing") is None:
+            self.extra_body.pop("realtime_tracing", None)
+        if isinstance(payload.get("turn_detection"), dict):
+            self.extra_body["realtime_turn_detection"] = dict(payload["turn_detection"])
+        elif "turn_detection" in payload and payload.get("turn_detection") is None:
+            self.extra_body["realtime_turn_detection"] = None
+        self.extra_body["realtime_session_payload"] = json_safe_realtime_payload(payload)
+        return None
+
+    @staticmethod
+    def _normalize_overlap_policy(value: str) -> str:
+        normalized = value.strip().lower()
+        if normalized in {policy.value for policy in DuplexOverlapPolicy}:
+            return normalized
+        return DuplexOverlapPolicy.LISTEN_ONLY.value
+
+    @staticmethod
+    def _normalize_playback_commit_policy(value: str) -> str:
+        normalized = value.strip().lower()
+        if normalized in {policy.value for policy in DuplexPlaybackCommitPolicy}:
+            return normalized
+        return DuplexPlaybackCommitPolicy.COMMIT_ALL_ON_DONE.value
+
+
+@dataclass(frozen=True)
+class ResponseCreateOptions:
+    instructions: str | None = None
+    voice: str | None = None
+    response_format: str | None = None
+    temperature: float | None = None
+    max_tokens: int | None = None
+    speed: float | None = None
+    modalities: tuple[str, ...] | None = None
+    extra_body: Mapping[str, object] = field(default_factory=dict)
+
+    def apply_to(self, config: DuplexSessionConfig) -> None:
+        for field_name in ("instructions", "voice", "response_format", "temperature", "max_tokens", "speed"):
+            value = getattr(self, field_name)
+            if value is not None:
+                setattr(config, field_name, value)
+        if self.modalities is not None:
+            config.modalities = list(self.modalities)
+        config.extra_body.update(self.extra_body)
+
+    @classmethod
+    def from_realtime(
+        cls,
+        response_payload: Mapping[str, object],
+        *,
+        private_runtime_config_keys: frozenset[str] = frozenset(),
+    ) -> ResponseCreateOptions:
+        """Parse an OpenAI Realtime ``response`` object into response-scoped options.
+
+        Raises :class:`DuplexConfigError` (``code="unsupported_native_response_options"``)
+        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 duplex_response_format
+        from vllm_omni.protocol.duplex import (
+            REALTIME_OUTPUT_AUDIO_FORMATS,
+            parse_realtime_audio_format,
+        )
+
+        payload: dict[str, object] = dict(response_payload)
+        audio_config = payload.get("audio")
+        audio_output = audio_config.get("output") if isinstance(audio_config, dict) else None
+        nested_voice = audio_output.get("voice") if isinstance(audio_output, dict) else None
+        unsupported = (
+            payload.get("instructions") is not None
+            or payload.get("voice") is not None
+            or nested_voice is not None
+            or payload.get("temperature") is not None
+            or any(
+                payload.get(field_name) is not None
+                for field_name in ("max_response_output_tokens", "max_output_tokens", "max_tokens")
+            )
+            or payload.get("tools") is not None
+            or payload.get("tool_choice") is not None
+        )
+        if unsupported:
+            raise DuplexConfigError(
+                "response.create options are not supported by a model-native duplex session",
+                code="unsupported_native_response_options",
+            )
+        instructions = str(payload["instructions"]) if isinstance(payload.get("instructions"), str) else None
+        voice = payload.get("voice")
+        if not isinstance(voice, str) and isinstance(audio_output, dict):
+            voice = audio_output.get("voice")
+        voice = str(voice) if isinstance(voice, str) else None
+        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")
+        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:
+            output_audio_format = None
+        temperature = (
+            float(cast("int | float", payload["temperature"]))
+            if isinstance(payload.get("temperature"), int | float)
+            else None
+        )
+        speed = payload.get("speed")
+        if not isinstance(speed, int | float) and isinstance(audio_output, dict):
+            speed = audio_output.get("speed")
+        speed = float(speed) if isinstance(speed, int | float) else None
+        max_tokens = (
+            payload.get("max_response_output_tokens")
+            if "max_response_output_tokens" in payload
+            else payload.get("max_output_tokens")
+            if "max_output_tokens" in payload
+            else payload.get("max_tokens")
+        )
+        if "max_response_output_tokens" in payload or "max_output_tokens" in payload or "max_tokens" in payload:
+            token_limit = realtime_max_output_tokens(max_tokens)
+        else:
+            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)
+        else:
+            modalities = None
+        response_extra: dict[str, object] = {}
+        conversation = payload.get("conversation")
+        if isinstance(conversation, str):
+            response_extra["realtime_response_conversation"] = conversation
+        metadata = payload.get("metadata")
+        if isinstance(metadata, dict):
+            response_extra["realtime_response_metadata"] = dict(metadata)
+        prompt = payload.get("prompt")
+        if isinstance(prompt, dict):
+            response_extra["realtime_response_prompt"] = dict(prompt)
+        if isinstance(payload.get("tools"), list):
+            response_extra["realtime_response_tools"] = payload["tools"]
+        if isinstance(payload.get("tool_choice"), str | dict):
+            response_extra["realtime_response_tool_choice"] = payload["tool_choice"]
+        extra_body = payload.get("extra_body")
+        if isinstance(extra_body, dict):
+            response_extra.update(
+                (key, value) for key, value in extra_body.items() if key not in private_runtime_config_keys
+            )
+        return cls(
+            instructions=instructions,
+            voice=voice,
+            response_format=output_audio_format,
+            temperature=temperature,
+            max_tokens=token_limit,
+            speed=speed,
+            modalities=modalities,
+            extra_body=response_extra,
+        )
+
+
+@dataclass
+class DuplexCommittedInput:
+    message: dict[str, object]
+    turn_id: int
+    epoch: int
+    input_commit_seq: int
+
+
+@dataclass
+class DuplexAssistantAudioTextMark:
+    text_chars: int
+    audio_end_ms: int
+
+
+def realtime_item_to_history_message(item: object) -> dict[str, object] | None:
+    """Convert a Realtime conversation item into a chat history message (None when empty)."""
+    if not isinstance(item, dict):
+        return None
+    role = item.get("role")
+    if role not in {"system", "user", "assistant"}:
+        return None
+    content = item.get("content")
+    if isinstance(content, str):
+        text = content.strip()
+        return {"role": role, "content": text} if text else None
+    if not isinstance(content, list):
+        return None
+    text_chunks: list[str] = []
+    audio_chunks: list[dict[str, object]] = []
+    for part in content:
+        if not isinstance(part, dict):
+            continue
+        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"
+            if isinstance(audio, str) and audio:
+                audio_chunks.append({"type": "audio_url", "audio_url": {"url": f"data:audio/{fmt};base64,{audio}"}})
+        elif part_type in {"audio_transcript", "transcript"} and isinstance(part.get("text"), str):
+            text_chunks.append(str(part["text"]))
+    text = "".join(text_chunks).strip()
+    if audio_chunks:
+        content_items: list[dict[str, object]] = []
+        if text:
+            content_items.append({"type": "text", "text": text})
+        content_items.extend(audio_chunks)
+        return {"role": role, "content": content_items}
+    if text:
+        return {"role": role, "content": text}
+    return None
+
+
+def realtime_max_output_tokens(value: object) -> int | None:
+    """Normalize Realtime max output tokens (``"inf"`` -> ``None``)."""
+    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.protocol.duplex import input_audio_transcription_config as _impl
+
+    return _impl(session_payload)
+
+
+__all__ = [
+    "DuplexAssistantAudioTextMark",
+    "DuplexAudioChunk",
+    "DuplexCapabilities",
+    "DuplexCommittedInput",
+    "DuplexConfigError",
+    "DuplexOverlapPolicy",
+    "DuplexPlaybackCommitPolicy",
+    "DuplexPlaybackCursor",
+    "DuplexPlaybackView",
+    "DuplexSessionConfig",
+    "DuplexSessionState",
+    "DuplexTurnEventType",
+    "DuplexTurnState",
+    "ResponseCreateOptions",
+    "input_audio_transcription_config",
+    "realtime_item_to_history_message",
+    "realtime_max_output_tokens",
+]
diff --git a/vllm_omni/engine/duplex/contracts.py b/vllm_omni/engine/duplex/contracts.py
index 6af4fdea5..ed14f5fb8 100644
--- a/vllm_omni/engine/duplex/contracts.py
+++ b/vllm_omni/engine/duplex/contracts.py
@@ -1,102 +1,50 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
-"""Model-neutral contracts for the experimental duplex engine plugin.
+"""Model-neutral value types shared by the duplex engine components.
 
-This module contains only immutable data transfer objects and narrow protocols.
-Duplex control algorithms, session implementations, model policy, and Realtime
-serving remain in sibling experimental modules.
+Immutable DTOs plus the ``DuplexStagePort`` base class that ``DuplexOrchestrator``
+implements for the session manager/runner.
 """
 
 from __future__ import annotations
 
 import base64
-from collections.abc import Iterable, Mapping
+from abc import ABC, abstractmethod
+from collections.abc import Mapping
 from dataclasses import dataclass, field
 from enum import Enum
 from types import MappingProxyType
-from typing import Any, Protocol
-
-from vllm_omni.engine.duplex.messages import DuplexFence
-from vllm_omni.engine.messages import EngineQueueMessage
 
 
-class SessionMode(str, Enum):
-    TURN = "turn"
-    DUPLEX = "duplex"
+@dataclass(frozen=True, slots=True)
+class DuplexFence:
+    """Engine-internal session identity used for stage request ids and stale filtering."""
 
-
-class DuplexInputMode(str, Enum):
-    APPEND_TOKENS = "append_tokens"
-    APPEND_AUDIO_CHUNK = "append_audio_chunk"
-    REPLACE_LATEST_CHUNK = "replace_latest_chunk"
-    REENCODE_CONTEXT = "reencode_context"
-    ROLLBACK_TO_CHECKPOINT = "rollback_to_checkpoint"
-    TURN_COMMIT_ONLY = "turn_commit_only"
+    session_id: str
+    epoch: int = 0
+    turn_id: int = 0
 
 
 class DuplexOutputAction(str, Enum):
     DIRECT_RESPONSE = "direct_response"
 
 
-@dataclass
-class DuplexRuntimeCapabilities:
-    input_modes: set[DuplexInputMode] = field(default_factory=lambda: {DuplexInputMode.TURN_COMMIT_ONLY})
-    implementation_level: str = "serving_session_adapter"
-
-
 @dataclass(frozen=True)
 class DuplexAppendPlan:
-    prompt: dict[str, Any]
+    prompt: dict[str, object]
 
 
 @dataclass(frozen=True)
 class DuplexOutputDecision:
     action: DuplexOutputAction
-    metadata: Mapping[str, Any] = field(default_factory=dict)
+    metadata: Mapping[str, object] = field(default_factory=dict)
     final_output_type: str = "text"
 
     def __post_init__(self) -> None:
         object.__setattr__(self, "metadata", MappingProxyType(dict(self.metadata)))
 
 
-class DuplexRuntimeExtension(Protocol):
-    """Pure model policy invoked by the experimental duplex control plane."""
-
-    def configure_sampling_params(
-        self,
-        *,
-        runtime_config: dict[str, Any],
-        defaults: tuple[object, ...],
-    ) -> tuple[object, ...]: ...
-
-    def plan_append(
-        self,
-        *,
-        request_id: str,
-        fence: DuplexFence,
-        session_config: dict[str, Any],
-        runtime_config: dict[str, Any],
-        seq: int,
-        turn_seq: int,
-        mode: DuplexInputMode,
-        payload: object,
-        final: bool,
-        sampling_params: object,
-    ) -> DuplexAppendPlan: ...
-
-    def decide_output(
-        self,
-        *,
-        stage_id: int,
-        final_stage_id: int,
-        segment_finished: bool,
-        segment_token_ids: tuple[int, ...],
-        segment_output_metadata: dict[str, Any],
-        output: object,
-    ) -> DuplexOutputDecision | None: ...
-
-
 @dataclass(frozen=True)
 class DuplexRequestIdentity:
     session_id: str
@@ -112,8 +60,8 @@ class DuplexStageRequestContext:
     final_stage_id: int
     config_generation: int
     sampling_params: tuple[object, ...]
-    session_config: Mapping[str, Any] = field(default_factory=dict)
-    runtime_config: Mapping[str, Any] = field(default_factory=dict)
+    session_config: Mapping[str, object] = field(default_factory=dict)
+    runtime_config: Mapping[str, object] = field(default_factory=dict)
 
     def __post_init__(self) -> None:
         object.__setattr__(self, "sampling_params", tuple(self.sampling_params))
@@ -128,7 +76,7 @@ class DuplexStageRequestContext:
 @dataclass(frozen=True)
 class DuplexStageSubmission:
     context: DuplexStageRequestContext
-    prompt: Mapping[str, Any]
+    prompt: Mapping[str, object]
     already_submitted: bool
 
     def __post_init__(self) -> None:
@@ -148,7 +96,7 @@ class DuplexOutputContext:
     final_stage_id: int
     segment_finished: bool
     segment_token_ids: tuple[int, ...] = ()
-    segment_output_metadata: Mapping[str, Any] = field(default_factory=dict)
+    segment_output_metadata: Mapping[str, object] = field(default_factory=dict)
 
     def __post_init__(self) -> None:
         object.__setattr__(self, "segment_token_ids", tuple(self.segment_token_ids))
@@ -159,53 +107,27 @@ class DuplexOutputContext:
         )
 
 
-class DuplexStagePort(Protocol):
+class DuplexStagePort(ABC):
+    """Narrow stage-management surface the session runner/manager use (implemented by DuplexOrchestrator)."""
+
     @property
+    @abstractmethod
     def stage_count(self) -> int: ...
 
+    @abstractmethod
     def sampling_defaults(self) -> tuple[object, ...]: ...
 
+    @abstractmethod
     def ensure_request(self, context: DuplexStageRequestContext) -> None: ...
 
+    @abstractmethod
     async def submit(self, submission: DuplexStageSubmission) -> DuplexStageSubmissionResult: ...
 
+    @abstractmethod
     async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None: ...
 
-
-class DuplexControlPlanePort(Protocol):
-    @property
-    def sessions(self) -> object: ...
-
-    def accepts(self, message: object) -> bool: ...
-
-    def dispatch(self, message: object) -> None: ...
-
-    async def shutdown(self) -> None: ...
-
-    def close_sessions_for_request_ids(self, request_ids: list[str]) -> dict[str, list[str]]: ...
-
-    def finalize_closed_sessions(self, session_ids: Iterable[str]) -> None: ...
-
-    def session_for_identity(self, identity: DuplexRequestIdentity | None) -> object | None: ...
-
-    def decide_output(
-        self,
-        stage_id: int,
-        output: object,
-        context: DuplexOutputContext | None,
-    ) -> DuplexOutputDecision | None: ...
-
-
-class CorrelatedRpcTransport(Protocol):
-    def execute(
-        self,
-        key: tuple[str, str],
-        message: EngineQueueMessage,
-        *,
-        timeout: float | None,
-        timeout_message: str,
-        block_on_submit: bool = False,
-    ) -> EngineQueueMessage: ...
+    @abstractmethod
+    async def abort_requests(self, request_ids: list[str]) -> None: ...
 
 
 def duplex_data_plane_request_info(result: dict[str, object]) -> tuple[str | None, int | None]:
@@ -232,20 +154,19 @@ def duplex_resource_request_id(fence: DuplexFence, role: str) -> str:
     ):
         raise ValueError(f"invalid duplex resource role: {role!r}")
     encoded_session_id = base64.urlsafe_b64encode(fence.session_id.encode("utf-8")).decode("ascii").rstrip("=")
-    return f"duplex-s.{encoded_session_id}.i.{fence.incarnation}.e.{fence.epoch}.r.{role}"
+    return f"duplex-s.{encoded_session_id}.e.{fence.epoch}.r.{role}"
 
 
 def duplex_resource_request_belongs_to_session(request_id: str, session_id: str) -> bool:
     """Return whether a current-format resource request belongs to a session."""
     parts = request_id.split(".")
-    if len(parts) != 8 or parts[0] != "duplex-s" or parts[2] != "i" or parts[4] != "e" or parts[6] != "r":
+    if len(parts) != 6 or parts[0] != "duplex-s" or parts[2] != "e" or parts[4] != "r":
         return False
     try:
         int(parts[3])
-        int(parts[5])
     except ValueError:
         return False
-    role = parts[7]
+    role = parts[5]
     if not role or any(
         character not in "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-" for character in role
     ):
@@ -255,21 +176,16 @@ def duplex_resource_request_belongs_to_session(request_id: str, session_id: str)
 
 
 __all__ = [
-    "CorrelatedRpcTransport",
+    "DuplexFence",
     "DuplexAppendPlan",
-    "DuplexControlPlanePort",
-    "DuplexInputMode",
     "DuplexOutputAction",
     "DuplexOutputContext",
     "DuplexOutputDecision",
     "DuplexRequestIdentity",
-    "DuplexRuntimeCapabilities",
-    "DuplexRuntimeExtension",
     "DuplexStagePort",
     "DuplexStageRequestContext",
     "DuplexStageSubmission",
     "DuplexStageSubmissionResult",
-    "SessionMode",
     "duplex_data_plane_request_info",
     "duplex_resource_request_belongs_to_session",
     "duplex_resource_request_id",
diff --git a/vllm_omni/engine/duplex/control_client.py b/vllm_omni/engine/duplex/control_client.py
deleted file mode 100644
index 05ec46e49..000000000
--- a/vllm_omni/engine/duplex/control_client.py
+++ /dev/null
@@ -1,228 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-from __future__ import annotations
-
-import uuid
-from collections.abc import Callable
-
-from vllm_omni.engine.duplex.contracts import CorrelatedRpcTransport
-from vllm_omni.engine.duplex.lease import DuplexLeaseActivity
-from vllm_omni.engine.duplex.messages import (
-    AppendDuplexInputMessage,
-    CloseDuplexSessionMessage,
-    DuplexControlResultMessage,
-    DuplexFence,
-    OpenDuplexSessionMessage,
-    ResumeDuplexSessionMessage,
-    SignalDuplexTurnMessage,
-    TouchDuplexSessionMessage,
-)
-
-DuplexControlMessage = (
-    OpenDuplexSessionMessage
-    | AppendDuplexInputMessage
-    | SignalDuplexTurnMessage
-    | CloseDuplexSessionMessage
-    | TouchDuplexSessionMessage
-    | ResumeDuplexSessionMessage
-)
-
-
-class DuplexControlRequestError(RuntimeError):
-    """Typed client-side failure returned by the duplex control plane."""
-
-    def __init__(self, result: dict[str, object]) -> None:
-        error = result.get("error")
-        error_data = error if isinstance(error, dict) else {}
-        self.result = result
-        self.code = str(error_data.get("code") or "internal_error")
-        self.retryable = bool(error_data.get("retryable", False))
-        accepted_fence = result.get("accepted_fence")
-        self.accepted_fence = accepted_fence if isinstance(accepted_fence, DuplexFence) else None
-        lease_generation = result.get("lease_generation")
-        self.lease_generation = lease_generation if isinstance(lease_generation, int) else None
-        super().__init__(f"duplex {result.get('operation')} failed: {result}")
-
-
-class DuplexControlClient:
-    """Builds duplex commands on top of an engine-owned RPC transport."""
-
-    def __init__(
-        self,
-        transport: CorrelatedRpcTransport,
-        *,
-        control_id_factory: Callable[[], str] | None = None,
-    ) -> None:
-        self._transport = transport
-        self._control_id_factory = control_id_factory or (lambda: uuid.uuid4().hex)
-
-    def execute(self, message: DuplexControlMessage, *, timeout: float | None) -> dict[str, object]:
-        result_message = self._transport.execute(
-            ("duplex", message.control_id),
-            message,
-            timeout=timeout,
-            timeout_message=f"duplex control timed out after {timeout} seconds",
-        )
-        if not isinstance(result_message, DuplexControlResultMessage):
-            raise RuntimeError(f"unexpected duplex control result type: {type(result_message).__name__}")
-        if result_message.fence != message.fence:
-            raise RuntimeError(
-                f"duplex control fence mismatch: expected {message.fence!r}, got {result_message.fence!r}"
-            )
-        result = {
-            "fence": result_message.fence,
-            "operation": result_message.operation,
-            "session_id": result_message.session_id,
-            "ok": result_message.ok,
-            "stage_results": list(result_message.stage_results),
-            "unsupported_count": result_message.unsupported_count,
-            "error_count": result_message.error_count,
-            "accepted_fence": result_message.accepted_fence,
-            "lease_generation": result_message.lease_generation,
-            "error": (
-                {
-                    "code": result_message.error.code,
-                    "message": result_message.error.message,
-                    "retryable": result_message.error.retryable,
-                }
-                if result_message.error is not None
-                else None
-            ),
-        }
-        if not result_message.ok:
-            raise DuplexControlRequestError(result)
-        return result
-
-    def open(
-        self,
-        session_id: str,
-        *,
-        session_mode: str,
-        capabilities: dict[str, object] | None,
-        session_config: dict[str, object] | None,
-        runtime_config: dict[str, object] | None,
-        fence: DuplexFence,
-        timeout: float | None,
-    ) -> dict[str, object]:
-        return self.execute(
-            OpenDuplexSessionMessage(
-                control_id=self._control_id_factory(),
-                fence=fence,
-                session_id=session_id,
-                session_mode=session_mode,
-                capabilities=dict(capabilities or {}),
-                session_config=dict(session_config or {}),
-                runtime_config=dict(runtime_config or {}),
-            ),
-            timeout=timeout,
-        )
-
-    def append(
-        self,
-        session_id: str,
-        *,
-        mode: str,
-        payload: object,
-        operation_id: str | None,
-        final: bool,
-        expected_epoch: int | None,
-        fence: DuplexFence,
-        timeout: float | None,
-    ) -> dict[str, object]:
-        if expected_epoch is not None and expected_epoch != fence.epoch:
-            raise ValueError("expected_epoch must match fence.epoch")
-        return self.execute(
-            AppendDuplexInputMessage(
-                control_id=self._control_id_factory(),
-                operation_id=operation_id,
-                fence=fence,
-                session_id=session_id,
-                expected_epoch=expected_epoch,
-                mode=mode,
-                payload=payload,
-                final=final,
-            ),
-            timeout=timeout,
-        )
-
-    def signal(
-        self,
-        session_id: str,
-        *,
-        event: str,
-        fence: DuplexFence,
-        next_fence: DuplexFence | None,
-        session_config: dict[str, object] | None,
-        runtime_config: dict[str, object] | None,
-        timeout: float | None,
-    ) -> dict[str, object]:
-        return self.execute(
-            SignalDuplexTurnMessage(
-                control_id=self._control_id_factory(),
-                fence=fence,
-                session_id=session_id,
-                event=event,
-                next_fence=next_fence,
-                session_config=dict(session_config) if session_config is not None else None,
-                runtime_config=dict(runtime_config) if runtime_config is not None else None,
-            ),
-            timeout=timeout,
-        )
-
-    def close(
-        self,
-        session_id: str,
-        *,
-        reason: str,
-        fence: DuplexFence,
-        timeout: float | None,
-    ) -> dict[str, object]:
-        return self.execute(
-            CloseDuplexSessionMessage(
-                control_id=self._control_id_factory(),
-                fence=fence,
-                session_id=session_id,
-                reason=reason,
-            ),
-            timeout=timeout,
-        )
-
-    def touch(
-        self,
-        session_id: str,
-        *,
-        fence: DuplexFence,
-        activity: DuplexLeaseActivity,
-        timeout: float | None,
-    ) -> dict[str, object]:
-        return self.execute(
-            TouchDuplexSessionMessage(
-                control_id=self._control_id_factory(),
-                fence=fence,
-                session_id=session_id,
-                activity=activity.value,
-            ),
-            timeout=timeout,
-        )
-
-    def resume(
-        self,
-        session_id: str,
-        *,
-        fence: DuplexFence,
-        expected_lease_generation: int,
-        timeout: float | None,
-    ) -> dict[str, object]:
-        return self.execute(
-            ResumeDuplexSessionMessage(
-                control_id=self._control_id_factory(),
-                fence=fence,
-                session_id=session_id,
-                expected_lease_generation=expected_lease_generation,
-            ),
-            timeout=timeout,
-        )
-
-
-__all__ = ["CorrelatedRpcTransport", "DuplexControlClient", "DuplexControlMessage"]
diff --git a/vllm_omni/engine/duplex/control_plane.py b/vllm_omni/engine/duplex/control_plane.py
deleted file mode 100644
index b425542b8..000000000
--- a/vllm_omni/engine/duplex/control_plane.py
+++ /dev/null
@@ -1,1063 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-"""Orchestrator-side control plane for experimental duplex sessions.
-
-``Orchestrator`` creates this component only when duplex control is enabled
-and supplies a narrow :class:`DuplexStagePort` implementation. Queue messages
-are routed through :meth:`DuplexControlPlane.handle`; stage outputs are passed
-to :meth:`DuplexControlPlane.decide_output`; request cleanup is reported back
-through the control plane so session leases and stage bindings stay coherent.
-
-The module owns duplex session/control algorithms. It deliberately does not
-own stage pools, request queues, or OpenAI Realtime protocol state.
-"""
-
-from __future__ import annotations
-
-import asyncio
-from collections.abc import Callable, Iterable
-from dataclasses import dataclass
-from typing import Any, Protocol
-
-from vllm.logger import init_logger
-
-from vllm_omni.engine.duplex.contracts import (
-    DuplexAppendPlan,
-    DuplexInputMode,
-    DuplexOutputContext,
-    DuplexOutputDecision,
-    DuplexRequestIdentity,
-    DuplexRuntimeCapabilities,
-    DuplexRuntimeExtension,
-    DuplexStagePort,
-    DuplexStageRequestContext,
-    DuplexStageSubmission,
-    DuplexStageSubmissionResult,
-    SessionMode,
-    duplex_resource_request_id,
-)
-from vllm_omni.engine.duplex.lease import DuplexLeaseActivity, DuplexLeaseConfig
-from vllm_omni.engine.duplex.messages import (
-    AppendDuplexInputMessage,
-    CloseDuplexSessionMessage,
-    DuplexControlError,
-    DuplexControlResultMessage,
-    DuplexFence,
-    DuplexSessionLifecycleMessage,
-    OpenDuplexSessionMessage,
-    ResumeDuplexSessionMessage,
-    SignalDuplexTurnMessage,
-    TouchDuplexSessionMessage,
-)
-from vllm_omni.engine.duplex.session import (
-    DuplexAppendReservation,
-    DuplexFenceMismatchError,
-    DuplexSessionExpiry,
-    DuplexSessionRuntimeManager,
-    DuplexSessionRuntimeState,
-)
-
-logger = init_logger(__name__)
-
-
-@dataclass(frozen=True)
-class _PendingControlCleanup:
-    kind: str
-    session_id: str
-    fence: DuplexFence
-    submitted_request_ids: tuple[str, ...]
-    reserved_request_ids: tuple[str, ...] = ()
-
-
-@dataclass(frozen=True)
-class _PendingSubmissionCleanup:
-    session_id: str
-    request_ids: tuple[str, ...]
-
-
-@dataclass(frozen=True)
-class _PendingRequestCleanup:
-    session_id: str
-    fence: DuplexFence
-    lease_generation: int
-    request_ids: tuple[str, ...]
-    abort: bool
-
-
-class DuplexResultSink(Protocol):
-    async def put(self, message: DuplexControlResultMessage) -> None: ...
-
-
-class DuplexLifecycleSink(Protocol):
-    async def put(self, message: DuplexSessionLifecycleMessage) -> None: ...
-
-
-class DuplexControlPlane:
-    _MESSAGE_TYPES = (
-        OpenDuplexSessionMessage,
-        AppendDuplexInputMessage,
-        SignalDuplexTurnMessage,
-        CloseDuplexSessionMessage,
-        TouchDuplexSessionMessage,
-        ResumeDuplexSessionMessage,
-    )
-
-    def __init__(
-        self,
-        *,
-        extension: DuplexRuntimeExtension | None,
-        stage_port: DuplexStagePort,
-        result_sink: DuplexResultSink,
-        lifecycle_sink: DuplexLifecycleSink | None = None,
-        lease_config: DuplexLeaseConfig | None = None,
-        clock: Callable[[], float] | None = None,
-        max_sessions: int | None = None,
-        completed_append_limit: int = 256,
-    ) -> None:
-        self._extension = extension
-        self._stage_port = stage_port
-        self._result_sink = result_sink
-        self._lifecycle_sink = lifecycle_sink
-        self._lease_config = lease_config or DuplexLeaseConfig()
-        self._sessions = DuplexSessionRuntimeManager(
-            clock=clock,
-            max_sessions=max_sessions,
-            completed_append_limit=completed_append_limit,
-        )
-        self._pending_expirations: dict[tuple[str, int], DuplexSessionExpiry] = {}
-        self._pending_control_cleanups: dict[tuple[str, str, int, int, int, int], _PendingControlCleanup] = {}
-        self._control_cleanup_tasks: dict[
-            tuple[str, str, int, int, int, int],
-            asyncio.Task[None],
-        ] = {}
-        self._pending_submission_cleanups: dict[str, _PendingSubmissionCleanup] = {}
-        self._submission_cleanup_tasks: dict[str, asyncio.Task[None]] = {}
-        self._pending_request_cleanups: dict[tuple[str, int, int], _PendingRequestCleanup] = {}
-        self._request_cleanup_tasks: dict[tuple[str, int, int], asyncio.Task[None]] = {}
-        self._request_cleanups_in_progress: set[tuple[str, int, int]] = set()
-        self._session_control_tails: dict[str, asyncio.Task[None]] = {}
-        self._dispatched_control_tasks: set[asyncio.Task[None]] = set()
-
-    @property
-    def sessions(self) -> DuplexSessionRuntimeManager:
-        return self._sessions
-
-    @property
-    def pending_submission_cleanup_count(self) -> int:
-        return len(self._pending_submission_cleanups)
-
-    def accepts(self, message: object) -> bool:
-        return isinstance(message, self._MESSAGE_TYPES)
-
-    async def handle(self, message: object) -> None:
-        if isinstance(message, OpenDuplexSessionMessage):
-            await self.handle_open(message)
-        elif isinstance(message, AppendDuplexInputMessage):
-            await self.handle_append(message)
-        elif isinstance(message, SignalDuplexTurnMessage):
-            await self.handle_signal(message)
-        elif isinstance(message, CloseDuplexSessionMessage):
-            await self.handle_close(message)
-        elif isinstance(message, TouchDuplexSessionMessage):
-            await self.handle_touch(message)
-        elif isinstance(message, ResumeDuplexSessionMessage):
-            await self.handle_resume(message)
-        else:
-            raise TypeError(f"Unsupported duplex control message: {type(message).__name__}")
-
-    def dispatch(self, message: object) -> None:
-        """Schedule one control command without blocking unrelated sessions."""
-        if not self.accepts(message):
-            raise TypeError(f"Unsupported duplex control message: {type(message).__name__}")
-        session_id = message.session_id
-        predecessor = self._session_control_tails.get(session_id)
-
-        async def run_ordered() -> None:
-            if predecessor is not None:
-                await predecessor
-            await self.handle(message)
-
-        task = asyncio.create_task(
-            run_ordered(),
-            name=f"duplex-control-{session_id}-{message.control_id}",
-        )
-        self._session_control_tails[session_id] = task
-        self._dispatched_control_tasks.add(task)
-
-        def discard(completed: asyncio.Task[None]) -> None:
-            self._dispatched_control_tasks.discard(completed)
-            if self._session_control_tails.get(session_id) is completed:
-                self._session_control_tails.pop(session_id, None)
-            if not completed.cancelled():
-                completed.exception()
-
-        task.add_done_callback(discard)
-
-    async def drain(self) -> None:
-        while self._dispatched_control_tasks:
-            await asyncio.gather(*tuple(self._dispatched_control_tasks))
-
-    async def shutdown(self) -> None:
-        tasks = tuple(
-            self._dispatched_control_tasks
-            | set(self._control_cleanup_tasks.values())
-            | set(self._submission_cleanup_tasks.values())
-            | set(self._request_cleanup_tasks.values())
-        )
-        for task in tasks:
-            task.cancel()
-        if tasks:
-            await asyncio.gather(*tasks, return_exceptions=True)
-
-    @staticmethod
-    def coerce_capabilities(raw: dict[str, object]) -> DuplexRuntimeCapabilities:
-        input_modes: set[DuplexInputMode] = set()
-        values = raw.get("input_modes")
-        if values is not None and not isinstance(values, list):
-            raise TypeError("duplex input_modes capability must be a list")
-        if isinstance(values, list):
-            for value in values:
-                try:
-                    input_modes.add(DuplexInputMode(value))
-                except (TypeError, ValueError) as exc:
-                    raise ValueError(f"unknown duplex input mode: {value!r}") from exc
-        return DuplexRuntimeCapabilities(
-            input_modes=input_modes or {DuplexInputMode.TURN_COMMIT_ONLY},
-            implementation_level=str(raw.get("implementation_level") or "serving_session_adapter"),
-        )
-
-    def sampling_params_for_config(self, runtime_config: dict[str, Any]) -> list[object]:
-        defaults = self._stage_port.sampling_defaults()
-        if self._extension is None:
-            return list(defaults)
-        configured = self._extension.configure_sampling_params(
-            runtime_config=runtime_config,
-            defaults=defaults,
-        )
-        if not isinstance(configured, tuple):
-            raise TypeError("duplex runtime extension must return sampling parameters as a tuple")
-        if len(configured) != len(defaults):
-            raise ValueError("duplex runtime extension must return one sampling parameter per stage")
-        return list(configured)
-
-    @staticmethod
-    def stage_request_id(fence: DuplexFence, *, stage_id: int) -> str:
-        return duplex_resource_request_id(fence, f"stage{stage_id}")
-
-    def ensure_stage_request(
-        self,
-        session: DuplexSessionRuntimeState,
-        *,
-        stage_id: int,
-        fence: DuplexFence | None = None,
-    ) -> DuplexStageRequestContext | None:
-        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)
-        session.reserve_stage_request(stage_id, request_id, fence=effective_fence)
-        context = DuplexStageRequestContext(
-            request_id=request_id,
-            session_id=session.session_id,
-            fence=effective_fence,
-            stage_id=stage_id,
-            final_stage_id=self._stage_port.stage_count - 1,
-            config_generation=session.config_generation,
-            sampling_params=tuple(self.sampling_params_for_config(session.runtime_config)),
-            session_config=session.session_config,
-            runtime_config=session.runtime_config,
-        )
-        self._stage_port.ensure_request(context)
-        return context
-
-    async def handle_open(self, message: OpenDuplexSessionMessage) -> None:
-        session: DuplexSessionRuntimeState | None = None
-        try:
-            session_mode = SessionMode(message.session_mode)
-            capabilities = self.coerce_capabilities(message.capabilities)
-            native_append_modes = capabilities.input_modes - {DuplexInputMode.TURN_COMMIT_ONLY}
-            if native_append_modes and self._extension is None:
-                raise RuntimeError("duplex_runtime_extension_not_configured")
-            session = self.sessions.open_session(
-                message.fence,
-                capabilities=capabilities,
-                session_config=message.session_config,
-                runtime_config=message.runtime_config,
-                lease_config=self._lease_config,
-            )
-            request_context = self.ensure_stage_request(session, stage_id=0) if self._extension is not None else None
-            await self.put_result(
-                message.control_id,
-                fence=message.fence,
-                operation="open",
-                session_id=message.session_id,
-                stage_results=[
-                    {
-                        "stage_id": -1,
-                        "replica_id": -1,
-                        "result": {
-                            "supported": True,
-                            "implementation_level": capabilities.implementation_level,
-                            "data_plane_session": True,
-                            "session_mode": session_mode.value,
-                            "scheduler_request_context": request_context is not None,
-                            "request_id": request_context.request_id if request_context is not None else None,
-                        },
-                    }
-                ],
-            )
-        except Exception as exc:
-            if self._control_error(exc).code == "resource_exhausted":
-                logger.info("open_duplex_session rejected: %s", exc)
-            else:
-                logger.exception("open_duplex_session failed: %s", exc)
-            if session is not None and self.sessions.get(message.session_id) is session:
-                reserved_request_ids = tuple(session.resource_request_ids())
-                self.sessions.begin_close_session(session.fence, reason="open_rollback")
-                cleanup_key = self._cleanup_key("open_rollback", session.fence)
-                pending = _PendingControlCleanup(
-                    kind="open_rollback",
-                    session_id=session.session_id,
-                    fence=session.fence,
-                    reserved_request_ids=reserved_request_ids,
-                    submitted_request_ids=(),
-                )
-                self._pending_control_cleanups[cleanup_key] = pending
-                try:
-                    await self._complete_control_cleanup(cleanup_key, pending)
-                except Exception as cleanup_exc:
-                    logger.warning(
-                        "duplex open rollback remains pending for session %s: %s",
-                        session.session_id,
-                        cleanup_exc,
-                    )
-            await self.put_result(
-                message.control_id,
-                fence=message.fence,
-                operation="open",
-                session_id=message.session_id,
-                stage_results=[],
-                error=exc,
-            )
-
-    async def handle_append(self, message: AppendDuplexInputMessage) -> None:
-        session: DuplexSessionRuntimeState | None = None
-        lease_operation_id = f"append:{message.control_id}"
-        operation_started = False
-        try:
-            session = self.sessions.require(message.session_id)
-            await self._complete_pending_submission_cleanup(message.session_id)
-            if message.expected_epoch is not None and message.expected_epoch != message.fence.epoch:
-                raise ValueError("expected_epoch must match fence.epoch")
-            mode = DuplexInputMode(message.mode)
-            if message.operation_id is not None:
-                completed = session.completed_append(
-                    message.operation_id,
-                    fence=message.fence,
-                    mode=mode,
-                    final=message.final,
-                )
-                if completed is not None:
-                    session.touch(message.fence, DuplexLeaseActivity.APPEND)
-                    await self.put_result(
-                        message.control_id,
-                        fence=message.fence,
-                        operation="append",
-                        session_id=message.session_id,
-                        stage_results=completed,
-                    )
-                    return
-            session.begin_operation(message.fence, lease_operation_id)
-            operation_started = True
-            reservation = session.prepare_append(mode=mode, fence=message.fence)
-            stage_results = await self.append_via_data_plane(
-                message,
-                session=session,
-                reservation=reservation,
-                mode=mode,
-            )
-            if message.operation_id is not None:
-                session.record_completed_append(
-                    message.operation_id,
-                    fence=message.fence,
-                    mode=mode,
-                    final=message.final,
-                    stage_results=stage_results,
-                )
-            await self.put_result(
-                message.control_id,
-                fence=message.fence,
-                operation="append",
-                session_id=message.session_id,
-                stage_results=stage_results,
-            )
-        except Exception as exc:
-            logger.exception("append_duplex_input failed: %s", exc)
-            await self.put_result(
-                message.control_id,
-                fence=message.fence,
-                operation="append",
-                session_id=message.session_id,
-                stage_results=[],
-                error=exc,
-            )
-        finally:
-            if session is not None and operation_started and lease_operation_id in session.lease.active_operations:
-                session.end_operation(session.fence, lease_operation_id)
-
-    async def append_via_data_plane(
-        self,
-        message: AppendDuplexInputMessage,
-        *,
-        session: DuplexSessionRuntimeState,
-        reservation: DuplexAppendReservation,
-        mode: DuplexInputMode,
-    ) -> list[dict[str, object]]:
-        if self._extension is None and mode is DuplexInputMode.TURN_COMMIT_ONLY:
-            update = session.commit_append(reservation)
-            return [
-                {
-                    "stage_id": -1,
-                    "replica_id": -1,
-                    "result": {
-                        "supported": True,
-                        "data_plane_append": False,
-                        "seq": update.seq,
-                        "turn_id": update.turn_id,
-                        "turn_seq": update.turn_seq,
-                        "mode": mode.value,
-                    },
-                }
-            ]
-        if self._stage_port.stage_count == 0:
-            return [
-                {
-                    "stage_id": -1,
-                    "replica_id": -1,
-                    "result": {"supported": False, "error": "duplex_data_plane_has_no_stage"},
-                }
-            ]
-        if self._extension is None:
-            raise RuntimeError("duplex_runtime_extension_not_configured")
-
-        stage_id = 0
-        request_id = self.stage_request_id(message.fence, stage_id=stage_id)
-        existing_binding = session.stage_bindings.get(stage_id)
-        already_submitted = existing_binding is not None and existing_binding.request_id == request_id
-        request_context = self.ensure_stage_request(
-            session,
-            stage_id=stage_id,
-            fence=message.fence,
-        )
-        if request_context is None:
-            raise RuntimeError("duplex_data_plane_has_no_stage")
-        append_plan = self._extension.plan_append(
-            request_id=request_id,
-            fence=message.fence,
-            session_config=dict(request_context.session_config),
-            runtime_config=dict(request_context.runtime_config),
-            seq=reservation.update.seq,
-            turn_seq=reservation.update.turn_seq,
-            mode=mode,
-            payload=message.payload,
-            final=message.final,
-            sampling_params=request_context.stage_sampling_params,
-        )
-        if not isinstance(append_plan, DuplexAppendPlan):
-            raise TypeError("duplex runtime extension plan_append() must return DuplexAppendPlan")
-        submission = DuplexStageSubmission(
-            context=request_context,
-            prompt=append_plan.prompt,
-            already_submitted=already_submitted,
-        )
-        submission_result = await self._stage_port.submit(submission)
-        try:
-            if submission_result.request_id != request_id or submission_result.stage_id != stage_id:
-                raise RuntimeError("duplex stage adapter returned a mismatched submission result")
-            update = session.commit_append(reservation)
-            session.bind_stage_request(stage_id, request_id, fence=message.fence)
-        except BaseException:
-            self._pending_submission_cleanups[session.session_id] = _PendingSubmissionCleanup(
-                session_id=session.session_id,
-                request_ids=(request_id,),
-            )
-            try:
-                await self._complete_pending_submission_cleanup(session.session_id)
-            except Exception as cleanup_exc:
-                logger.warning(
-                    "duplex append compensation remains pending for session %s: %s",
-                    session.session_id,
-                    cleanup_exc,
-                )
-            raise
-        return [
-            {
-                "stage_id": stage_id,
-                "replica_id": submission_result.replica_id,
-                "result": {
-                    "supported": True,
-                    "implementation_level": session.capabilities.implementation_level,
-                    "data_plane_append": True,
-                    "request_id": request_id,
-                    "response_stage_id": request_context.final_stage_id,
-                    "seq": update.seq,
-                    "turn_id": update.turn_id,
-                    "response_seq": message.fence.response_seq,
-                    "turn_seq": update.turn_seq,
-                    "mode": mode.value,
-                    "resumable": True,
-                },
-            }
-        ]
-
-    async def handle_signal(self, message: SignalDuplexTurnMessage) -> None:
-        try:
-            cancel_events = {"barge_in", "input.cancel", "response.cancel"}
-            if message.event not in {*cancel_events, "session.update"}:
-                raise ValueError(f"unsupported duplex runtime signal: {message.event}")
-            session = self.sessions.require(message.session_id)
-            await self._complete_pending_submission_cleanup(message.session_id)
-            effective_next_fence = message.next_fence
-            if message.event in cancel_events:
-                if effective_next_fence is None:
-                    raise ValueError(f"{message.event} requires next_fence")
-                cleanup_key = self._cleanup_key("cancel", message.fence)
-                pending = self._pending_control_cleanups.get(cleanup_key)
-                if pending is None:
-                    stale_request_ids = session.prepare_cancel_fence(message.fence, effective_next_fence)
-                    pending = _PendingControlCleanup(
-                        kind="cancel",
-                        session_id=message.session_id,
-                        fence=message.fence,
-                        submitted_request_ids=tuple(stale_request_ids),
-                    )
-                    self._pending_control_cleanups[cleanup_key] = pending
-                await self._complete_control_cleanup(cleanup_key, pending)
-            else:
-                session.accept_fence(message.fence)
-            if message.runtime_config is not None:
-                self.sampling_params_for_config(message.runtime_config)
-            session.replace_configs(
-                session_config=message.session_config,
-                runtime_config=message.runtime_config,
-            )
-            session.touch(session.fence, DuplexLeaseActivity.SIGNAL)
-            await self.put_result(
-                message.control_id,
-                fence=message.fence,
-                operation="signal",
-                session_id=message.session_id,
-                stage_results=[
-                    {
-                        "stage_id": -1,
-                        "replica_id": -1,
-                        "result": {
-                            "supported": True,
-                            "data_plane_signal": True,
-                            "event": message.event,
-                            "fence": message.fence,
-                            "next_fence": effective_next_fence,
-                        },
-                    }
-                ],
-            )
-        except Exception as exc:
-            logger.exception("signal_duplex_turn failed: %s", exc)
-            await self.put_result(
-                message.control_id,
-                fence=message.fence,
-                operation="signal",
-                session_id=message.session_id,
-                stage_results=[],
-                error=exc,
-            )
-
-    async def handle_close(self, message: CloseDuplexSessionMessage) -> None:
-        try:
-            await self._complete_pending_submission_cleanup(message.session_id)
-            session = self.sessions.get(message.session_id)
-            if session is None:
-                await self.put_result(
-                    message.control_id,
-                    fence=message.fence,
-                    operation="close",
-                    session_id=message.session_id,
-                    stage_results=[],
-                )
-                return
-            cleanup_key = self._cleanup_key("close", message.fence)
-            pending = self._pending_control_cleanups.get(cleanup_key)
-            if pending is None:
-                submitted = tuple(session.resource_request_ids(submitted=True))
-                reserved = tuple(session.resource_request_ids(submitted=False))
-                self.sessions.begin_close_session(message.fence, reason=message.reason)
-                pending = _PendingControlCleanup(
-                    kind="close",
-                    session_id=message.session_id,
-                    fence=message.fence,
-                    submitted_request_ids=submitted,
-                    reserved_request_ids=reserved,
-                )
-                self._pending_control_cleanups[cleanup_key] = pending
-            await self._complete_control_cleanup(cleanup_key, pending)
-            await self.put_result(
-                message.control_id,
-                fence=message.fence,
-                operation="close",
-                session_id=message.session_id,
-                stage_results=[
-                    {
-                        "stage_id": -1,
-                        "replica_id": -1,
-                        "result": {
-                            "supported": True,
-                            "data_plane_close": True,
-                            "reason": message.reason,
-                        },
-                    }
-                ],
-            )
-        except Exception as exc:
-            logger.exception("close_duplex_session failed: %s", exc)
-            await self.put_result(
-                message.control_id,
-                fence=message.fence,
-                operation="close",
-                session_id=message.session_id,
-                stage_results=[],
-                error=exc,
-            )
-
-    async def handle_touch(self, message: TouchDuplexSessionMessage) -> None:
-        try:
-            session = self.sessions.require(message.session_id)
-            activity = DuplexLeaseActivity(message.activity)
-            if activity is DuplexLeaseActivity.DETACH:
-                session.detach(message.fence)
-            else:
-                session.touch(message.fence, activity)
-            await self.put_result(
-                message.control_id,
-                fence=message.fence,
-                operation="touch",
-                session_id=message.session_id,
-                stage_results=[
-                    {
-                        "stage_id": -1,
-                        "replica_id": -1,
-                        "result": {
-                            "supported": True,
-                            "activity": activity.value,
-                            "lease_generation": session.lease.generation,
-                        },
-                    }
-                ],
-            )
-        except Exception as exc:
-            logger.exception("touch_duplex_session failed: %s", exc)
-            await self.put_result(
-                message.control_id,
-                fence=message.fence,
-                operation="touch",
-                session_id=message.session_id,
-                stage_results=[],
-                error=exc,
-            )
-
-    async def handle_resume(self, message: ResumeDuplexSessionMessage) -> None:
-        try:
-            session = self.sessions.require(message.session_id)
-            generation = session.resume(
-                message.fence,
-                expected_lease_generation=message.expected_lease_generation,
-            )
-            await self.put_result(
-                message.control_id,
-                fence=message.fence,
-                operation="resume",
-                session_id=message.session_id,
-                stage_results=[
-                    {
-                        "stage_id": -1,
-                        "replica_id": -1,
-                        "result": {
-                            "supported": True,
-                            "lease_generation": generation,
-                        },
-                    }
-                ],
-            )
-        except Exception as exc:
-            logger.exception("resume_duplex_session failed: %s", exc)
-            await self.put_result(
-                message.control_id,
-                fence=message.fence,
-                operation="resume",
-                session_id=message.session_id,
-                stage_results=[],
-                error=exc,
-            )
-
-    async def reap_expired(self, now: float | None = None) -> int:
-        completed = 0
-        for session_id in list(self._pending_submission_cleanups):
-            try:
-                await self._complete_pending_submission_cleanup(session_id)
-            except Exception as exc:
-                logger.warning(
-                    "duplex append compensation remains pending for session %s: %s",
-                    session_id,
-                    exc,
-                )
-        for key, pending in list(self._pending_control_cleanups.items()):
-            try:
-                await self._complete_control_cleanup(key, pending)
-            except Exception as exc:
-                logger.warning(
-                    "duplex %s cleanup remains pending for session %s: %s",
-                    pending.kind,
-                    pending.session_id,
-                    exc,
-                )
-        for key, pending in list(self._pending_request_cleanups.items()):
-            if key in self._request_cleanups_in_progress:
-                continue
-            try:
-                await self._complete_request_cleanup(key, pending)
-            except Exception as exc:
-                logger.warning(
-                    "duplex request cleanup remains pending for session %s: %s",
-                    pending.session_id,
-                    exc,
-                )
-                continue
-            completed += 1
-        for item in self.sessions.collect_expired(
-            now,
-            excluded_session_ids=set(self._pending_submission_cleanups),
-        ):
-            self._pending_expirations.setdefault(
-                (item.session_id, item.lease_generation),
-                item,
-            )
-        for key, item in list(self._pending_expirations.items()):
-            try:
-                if item.submitted_request_ids:
-                    await self._stage_port.cleanup(list(item.submitted_request_ids), abort=True)
-                if item.reserved_request_ids:
-                    await self._stage_port.cleanup(list(item.reserved_request_ids))
-                if self._lifecycle_sink is not None:
-                    await self._lifecycle_sink.put(
-                        DuplexSessionLifecycleMessage(
-                            fence=item.fence,
-                            session_id=item.session_id,
-                            event="expired",
-                            reason=item.reason,
-                            lease_generation=item.lease_generation,
-                            submitted_request_ids=list(item.submitted_request_ids),
-                            reserved_request_ids=list(item.reserved_request_ids),
-                        )
-                    )
-            except Exception as exc:
-                logger.warning(
-                    "duplex expiry cleanup remains pending for session %s: %s",
-                    item.session_id,
-                    exc,
-                )
-                continue
-            session = self.sessions.get(item.session_id)
-            if session is not None and session.lease.generation == item.lease_generation:
-                self.sessions.finalize_close_session(session)
-            self._pending_expirations.pop(key, None)
-            completed += 1
-        return completed
-
-    async def _complete_pending_submission_cleanup(self, session_id: str) -> None:
-        pending = self._pending_submission_cleanups.get(session_id)
-        if pending is None:
-            return
-        task = self._submission_cleanup_tasks.get(session_id)
-        if task is not None and task.done():
-            self._submission_cleanup_tasks.pop(session_id, None)
-            task = None
-        if task is None:
-            task = asyncio.create_task(
-                self._run_submission_cleanup(pending),
-                name=f"duplex-append-compensation-{session_id}",
-            )
-            self._submission_cleanup_tasks[session_id] = task
-
-            def discard(completed: asyncio.Task[None]) -> None:
-                if self._submission_cleanup_tasks.get(session_id) is completed:
-                    self._submission_cleanup_tasks.pop(session_id, None)
-
-            task.add_done_callback(discard)
-        await asyncio.shield(task)
-
-    async def _run_submission_cleanup(self, pending: _PendingSubmissionCleanup) -> None:
-        await self._stage_port.cleanup(list(pending.request_ids), abort=True)
-        session = self.sessions.get(pending.session_id)
-        if session is not None:
-            session.release_request_ids(list(pending.request_ids))
-        if self._pending_submission_cleanups.get(pending.session_id) is pending:
-            self._pending_submission_cleanups.pop(pending.session_id, None)
-
-    async def _complete_request_cleanup(
-        self,
-        key: tuple[str, int, int],
-        pending: _PendingRequestCleanup,
-    ) -> None:
-        task = self._request_cleanup_tasks.get(key)
-        if task is not None and task.done():
-            self._request_cleanup_tasks.pop(key, None)
-            task = None
-        if task is None:
-            task = asyncio.create_task(
-                self._run_request_cleanup(key, pending),
-                name=f"duplex-request-cleanup-{pending.session_id}",
-            )
-            self._request_cleanup_tasks[key] = task
-
-            def discard(completed: asyncio.Task[None]) -> None:
-                if self._request_cleanup_tasks.get(key) is completed:
-                    self._request_cleanup_tasks.pop(key, None)
-
-            task.add_done_callback(discard)
-        await asyncio.shield(task)
-
-    async def _run_request_cleanup(
-        self,
-        key: tuple[str, int, int],
-        pending: _PendingRequestCleanup,
-    ) -> None:
-        await self._stage_port.cleanup(list(pending.request_ids), abort=pending.abort)
-        session = self.sessions.get(pending.session_id)
-        if (
-            session is not None
-            and session.fence.incarnation == pending.fence.incarnation
-            and session.lease.generation == pending.lease_generation
-        ):
-            self.sessions.finalize_close_session(session)
-        if self._pending_request_cleanups.get(key) is pending:
-            self._pending_request_cleanups.pop(key, None)
-            self._request_cleanups_in_progress.discard(key)
-
-    @staticmethod
-    def _cleanup_key(kind: str, fence: DuplexFence) -> tuple[str, str, int, int, int, int]:
-        return (kind, fence.session_id, fence.incarnation, fence.epoch, fence.turn_id, fence.response_seq)
-
-    async def _complete_control_cleanup(
-        self,
-        key: tuple[str, str, int, int, int, int],
-        pending: _PendingControlCleanup,
-    ) -> None:
-        task = self._control_cleanup_tasks.get(key)
-        if task is not None and task.done():
-            self._control_cleanup_tasks.pop(key, None)
-            task = None
-        if task is None:
-            task = asyncio.create_task(
-                self._run_control_cleanup(key, pending),
-                name=f"duplex-{pending.kind}-cleanup-{pending.session_id}",
-            )
-            self._control_cleanup_tasks[key] = task
-
-            def discard(completed: asyncio.Task[None]) -> None:
-                if self._control_cleanup_tasks.get(key) is completed:
-                    self._control_cleanup_tasks.pop(key, None)
-
-            task.add_done_callback(discard)
-        await asyncio.shield(task)
-
-    async def _run_control_cleanup(
-        self,
-        key: tuple[str, str, int, int, int, int],
-        pending: _PendingControlCleanup,
-    ) -> None:
-        if pending.submitted_request_ids:
-            await self._stage_port.cleanup(list(pending.submitted_request_ids), abort=True)
-        if pending.reserved_request_ids:
-            await self._stage_port.cleanup(list(pending.reserved_request_ids))
-        session = self.sessions.get(pending.session_id)
-        if session is not None:
-            if pending.kind == "cancel":
-                session.release_fence(pending.fence)
-            elif pending.kind in {"close", "open_rollback"}:
-                self.sessions.finalize_close_session(session)
-        self._pending_control_cleanups.pop(key, None)
-
-    @classmethod
-    def _iter_result_dicts(cls, result: object):
-        if isinstance(result, dict):
-            yield result
-        elif isinstance(result, list | tuple):
-            for item in result:
-                yield from cls._iter_result_dicts(item)
-
-    @classmethod
-    def _result_counts(cls, stage_results: list[dict[str, object]]) -> tuple[int, int]:
-        unsupported_count = 0
-        error_count = 0
-        for item in stage_results:
-            for result in cls._iter_result_dicts(item.get("result")):
-                if result.get("supported") is False:
-                    unsupported_count += 1
-                if result.get("error"):
-                    error_count += 1
-        return unsupported_count, error_count
-
-    async def put_result(
-        self,
-        control_id: str,
-        *,
-        fence: DuplexFence,
-        operation: str,
-        session_id: str,
-        stage_results: list[dict[str, object]],
-        error: BaseException | str | None = None,
-    ) -> None:
-        control_error = self._control_error(error) if error is not None else None
-        if error is not None:
-            stage_results = [
-                {
-                    "stage_id": -1,
-                    "replica_id": -1,
-                    "result": {"supported": False, "error": control_error.message},
-                }
-            ]
-        unsupported_count, error_count = self._result_counts(stage_results)
-        session = self.sessions.get(session_id)
-        await self._result_sink.put(
-            DuplexControlResultMessage(
-                control_id=control_id,
-                fence=fence,
-                operation=operation,
-                session_id=session_id,
-                ok=error_count == 0 and unsupported_count == 0,
-                stage_results=stage_results,
-                unsupported_count=unsupported_count,
-                error_count=error_count,
-                error=control_error,
-                accepted_fence=session.fence if session is not None else None,
-                lease_generation=session.lease.generation if session is not None else None,
-            )
-        )
-
-    @staticmethod
-    def _control_error(error: BaseException | str) -> DuplexControlError:
-        message = str(error)
-        if isinstance(error, DuplexFenceMismatchError):
-            code = "stale_fence"
-            retryable = False
-        elif "unknown duplex input mode" in message:
-            code = "invalid_capability"
-            retryable = False
-        elif "duplex_session_capacity_exhausted" in message:
-            code = "resource_exhausted"
-            retryable = True
-        elif isinstance(error, KeyError):
-            code = "not_found"
-            retryable = False
-        elif isinstance(error, (TypeError, ValueError)):
-            code = "invalid_argument"
-            retryable = False
-        elif isinstance(error, TimeoutError):
-            code = "timeout"
-            retryable = True
-        else:
-            code = "failed_precondition"
-            retryable = False
-        return DuplexControlError(code=code, message=message, retryable=retryable)
-
-    def decide_output(
-        self,
-        stage_id: int,
-        output: object,
-        context: DuplexOutputContext | None,
-    ) -> DuplexOutputDecision | None:
-        if context is None or self._extension is None:
-            return None
-        session = self._sessions.get(context.identity.session_id)
-        if session is None:
-            return None
-        try:
-            session.touch(context.identity.fence, DuplexLeaseActivity.MODEL_OUTPUT)
-        except RuntimeError:
-            return None
-        decision = self._extension.decide_output(
-            stage_id=stage_id,
-            final_stage_id=context.final_stage_id,
-            segment_finished=context.segment_finished,
-            segment_token_ids=context.segment_token_ids,
-            segment_output_metadata=dict(context.segment_output_metadata),
-            output=output,
-        )
-        if decision is not None and not isinstance(decision, DuplexOutputDecision):
-            raise TypeError("duplex runtime extension decide_output() must return DuplexOutputDecision or None")
-        return decision
-
-    def session_for_identity(self, identity: DuplexRequestIdentity | None) -> DuplexSessionRuntimeState | None:
-        if identity is None:
-            return None
-        return self._sessions.get(identity.session_id)
-
-    def close_sessions_for_request_ids(
-        self,
-        request_ids: list[str],
-        *,
-        abort: bool = False,
-        cleanup_in_progress: bool = False,
-    ) -> dict[str, list[str]]:
-        closed = self._sessions.close_sessions_for_request_ids(request_ids)
-        for session_id, stale_request_ids in closed.items():
-            session = self._sessions.get(session_id)
-            if session is None:
-                continue
-            key = (session_id, session.fence.incarnation, session.lease.generation)
-            existing = self._pending_request_cleanups.get(key)
-            merged_request_ids = tuple(
-                dict.fromkeys(
-                    [
-                        *(existing.request_ids if existing is not None else ()),
-                        *stale_request_ids,
-                    ]
-                )
-            )
-            self._pending_request_cleanups[key] = _PendingRequestCleanup(
-                session_id=session_id,
-                fence=session.fence,
-                lease_generation=session.lease.generation,
-                request_ids=merged_request_ids,
-                abort=abort or (existing.abort if existing is not None else False),
-            )
-            if cleanup_in_progress:
-                self._request_cleanups_in_progress.add(key)
-        return closed
-
-    def defer_request_cleanups(self, session_ids: Iterable[str]) -> None:
-        session_id_set = set(session_ids)
-        active_keys = {key for key in self._request_cleanups_in_progress if key[0] in session_id_set}
-        self._request_cleanups_in_progress.difference_update(active_keys)
-
-    def finalize_closed_sessions(self, session_ids: Iterable[str]) -> None:
-        session_id_set = set(session_ids)
-        for key in list(self._pending_request_cleanups):
-            if key[0] not in session_id_set:
-                continue
-            self._pending_request_cleanups.pop(key, None)
-            self._request_cleanups_in_progress.discard(key)
-        self._sessions.finalize_closed_sessions(session_ids)
-
-
-__all__ = [
-    "DuplexControlPlane",
-    "DuplexOutputContext",
-    "DuplexRequestIdentity",
-    "DuplexResultSink",
-    "DuplexLifecycleSink",
-    "DuplexStagePort",
-    "DuplexStageRequestContext",
-    "DuplexStageSubmission",
-    "DuplexStageSubmissionResult",
-]
diff --git a/vllm_omni/engine/duplex/events.py b/vllm_omni/engine/duplex/events.py
new file mode 100644
index 000000000..197dec613
--- /dev/null
+++ b/vllm_omni/engine/duplex/events.py
@@ -0,0 +1,157 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""The event vocabulary one duplex session speaks, assembled from two layers.
+
+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.
+
+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
+
+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,
+)
+
+DOMAIN_TERMINAL_EVENTS = frozenset(
+    {
+        "response.done",
+        "response.listen",
+        "audio.cancelled",
+        "input.cancelled",
+        "session.closed",
+    }
+)
+
+MODEL_OUTPUT_EVENTS = frozenset(
+    {
+        "response.created",
+        "response.listen",
+        "response.speak",
+        "response.output_item.added",
+        "response.content_part.added",
+        "response.output_audio.delta",
+        "response.output_audio.done",
+        "response.output_text.delta",
+        "response.output_text.done",
+        "response.text.delta",
+        "response.text.done",
+        "response.message",
+        "response.output_item.done",
+        "response.content_part.done",
+        "response.done",
+    }
+)
+
+
+__all__ = [
+    "AudioDelta",
+    "AudioDone",
+    "ContentPartAdded",
+    "ContentPartDone",
+    "DOMAIN_TERMINAL_EVENTS",
+    "DuplexEvent",
+    "DuplexRawEvent",
+    "ErrorEvent",
+    "FunctionCallArgumentsDelta",
+    "FunctionCallArgumentsDone",
+    "InputCleared",
+    "InputCommitted",
+    "InputTranscriptionCompleted",
+    "ItemAdded",
+    "ItemCreated",
+    "ItemDeleted",
+    "ItemDone",
+    "ItemRetrieved",
+    "ItemTruncated",
+    "Listen",
+    "MODEL_OUTPUT_EVENTS",
+    "OutputAudioCleared",
+    "OutputItemAdded",
+    "OutputItemDone",
+    "OverlapDecision",
+    "PlaybackAcknowledged",
+    "REALTIME_ERROR_TYPES_BY_CODE",
+    "RateLimitsUpdated",
+    "ResponseCreated",
+    "ResponseDone",
+    "SessionClosed",
+    "SessionCreated",
+    "SessionExpired",
+    "SessionHeartbeatAck",
+    "SessionReplaced",
+    "SessionResumed",
+    "SessionResyncRequired",
+    "SessionUpdated",
+    "Speak",
+    "SpeechStarted",
+    "SpeechStopped",
+    "TextDelta",
+    "TextDone",
+    "TranscriptDelta",
+    "TranscriptDone",
+    "TurnEvent",
+    "error_event",
+    "new_event_id",
+]
diff --git a/vllm_omni/engine/duplex/messages.py b/vllm_omni/engine/duplex/messages.py
index 2c49d573f..ad264e0c5 100644
--- a/vllm_omni/engine/duplex/messages.py
+++ b/vllm_omni/engine/duplex/messages.py
@@ -1,130 +1,114 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
-"""Queue contracts owned by the experimental duplex control plane."""
+"""Queue envelopes exchanged between ``DuplexOmniEngine`` and ``DuplexOrchestrator``.
+
+Sessions live inside the engine (``DuplexSessionRunner`` on the orchestrator
+loop). The API layer only opens/closes/resumes/touches sessions through
+correlated RPC and pushes ``DuplexCommand`` objects one-way; every session
+output travels back as a ``DuplexSessionEventMessage``.
+"""
 
 from __future__ import annotations
 
-from dataclasses import dataclass
-from typing import Literal
+from typing import TYPE_CHECKING, Literal
 
 from vllm_omni.engine.messages import EngineQueueMessage
 
+if TYPE_CHECKING:
+    from vllm_omni.engine.duplex.commands import DuplexCommand
+    from vllm_omni.engine.duplex.config import DuplexCapabilities, DuplexSessionConfig
+    from vllm_omni.engine.duplex.events import DuplexEvent
 
-@dataclass(frozen=True, slots=True)
-class DuplexFence:
-    """Identity fence carried by experimental duplex control messages."""
 
-    session_id: str
-    epoch: int = 0
-    turn_id: int = 0
-    response_seq: int = 0
-    incarnation: int = 0
+class DuplexSessionError(RuntimeError):
+    """A session control operation was rejected by the engine."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        code: str = "internal_error",
+        retryable: bool = False,
+        session_id: str | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.code = code
+        self.retryable = retryable
+        self.session_id = session_id
 
 
 class OpenDuplexSessionMessage(EngineQueueMessage, kw_only=True):
     type: Literal["open_duplex_session"] = "open_duplex_session"
     control_id: str
-    fence: DuplexFence
     session_id: str
-    session_mode: str = "duplex"
-    capabilities: dict[str, object]
-    session_config: dict[str, object] | None = None
-    runtime_config: dict[str, object] | None = None
-
-
-class AppendDuplexInputMessage(EngineQueueMessage, kw_only=True):
-    type: Literal["append_duplex_input"] = "append_duplex_input"
-    control_id: str
-    operation_id: str | None = None
-    fence: DuplexFence
-    session_id: str
-    expected_epoch: int | None = None
-    mode: str
-    payload: object
-    final: bool = False
-
-
-class SignalDuplexTurnMessage(EngineQueueMessage, kw_only=True):
-    type: Literal["signal_duplex_turn"] = "signal_duplex_turn"
-    control_id: str
-    fence: DuplexFence
-    session_id: str
-    event: str
-    next_fence: DuplexFence | None = None
-    session_config: dict[str, object] | None = None
-    runtime_config: dict[str, object] | None = None
+    #: Already normalized by ``DuplexOmni``; the queue is in-process, so the object crosses as is.
+    session_config: DuplexSessionConfig
 
 
 class CloseDuplexSessionMessage(EngineQueueMessage, kw_only=True):
     type: Literal["close_duplex_session"] = "close_duplex_session"
     control_id: str
-    fence: DuplexFence
     session_id: str
     reason: str = "client_close"
 
 
-class TouchDuplexSessionMessage(EngineQueueMessage, kw_only=True):
-    type: Literal["touch_duplex_session"] = "touch_duplex_session"
-    control_id: str
-    fence: DuplexFence
-    session_id: str
-    activity: str
-
-
 class ResumeDuplexSessionMessage(EngineQueueMessage, kw_only=True):
     type: Literal["resume_duplex_session"] = "resume_duplex_session"
     control_id: str
-    fence: DuplexFence
     session_id: str
     expected_lease_generation: int
 
 
-class DuplexSessionLifecycleMessage(EngineQueueMessage, kw_only=True):
-    type: Literal["duplex_session_lifecycle"] = "duplex_session_lifecycle"
-    fence: DuplexFence
+class TouchDuplexSessionMessage(EngineQueueMessage, kw_only=True):
+    type: Literal["touch_duplex_session"] = "touch_duplex_session"
+    control_id: str
     session_id: str
-    event: str
-    reason: str
-    lease_generation: int
-    submitted_request_ids: list[str]
-    reserved_request_ids: list[str]
+    activity: str
 
 
-class DuplexControlError(EngineQueueMessage, kw_only=True):
-    code: str
-    message: str
-    retryable: bool = False
+class DuplexSessionCommandMessage(EngineQueueMessage, kw_only=True):
+    """One-way session command; rejections come back as ``ErrorEvent``."""
+
+    type: Literal["duplex_session_command"] = "duplex_session_command"
+    session_id: str
+    command: DuplexCommand
 
 
 class DuplexControlResultMessage(EngineQueueMessage, kw_only=True):
     type: Literal["duplex_control_result"] = "duplex_control_result"
     control_id: str
-    fence: DuplexFence
     operation: str
     session_id: str
     ok: bool
-    stage_results: list[dict[str, object]]
-    unsupported_count: int = 0
-    error_count: int = 0
-    error: DuplexControlError | None = None
-    accepted_fence: DuplexFence | None = None
     lease_generation: int | None = None
+    capabilities: DuplexCapabilities | None = None
+    #: The Realtime ``session`` object of the session (wire payload, already a dict).
+    public_session: dict[str, object] | None = None
+    error_code: str | None = None
+    error_message: str | None = None
+    error_retryable: bool = False
 
     @property
     def rpc_correlation_key(self) -> tuple[str, str]:
         return ("duplex", self.control_id)
 
 
+class DuplexSessionEventMessage(EngineQueueMessage, kw_only=True):
+    """A typed session event on the engine output queue."""
+
+    type: Literal["duplex_session_event"] = "duplex_session_event"
+    session_id: str
+    event: DuplexEvent
+
+
 __all__ = [
-    "AppendDuplexInputMessage",
     "CloseDuplexSessionMessage",
-    "DuplexControlError",
     "DuplexControlResultMessage",
-    "DuplexFence",
-    "DuplexSessionLifecycleMessage",
+    "DuplexSessionCommandMessage",
+    "DuplexSessionError",
+    "DuplexSessionEventMessage",
     "OpenDuplexSessionMessage",
     "ResumeDuplexSessionMessage",
-    "SignalDuplexTurnMessage",
     "TouchDuplexSessionMessage",
 ]
diff --git a/vllm_omni/engine/duplex/plugin.py b/vllm_omni/engine/duplex/plugin.py
new file mode 100644
index 000000000..1e2517ef6
--- /dev/null
+++ b/vllm_omni/engine/duplex/plugin.py
@@ -0,0 +1,351 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Model plugin contract for full-duplex models.
+
+One ``DuplexModelPlugin`` subclass per model binds what used to be two dotted
+paths (the engine ``DuplexRuntimeExtension`` and the serving
+``ServingRuntimeAdapter``). Everything runs engine-side now, so the plugin is
+loaded once by ``DuplexOmniEngine`` and handed to ``DuplexOrchestrator`` /
+``DuplexSessionManager``.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from abc import ABC, abstractmethod
+from collections.abc import Callable, Iterable, Mapping
+from importlib import import_module
+from typing import TYPE_CHECKING
+
+from vllm_omni.engine.duplex.config import DuplexCapabilities, DuplexSessionConfig
+from vllm_omni.engine.duplex.contracts import (
+    DuplexAppendPlan,
+    DuplexFence,
+    DuplexOutputDecision,
+)
+
+if TYPE_CHECKING:
+    from vllm.config import ModelConfig
+
+
+class DuplexRuntimeConfigError(ValueError):
+    """A model plugin rejected client-visible runtime configuration."""
+
+    def __init__(self, message: str, *, code: str = "invalid_duplex_runtime_config") -> None:
+        super().__init__(message)
+        self.code = code
+
+
+def reject_changed_runtime_value(
+    new_value: object,
+    current_value: object,
+    *,
+    message: str,
+    code: str,
+    error_cls: type[DuplexRuntimeConfigError] = DuplexRuntimeConfigError,
+) -> None:
+    if new_value != current_value:
+        raise error_cls(message, code=code)
+
+
+class PcmAppendReservation(ABC):
+    operation_id: str
+    payload: dict[str, object] | None
+
+    @property
+    @abstractmethod
+    def active(self) -> bool: ...
+
+    @property
+    @abstractmethod
+    def byte_count(self) -> int: ...
+
+    @abstractmethod
+    def commit(self) -> None: ...
+
+    @abstractmethod
+    def rollback(self) -> None: ...
+
+
+class PcmAppendBuffer(ABC):
+    @property
+    @abstractmethod
+    def pending_byte_count(self) -> int: ...
+
+    @abstractmethod
+    def clear(self) -> None: ...
+
+    @abstractmethod
+    def clear_force_listen(self) -> None: ...
+
+    @abstractmethod
+    def has_pending(self) -> bool: ...
+
+    @abstractmethod
+    def has_reserved(self) -> bool: ...
+
+    @abstractmethod
+    def prepare_append(
+        self,
+        payload: dict[str, object],
+        *,
+        operation_id: str,
+        chunk_period_ms: int,
+        allow_emit: bool,
+    ) -> PcmAppendReservation | None: ...
+
+    @abstractmethod
+    def prepare_commit(
+        self,
+        *,
+        operation_id: str,
+        chunk_period_ms: int,
+    ) -> PcmAppendReservation: ...
+
+    @abstractmethod
+    def flush(self, *, chunk_period_ms: int) -> dict[str, object] | None: ...
+
+
+class DuplexModelSessionState(ABC):
+    """Model-owned per-session state; owned by the session runner (one per session)."""
+
+    audio_buffer: PcmAppendBuffer
+    input_since_commit: bool
+    speech_since_commit: bool
+    context_locked: bool
+    committed_audio_payload: dict[str, object] | None
+    committed_audio_operation_id: str | None
+    committed_audio_reserved_bytes: int
+    deferred_response_create: bool
+    deferred_precreate_response: bool
+    continuation_owner_id: str | None
+    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(
+        self,
+        payload: dict[str, object],
+        *,
+        operation_id: str | None,
+        reserved_bytes: int = 0,
+    ) -> None: ...
+
+    @abstractmethod
+    def clear_committed_audio(self) -> int: ...
+
+    @abstractmethod
+    def clear_continuation(self) -> None: ...
+
+
+class DuplexDataPlane(ABC):
+    """Projects raw stage outputs of one model into internal duplex events."""
+
+    @abstractmethod
+    def begin_request(self, request_id: str) -> None: ...
+
+    @abstractmethod
+    def is_terminal(self, request_id: str | None) -> bool: ...
+
+    @abstractmethod
+    def mark_terminal(self, request_id: str) -> None: ...
+
+    @abstractmethod
+    def close_stream(self, request_id: str) -> None: ...
+
+    @abstractmethod
+    def close_session(self, session_id: str, *, active_request_id: str | None = None) -> None: ...
+
+    @abstractmethod
+    def project(self, result: object, *, context: object | None = None) -> Iterable[dict[str, object]]: ...
+
+
+EncodeAudio = Callable[[object, int, str, float | None], str | None]
+
+
+class DuplexModelPlugin(ABC):
+    """Everything vLLM-Omni needs to know about one full-duplex model.
+
+    Engine policy (sampling params, append planning, output decisions) and
+    session policy (capabilities, runtime configuration, per-session state,
+    data-plane projection) live on the same object so a mismatch between the
+    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.
+    silence_continuation_samples: int = 16000
+    data_plane: DuplexDataPlane
+
+    def __init__(self, encode_audio: EncodeAudio) -> None:
+        # Constructor-only: concrete plugins hand the encoder to their data plane.
+        del encode_audio
+
+    # ---- engine policy (was DuplexRuntimeExtension) ----
+
+    @abstractmethod
+    def configure_sampling_params(
+        self,
+        *,
+        runtime_config: dict[str, object],
+        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,
+        *,
+        request_id: str,
+        fence: DuplexFence,
+        session_config: dict[str, object],
+        runtime_config: dict[str, object],
+        seq: int,
+        turn_seq: int,
+        payload: object,
+        final: bool,
+        sampling_params: object,
+    ) -> DuplexAppendPlan: ...
+
+    @abstractmethod
+    def decide_output(
+        self,
+        *,
+        stage_id: int,
+        final_stage_id: int,
+        segment_finished: bool,
+        segment_token_ids: tuple[int, ...],
+        segment_output_metadata: dict[str, object],
+        output: object,
+    ) -> DuplexOutputDecision | None: ...
+
+    # ---- session policy (was ServingRuntimeAdapter) ----
+
+    @abstractmethod
+    def create_session_state(self) -> DuplexModelSessionState: ...
+
+    @abstractmethod
+    def capabilities(self, *, max_sessions: int) -> DuplexCapabilities: ...
+
+    @abstractmethod
+    def validate_client_extra_body(self, extra_body: object) -> None: ...
+
+    @abstractmethod
+    async def prepare_runtime_config(
+        self, config: DuplexSessionConfig, *, model_config: ModelConfig | None
+    ) -> dict[str, object]: ...
+
+    @abstractmethod
+    def runtime_config_for_update(
+        self,
+        config: DuplexSessionConfig,
+        current: Mapping[str, object],
+    ) -> dict[str, object]: ...
+
+    @abstractmethod
+    def data_plane_context(
+        self,
+        *,
+        epoch: int,
+        turn_id: int,
+        active_response_turn_id: int | None,
+        active_response_id: str | None,
+        auto_responds: bool,
+        response_format: str,
+        speed: float | None,
+        modalities: tuple[str, ...],
+    ) -> object: ...
+
+    # Optional hook: build the runtime config patch for a function-call output
+    # item. Plugins without tools keep the default (no change).
+    def runtime_config_for_function_output(
+        self,
+        config: DuplexSessionConfig,
+        current: Mapping[str, object],
+        item: Mapping[str, object],
+    ) -> dict[str, object] | None:
+        del config, current, item
+        return None
+
+
+def load_duplex_plugin(path: str, encode_audio: EncodeAudio) -> DuplexModelPlugin:
+    module_name, separator, attribute_name = path.rpartition(".")
+    if not separator:
+        raise ValueError(f"Invalid duplex plugin path: {path!r}")
+    plugin_type = getattr(import_module(module_name), attribute_name)
+    plugin = plugin_type(encode_audio)
+    if not isinstance(plugin, DuplexModelPlugin):
+        raise TypeError(f"{path!r} is not a DuplexModelPlugin")
+    if not plugin.plugin_id:
+        raise TypeError("Duplex plugin must declare plugin_id")
+    if not isinstance(getattr(plugin, "data_plane", None), DuplexDataPlane):
+        raise TypeError("Duplex plugin must declare a DuplexDataPlane as data_plane")
+    return plugin
+
+
+def validate_duplex_plugin_sampling(plugin: DuplexModelPlugin, *, sampling_defaults: tuple[object, ...]) -> None:
+    """Fail fast when the plugin cannot produce one sampling parameter per stage."""
+    configured = plugin.configure_sampling_params(runtime_config={}, defaults=sampling_defaults)
+    if not isinstance(configured, tuple):
+        raise TypeError("Duplex plugin must return sampling parameters as a tuple")
+    if len(configured) != len(sampling_defaults):
+        raise ValueError("Duplex plugin must return one sampling parameter per stage")
+    for stage_id, (value, default) in enumerate(zip(configured, sampling_defaults, strict=True)):
+        if default is not None and not isinstance(value, type(default)):
+            raise TypeError(
+                "Duplex plugin sampling parameter type mismatch "
+                f"for stage {stage_id}: expected {type(default).__name__}, got {type(value).__name__}"
+            )
+
+
+def payload_turn_id(payload: object) -> int | None:
+    if not isinstance(payload, Mapping):
+        return None
+    return coerce_int(payload.get("duplex_turn_id", payload.get("model_turn_id")))
+
+
+def coerce_int(value: object) -> int | 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__ = [
+    "DuplexDataPlane",
+    "DuplexModelPlugin",
+    "DuplexModelSessionState",
+    "DuplexRuntimeConfigError",
+    "EncodeAudio",
+    "PcmAppendBuffer",
+    "PcmAppendReservation",
+    "coerce_int",
+    "load_duplex_plugin",
+    "payload_turn_id",
+    "reject_changed_runtime_value",
+    "validate_duplex_plugin_sampling",
+]
diff --git a/vllm_omni/engine/duplex/realtime_commands.py b/vllm_omni/engine/duplex/realtime_commands.py
new file mode 100644
index 000000000..31b1c0949
--- /dev/null
+++ b/vllm_omni/engine/duplex/realtime_commands.py
@@ -0,0 +1,382 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""OpenAI Realtime client events -> :class:`DuplexCommand` (stateless).
+
+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
+
+from collections.abc import Mapping
+from typing import cast
+
+from vllm_omni.engine.duplex.commands import (
+    AckPlayback,
+    AppendAudio,
+    AppendText,
+    BargeIn,
+    CancelInput,
+    CancelResponse,
+    ClearInput,
+    ClearOutputAudio,
+    CloseSession,
+    Commit,
+    CreateItem,
+    CreateResponse,
+    DeleteItem,
+    DuplexCommand,
+    DuplexCommandError,
+    Heartbeat,
+    SignalTurn,
+    TruncateItem,
+    UpdateSession,
+)
+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,
+)
+
+
+def _validate_duplex_turn_detection(session_payload: Mapping[str, object]) -> str | None:
+    """The duplex engine's answer for ``turn_detection`` on a session object.
+
+    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
+
+    return validate_realtime_turn_detection(session_payload)
+
+
+#: 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"
+    if normalized in {"g711_ulaw", "g711_alaw"}:
+        return "pcm"
+    if normalized in {"wav", "pcm"}:
+        return normalized
+    return "wav"
+
+
+# ---- append / item audio conversion ----
+
+
+def build_append_audio(
+    event: Mapping[str, object],
+    *,
+    defaults: RealtimeInputDefaults,
+    hints_source: Mapping[str, object] | None = None,
+) -> AppendAudio:
+    """Decode one audio append (shared codec) and pack it as the duplex command."""
+    try:
+        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=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,
+    )
+
+
+# ---- translation ----
+
+
+def translate_realtime_command(
+    payload: Mapping[str, object],
+    *,
+    defaults: RealtimeInputDefaults | None = None,
+) -> DuplexCommand:
+    """Map one OpenAI Realtime client event onto a :class:`DuplexCommand`.
+
+    Raises :class:`DuplexCommandError` for malformed or unsupported payloads.
+    ``session.resume`` and ``session.event_ack`` are transport concerns and are
+    rejected with ``code="unknown_event"``.
+    """
+    defaults = defaults or RealtimeInputDefaults()
+    event_type = payload.get("type")
+    event_id = cast("str", payload.get("event_id")) if isinstance(payload.get("event_id"), str) else None
+    if not isinstance(event_type, str):
+        raise DuplexCommandError("Duplex event missing string type", code="bad_event", event_id=event_id)
+
+    if event_type == "session.update":
+        session = payload.get("session")
+        session_payload: Mapping[str, object] = session if isinstance(session, dict) else payload
+        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":
+        item = payload.get("item")
+        format_error = validate_conversation_item_audio_formats(item)
+        if format_error is not None:
+            raise DuplexCommandError(format_error, code="unsupported_audio_format", event_id=event_id)
+        if not isinstance(item, dict):
+            raise DuplexCommandError("conversation.item.create requires item", code="bad_event", event_id=event_id)
+        previous_item_id = payload.get("previous_item_id")
+        return CreateItem(
+            event_id=event_id,
+            item=normalize_conversation_item(item),
+            previous_item_id=previous_item_id if isinstance(previous_item_id, str) else None,
+        )
+
+    if event_type == "conversation.item.delete":
+        item_id = payload.get("item_id")
+        if not isinstance(item_id, str) or not item_id:
+            raise DuplexCommandError(
+                "conversation.item.delete requires item_id", code="missing_item_id", event_id=event_id
+            )
+        return DeleteItem(event_id=event_id, item_id=item_id)
+
+    if event_type == "conversation.item.truncate":
+        item_id = payload.get("item_id")
+        audio_end_ms = payload.get("audio_end_ms")
+        content_index = payload.get("content_index", 0)
+        if not isinstance(item_id, str) or not item_id:
+            raise DuplexCommandError(
+                "conversation.item.truncate requires item_id", code="missing_item_id", event_id=event_id
+            )
+        if not isinstance(audio_end_ms, int | float):
+            raise DuplexCommandError(
+                "conversation.item.truncate requires numeric audio_end_ms", code="bad_event", event_id=event_id
+            )
+        return TruncateItem(
+            event_id=event_id,
+            item_id=item_id,
+            audio_end_ms=int(audio_end_ms),
+            content_index=int(content_index) if isinstance(content_index, int | float) else 0,
+        )
+
+    if event_type == "input_audio_buffer.append":
+        return build_append_audio(dict(payload), defaults=defaults)
+
+    if event_type in {"input_audio_buffer.commit", "input.commit"}:
+        final = payload.get("final", True)
+        create_response = payload.get("response_create", payload.get("create_response"))
+        is_speech = payload.get("is_speech")
+        return Commit(
+            event_id=event_id,
+            final=bool(final) if isinstance(final, bool) else True,
+            create_response=(
+                bool(create_response)
+                if isinstance(create_response, bool)
+                else (True if event_type == "input.commit" and create_response is None else None)
+            ),
+            is_speech=is_speech if isinstance(is_speech, bool) else None,
+        )
+
+    if event_type == "input_audio_buffer.clear":
+        return ClearInput(event_id=event_id)
+
+    if event_type == "output_audio_buffer.clear":
+        response_id = payload.get("response_id")
+        return ClearOutputAudio(
+            event_id=event_id,
+            response_id=response_id if isinstance(response_id, str) and response_id else None,
+        )
+
+    if event_type == "response.cancel":
+        response_id = payload.get("response_id")
+        return CancelResponse(
+            event_id=event_id,
+            response_id=response_id if isinstance(response_id, str) and response_id else None,
+        )
+
+    if event_type == "response.create":
+        response_payload = payload.get("response")
+        if isinstance(response_payload, dict):
+            format_error = validate_realtime_response_audio_formats(response_payload)
+            if format_error is not None:
+                raise DuplexCommandError(format_error, code="unsupported_audio_format", event_id=event_id)
+        return CreateResponse(
+            event_id=event_id,
+            options=dict(response_payload) if isinstance(response_payload, dict) else {},
+        )
+
+    if event_type in {"playback.ack", "audio.playback_ack"}:
+        played_ms = payload.get("played_ms")
+        if not isinstance(played_ms, int | float):
+            raise DuplexCommandError("playback.ack requires numeric played_ms", code="bad_event", event_id=event_id)
+        committed_ms = payload.get("committed_ms")
+        response_id = payload.get("response_id")
+        item_id = payload.get("item_id")
+        return AckPlayback(
+            event_id=event_id,
+            played_ms=int(played_ms),
+            committed_ms=int(committed_ms) if isinstance(committed_ms, int | float) else None,
+            response_id=response_id if isinstance(response_id, str) and response_id else None,
+            item_id=item_id if isinstance(item_id, str) and item_id else None,
+        )
+
+    if event_type == "session.heartbeat":
+        return Heartbeat(event_id=event_id)
+
+    if event_type == "conversation.item.retrieve":
+        # The projected conversation items live engine-side; the runner answers.
+        return SignalTurn(event_id=event_id, event="conversation.item.retrieve", signal_payload=dict(payload))
+
+    if event_type in {"session.close", "close", "close_session"}:
+        reason = payload.get("reason")
+        return CloseSession(event_id=event_id, reason=reason if isinstance(reason, str) and reason else "client_close")
+
+    if event_type in {"input.text.append", "input_text.append", "push_text"}:
+        text = payload.get("text")
+        if not isinstance(text, str):
+            raise DuplexCommandError("input.text.append requires text", code="bad_event", event_id=event_id)
+        return AppendText(event_id=event_id, text=text)
+
+    if event_type == "input.cancel":
+        return CancelInput(event_id=event_id)
+
+    if event_type == "barge_in":
+        return BargeIn(event_id=event_id)
+
+    if event_type in {"turn.signal", "signal_turn"}:
+        signal_event = payload.get("event")
+        if not isinstance(signal_event, str) or not signal_event:
+            raise DuplexCommandError("turn.signal requires event", code="bad_event", event_id=event_id)
+        signal_payload = payload.get("payload")
+        signal_payload = dict(signal_payload) if isinstance(signal_payload, dict) else {}
+        if signal_event == "input.cancel":
+            return CancelInput(event_id=event_id)
+        if signal_event == "barge_in":
+            return BargeIn(event_id=event_id)
+        if signal_event == "response.cancel":
+            response_id = signal_payload.get("response_id", payload.get("response_id"))
+            return CancelResponse(
+                event_id=event_id,
+                response_id=response_id if isinstance(response_id, str) and response_id else None,
+            )
+        if signal_event == "session.update":
+            return UpdateSession(event_id=event_id, patch=signal_payload)
+        if signal_event == "conversation.item.create":
+            item = signal_payload.get("item")
+            if not isinstance(item, dict):
+                raise DuplexCommandError("conversation.item.create requires item", code="bad_event", event_id=event_id)
+            previous_item_id = signal_payload.get("previous_item_id")
+            return CreateItem(
+                event_id=event_id,
+                item=normalize_conversation_item(item),
+                previous_item_id=previous_item_id if isinstance(previous_item_id, str) else None,
+            )
+        if signal_event == "conversation.item.delete":
+            item_id = signal_payload.get("item_id")
+            if not isinstance(item_id, str) or not item_id:
+                raise DuplexCommandError(
+                    "conversation.item.delete requires item_id", code="missing_item_id", event_id=event_id
+                )
+            return DeleteItem(event_id=event_id, item_id=item_id)
+        if signal_event == "conversation.item.truncate":
+            item_id = signal_payload.get("item_id")
+            audio_end_ms = signal_payload.get("audio_end_ms")
+            content_index = signal_payload.get("content_index", 0)
+            if not isinstance(item_id, str) or not item_id or not isinstance(audio_end_ms, int | float):
+                raise DuplexCommandError(
+                    "conversation.item.truncate requires item_id and numeric audio_end_ms",
+                    code="bad_event",
+                    event_id=event_id,
+                )
+            return TruncateItem(
+                event_id=event_id,
+                item_id=item_id,
+                audio_end_ms=int(audio_end_ms),
+                content_index=int(content_index) if isinstance(content_index, int | float) else 0,
+            )
+        return SignalTurn(event_id=event_id, event=signal_event, signal_payload=signal_payload)
+
+    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",
+    "RealtimeInputDefaults",
+    "apply_realtime_session_defaults",
+    "build_append_audio",
+    "copy_realtime_input_hints",
+    "duplex_response_format",
+    "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",
+    "translate_realtime_command",
+    "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",
+]
diff --git a/vllm_omni/engine/duplex/realtime_events.py b/vllm_omni/engine/duplex/realtime_events.py
new file mode 100644
index 000000000..e6292b213
--- /dev/null
+++ b/vllm_omni/engine/duplex/realtime_events.py
@@ -0,0 +1,1566 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Session-internal duplex events -> typed :class:`DuplexEvent` objects (stateful projection).
+
+This is the former ``entrypoints/duplex/realtime_output.py`` projector plus the
+projection-relevant fields of ``realtime_state.py``, now owned by the session
+runner through :class:`RealtimeProjectionState`. The projection consumes the
+state (response / item ids, content-part bookkeeping) when it *constructs*
+events; rendering an event to wire JSON (``event.to_realtime()``) is pure and
+lives on the event classes in ``vllm_omni.engine.duplex.events``.
+
+Besides the output projection (:func:`project_internal_event`) the state also
+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
+
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, cast
+from uuid import uuid4
+
+from vllm_omni.engine.duplex.commands import (
+    AppendAudio,
+    CancelResponse,
+    ClearOutputAudio,
+    Commit,
+    CreateItem,
+    DeleteItem,
+    TruncateItem,
+)
+from vllm_omni.engine.duplex.events import (
+    AudioDelta,
+    AudioDone,
+    ContentPartAdded,
+    ContentPartDone,
+    DuplexEvent,
+    DuplexRawEvent,
+    FunctionCallArgumentsDelta,
+    FunctionCallArgumentsDone,
+    InputCleared,
+    InputCommitted,
+    InputTranscriptionCompleted,
+    ItemAdded,
+    ItemCreated,
+    ItemDeleted,
+    ItemDone,
+    ItemRetrieved,
+    ItemTruncated,
+    Listen,
+    OutputAudioCleared,
+    OutputItemAdded,
+    OutputItemDone,
+    RateLimitsUpdated,
+    ResponseCreated,
+    ResponseDone,
+    SessionClosed,
+    SessionCreated,
+    SessionReplaced,
+    SessionResumed,
+    SessionResyncRequired,
+    SessionUpdated,
+    Speak,
+    SpeechStarted,
+    SpeechStopped,
+    TextDelta,
+    TextDone,
+    TranscriptDelta,
+    TranscriptDone,
+    error_event,
+)
+from vllm_omni.engine.duplex.realtime_commands import build_append_audio
+from vllm_omni.protocol.duplex import (
+    RealtimeInputDefaults,
+    apply_realtime_session_defaults,
+    convert_output_audio,
+    copy_realtime_input_hints,
+    input_looks_like_speech,
+    input_transcript_from_item,
+    parse_realtime_audio_format,
+    realtime_audio_format_object,
+    realtime_output_format,
+    truncate_realtime_item_content,
+    validate_realtime_item_truncate,
+)
+
+if TYPE_CHECKING:
+    # Runtime import pulls in the VAD backend; the projection only needs the type.
+    from vllm_omni.engine.duplex.turn_detection import TurnDetectionResult
+
+
+def _str_or_none(value: object) -> str | None:
+    return value if isinstance(value, str) and value else None
+
+
+def _int_or(value: object, default: int = 0) -> int:
+    return int(value) if isinstance(value, int | float) else default
+
+
+@dataclass(slots=True)
+class _ResponseProjection:
+    item_id: str
+    transcript_parts: list[str] = field(default_factory=list)
+    text_parts: list[str] = field(default_factory=list)
+    audio_duration_ms: int | None = None
+    audio_text_marks: list[dict[str, int]] = field(default_factory=list)
+    audio_delta_emitted: bool = False
+    audio_done_emitted: bool = False
+    audio_part_added: bool = False
+    audio_part_done: bool = False
+    text_part_added: bool = False
+    text_part_done: bool = False
+    output_text_done: bool = False
+    output_item_done: bool = False
+    conversation_item_done: bool = False
+    speak_emitted: bool = False
+    done_emitted: bool = False
+
+    @property
+    def transcript(self) -> str:
+        return "".join(self.transcript_parts)
+
+    @property
+    def text(self) -> str:
+        return "".join(self.text_parts)
+
+
+@dataclass(slots=True)
+class RealtimeProjectionState:
+    """Per-session Realtime projection state (lives on the engine-side runner)."""
+
+    session_id: str
+    model: str | None = None
+    default_payload: Mapping[str, object] | None = None
+    #: Wire defaults (input/output formats, rates, silence rms) declared by the session object.
+    defaults: RealtimeInputDefaults = field(default_factory=RealtimeInputDefaults)
+    #: The first ``session.created`` also emits ``session.updated`` (client sent session.update to open).
+    initial_session_update: bool = False
+    # ---- response / item projection ----
+    response_states: dict[str | int, _ResponseProjection] = field(default_factory=dict)
+    item_truncation_cursors: dict[str, tuple[int, int]] = field(default_factory=dict)
+    active_response_id: str | None = None
+    last_response_id: str | None = None
+    conversation_items: dict[str, dict[str, object]] = field(default_factory=dict)
+    last_conversation_item_id: str | None = None
+    pending_commit_item_ids: list[str] = field(default_factory=list)
+    # ---- input buffer projection (was on the input translator) ----
+    input_speech_started: bool = False
+    active_input_item_id: str | None = None
+    input_audio_buffer_has_audio: bool = False
+    input_audio_buffer_had_non_speech: bool = False
+    input_audio_buffer_transcript_parts: list[str] = field(default_factory=list)
+
+    def __post_init__(self) -> None:
+        if self.default_payload is not None:
+            self.apply_session_defaults(self.default_payload)
+
+    # ---- session defaults ----
+
+    def apply_session_defaults(self, session_payload: Mapping[str, object]) -> None:
+        self.defaults = apply_realtime_session_defaults(self.defaults, session_payload)
+
+    @property
+    def input_audio_format(self) -> str:
+        return self.defaults.input_audio_format
+
+    @property
+    def input_sample_rate_hz(self) -> int:
+        return self.defaults.input_sample_rate_hz
+
+    @property
+    def output_audio_format(self) -> str:
+        return self.defaults.output_audio_format
+
+    @property
+    def output_sample_rate_hz(self) -> int | None:
+        return self.defaults.output_sample_rate_hz
+
+    @property
+    def overlap_silence_rms(self) -> float:
+        return self.defaults.overlap_silence_rms
+
+
+# ---- response projection helpers ----
+
+
+def _response_state(
+    state: RealtimeProjectionState,
+    response_id: object,
+    *,
+    event: Mapping[str, object] | None = None,
+    create: bool = True,
+) -> _ResponseProjection | None:
+    if not (isinstance(response_id, str) and response_id):
+        # An event without a response id has no projection to attach to; a
+        # key derived from the transient event object would alias later
+        # anonymous events (and leak an entry per terminal).
+        return None
+    key = response_id
+    item_id = f"item_{response_id}"
+    projection = state.response_states.get(key)
+    if projection is None and create:
+        projection = _ResponseProjection(item_id=item_id)
+        state.response_states[key] = projection
+    return projection
+
+
+def response_is_done(state: RealtimeProjectionState, response_id: object) -> bool:
+    projection = _response_state(state, response_id, create=False)
+    return projection is not None and projection.done_emitted
+
+
+def _response_item_id(state: RealtimeProjectionState, response_id: object) -> str:
+    projection = _response_state(state, response_id)
+    if projection is not None:
+        return projection.item_id
+    return f"item_{uuid4().hex}"
+
+
+def _response_content_part(*, transcript: str = "") -> dict[str, object]:
+    return {"type": "audio", "transcript": transcript}
+
+
+def _response_text_content_part(*, text: str = "") -> dict[str, object]:
+    return {"type": "text", "text": text}
+
+
+def _response_item_content_part(
+    *,
+    transcript: str = "",
+    audio_duration_ms: int | None = None,
+    audio_text_marks: list[dict[str, int]] | None = None,
+) -> dict[str, object]:
+    part: dict[str, object] = {"type": "output_audio", "transcript": transcript}
+    if audio_duration_ms is not None:
+        part["audio_duration_ms"] = int(audio_duration_ms)
+    if audio_text_marks:
+        part["audio_text_marks"] = [dict(mark) for mark in audio_text_marks]
+    return part
+
+
+def _response_item_text_content_part(*, text: str = "") -> dict[str, object]:
+    return {"type": "output_text", "text": text}
+
+
+def _previous_item_id(state: RealtimeProjectionState, item_id: str) -> str | None:
+    previous: str | None = None
+    for known_id in state.conversation_items:
+        if known_id == item_id:
+            return previous
+        previous = known_id
+    if state.last_conversation_item_id == item_id:
+        return previous
+    return state.last_conversation_item_id
+
+
+def _conversation_item_added_events(state: RealtimeProjectionState, item: dict[str, object]) -> list[DuplexEvent]:
+    item_id = item.get("id")
+    explicit_previous_item_id = item.pop("_previous_item_id", None)
+    previous_item_id = (
+        explicit_previous_item_id if isinstance(explicit_previous_item_id, str) else state.last_conversation_item_id
+    )
+    if isinstance(item_id, str) and item_id:
+        state.last_conversation_item_id = item_id
+    return [
+        ItemAdded(previous_item_id=previous_item_id, item=item),
+        ItemCreated(previous_item_id=previous_item_id, item=item),
+    ]
+
+
+def _conversation_item_done_event(state: RealtimeProjectionState, item: dict[str, object]) -> ItemDone:
+    item_id = item.get("id")
+    previous_item_id = _previous_item_id(state, item_id) if isinstance(item_id, str) else None
+    if isinstance(item_id, str) and item_id:
+        state.conversation_items[item_id] = item
+        state.last_conversation_item_id = item_id
+    return ItemDone(previous_item_id=previous_item_id, item=item)
+
+
+def _remove_conversation_item(state: RealtimeProjectionState, item_id: str) -> bool:
+    removed = state.conversation_items.pop(item_id, None) is not None
+    if state.last_conversation_item_id == item_id:
+        remaining_ids = list(state.conversation_items)
+        state.last_conversation_item_id = remaining_ids[-1] if remaining_ids else None
+    state.item_truncation_cursors.pop(item_id, None)
+    return removed
+
+
+def _apply_pending_item_truncation(state: RealtimeProjectionState, item: dict[str, object]) -> None:
+    item_id = item.get("id")
+    if not isinstance(item_id, str) or not item_id:
+        return
+    cursor = state.item_truncation_cursors.get(item_id)
+    if cursor is None:
+        return
+    content_index, audio_end_ms = cursor
+    truncate_realtime_item_content(item, content_index=content_index, audio_end_ms=audio_end_ms)
+
+
+def _response_done_output_item(
+    state: RealtimeProjectionState, response_id: object, *, status: str
+) -> dict[str, object]:
+    item_id = _response_item_id(state, response_id)
+    projection = _response_state(state, response_id)
+    transcript = projection.transcript if projection is not None else ""
+    text = projection.text if projection is not None else ""
+    audio_duration_ms = projection.audio_duration_ms if projection is not None else None
+    audio_text_marks = projection.audio_text_marks if projection is not None else None
+    content: list[dict[str, object]] = []
+    if (projection is not None and projection.audio_part_added) or transcript or audio_duration_ms is not None:
+        content.append(
+            _response_item_content_part(
+                transcript=transcript,
+                audio_duration_ms=audio_duration_ms,
+                audio_text_marks=audio_text_marks,
+            )
+        )
+    if text:
+        content.append(_response_item_text_content_part(text=text))
+    item: dict[str, object] = {
+        "id": item_id,
+        "object": "realtime.item",
+        "type": "message",
+        "role": "assistant",
+        "status": status,
+        "content": content,
+    }
+    _apply_pending_item_truncation(state, item)
+    return item
+
+
+def _refresh_in_progress_response_item(state: RealtimeProjectionState, response_id: object) -> None:
+    if not isinstance(response_id, str) or not response_id:
+        return
+    item_id = _response_item_id(state, response_id)
+    item = state.conversation_items.get(item_id)
+    if not isinstance(item, dict):
+        return
+    content = item.get("content")
+    if not isinstance(content, list):
+        content = []
+        item["content"] = content
+    projection = _response_state(state, response_id)
+    if projection is None:
+        return
+    transcript = projection.transcript
+    audio_duration_ms = projection.audio_duration_ms
+    audio_text_marks = projection.audio_text_marks
+    has_audio = projection.audio_part_added or bool(transcript) or audio_duration_ms is not None
+    if has_audio:
+        audio_part = _response_item_content_part(
+            transcript=transcript,
+            audio_duration_ms=audio_duration_ms,
+            audio_text_marks=audio_text_marks,
+        )
+        if content and isinstance(content[0], dict) and content[0].get("type") in {"audio", "output_audio"}:
+            content[0] = audio_part
+        else:
+            content.insert(0, audio_part)
+    text = projection.text
+    if text:
+        text_index = (
+            1 if content and isinstance(content[0], dict) and content[0].get("type") in {"audio", "output_audio"} else 0
+        )
+        text_part = _response_item_text_content_part(text=text)
+        if (
+            len(content) > text_index
+            and isinstance(content[text_index], dict)
+            and content[text_index].get("type") in {"text", "output_text"}
+        ):
+            content[text_index] = text_part
+        else:
+            content.insert(text_index, text_part)
+    _apply_pending_item_truncation(state, item)
+
+
+def _append_response_transcript(state: RealtimeProjectionState, response_id: object, text: str) -> None:
+    projection = _response_state(state, response_id)
+    if projection is None or not text:
+        return
+    projection.transcript_parts.append(text)
+
+
+def _ensure_response_text_part_added(state: RealtimeProjectionState, response_id: object) -> list[DuplexEvent]:
+    projection = _response_state(state, response_id)
+    if projection is None or projection.text_part_added:
+        return []
+    projection.text_part_added = True
+    return [
+        ContentPartAdded(
+            response_id=_str_or_none(response_id),
+            item_id=_response_item_id(state, response_id),
+            content_index=1 if projection.audio_part_added else 0,
+            part=_response_text_content_part(),
+        )
+    ]
+
+
+def _ensure_response_audio_part_added(state: RealtimeProjectionState, response_id: object) -> list[DuplexEvent]:
+    projection = _response_state(state, response_id)
+    if projection is None or projection.audio_part_added:
+        return []
+    projection.audio_part_added = True
+    return [
+        ContentPartAdded(
+            response_id=_str_or_none(response_id),
+            item_id=_response_item_id(state, response_id),
+            part=_response_content_part(),
+        )
+    ]
+
+
+def _remember_response_audio_metadata(
+    state: RealtimeProjectionState, response_id: object, event: Mapping[str, object]
+) -> None:
+    projection = _response_state(state, response_id)
+    if projection is None:
+        return
+    duration = event.get("audio_duration_ms")
+    playback = event.get("playback")
+    if not isinstance(duration, int | float) and isinstance(playback, dict):
+        duration = playback.get("sent_ms") or playback.get("generated_ms")
+    if isinstance(duration, int | float):
+        projection.audio_duration_ms = max(projection.audio_duration_ms or 0, int(duration))
+    marks = event.get("audio_text_marks")
+    if not isinstance(marks, list):
+        return
+    clean_marks: list[dict[str, int]] = []
+    for mark in marks:
+        if not isinstance(mark, dict):
+            continue
+        text_chars = mark.get("text_chars")
+        audio_end_ms = mark.get("audio_end_ms", mark.get("audio_ms"))
+        if not isinstance(text_chars, int | float) or not isinstance(audio_end_ms, int | float):
+            continue
+        clean_marks.append({"text_chars": max(0, int(text_chars)), "audio_end_ms": max(0, int(audio_end_ms))})
+    if clean_marks:
+        merged = list(projection.audio_text_marks)
+        merged.extend(clean_marks)
+        deduped: dict[tuple[int, int], dict[str, int]] = {}
+        for mark in merged:
+            deduped[(int(mark["audio_end_ms"]), int(mark["text_chars"]))] = mark
+        projection.audio_text_marks = sorted(
+            deduped.values(), key=lambda mark: (mark["audio_end_ms"], mark["text_chars"])
+        )
+
+
+def _response_created_event(event: Mapping[str, object]) -> ResponseCreated:
+    response_id = event.get("response_id")
+    metadata = event.get("metadata")
+    if not isinstance(metadata, dict):
+        metadata = {}
+    metadata = {**metadata, "duplex_event": dict(event)}
+    return ResponseCreated(
+        response_id=_str_or_none(response_id),
+        response={
+            "id": response_id,
+            "object": "realtime.response",
+            "status": "in_progress",
+            "status_details": None,
+            "output": [],
+            "modalities": event.get("modalities") or ["audio", "text"],
+            "metadata": metadata,
+        },
+    )
+
+
+def _response_speak_metadata(event: Mapping[str, object]) -> dict[str, object]:
+    return {key: event[key] for key in ("session_id", "epoch", "model_speak") if key in event}
+
+
+def _realtime_audio_delta_events(
+    state: RealtimeProjectionState,
+    event: Mapping[str, object],
+    response_id: object,
+    audio: str,
+) -> list[DuplexEvent]:
+    item_id = _response_item_id(state, response_id)
+    fmt, format_rate = parse_realtime_audio_format(event.get("format", "wav"))
+    source_fmt = realtime_output_format(fmt)
+    source_sample_rate_hz = event.get("sample_rate_hz") or format_rate
+    target_sample_rate_hz = (
+        state.output_sample_rate_hz if state.output_audio_format in {"g711_ulaw", "g711_alaw"} else None
+    )
+    audio, fmt, converted_sample_rate_hz = convert_output_audio(
+        audio,
+        source_fmt=source_fmt,
+        target_fmt=state.output_audio_format,
+        source_sample_rate_hz=(int(source_sample_rate_hz) if isinstance(source_sample_rate_hz, int | float) else None),
+        target_sample_rate_hz=target_sample_rate_hz,
+    )
+    sample_rate_hz = (
+        converted_sample_rate_hz
+        if fmt in {"g711_ulaw", "g711_alaw"}
+        else event.get("sample_rate_hz") or format_rate or state.output_sample_rate_hz
+    )
+    metadata: dict[str, object] = {}
+    for key in ("session_id", "epoch", "model_speak", "end_of_turn", "playback", "vllm_omni"):
+        if key in event:
+            metadata[key] = event[key]
+    duration_ms = event.get("audio_duration_ms")
+    if isinstance(duration_ms, int | float):
+        metadata["audio_duration_ms"] = int(duration_ms)
+    marks = event.get("audio_text_marks")
+    if isinstance(marks, list):
+        metadata["audio_text_marks"] = marks
+    projection = _response_state(state, response_id)
+    if projection is not None:
+        projection.audio_delta_emitted = True
+        _remember_response_audio_metadata(state, response_id, event)
+    events: list[DuplexEvent] = []
+    if projection is not None and not projection.speak_emitted and metadata.get("model_speak") is True:
+        projection.speak_emitted = True
+        events.append(
+            Speak(response_id=_str_or_none(response_id), item_id=item_id, metadata=_response_speak_metadata(event))
+        )
+    events.append(
+        AudioDelta(
+            response_id=_str_or_none(response_id),
+            item_id=item_id,
+            delta=str(audio),
+            format=str(fmt),
+            sample_rate_hz=int(sample_rate_hz) if isinstance(sample_rate_hz, int | float) else None,
+            metadata=metadata or None,
+        )
+    )
+    return events
+
+
+def _realtime_audio_done_events(
+    state: RealtimeProjectionState, event: Mapping[str, object], response_id: object
+) -> list[DuplexEvent]:
+    item_id = _response_item_id(state, response_id)
+    projection = _response_state(state, response_id, event=event)
+    transcript = projection.transcript if projection is not None else ""
+    events: list[DuplexEvent] = []
+    if (
+        isinstance(response_id, str)
+        and projection is not None
+        and not projection.audio_delta_emitted
+        and not transcript
+    ):
+        return events
+    if projection is None or not projection.audio_done_emitted:
+        if projection is not None:
+            projection.audio_done_emitted = True
+        events.append(AudioDone(response_id=_str_or_none(response_id), item_id=item_id))
+        if transcript:
+            events.append(TranscriptDone(response_id=_str_or_none(response_id), item_id=item_id, transcript=transcript))
+    return events
+
+
+def _realtime_response_done_event(
+    state: RealtimeProjectionState,
+    event: Mapping[str, object],
+    *,
+    projection: _ResponseProjection | None = None,
+    status: str = "completed",
+    status_details: dict[str, object] | None = None,
+) -> ResponseDone | None:
+    response_id = event.get("response_id")
+    if projection is None:
+        projection = _response_state(state, response_id, event=event)
+    if projection is not None:
+        if projection.done_emitted:
+            return None
+        projection.done_emitted = True
+    return ResponseDone(
+        response_id=_str_or_none(response_id),
+        response={
+            "id": response_id,
+            "object": "realtime.response",
+            "status": status,
+            "status_details": status_details,
+            "output": [_response_done_output_item(state, response_id, status=status)],
+            "metadata": dict(event),
+        },
+    )
+
+
+def _realtime_response_terminal_events(
+    state: RealtimeProjectionState,
+    event: Mapping[str, object],
+    response_id: object,
+    *,
+    status: str = "completed",
+    status_details: dict[str, object] | None = None,
+) -> list[DuplexEvent]:
+    item_id = _response_item_id(state, response_id)
+    projection = _response_state(state, response_id, event=event)
+    transcript = projection.transcript if projection is not None else ""
+    rid = _str_or_none(response_id)
+    events: list[DuplexEvent] = []
+    if projection is not None and projection.audio_part_added and not projection.audio_part_done:
+        projection.audio_part_done = True
+        events.append(
+            ContentPartDone(response_id=rid, item_id=item_id, part=_response_content_part(transcript=transcript))
+        )
+    if projection is not None and projection.text_parts and not projection.output_text_done:
+        projection.output_text_done = True
+        events.append(
+            TextDone(
+                response_id=rid,
+                item_id=item_id,
+                content_index=1 if projection.audio_part_added else 0,
+                text=projection.text,
+            )
+        )
+    if projection is not None and projection.text_parts and not projection.text_part_done:
+        projection.text_part_done = True
+        events.append(
+            ContentPartDone(
+                response_id=rid,
+                item_id=item_id,
+                content_index=1 if projection.audio_part_added else 0,
+                part=_response_text_content_part(text=projection.text),
+            )
+        )
+    if projection is None or not projection.output_item_done:
+        if projection is not None:
+            projection.output_item_done = True
+        item = _response_done_output_item(state, response_id, status=status)
+        events.append(OutputItemDone(response_id=rid, item=item))
+        if projection is None or not projection.conversation_item_done:
+            if projection is not None:
+                projection.conversation_item_done = True
+            events.append(_conversation_item_done_event(state, item))
+    done_event = _realtime_response_done_event(
+        state,
+        {**event, "response_id": response_id},
+        projection=projection,
+        status=status,
+        status_details=status_details,
+    )
+    if done_event is not None:
+        events.append(done_event)
+        # vLLM-Omni does not expose a Realtime-specific quota budget; emit the
+        # terminal event with an empty list so clients that sequence on it work.
+        events.append(RateLimitsUpdated())
+        if isinstance(response_id, str) and response_id == state.active_response_id:
+            state.active_response_id = None
+    return events
+
+
+def _user_item_content_from_duplex_message(message: object) -> list[dict[str, object]]:
+    if not isinstance(message, dict):
+        return [{"type": "input_audio", "transcript": ""}]
+    message_transcript = message.get("transcript")
+    content = message.get("content")
+    if isinstance(content, str):
+        return [{"type": "input_text", "text": content}]
+    if not isinstance(content, list):
+        return [
+            {"type": "input_audio", "transcript": message_transcript if isinstance(message_transcript, str) else ""}
+        ]
+    parts: list[dict[str, object]] = []
+    for part in content:
+        if not isinstance(part, dict):
+            continue
+        part_type = part.get("type")
+        if part_type in {"text", "input_text"} and isinstance(part.get("text"), str):
+            parts.append({"type": "input_text", "text": part["text"]})
+            continue
+        if part_type == "audio_url":
+            transcript = (
+                part.get("transcript")
+                if isinstance(part.get("transcript"), str)
+                else message_transcript
+                if isinstance(message_transcript, str)
+                else ""
+            )
+            parts.append({"type": "input_audio", "transcript": transcript})
+            continue
+        if part_type in {"audio", "input_audio"}:
+            transcript = part.get("transcript") if isinstance(part.get("transcript"), str) else ""
+            parts.append({"type": "input_audio", "transcript": transcript})
+    return parts or [{"type": "input_audio", "transcript": ""}]
+
+
+def _input_audio_transcription_completed_event(
+    item_id: str, item: Mapping[str, object]
+) -> InputTranscriptionCompleted | None:
+    content = item.get("content")
+    if not isinstance(content, list):
+        return None
+    for index, part in enumerate(content):
+        if not isinstance(part, dict) or part.get("type") != "input_audio":
+            continue
+        transcript = part.get("transcript")
+        if isinstance(transcript, str) and transcript:
+            return InputTranscriptionCompleted(item_id=item_id, content_index=index, transcript=transcript)
+    return None
+
+
+def _pop_pending_commit_item_id(state: RealtimeProjectionState) -> str:
+    if state.pending_commit_item_ids:
+        return state.pending_commit_item_ids.pop(0)
+    return f"item_{uuid4().hex}"
+
+
+def realtime_session_payload(state: RealtimeProjectionState, session: object) -> dict[str, object]:
+    """Fill the Realtime ``session`` object defaults for session.created/updated."""
+    payload = dict(session) if isinstance(session, Mapping) else {}
+    payload.setdefault("object", "realtime.session")
+    payload.setdefault("type", "realtime")
+    payload.setdefault("id", payload.get("id") or state.session_id)
+    payload.setdefault("model", payload.get("model") or state.model)
+    payload.setdefault("input_audio_format", state.input_audio_format)
+    payload.setdefault("output_audio_format", state.output_audio_format)
+    payload.setdefault("modalities", payload.get("modalities") or ["text", "audio"])
+    payload.setdefault("output_modalities", payload.get("output_modalities") or payload.get("modalities"))
+    payload.setdefault(
+        "audio",
+        {
+            "input": {
+                "format": realtime_audio_format_object(
+                    state.input_audio_format, sample_rate_hz=state.input_sample_rate_hz
+                ),
+                "sample_rate_hz": state.input_sample_rate_hz,
+            },
+            "output": {
+                "format": realtime_audio_format_object(
+                    state.output_audio_format, sample_rate_hz=state.output_sample_rate_hz
+                ),
+            },
+        },
+    )
+    payload.setdefault("turn_detection", payload.get("turn_detection"))
+    payload.setdefault("input_audio_transcription", payload.get("input_audio_transcription"))
+    payload.setdefault("tracing", payload.get("tracing"))
+    return payload
+
+
+# ---- main projection ----
+
+
+def project_internal_event(state: RealtimeProjectionState, event: Mapping[str, object]) -> list[DuplexEvent]:
+    """Project one session-internal event onto 0..n typed public events."""
+    return _project(state, dict(event))
+
+
+def _project(state: RealtimeProjectionState, event: dict[str, object]) -> list[DuplexEvent]:
+    event_type = event.get("type")
+    if event_type == "session.created":
+        session = realtime_session_payload(state, event.get("session"))
+        events: list[DuplexEvent] = [
+            SessionCreated(
+                session=session,
+                attachment_generation=(
+                    cast("int", event["attachment_generation"])
+                    if isinstance(event.get("attachment_generation"), int)
+                    else None
+                ),
+                resume_token=_str_or_none(event.get("resume_token")),
+            )
+        ]
+        if state.initial_session_update:
+            events.append(SessionUpdated(session=session))
+            state.initial_session_update = False
+        return events
+    if event_type == "session.updated":
+        return [SessionUpdated(session=realtime_session_payload(state, event.get("session")))]
+    if event_type == "session.resumed":
+        return [
+            SessionResumed(
+                session=realtime_session_payload(state, event.get("session")),
+                attachment_generation=(
+                    cast("int", event["attachment_generation"])
+                    if isinstance(event.get("attachment_generation"), int)
+                    else None
+                ),
+                resume_token=_str_or_none(event.get("resume_token")),
+            )
+        ]
+    if event_type == "session.replaced":
+        return [SessionReplaced(attachment_generation=_int_or(event.get("attachment_generation")))]
+    if event_type == "session.resync_required":
+        return [SessionResyncRequired(reason=str(event.get("reason") or "journal_gap"))]
+    if event_type == "session.closed":
+        return [SessionClosed(reason=str(event.get("reason") or "closed"), details=event)]
+    if event_type == "response.created":
+        response_id = event.get("response_id")
+        if isinstance(response_id, str) and response_id:
+            state.active_response_id = response_id
+            state.last_response_id = response_id
+        item_id = _response_item_id(state, response_id)
+        modalities = event.get("modalities")
+        has_audio_modality = not isinstance(modalities, list) or "audio" in modalities
+        item: dict[str, object] = {
+            "id": item_id,
+            "object": "realtime.item",
+            "type": "message",
+            "role": "assistant",
+            "status": "in_progress",
+            "content": [],
+        }
+        state.conversation_items[item_id] = item
+        events = [
+            _response_created_event(event),
+            *_conversation_item_added_events(state, item),
+            OutputItemAdded(response_id=_str_or_none(response_id), item=item),
+        ]
+        if has_audio_modality:
+            events.extend(_ensure_response_audio_part_added(state, response_id))
+        return events
+    if event_type == "response.listen":
+        return [Listen(response_id=_str_or_none(event.get("response_id")), details=event)]
+    if event_type == "response.speak":
+        response_id = event.get("response_id")
+        projection = _response_state(state, response_id)
+        if projection is not None:
+            if projection.speak_emitted:
+                return []
+            projection.speak_emitted = True
+        return [
+            Speak(
+                response_id=_str_or_none(response_id),
+                item_id=_response_item_id(state, response_id),
+                metadata=_response_speak_metadata(event),
+            )
+        ]
+    if event_type == "response.output_audio.delta":
+        response_id = event.get("response_id")
+        audio = event.get("audio", "")
+        events = []
+        if isinstance(audio, str) and audio:
+            events.extend(_ensure_response_audio_part_added(state, response_id))
+            events.extend(_realtime_audio_delta_events(state, event, response_id, audio))
+            _refresh_in_progress_response_item(state, response_id)
+        text = event.get("text")
+        has_text = isinstance(text, str) and bool(text)
+        if has_text:
+            _append_response_transcript(state, response_id, cast("str", text))
+            _refresh_in_progress_response_item(state, response_id)
+        # Keep the audio.delta + transcript.delta pair invariant even for
+        # text-less units so clients that treat the pair as unit-complete work.
+        if has_text or (isinstance(audio, str) and bool(audio)):
+            events.append(
+                TranscriptDelta(
+                    response_id=_str_or_none(response_id),
+                    item_id=_response_item_id(state, response_id),
+                    delta=cast("str", text) if has_text else "",
+                )
+            )
+        if event.get("end_of_turn") is True:
+            events.extend(_realtime_audio_done_events(state, event, response_id))
+            events.extend(
+                _realtime_response_terminal_events(
+                    state,
+                    event,
+                    response_id,
+                    status="completed",
+                    status_details={"type": "completed", "reason": event.get("finish_reason") or "stop"},
+                )
+            )
+        return events
+    if event_type == "response.text.delta":
+        response_id = event.get("response_id")
+        text = event.get("delta", "")
+        projection = _response_state(state, response_id)
+        if projection is not None and isinstance(text, str) and text:
+            projection.text_parts.append(text)
+            _refresh_in_progress_response_item(state, response_id)
+        events = _ensure_response_text_part_added(state, response_id)
+        events.append(
+            TextDelta(
+                response_id=_str_or_none(response_id),
+                item_id=_response_item_id(state, response_id),
+                content_index=1 if projection is not None and projection.audio_part_added else 0,
+                delta=str(text) if isinstance(text, str) else "",
+            )
+        )
+        return events
+    if event_type == "response.done":
+        response_id = event.get("response_id")
+        status = cast("str", event.get("status")) if isinstance(event.get("status"), str) else "completed"
+        status_details = (
+            cast("dict[str, object]", event.get("status_details"))
+            if isinstance(event.get("status_details"), dict)
+            else None
+        )
+        return [
+            *_realtime_audio_done_events(state, event, response_id),
+            *_realtime_response_terminal_events(
+                state, event, response_id, status=status, status_details=status_details
+            ),
+        ]
+    if event_type == "input.committed":
+        event_item_id = event.get("realtime_item_id")
+        item_id = (
+            event_item_id if isinstance(event_item_id, str) and event_item_id else _pop_pending_commit_item_id(state)
+        )
+        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")
+            created_commit_item: dict[str, object] = {
+                "id": item_id,
+                "object": "realtime.item",
+                "type": "message",
+                "role": "user",
+                "status": "completed",
+                "content": (
+                    [{"type": "input_audio", "transcript": "", "is_speech": False}]
+                    if no_response and is_speech is False
+                    else _user_item_content_from_duplex_message(message)
+                ),
+            }
+            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, committed_item)
+        if transcription_event is not None:
+            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":
+        response_id = event.get("response_id")
+        events = []
+        if event.get("reason") == "output_audio_buffer_clear":
+            if not isinstance(response_id, str) or not response_id:
+                response_id = state.active_response_id or state.last_response_id
+            events.append(OutputAudioCleared(response_id=_str_or_none(response_id)))
+            if not isinstance(response_id, str) or not response_id:
+                return events
+        elif not isinstance(response_id, str) or not response_id:
+            response_id = state.active_response_id
+        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)
+            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(
+                state,
+                event,
+                response_id,
+                status="cancelled",
+                status_details={"type": "cancelled", "reason": event.get("reason") or "client_cancelled"},
+            )
+        )
+        if isinstance(response_id, str) and response_id == state.active_response_id:
+            state.active_response_id = None
+        return events
+    if event_type == "conversation.item.created":
+        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 created_item.get("status") == "completed":
+                    return [_conversation_item_done_event(state, created_item)]
+                return []
+            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":
+        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":
+        truncated_item_id = event.get("item_id")
+        audio_end_ms = event.get("audio_end_ms")
+        content_index = event.get("content_index", 0)
+        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(
+                    truncated_item,
+                    content_index=_int_or(content_index),
+                    audio_end_ms=_int_or(audio_end_ms),
+                )
+        return [
+            ItemTruncated(
+                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":
+        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(
+            state,
+            event,
+            response_id,
+            status="completed",
+            status_details={"type": "completed", "reason": event.get("finish_reason") or "stop"},
+        )
+    if event_type == "function_call.done":
+        return _function_call_done_events(state, event)
+    if event_type == "input_audio_buffer.speech_started":
+        return [
+            SpeechStarted(
+                audio_start_ms=_int_or(event.get("audio_start_ms")), item_id=_str_or_none(event.get("item_id"))
+            )
+        ]
+    if event_type == "input_audio_buffer.speech_stopped":
+        return [
+            SpeechStopped(audio_end_ms=_int_or(event.get("audio_end_ms")), item_id=_str_or_none(event.get("item_id")))
+        ]
+    return [DuplexRawEvent(internal_type=str(event_type), details=event)]
+
+
+def _function_call_done_events(state: RealtimeProjectionState, event: dict[str, object]) -> list[DuplexEvent]:
+    call_id = event.get("call_id")
+    name = event.get("name")
+    arguments = event.get("arguments", "")
+    if not isinstance(call_id, str) or not call_id or not isinstance(name, str) or not name:
+        return [DuplexRawEvent(internal_type="function_call.done", details=event)]
+    if not isinstance(arguments, str):
+        arguments = str(arguments)
+    response_id = f"resp_{uuid4().hex}"
+    item_id = f"item_{uuid4().hex}"
+    item: dict[str, object] = {
+        "id": item_id,
+        "object": "realtime.item",
+        "type": "function_call",
+        "status": "completed",
+        "name": name,
+        "call_id": call_id,
+        "arguments": arguments,
+    }
+    state.conversation_items[item_id] = item
+    response = {
+        "id": response_id,
+        "object": "realtime.response",
+        "status": "completed",
+        "status_details": {"type": "completed", "reason": "completed"},
+        "output": [dict(item)],
+        "metadata": {},
+    }
+    return [
+        ResponseCreated(response_id=response_id, response={**response, "status": "in_progress", "output": []}),
+        *_conversation_item_added_events(state, item),
+        OutputItemAdded(response_id=response_id, item=dict(item)),
+        FunctionCallArgumentsDelta(response_id=response_id, item_id=item_id, call_id=call_id, delta=arguments),
+        FunctionCallArgumentsDone(response_id=response_id, item_id=item_id, call_id=call_id, arguments=arguments),
+        OutputItemDone(response_id=response_id, item=dict(item)),
+        _conversation_item_done_event(state, item),
+        ResponseDone(response_id=response_id, response=response),
+    ]
+
+
+# ---- input-side helpers for the runner (were on the input translator) ----
+
+
+def register_user_item(
+    state: RealtimeProjectionState,
+    item: Mapping[str, object],
+    *,
+    previous_item_id: str | None = None,
+) -> list[DuplexEvent]:
+    """Record a client-created user message item and return its ack events.
+
+    Replaces the old translator's ``_send_realtime_input_ack``: call it when
+    handling a ``CreateItem`` whose item role is ``user`` (before the internal
+    ``conversation.item.created`` is emitted, which then projects to ``done``).
+    """
+    normalized = dict(item)
+    if isinstance(previous_item_id, str):
+        normalized["_previous_item_id"] = previous_item_id
+    if normalized.get("role") != "user":
+        return []
+    state.conversation_items[str(normalized["id"])] = normalized
+    return _conversation_item_added_events(state, normalized)
+
+
+def retrieve_item_events(state: RealtimeProjectionState, payload: Mapping[str, object]) -> list[DuplexEvent]:
+    """Answer ``conversation.item.retrieve`` from the projected conversation items."""
+    event_id = payload.get("event_id")
+    item_id = payload.get("item_id")
+    if not isinstance(item_id, str) or not item_id:
+        return [error_event("missing_item_id", "conversation.item.retrieve requires item_id", event_id=event_id)]
+    item = state.conversation_items.get(item_id)
+    if item is None:
+        return [error_event("item_not_found", f"Conversation item not found: {item_id}", event_id=event_id)]
+    return [ItemRetrieved(item=item)]
+
+
+def emit_input_speech_started(state: RealtimeProjectionState, audio_start_ms: object = 0) -> list[DuplexEvent]:
+    if state.input_speech_started:
+        return []
+    state.input_speech_started = True
+    if state.active_input_item_id is None:
+        state.active_input_item_id = f"item_{uuid4().hex}"
+    return [SpeechStarted(audio_start_ms=_int_or(audio_start_ms), item_id=state.active_input_item_id)]
+
+
+def emit_input_speech_stopped(
+    state: RealtimeProjectionState, *, item_id: str, audio_end_ms: object = 0
+) -> list[DuplexEvent]:
+    if not state.input_speech_started:
+        return []
+    state.input_speech_started = False
+    return [SpeechStopped(audio_end_ms=_int_or(audio_end_ms), item_id=item_id)]
+
+
+def _remember_input_transcript_hint(state: RealtimeProjectionState, event: Mapping[str, object]) -> None:
+    transcript = event.get("transcript")
+    if not isinstance(transcript, str):
+        transcript = event.get("text") if isinstance(event.get("text"), str) else None
+    if not isinstance(transcript, str):
+        hints = event.get("hints")
+        if isinstance(hints, dict):
+            transcript = hints.get("transcript")
+            if not isinstance(transcript, str):
+                transcript = hints.get("text") if isinstance(hints.get("text"), str) else None
+    if isinstance(transcript, str) and transcript:
+        parts = state.input_audio_buffer_transcript_parts
+        if parts and parts[-1] == transcript:
+            return
+        parts.append(transcript)
+
+
+def _consume_input_transcript_hint(state: RealtimeProjectionState) -> str:
+    transcript = "".join(state.input_audio_buffer_transcript_parts).strip()
+    state.input_audio_buffer_transcript_parts.clear()
+    return transcript
+
+
+def note_input_append(
+    state: RealtimeProjectionState,
+    payload: dict[str, object],
+    *,
+    vad_result: TurnDetectionResult | None = None,
+) -> list[DuplexEvent]:
+    """Update the input-buffer projection for one appended chunk; returns typed events.
+
+    ``payload`` is the internal ``input_audio_buffer.append`` dictionary
+    (``AppendAudio.payload()``), optionally after ``apply_turn_detection_result``;
+    ``vad_result`` is the ``TurnDetectionResult`` when server VAD is active. The
+    returned events are ``input_audio_buffer.speech_started`` /
+    ``speech_stopped`` exactly as the old translator produced them.
+    """
+    audio = payload.get("audio")
+    looks_like_speech = bool(vad_result.is_speech) if vad_result is not None else payload.get("is_speech") is not False
+    has_audio = isinstance(audio, str) and bool(audio)
+    state.input_audio_buffer_has_audio = state.input_audio_buffer_has_audio or (looks_like_speech and has_audio)
+    state.input_audio_buffer_had_non_speech = state.input_audio_buffer_had_non_speech or (
+        not looks_like_speech and has_audio
+    )
+    events: list[DuplexEvent] = []
+    stop_ms: object = payload.get("audio_end_ms", payload.get("audio_ms", 0))
+    if vad_result is not None:
+        if vad_result.speech_stopped and vad_result.audio_end_ms is not None:
+            stop_ms = vad_result.audio_end_ms
+        if vad_result.speech_stopped and vad_result.speech_active:
+            events.extend(
+                emit_input_speech_stopped(
+                    state,
+                    item_id=state.active_input_item_id or f"item_{uuid4().hex}",
+                    audio_end_ms=stop_ms,
+                )
+            )
+        if vad_result.speech_started:
+            start_ms = (
+                vad_result.audio_start_ms if vad_result.audio_start_ms is not None else payload.get("audio_start_ms", 0)
+            )
+            events.extend(emit_input_speech_started(state, start_ms))
+        if vad_result.speech_stopped and not vad_result.speech_active:
+            events.extend(
+                emit_input_speech_stopped(
+                    state,
+                    item_id=state.active_input_item_id or f"item_{uuid4().hex}",
+                    audio_end_ms=stop_ms,
+                )
+            )
+    elif looks_like_speech:
+        events.extend(emit_input_speech_started(state, payload.get("audio_start_ms", 0)))
+    if looks_like_speech:
+        _remember_input_transcript_hint(state, payload)
+    return events
+
+
+def discard_pending_input_audio(state: RealtimeProjectionState, audio_end_ms: int | None = None) -> list[DuplexEvent]:
+    """Drop Realtime input-buffer state that was consumed as overlap (returns typed events)."""
+    events: list[DuplexEvent] = []
+    if state.input_speech_started and state.active_input_item_id is not None:
+        events.append(SpeechStopped(audio_end_ms=max(0, int(audio_end_ms or 0)), item_id=state.active_input_item_id))
+    state.input_speech_started = False
+    state.active_input_item_id = None
+    state.input_audio_buffer_has_audio = False
+    state.input_audio_buffer_had_non_speech = False
+    state.input_audio_buffer_transcript_parts.clear()
+    return events
+
+
+def clear_input_buffer(state: RealtimeProjectionState) -> None:
+    """Input-buffer projection reset for ``input_audio_buffer.clear``."""
+    state.input_speech_started = False
+    state.active_input_item_id = None
+    state.input_audio_buffer_has_audio = False
+    state.input_audio_buffer_had_non_speech = False
+    state.input_audio_buffer_transcript_parts.clear()
+
+
+@dataclass(frozen=True, slots=True)
+class ResolvedCommit:
+    """What a ``Commit`` means given the projected input buffer."""
+
+    #: Internal ``input_audio_buffer.commit`` payload to run, or None when rejected.
+    payload: dict[str, object] | None
+    #: Events to emit before running (speech_stopped) or instead (error).
+    events: list[DuplexEvent]
+    #: True when the VAD detector should be reset.
+    reset_vad: bool = False
+
+
+def resolve_commit(state: RealtimeProjectionState, command: Commit) -> ResolvedCommit:
+    """Apply the old translator's commit rules (empty buffer, non-speech commit, item id)."""
+    if command.realtime_item_id is None and not state.input_audio_buffer_has_audio:
+        if state.input_audio_buffer_had_non_speech:
+            state.input_audio_buffer_had_non_speech = False
+            state.active_input_item_id = None
+            payload: dict[str, object] = {
+                "type": "input_audio_buffer.commit",
+                "final": command.final,
+                "response_create": False,
+                "is_speech": False,
+            }
+            if command.event_id is not None:
+                payload["realtime_event_id"] = command.event_id
+            return ResolvedCommit(payload=payload, events=[], reset_vad=True)
+        return ResolvedCommit(
+            payload=None,
+            events=[
+                error_event(
+                    "input_audio_buffer_empty",
+                    "input_audio_buffer.commit requires a non-empty input audio buffer",
+                    event_id=command.event_id,
+                )
+            ],
+        )
+    item_id = command.realtime_item_id or state.active_input_item_id or f"item_{uuid4().hex}"
+    state.pending_commit_item_ids.append(item_id)
+    events = emit_input_speech_stopped(state, item_id=item_id, audio_end_ms=0)
+    transcript = _consume_input_transcript_hint(state)
+    state.active_input_item_id = None
+    state.input_audio_buffer_has_audio = False
+    state.input_audio_buffer_had_non_speech = False
+    payload = {
+        "type": "input_audio_buffer.commit",
+        "final": command.final,
+        "realtime_item_id": item_id,
+        "response_create": bool(command.create_response) if command.create_response is not None else False,
+    }
+    if command.is_speech is not None:
+        payload["is_speech"] = command.is_speech
+    if transcript:
+        payload["transcript"] = transcript
+    if command.event_id is not None:
+        payload["realtime_event_id"] = command.event_id
+    return ResolvedCommit(payload=payload, events=events, reset_vad=True)
+
+
+@dataclass(frozen=True, slots=True)
+class ResolvedControl:
+    """Result of resolving a cancel/clear/delete/truncate against the projection."""
+
+    #: Internal payload(s) to run in order (empty when nothing to do).
+    payloads: list[dict[str, object]]
+    #: Events to emit instead (already-done response ack, errors).
+    events: list[DuplexEvent]
+
+
+def resolve_cancel_response(state: RealtimeProjectionState, command: CancelResponse) -> ResolvedControl:
+    payload: dict[str, object] = {"type": "response.cancel", "reason": "response.cancel"}
+    response_id = command.response_id or state.active_response_id or state.last_response_id
+    if response_is_done(state, response_id):
+        return ResolvedControl(
+            payloads=[],
+            events=[
+                error_event(
+                    "response_not_active", f"Response is already complete: {response_id}", event_id=command.event_id
+                )
+            ],
+        )
+    if isinstance(response_id, str) and response_id:
+        payload["response_id"] = response_id
+    if command.event_id is not None:
+        payload["realtime_event_id"] = command.event_id
+    return ResolvedControl(payloads=[payload], events=[])
+
+
+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
+    # 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
+    if command.event_id is not None:
+        payload["realtime_event_id"] = command.event_id
+    return ResolvedControl(payloads=[payload], events=[])
+
+
+def resolve_delete_item(state: RealtimeProjectionState, command: DeleteItem) -> ResolvedControl:
+    if command.item_id not in state.conversation_items:
+        return ResolvedControl(
+            payloads=[],
+            events=[
+                error_event(
+                    "item_not_found", f"Conversation item not found: {command.item_id}", event_id=command.event_id
+                )
+            ],
+        )
+    _remove_conversation_item(state, command.item_id)
+    return ResolvedControl(payloads=[command.payload()], events=[])
+
+
+def resolve_truncate_item(state: RealtimeProjectionState, command: TruncateItem) -> ResolvedControl:
+    item = state.conversation_items.get(command.item_id)
+    if not isinstance(item, dict):
+        return ResolvedControl(
+            payloads=[],
+            events=[
+                error_event(
+                    "item_not_found", f"Conversation item not found: {command.item_id}", event_id=command.event_id
+                )
+            ],
+        )
+    truncate_error = validate_realtime_item_truncate(
+        item, content_index=command.content_index, audio_end_ms=command.audio_end_ms
+    )
+    if truncate_error is not None:
+        return ResolvedControl(
+            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)
+    ack_payload: dict[str, object] = {
+        "type": "playback.ack",
+        "item_id": command.item_id,
+        "committed_ms": int(command.audio_end_ms),
+        "played_ms": int(command.audio_end_ms),
+        "truncate": True,
+    }
+    return ResolvedControl(payloads=[command.payload(), ack_payload], events=[])
+
+
+def _duplicate_function_call_output(state: RealtimeProjectionState, call_id: object) -> tuple[bool, bool]:
+    matching_call = any(
+        known.get("type") == "function_call" and known.get("call_id") == call_id
+        for known in state.conversation_items.values()
+    )
+    duplicate_output = any(
+        known.get("type") == "function_call_output" and known.get("call_id") == call_id
+        for known in state.conversation_items.values()
+    )
+    return matching_call, duplicate_output
+
+
+def resolve_create_item(state: RealtimeProjectionState, command: CreateItem) -> ResolvedControl:
+    """Expand ``conversation.item.create`` the way the old translator did.
+
+    Assistant/system/function items and text-only user items become one
+    ``turn.signal conversation.item.create`` payload. User items carrying audio
+    become one ``input_audio_buffer.append`` per audio part followed by an
+    ``input_audio_buffer.commit`` (no response). The user-item ack events are
+    returned in ``events`` and must be emitted *before* running the payloads.
+    """
+    item = dict(command.item)
+    if isinstance(command.previous_item_id, str):
+        item["_previous_item_id"] = command.previous_item_id
+    item_id = str(item["id"])
+    item_type = item.get("type")
+    role = item.get("role")
+    if item_type == "function_call_output":
+        call_id = item.get("call_id")
+        output = item.get("output")
+        matching_call, duplicate_output = _duplicate_function_call_output(state, call_id)
+        if not isinstance(call_id, str) or not call_id or not matching_call:
+            return ResolvedControl(
+                payloads=[],
+                events=[
+                    error_event(
+                        "invalid_function_call_output",
+                        "function_call_output requires the call_id of a completed function call",
+                        event_id=command.event_id,
+                        param="item.call_id",
+                    )
+                ],
+            )
+        if not isinstance(output, str) or duplicate_output:
+            return ResolvedControl(
+                payloads=[],
+                events=[
+                    error_event(
+                        "invalid_function_call_output",
+                        (
+                            "function_call_output requires a string output"
+                            if not isinstance(output, str)
+                            else f"function_call_output already exists for call_id {call_id}"
+                        ),
+                        event_id=command.event_id,
+                        param="item.output",
+                    )
+                ],
+            )
+    ack_events = register_user_item(state, item) if item_type == "message" and role == "user" else []
+    signal_payload: dict[str, object] = {
+        "type": "turn.signal",
+        "event": "conversation.item.create",
+        "payload": {"item": item},
+    }
+    if command.event_id is not None:
+        signal_payload["realtime_event_id"] = command.event_id
+    if item_type != "message" or role in {"assistant", "system"}:
+        return ResolvedControl(payloads=[signal_payload], events=ack_events)
+    content = item.get("content")
+    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:
+                continue
+            try:
+                append = build_append_audio(
+                    {
+                        "audio": audio,
+                        "format": part.get("format"),
+                        "sample_rate_hz": part.get("sample_rate_hz") or part.get("sample_rate"),
+                        "event_id": command.event_id,
+                    },
+                    defaults=state.defaults,
+                    hints_source={**item, **part},
+                )
+            except Exception as exc:  # DuplexCommandError from validation/conversion
+                code = getattr(exc, "code", "bad_event")
+                if code == "unsupported_audio_format":
+                    continue
+                return ResolvedControl(
+                    payloads=[],
+                    events=[error_event(code, str(exc), event_id=command.event_id, param="sample_rate_hz")],
+                )
+            speech_hints = {**item, **part}
+            if not input_looks_like_speech(
+                speech_hints, audio=append.audio, fmt=append.format, overlap_silence_rms=state.overlap_silence_rms
+            ):
+                continue
+            state.input_speech_started = True
+            payload = append.payload()
+            copy_realtime_input_hints(part, payload)
+            copy_realtime_input_hints(item, payload)
+            audio_payloads.append(payload)
+    if audio_payloads:
+        state.input_audio_buffer_has_audio = True
+        transcript = input_transcript_from_item(item)
+        commit_payload: dict[str, object] = {
+            "type": "input_audio_buffer.commit",
+            "final": True,
+            "realtime_item_id": item_id,
+            "response_create": False,
+        }
+        if transcript:
+            commit_payload["transcript"] = transcript
+        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)
+    # 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)
+
+
+def append_audio_payload(command: AppendAudio) -> dict[str, object]:
+    """Internal ``input_audio_buffer.append`` payload for a command (convenience for the runner)."""
+    return command.payload()
+
+
+__all__ = [
+    "RealtimeProjectionState",
+    "ResolvedCommit",
+    "ResolvedControl",
+    "append_audio_payload",
+    "clear_input_buffer",
+    "discard_pending_input_audio",
+    "emit_input_speech_started",
+    "emit_input_speech_stopped",
+    "note_input_append",
+    "project_internal_event",
+    "realtime_session_payload",
+    "register_user_item",
+    "resolve_cancel_response",
+    "resolve_clear_output_audio",
+    "resolve_commit",
+    "resolve_create_item",
+    "resolve_delete_item",
+    "resolve_truncate_item",
+    "response_is_done",
+    "retrieve_item_events",
+]
diff --git a/vllm_omni/engine/duplex/runtime.py b/vllm_omni/engine/duplex/runtime.py
deleted file mode 100644
index dede0e0a6..000000000
--- a/vllm_omni/engine/duplex/runtime.py
+++ /dev/null
@@ -1,108 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-"""Experimental duplex runtime loading and compatibility exports."""
-
-from __future__ import annotations
-
-from importlib import import_module
-
-from vllm_omni.engine.duplex.contracts import (
-    DuplexAppendPlan,
-    DuplexInputMode,
-    DuplexOutputAction,
-    DuplexOutputDecision,
-    DuplexRuntimeCapabilities,
-    DuplexRuntimeExtension,
-    SessionMode,
-    duplex_data_plane_request_info,
-    duplex_resource_request_belongs_to_session,
-    duplex_resource_request_id,
-)
-
-
-def load_duplex_runtime_extension(path: str | None) -> DuplexRuntimeExtension | None:
-    if not path:
-        return None
-    module_name, separator, attribute_name = path.rpartition(".")
-    if not separator:
-        raise ValueError(f"Invalid duplex runtime extension path: {path!r}")
-    extension_type = getattr(import_module(module_name), attribute_name)
-    return validate_duplex_runtime_extension(extension_type())
-
-
-def validate_duplex_runtime_extension(
-    extension: object,
-    *,
-    sampling_defaults: tuple[object, ...] | None = None,
-) -> DuplexRuntimeExtension:
-    required_methods = (
-        "configure_sampling_params",
-        "plan_append",
-        "decide_output",
-    )
-    missing = [name for name in required_methods if not callable(getattr(extension, name, None))]
-    if missing:
-        raise TypeError(f"Duplex runtime extension is missing callable method(s): {', '.join(missing)}")
-    typed_extension = extension  # type: ignore[assignment]
-    if sampling_defaults is not None:
-        configured = typed_extension.configure_sampling_params(
-            runtime_config={},
-            defaults=sampling_defaults,
-        )
-        if not isinstance(configured, tuple):
-            raise TypeError("Duplex runtime extension must return sampling parameters as a tuple")
-        if len(configured) != len(sampling_defaults):
-            raise ValueError("Duplex runtime extension must return one sampling parameter per stage")
-        for stage_id, (value, default) in enumerate(zip(configured, sampling_defaults, strict=True)):
-            if default is not None and not isinstance(value, type(default)):
-                raise TypeError(
-                    "Duplex runtime extension sampling parameter type mismatch "
-                    f"for stage {stage_id}: expected {type(default).__name__}, got {type(value).__name__}"
-                )
-    return typed_extension
-
-
-from vllm_omni.engine.duplex.lease import (  # noqa: E402, F401
-    DuplexLeaseActivity,
-    DuplexLeaseConfig,
-    DuplexLeaseState,
-    DuplexSessionExpiry,
-)
-from vllm_omni.engine.duplex.session import (  # noqa: E402, F401
-    DuplexAppendReservation,
-    DuplexCompletedAppend,
-    DuplexFenceMismatchError,
-    DuplexInputAppend,
-    DuplexRequestResource,
-    DuplexSessionRuntimeManager,
-    DuplexSessionRuntimeState,
-    DuplexStageBinding,
-)
-
-__all__ = [
-    "DuplexAppendPlan",
-    "DuplexAppendReservation",
-    "DuplexCompletedAppend",
-    "DuplexFenceMismatchError",
-    "DuplexInputAppend",
-    "DuplexInputMode",
-    "DuplexLeaseActivity",
-    "DuplexLeaseConfig",
-    "DuplexLeaseState",
-    "DuplexOutputAction",
-    "DuplexOutputDecision",
-    "DuplexRequestResource",
-    "DuplexRuntimeCapabilities",
-    "DuplexRuntimeExtension",
-    "DuplexSessionExpiry",
-    "DuplexSessionRuntimeManager",
-    "DuplexSessionRuntimeState",
-    "DuplexStageBinding",
-    "SessionMode",
-    "duplex_data_plane_request_info",
-    "duplex_resource_request_belongs_to_session",
-    "duplex_resource_request_id",
-    "load_duplex_runtime_extension",
-    "validate_duplex_runtime_extension",
-]
diff --git a/vllm_omni/engine/duplex/session.py b/vllm_omni/engine/duplex/session.py
deleted file mode 100644
index b7ad51504..000000000
--- a/vllm_omni/engine/duplex/session.py
+++ /dev/null
@@ -1,534 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-from __future__ import annotations
-
-import time
-from collections import OrderedDict
-from collections.abc import Callable, Iterable
-from dataclasses import dataclass, field
-from typing import Any
-
-from vllm_omni.engine.duplex.contracts import (
-    DuplexInputMode,
-    DuplexRuntimeCapabilities,
-)
-from vllm_omni.engine.duplex.lease import (
-    DuplexLeaseActivity,
-    DuplexLeaseConfig,
-    DuplexLeaseState,
-    DuplexSessionExpiry,
-)
-from vllm_omni.engine.duplex.messages import DuplexFence
-
-
-def _default_capabilities() -> DuplexRuntimeCapabilities:
-    return DuplexRuntimeCapabilities()
-
-
-class DuplexFenceMismatchError(RuntimeError):
-    def __init__(self, expected: DuplexFence, actual: DuplexFence) -> None:
-        super().__init__(f"duplex fence mismatch: expected {expected!r}, got {actual!r}")
-        self.expected = expected
-        self.actual = actual
-
-
-@dataclass
-class DuplexStageBinding:
-    request_id: str
-    fence: DuplexFence
-
-
-@dataclass
-class DuplexRequestResource:
-    stage_id: int
-    request_id: str
-    fence: DuplexFence
-    submitted: bool = False
-
-
-@dataclass
-class DuplexInputAppend:
-    seq: int
-    turn_seq: int
-    turn_id: int
-
-
-@dataclass(frozen=True)
-class DuplexAppendReservation:
-    fence: DuplexFence
-    mode: DuplexInputMode
-    base_fence: DuplexFence
-    base_input_seq: int
-    base_input_turn_seq: int
-    base_append_turn_key: tuple[int, int, int] | None
-    update: DuplexInputAppend
-
-
-@dataclass(frozen=True)
-class DuplexCompletedAppend:
-    fence: DuplexFence
-    mode: DuplexInputMode
-    final: bool
-    stage_results: tuple[dict[str, object], ...]
-
-
-@dataclass
-class DuplexSessionRuntimeState:
-    """Engine resource handles associated with a core-owned identity fence."""
-
-    fence: DuplexFence
-    lease: DuplexLeaseState
-    _clock: Callable[[], float] = field(repr=False)
-    capabilities: DuplexRuntimeCapabilities = field(default_factory=_default_capabilities)
-    session_config: dict[str, Any] = field(default_factory=dict)
-    runtime_config: dict[str, Any] = field(default_factory=dict)
-    config_generation: int = 0
-    stage_bindings: dict[int, DuplexStageBinding] = field(default_factory=dict)
-    request_resources: dict[tuple[int, str], DuplexRequestResource] = field(default_factory=dict)
-    input_seq: int = 0
-    input_turn_seq: int = 0
-    _append_turn_key: tuple[int, int, int] | None = None
-    completed_append_limit: int = 256
-    completed_appends: OrderedDict[str, DuplexCompletedAppend] = field(default_factory=OrderedDict)
-
-    def __post_init__(self) -> None:
-        if self.completed_append_limit <= 0:
-            raise ValueError("completed_append_limit must be positive")
-
-    @property
-    def session_id(self) -> str:
-        return self.fence.session_id
-
-    @property
-    def epoch(self) -> int:
-        return self.fence.epoch
-
-    @property
-    def turn_id(self) -> int:
-        return self.fence.turn_id
-
-    def _validate_fence(self, fence: DuplexFence) -> None:
-        if fence.session_id != self.session_id or fence.incarnation != self.fence.incarnation:
-            raise DuplexFenceMismatchError(self.fence, fence)
-        current = self.fence
-        if fence.epoch < current.epoch or (
-            fence.epoch == current.epoch
-            and (fence.turn_id < current.turn_id or fence.response_seq < current.response_seq)
-        ):
-            raise DuplexFenceMismatchError(current, fence)
-
-    def accept_fence(self, fence: DuplexFence) -> None:
-        self._validate_fence(fence)
-        if fence.epoch != self.fence.epoch:
-            self.input_seq = 0
-            self.input_turn_seq = 0
-            self._append_turn_key = None
-            self.completed_appends.clear()
-        self.fence = fence
-
-    def touch(self, fence: DuplexFence, activity: DuplexLeaseActivity) -> None:
-        self._validate_fence(fence)
-        self.lease.touch(self._clock(), activity)
-
-    def detach(self, fence: DuplexFence) -> None:
-        self._validate_fence(fence)
-        self.lease.detach(self._clock())
-
-    def resume(self, fence: DuplexFence, *, expected_lease_generation: int) -> int:
-        self._validate_fence(fence)
-        return self.lease.resume(
-            self._clock(),
-            expected_generation=expected_lease_generation,
-        )
-
-    def begin_operation(self, fence: DuplexFence, operation_id: str) -> None:
-        self._validate_fence(fence)
-        self.lease.begin_operation(self._clock(), operation_id)
-
-    def end_operation(self, fence: DuplexFence, operation_id: str) -> None:
-        self._validate_fence(fence)
-        self.lease.end_operation(self._clock(), operation_id)
-
-    def replace_session_config(self, session_config: dict[str, Any]) -> None:
-        self.session_config = dict(session_config)
-        self.config_generation += 1
-
-    def replace_runtime_config(self, runtime_config: dict[str, Any]) -> None:
-        self.runtime_config = dict(runtime_config)
-        self.config_generation += 1
-
-    def replace_configs(
-        self,
-        *,
-        session_config: dict[str, Any] | None = None,
-        runtime_config: dict[str, Any] | None = None,
-    ) -> None:
-        """Atomically publish one validated configuration generation."""
-        if session_config is None and runtime_config is None:
-            return
-        next_session_config = self.session_config if session_config is None else dict(session_config)
-        next_runtime_config = self.runtime_config if runtime_config is None else dict(runtime_config)
-        self.session_config = next_session_config
-        self.runtime_config = next_runtime_config
-        self.config_generation += 1
-
-    def reserve_stage_request(self, stage_id: int, request_id: str, *, fence: DuplexFence) -> None:
-        self._validate_fence(fence)
-        resource_key = (stage_id, request_id)
-        existing = self.request_resources.get(resource_key)
-        if existing is not None:
-            if (
-                existing.fence.session_id != fence.session_id
-                or existing.fence.incarnation != fence.incarnation
-                or existing.fence.epoch != fence.epoch
-            ):
-                raise ValueError(f"Duplex request resource already reserved with different identity: {request_id}")
-            return
-        self.request_resources[resource_key] = DuplexRequestResource(
-            stage_id=stage_id,
-            request_id=request_id,
-            fence=fence,
-        )
-
-    def bind_stage_request(self, stage_id: int, request_id: str, *, fence: DuplexFence) -> None:
-        self.reserve_stage_request(stage_id, request_id, fence=fence)
-        self.accept_fence(fence)
-        resource = self.request_resources[(stage_id, request_id)]
-        resource.fence = fence
-        resource.submitted = True
-        self.stage_bindings[stage_id] = DuplexStageBinding(request_id=request_id, fence=fence)
-
-    def stage_request_ids(self, fence: DuplexFence | None = None) -> list[str]:
-        return [
-            binding.request_id for binding in self.stage_bindings.values() if fence is None or binding.fence == fence
-        ]
-
-    def resource_request_ids(
-        self,
-        fence: DuplexFence | None = None,
-        *,
-        submitted: bool | None = None,
-    ) -> list[str]:
-        return list(
-            dict.fromkeys(
-                resource.request_id
-                for resource in self.request_resources.values()
-                if (fence is None or resource.fence == fence) and (submitted is None or resource.submitted is submitted)
-            )
-        )
-
-    def release_request_ids(self, request_ids: list[str]) -> None:
-        released = set(request_ids)
-        if not released:
-            return
-        self.stage_bindings = {
-            stage_id: binding for stage_id, binding in self.stage_bindings.items() if binding.request_id not in released
-        }
-        self.request_resources = {
-            resource_key: resource
-            for resource_key, resource in self.request_resources.items()
-            if resource.request_id not in released
-        }
-
-    def prepare_append(self, *, mode: DuplexInputMode, fence: DuplexFence) -> DuplexAppendReservation:
-        if mode not in self.capabilities.input_modes:
-            raise ValueError(f"Duplex input mode {mode.value!r} is not supported by session {self.session_id}")
-        self._validate_fence(fence)
-        input_seq = 0 if fence.epoch != self.fence.epoch else self.input_seq
-        input_turn_seq = 0 if fence.epoch != self.fence.epoch else self.input_turn_seq
-        append_turn_key = None if fence.epoch != self.fence.epoch else self._append_turn_key
-        turn_key = (fence.epoch, fence.turn_id, fence.response_seq)
-        turn_seq = input_turn_seq + 1 if turn_key == append_turn_key else 1
-        return DuplexAppendReservation(
-            fence=fence,
-            mode=mode,
-            base_fence=self.fence,
-            base_input_seq=self.input_seq,
-            base_input_turn_seq=self.input_turn_seq,
-            base_append_turn_key=self._append_turn_key,
-            update=DuplexInputAppend(
-                seq=input_seq + 1,
-                turn_seq=turn_seq,
-                turn_id=fence.turn_id,
-            ),
-        )
-
-    def commit_append(self, reservation: DuplexAppendReservation) -> DuplexInputAppend:
-        if (
-            self.fence != reservation.base_fence
-            or self.input_seq != reservation.base_input_seq
-            or self.input_turn_seq != reservation.base_input_turn_seq
-            or self._append_turn_key != reservation.base_append_turn_key
-        ):
-            raise RuntimeError("duplex append reservation is stale")
-        self.accept_fence(reservation.fence)
-        self.input_seq = reservation.update.seq
-        self.input_turn_seq = reservation.update.turn_seq
-        self._append_turn_key = (
-            reservation.fence.epoch,
-            reservation.fence.turn_id,
-            reservation.fence.response_seq,
-        )
-        return reservation.update
-
-    def completed_append(
-        self,
-        operation_id: str,
-        *,
-        fence: DuplexFence,
-        mode: DuplexInputMode,
-        final: bool,
-    ) -> list[dict[str, object]] | None:
-        self._validate_fence(fence)
-        completed = self.completed_appends.get(operation_id)
-        if completed is None:
-            return None
-        if completed.fence != fence or completed.mode != mode or completed.final != final:
-            raise ValueError(f"duplex append operation {operation_id!r} was reused with different metadata")
-        return [dict(result) for result in completed.stage_results]
-
-    def record_completed_append(
-        self,
-        operation_id: str,
-        *,
-        fence: DuplexFence,
-        mode: DuplexInputMode,
-        final: bool,
-        stage_results: list[dict[str, object]],
-    ) -> None:
-        self.completed_appends[operation_id] = DuplexCompletedAppend(
-            fence=fence,
-            mode=mode,
-            final=final,
-            stage_results=tuple(dict(result) for result in stage_results),
-        )
-        self.completed_appends.move_to_end(operation_id)
-        while len(self.completed_appends) > self.completed_append_limit:
-            self.completed_appends.popitem(last=False)
-
-    def append_input(self, *, mode: DuplexInputMode, fence: DuplexFence) -> DuplexInputAppend:
-        return self.commit_append(self.prepare_append(mode=mode, fence=fence))
-
-    def release_fence(self, fence: DuplexFence) -> list[str]:
-        stale = self.resource_request_ids(fence)
-        self.stage_bindings = {
-            stage_id: binding for stage_id, binding in self.stage_bindings.items() if binding.fence != fence
-        }
-        self.request_resources = {
-            resource_key: resource
-            for resource_key, resource in self.request_resources.items()
-            if resource.fence != fence
-        }
-        return stale
-
-    def cancel_fence(self, cancelled_fence: DuplexFence, next_fence: DuplexFence) -> list[str]:
-        stale = self.prepare_cancel_fence(cancelled_fence, next_fence)
-        self.release_fence(cancelled_fence)
-        return stale
-
-    def prepare_cancel_fence(self, cancelled_fence: DuplexFence, next_fence: DuplexFence) -> list[str]:
-        """Advance the cancellation fence without dropping cleanup records."""
-        if cancelled_fence.session_id != self.session_id or cancelled_fence.incarnation != self.fence.incarnation:
-            raise DuplexFenceMismatchError(self.fence, cancelled_fence)
-        if (
-            next_fence.session_id != self.session_id
-            or next_fence.incarnation != self.fence.incarnation
-            or next_fence.epoch <= cancelled_fence.epoch
-        ):
-            raise DuplexFenceMismatchError(cancelled_fence, next_fence)
-        current_key = (self.fence.epoch, self.fence.turn_id, self.fence.response_seq)
-        cancelled_key = (cancelled_fence.epoch, cancelled_fence.turn_id, cancelled_fence.response_seq)
-        next_key = (next_fence.epoch, next_fence.turn_id, next_fence.response_seq)
-        if cancelled_key > current_key:
-            raise DuplexFenceMismatchError(self.fence, cancelled_fence)
-        if next_key > current_key:
-            self.accept_fence(next_fence)
-        return self.resource_request_ids(cancelled_fence)
-
-    def begin_close(self, fence: DuplexFence, *, reason: str) -> bool:
-        """Make close irreversible while retaining resources for cleanup retry."""
-        self.accept_fence(fence)
-        if self.lease.terminal_reason is not None:
-            return True
-        return self.lease.mark_terminal(reason)
-
-    def finalize_close(self) -> list[str]:
-        return self.close()
-
-    def close(self, fence: DuplexFence | None = None) -> list[str]:
-        if fence is not None:
-            self.accept_fence(fence)
-        stale = self.resource_request_ids()
-        self.stage_bindings.clear()
-        self.request_resources.clear()
-        return stale
-
-    def terminate(self, fence: DuplexFence, *, reason: str) -> bool:
-        if not self.begin_close(fence, reason=reason):
-            return False
-        self.finalize_close()
-        return True
-
-
-class DuplexSessionRuntimeManager:
-    def __init__(
-        self,
-        *,
-        clock: Callable[[], float] | None = None,
-        max_sessions: int | None = None,
-        completed_append_limit: int = 256,
-    ) -> None:
-        if max_sessions is not None and max_sessions <= 0:
-            raise ValueError("max_sessions must be positive or null")
-        if completed_append_limit <= 0:
-            raise ValueError("completed_append_limit must be positive")
-        self._sessions: dict[str, DuplexSessionRuntimeState] = {}
-        self._clock = clock or time.monotonic
-        self._max_sessions = max_sessions
-        self._completed_append_limit = completed_append_limit
-
-    def open_session(
-        self,
-        fence: DuplexFence,
-        *,
-        capabilities: DuplexRuntimeCapabilities | None = None,
-        session_config: dict[str, Any] | None = None,
-        runtime_config: dict[str, Any] | None = None,
-        lease_config: DuplexLeaseConfig | None = None,
-    ) -> DuplexSessionRuntimeState:
-        if not isinstance(fence, DuplexFence):
-            raise TypeError("open_session requires DuplexFence")
-        if fence.session_id in self._sessions:
-            raise ValueError(f"Duplex session already exists: {fence.session_id}")
-        if self._max_sessions is not None and len(self._sessions) >= self._max_sessions:
-            raise RuntimeError(f"duplex_session_capacity_exhausted: limit={self._max_sessions}")
-        session = DuplexSessionRuntimeState(
-            fence=fence,
-            lease=DuplexLeaseState(
-                config=lease_config or DuplexLeaseConfig(),
-                generation=0,
-                last_activity=self._clock(),
-            ),
-            _clock=self._clock,
-            capabilities=capabilities or _default_capabilities(),
-            session_config=dict(session_config or {}),
-            runtime_config=dict(runtime_config or {}),
-            completed_append_limit=self._completed_append_limit,
-        )
-        self._sessions[fence.session_id] = session
-        return session
-
-    def get(self, session_id: str) -> DuplexSessionRuntimeState | None:
-        return self._sessions.get(session_id)
-
-    def require(self, session_id: str) -> DuplexSessionRuntimeState:
-        session = self.get(session_id)
-        if session is None:
-            raise KeyError(f"Unknown duplex session: {session_id}")
-        return session
-
-    def close_session(
-        self,
-        fence: DuplexFence,
-        *,
-        reason: str = "explicit_close",
-    ) -> DuplexSessionRuntimeState | None:
-        if not isinstance(fence, DuplexFence):
-            raise TypeError("close_session requires DuplexFence")
-        session = self._sessions.get(fence.session_id)
-        if session is not None:
-            if session.lease.terminal_reason is not None:
-                return None
-            if not session.terminate(fence, reason=reason):
-                return None
-            if self._sessions.get(fence.session_id) is session:
-                self._sessions.pop(fence.session_id)
-        return session
-
-    def begin_close_session(
-        self,
-        fence: DuplexFence,
-        *,
-        reason: str = "explicit_close",
-    ) -> DuplexSessionRuntimeState | None:
-        if not isinstance(fence, DuplexFence):
-            raise TypeError("begin_close_session requires DuplexFence")
-        session = self._sessions.get(fence.session_id)
-        if session is not None:
-            session.begin_close(fence, reason=reason)
-        return session
-
-    def finalize_close_session(self, session: DuplexSessionRuntimeState) -> None:
-        session.finalize_close()
-        if self._sessions.get(session.session_id) is session:
-            self._sessions.pop(session.session_id, None)
-
-    def collect_expired(
-        self,
-        now: float | None = None,
-        *,
-        excluded_session_ids: set[str] | None = None,
-    ) -> list[DuplexSessionExpiry]:
-        effective_now = self._clock() if now is None else now
-        excluded = excluded_session_ids or set()
-        expired: list[DuplexSessionExpiry] = []
-        for session_id, session in list(self._sessions.items()):
-            if session_id in excluded:
-                continue
-            if session.lease.disconnect_grace_expired(effective_now):
-                reason = "disconnect_grace_expired"
-            elif session.lease.idle_expired(effective_now):
-                reason = "idle_ttl_expired"
-            else:
-                continue
-            submitted = tuple(session.resource_request_ids(submitted=True))
-            reserved = tuple(session.resource_request_ids(submitted=False))
-            if not session.begin_close(session.fence, reason=reason):
-                continue
-            expired.append(
-                DuplexSessionExpiry(
-                    session_id=session_id,
-                    fence=session.fence,
-                    lease_generation=session.lease.generation,
-                    reason=reason,
-                    submitted_request_ids=submitted,
-                    reserved_request_ids=reserved,
-                )
-            )
-        return expired
-
-    def close_sessions_for_request_ids(self, request_ids: list[str]) -> dict[str, list[str]]:
-        request_id_set = set(request_ids)
-        closed: dict[str, list[str]] = {}
-        for session_id, session in list(self._sessions.items()):
-            stale = session.resource_request_ids()
-            if request_id_set.isdisjoint(stale):
-                continue
-            if not session.begin_close(session.fence, reason="request_cleanup"):
-                continue
-            closed[session_id] = stale
-        return closed
-
-    def finalize_closed_sessions(self, session_ids: Iterable[str]) -> None:
-        for session_id in session_ids:
-            session = self._sessions.get(session_id)
-            if session is None or session.lease.terminal_reason is None:
-                continue
-            self.finalize_close_session(session)
-
-
-__all__ = [
-    "DuplexAppendReservation",
-    "DuplexCompletedAppend",
-    "DuplexFenceMismatchError",
-    "DuplexInputAppend",
-    "DuplexLeaseActivity",
-    "DuplexLeaseConfig",
-    "DuplexLeaseState",
-    "DuplexRequestResource",
-    "DuplexSessionExpiry",
-    "DuplexSessionRuntimeManager",
-    "DuplexSessionRuntimeState",
-    "DuplexStageBinding",
-]
diff --git a/vllm_omni/engine/duplex/session/__init__.py b/vllm_omni/engine/duplex/session/__init__.py
new file mode 100644
index 000000000..a062ebf0e
--- /dev/null
+++ b/vllm_omni/engine/duplex/session/__init__.py
@@ -0,0 +1,38 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""One engine-resident duplex session, and everything that runs it.
+
+``DuplexEngineSession`` (``engine_session``) is the state -- the input,
+response, playback and conversation ledgers, the lease and the identity fence.
+``DuplexSessionRunner`` (``runner``) owns one of those on the orchestrator loop
+and is the only writer of it; ``DuplexSessionManager`` (``manager``) owns the
+runners and the admission slots.
+
+The rest of the package is what the runner was split into, and each module
+names the thing it owns rather than a layer:
+
+* ``context``  -- the state a runner and its components share, and the only
+  services a component may ask the runner for.
+* ``emitter``  -- everything the session sends: the Realtime projection, the
+  epoch filter, the domain effects a terminal event applies.
+* ``model_channel`` -- the model side: submitting an append, projecting the
+  stage output that comes back, continuing a turn with silence.
+* ``control``  -- server VAD and the events that reconfigure the session.
+* ``append_task`` -- one append in flight, and the rollback its failure owes.
+* ``helpers``  -- the small pure reads and payload builders over a session.
+* ``overlap_policy`` / ``commit_policy`` / ``playback_ledger`` -- the decisions
+  a session makes about speech that arrives while the model is speaking, what a
+  commit should do, and what the client has actually played.
+* ``lease`` -- the idle/activity lease that decides when a session expires.
+
+Imports here are the package's public surface; a module of this package is fair
+game for anything inside it, but code outside ``engine.duplex`` should reach for
+these three names.
+"""
+
+from vllm_omni.engine.duplex.session.engine_session import DuplexEngineSession
+from vllm_omni.engine.duplex.session.manager import DuplexSessionManager
+from vllm_omni.engine.duplex.session.runner import DuplexSessionRunner
+
+__all__ = ["DuplexEngineSession", "DuplexSessionManager", "DuplexSessionRunner"]
diff --git a/vllm_omni/engine/duplex/session/append_task.py b/vllm_omni/engine/duplex/session/append_task.py
new file mode 100644
index 000000000..6092f26cf
--- /dev/null
+++ b/vllm_omni/engine/duplex/session/append_task.py
@@ -0,0 +1,200 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""One append in flight, and what its failure owes the session.
+
+An append is not a call: it is a task queued behind the previous append, which
+may be cancelled, may find the session closed before it starts, and on any of
+those paths has to give back what it reserved --- the PCM bytes it took from the
+input budget, the committed audio it was going to consume, and the response it
+precreated.
+
+That compensation is the reason this is an object. The five steps of an append
+all need the same eleven values, so as closures over ``_start_append`` they read
+as one function with five entry points and no way to test any of them. Named
+fields make the captured state explicit and the compensation a method.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from vllm.logger import init_logger
+
+from vllm_omni.engine.duplex.config import DuplexSessionState, DuplexTurnEventType
+from vllm_omni.engine.duplex.plugin import PcmAppendReservation
+from vllm_omni.engine.duplex.session import helpers
+from vllm_omni.engine.duplex.session.context import DuplexSessionContext
+from vllm_omni.engine.duplex.session.emitter import SessionEmitter
+from vllm_omni.engine.duplex.session.model_channel import ModelChannel
+
+logger = init_logger(__name__)
+
+
+@dataclass(slots=True)
+class AppendAttempt:
+    """One queued append to the model, with the rollback each failure path owes."""
+
+    ctx: DuplexSessionContext
+    out: SessionEmitter
+    model: ModelChannel
+    #: Marks the session closing before the close coroutine gets to run.
+    fail_session: Callable[[str], None]
+
+    payload: dict[str, object]
+    epoch: int
+    request_id: str
+    final: bool
+    pcm_reservation: PcmAppendReservation | None
+    operation_id: str | None
+    #: Committed audio this append consumes; released once it is safely submitted.
+    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 = None
+
+    # ------------------------------------------------------------------ #
+    # Compensation                                                       #
+    # ------------------------------------------------------------------ #
+
+    def discard_retained_audio(self) -> None:
+        """Release the committed audio this append was going to consume.
+
+        Only if it is still the session's: a later commit may have replaced it,
+        and that one belongs to the append that will carry it.
+        """
+        model_state = self.ctx.model_state
+        if self.retained_committed_payload is not None and (
+            model_state.committed_audio_payload is self.retained_committed_payload
+        ):
+            self.ctx.session.release_input_bytes(model_state.clear_committed_audio())
+
+    def abandon(self) -> None:
+        """Give back everything this append reserved but never used."""
+        if self.pcm_reservation is not None:
+            self.pcm_reservation.rollback()
+        self.discard_retained_audio()
+
+    def release_on_failure(self, done: asyncio.Task[bool]) -> None:
+        """Done-callback: a cancelled or failed append must not hold the audio."""
+        if done.cancelled():
+            self.discard_retained_audio()
+            return
+        try:
+            append_ok = done.result()
+        except Exception:
+            append_ok = False
+        if not append_ok:
+            self.discard_retained_audio()
+
+    def clear_pending_silence(self, done: asyncio.Task[bool]) -> None:
+        """Done-callback of a silence continuation: it is no longer pending."""
+        model_state = self.ctx.model_state
+        if model_state.pending_silence_task is done:
+            model_state.pending_silence_task = None
+            model_state.pending_silence_owner_id = None
+
+    # ------------------------------------------------------------------ #
+    # Running                                                            #
+    # ------------------------------------------------------------------ #
+
+    async def run_in_wire_order(self, predecessor: asyncio.Task[bool] | None) -> bool:
+        """Wait for the previous append, then submit this one if it still applies."""
+        if predecessor is not None:
+            try:
+                predecessor_ok = await predecessor
+            except asyncio.CancelledError:
+                if helpers.task_is_cancelling(asyncio.current_task()):
+                    raise
+                predecessor_ok = False
+            except Exception:
+                predecessor_ok = False
+            if not predecessor_ok:
+                self.abandon()
+                return False
+        run = self.ctx.run
+        if run.closing or run.runtime_closed or self.ctx.session.state != DuplexSessionState.OPEN:
+            self.abandon()
+            return False
+        if self.before_append is not None and not self.before_append():
+            self.abandon()
+            # Called off, not failed: the chain behind it still runs.
+            return True
+        if self.pcm_reservation is not None and not self.pcm_reservation.active:
+            self.discard_retained_audio()
+            return False
+        return await self._submit()
+
+    async def _submit(self) -> bool:
+        session = self.ctx.session
+        model_state = self.ctx.model_state
+        try:
+            append_ok, emitted_response = await self.model.append_runtime_input(
+                self.payload,
+                operation_id=(
+                    self.pcm_reservation.operation_id if self.pcm_reservation is not None else self.operation_id
+                ),
+                final=self.final,
+                expected_epoch=self.epoch,
+                on_append_accepted=self.on_append_accepted,
+            )
+            if append_ok:
+                model_state.context_locked = True
+                if self.pcm_reservation is not None:
+                    self.pcm_reservation.commit()
+                    session.release_input_bytes(self.pcm_reservation.byte_count)
+                self.discard_retained_audio()
+            else:
+                self.abandon()
+            if not append_ok and self._precreated_response_still_active():
+                self._fail_precreated_response()
+            if not append_ok and session.state == DuplexSessionState.CLOSED:
+                self.ctx.run.runtime_closed = True
+                return False
+            if not emitted_response and session.epoch == self.epoch:
+                # 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
+        except asyncio.CancelledError:
+            if self.pcm_reservation is not None:
+                self.pcm_reservation.rollback()
+            raise
+        except Exception as exc:
+            self.abandon()
+            logger.exception("Native duplex append task failed: %s", exc)
+            self.model.send_runtime_error("runtime_append_task_failed", exc)
+            if session.state != DuplexSessionState.CLOSED:
+                self.fail_session("runtime_append_task_failed")
+            return False
+
+    def _precreated_response_still_active(self) -> bool:
+        return (
+            self.precreated_response_id is not None
+            and self.ctx.session.active_response_id == self.precreated_response_id
+        )
+
+    def _fail_precreated_response(self) -> None:
+        session = self.ctx.session
+        session.end_response(commit_text=False)
+        self.out.emit(
+            {
+                "type": "response.done",
+                "session_id": session.session_id,
+                "response_id": self.precreated_response_id,
+                "epoch": session.epoch,
+                "committed": False,
+                "status": "failed",
+                "status_details": {"type": "failed", "reason": "runtime_append_failed"},
+                "playback": session.playback.as_dict(),
+            }
+        )
diff --git a/vllm_omni/entrypoints/duplex/commit_policy.py b/vllm_omni/engine/duplex/session/commit_policy.py
similarity index 91%
rename from vllm_omni/entrypoints/duplex/commit_policy.py
rename to vllm_omni/engine/duplex/session/commit_policy.py
index 868b98c98..0c07a6fa3 100644
--- a/vllm_omni/entrypoints/duplex/commit_policy.py
+++ b/vllm_omni/engine/duplex/session/commit_policy.py
@@ -21,7 +21,7 @@ class CommitSnapshot:
     speech_since_commit: bool
     active_response_id: str | None
     overlap_speech_ms: int
-    native_response_in_progress: bool
+    response_in_progress: bool
     playback_active: bool
 
 
@@ -31,7 +31,7 @@ def decide_commit_action(snapshot: CommitSnapshot) -> CommitAction:
         if snapshot.speech_since_commit:
             return CommitAction.START_AUTO_RESPONSE
         return CommitAction.COMMIT_ONLY
-    if snapshot.native_response_in_progress and snapshot.overlap_speech_ms > 0:
+    if snapshot.response_in_progress and snapshot.overlap_speech_ms > 0:
         return CommitAction.DEFER_ACTIVE_RESPONSE
     if snapshot.playback_active and snapshot.overlap_speech_ms > 0:
         return CommitAction.DEFER_ACTIVE_RESPONSE
diff --git a/vllm_omni/engine/duplex/session/context.py b/vllm_omni/engine/duplex/session/context.py
new file mode 100644
index 000000000..1e7b861bc
--- /dev/null
+++ b/vllm_omni/engine/duplex/session/context.py
@@ -0,0 +1,161 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Shared state for :class:`DuplexSessionRunner` and its components.
+
+The runner is a state machine that several components read and write. Splitting
+it into modules only helps if the shared part stops being implicit: a component
+holding a back-reference to the runner is a mixin with extra steps, and one
+holding its own copy of a flag diverges from the others.
+
+So the mutable part is named. ``DuplexRunState`` is the small set of flags that
+more than one component touches -- ``grep "\\.run\\."`` finds every mutation --
+and ``DuplexSessionContext`` is the read-mostly collaborator bundle everything
+is constructed with. Anything a component needs from the runner that is neither
+of those is infrastructure, and goes through :class:`RunnerServices`.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Protocol, TypeVar
+
+if TYPE_CHECKING:
+    from vllm.outputs import RequestOutput
+
+    from vllm_omni.engine.duplex.contracts import (
+        DuplexOutputContext,
+        DuplexOutputDecision,
+        DuplexStagePort,
+    )
+    from vllm_omni.engine.duplex.plugin import DuplexModelPlugin, DuplexModelSessionState
+    from vllm_omni.engine.duplex.session.engine_session import DuplexEngineSession
+    from vllm_omni.engine.duplex.session.manager import DuplexSessionManager
+    from vllm_omni.metrics.stats import StageRequestStats
+
+_OffloadT = TypeVar("_OffloadT")
+
+
+@dataclass(slots=True)
+class DuplexRunState:
+    """Mutable per-run flags shared by the runner and its components.
+
+    Every field here is written by one component and read by another; that is
+    the criterion for being in this object rather than private to a component.
+    """
+
+    #: An irreversible close has begun: commands and control ops are refused.
+    closing: bool = False
+    #: ``session.closed`` / ``session.expired`` already left the runner.
+    closed_emitted: bool = False
+    #: The terminal event is deferred to the manager, which emits it after the
+    #: stage cleanup so it also means "the admission slot is free again".
+    closed_deferred: bool = False
+    close_reason: str | None = None
+    #: The model runtime reported a close; further data-plane work is pointless.
+    runtime_closed: bool = False
+    #: Request id of the resumable data-plane stream currently bound to the session.
+    stream_request_id: str | None = None
+
+
+class RunnerServices(Protocol):
+    """The only things a component may ask the runner for.
+
+    Deliberately two methods. A component that needs more than task scheduling
+    from the runner is reaching for orchestration that belongs in the runner.
+    """
+
+    def spawn(self, coro: Awaitable[None], *, name: str) -> None:
+        """Run ``coro`` as a tracked background task on the session's loop."""
+        ...
+
+    async def offload(self, fn: Callable[..., _OffloadT], *args: object, **kwargs: object) -> _OffloadT:
+        """Run a blocking call off the orchestrator loop."""
+        ...
+
+
+@dataclass(slots=True)
+class DuplexSessionContext:
+    """Collaborators one session's components are built with.
+
+    Read-mostly: the session and the model state are mutated through their own
+    APIs, not by rebinding these fields. The mutable flags live in ``run``.
+    """
+
+    session: DuplexEngineSession
+    model_state: DuplexModelSessionState
+    plugin: DuplexModelPlugin
+    stage_port: DuplexStagePort
+    manager: DuplexSessionManager
+    tasks: DuplexSessionTasks
+    run: DuplexRunState
+    services: RunnerServices
+
+
+# --------------------------------------------------------------------------- #
+# Task bookkeeping                                                            #
+# --------------------------------------------------------------------------- #
+
+
+@dataclass(frozen=True, slots=True)
+class DuplexAppendTaskMeta:
+    epoch: int
+    final: bool
+    response_bound: bool
+
+
+@dataclass
+class DuplexSessionTasks:
+    """Tracked task handles of one session (append tail, active response, pending silence)."""
+
+    append_tasks: dict[asyncio.Task[bool], DuplexAppendTaskMeta] = field(default_factory=dict)
+    append_tail: asyncio.Task[bool] | None = None
+    active_response_task: asyncio.Task[None] | None = None
+
+    def track_append_task(
+        self,
+        task: asyncio.Task[bool],
+        *,
+        epoch: int,
+        final: bool,
+        response_bound: bool,
+    ) -> None:
+        self.append_tasks[task] = DuplexAppendTaskMeta(epoch, final, response_bound)
+        task.add_done_callback(self.append_tasks.pop)
+
+    def has_response_bound_append_tasks(self) -> bool:
+        return any(meta.response_bound for meta in self.append_tasks.values())
+
+    async def cancel_append_tasks(self, timeout_s: float = 0.25, *, response_bound_only: bool = False) -> bool:
+        tasks = [task for task, meta in self.append_tasks.items() if not response_bound_only or meta.response_bound]
+        if not tasks:
+            return False
+        cancelled_tail = self.append_tail if self.append_tail in tasks else None
+        for task in tasks:
+            task.cancel()
+        try:
+            await asyncio.wait_for(asyncio.gather(*tasks, return_exceptions=True), timeout=timeout_s)
+        except TimeoutError:
+            pass
+        if cancelled_tail is not None and self.append_tail is cancelled_tail:
+            self.append_tail = None
+        return True
+
+
+# --------------------------------------------------------------------------- #
+# Stage output (the mailbox item the orchestrator hands the runner)           #
+# --------------------------------------------------------------------------- #
+
+
+@dataclass(frozen=True, slots=True)
+class StageOutput:
+    """One stage result, queued for the session that owns the request."""
+
+    stage_id: int
+    output: RequestOutput
+    metrics: StageRequestStats | None
+    request_id: str
+    context: DuplexOutputContext
+    decision: DuplexOutputDecision | None
diff --git a/vllm_omni/engine/duplex/session/control.py b/vllm_omni/engine/duplex/session/control.py
new file mode 100644
index 000000000..5de703acd
--- /dev/null
+++ b/vllm_omni/engine/duplex/session/control.py
@@ -0,0 +1,382 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Control of one duplex session: server VAD, and the events that reconfigure it.
+
+Server turn detection and ``session.update`` are the same concern seen from two
+sides. The detector is per-session mutable state, and ``session.update`` is the
+event that replaces it mid-flight -- along with the session config, the runtime
+config and the sampling policy, each of which has to be validated against a
+candidate before the live session adopts it. The rest of ``turn.signal``
+(conversation items, local turn markers) travels the same path and is small, so
+it lives here rather than in a module of its own.
+
+The one thing this does not own is ordering against the data plane: a
+``session.update`` must not overtake an append still in flight, so the runner
+supplies ``wait_for_append_tail``.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from copy import deepcopy
+
+from vllm.logger import init_logger
+
+from vllm_omni.engine.duplex.config import DuplexConfigError, realtime_item_to_history_message
+from vllm_omni.engine.duplex.plugin import DuplexRuntimeConfigError
+from vllm_omni.engine.duplex.session import helpers
+from vllm_omni.engine.duplex.session.context import DuplexSessionContext
+from vllm_omni.engine.duplex.session.emitter import SessionEmitter
+from vllm_omni.engine.duplex.session.lease import DuplexLeaseActivity
+from vllm_omni.engine.duplex.session.model_channel import ModelChannel
+from vllm_omni.engine.duplex.turn_detection import (
+    PendingTurnDetectionUpdate,
+    ServerTurnDetector,
+    ServerVADUnavailableError,
+    SileroVADBackendProvider,
+    TurnDetectionConfig,
+    TurnDetectionResult,
+    apply_turn_detection_result,
+)
+
+logger = init_logger(__name__)
+
+
+class SessionControl:
+    """Server VAD and the control events that reconfigure one session."""
+
+    def __init__(
+        self,
+        ctx: DuplexSessionContext,
+        out: SessionEmitter,
+        model: ModelChannel,
+        *,
+        wait_for_append_tail: Callable[[], Awaitable[bool]],
+    ) -> None:
+        self._ctx = ctx
+        self._out = out
+        self._model = model
+        self._wait_for_append_tail = wait_for_append_tail
+        self._config: TurnDetectionConfig | None = None
+        self._detector: ServerTurnDetector | None = None
+
+    def init_turn_detection(self) -> None:
+        turn_detection = self._ctx.session.config.extra_body.get("realtime_turn_detection")
+        if not isinstance(turn_detection, dict) or turn_detection.get("type") != "server_vad":
+            self._config = None
+            self._detector = None
+            return
+        try:
+            config = TurnDetectionConfig.from_realtime(turn_detection)
+            self._config = config
+            self._detector = config.build_detector(self._vad_backend_provider())
+        except Exception as exc:
+            logger.warning("Duplex session %s: turn detection disabled: %s", self._ctx.session.session_id, exc)
+            self._config = None
+            self._detector = None
+
+    def _vad_backend_provider(self) -> SileroVADBackendProvider | None:
+        """The engine-wide Silero backend, so one model serves every session.
+
+        Held by the manager rather than built here: the ONNX backend is shared,
+        and ``duplex_session.server_vad_model_path`` is a deploy-level setting.
+        """
+        return getattr(self._ctx.manager, "vad_backend_provider", None)
+
+    def reset_vad(self) -> None:
+        """Drop the detector's speech state (a barge-in or a clear starts a new turn)."""
+        if self._detector is not None:
+            self._detector.reset()
+
+    async def run_turn_detection(self, event: dict[str, object]) -> TurnDetectionResult | None:
+        detector = self._detector
+        if detector is None:
+            return None
+        audio = event.get("audio")
+        if not isinstance(audio, str) or not audio:
+            return None
+        fmt = event.get("format") if isinstance(event.get("format"), str) else "pcm_f32le"
+        sample_rate_hz = event.get("sample_rate_hz")
+        try:
+            result = await self._ctx.services.offload(
+                detector.process,
+                audio,
+                fmt=fmt,
+                sample_rate_hz=sample_rate_hz if isinstance(sample_rate_hz, int) else None,
+                audio_end_ms=event.get("audio_end_ms") if isinstance(event.get("audio_end_ms"), int) else None,
+            )
+        except ServerVADUnavailableError as exc:
+            self._out.emit_error("server_vad_unavailable", str(exc))
+            self._detector = None
+            return None
+        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
+
+    # ------------------------------------------------------------------ #
+    # Control events                                                     #
+    # ------------------------------------------------------------------ #
+
+    async def on_turn_signal(self, event: dict[str, object]) -> None:
+        session = self._ctx.session
+        turn_event = event.get("event")
+        realtime_event_id = event.get("realtime_event_id")
+        if not isinstance(turn_event, str):
+            self._out.emit_error("bad_event", "turn.signal requires event")
+            return
+        if turn_event == "barge_in" and not session.capabilities.supports_barge_in:
+            self._out.emit_events([helpers.barge_in_unsupported_error()])
+            return
+        if turn_event == "session.update":
+            payload = event.get("payload")
+            if not isinstance(payload, dict):
+                self._out.emit_error(
+                    "bad_event", "session.update requires a session payload", event_id=realtime_event_id
+                )
+                return
+            await self.on_session_update(
+                payload,
+                realtime_event_id=realtime_event_id if isinstance(realtime_event_id, str) else None,
+            )
+            return
+        if turn_event == "conversation.item.create":
+            await self._on_conversation_item_create(event)
+            return
+        if turn_event == "conversation.item.delete":
+            payload = event.get("payload")
+            item_id = payload.get("item_id") if isinstance(payload, dict) else None
+            deleted = session.delete_history_item(item_id) if isinstance(item_id, str) else False
+            self._out.emit(
+                {
+                    "type": "conversation.item.deleted",
+                    "session_id": session.session_id,
+                    "item_id": item_id,
+                    "deleted": deleted,
+                }
+            )
+            return
+        if turn_event == "conversation.item.truncate":
+            payload = event.get("payload")
+            item_id = payload.get("item_id") if isinstance(payload, dict) else None
+            audio_end_ms = payload.get("audio_end_ms") if isinstance(payload, dict) else None
+            truncated = (
+                session.truncate_history_item(
+                    item_id,
+                    audio_end_ms=int(audio_end_ms) if isinstance(audio_end_ms, int | float) else 0,
+                    hard=True,
+                )
+                if isinstance(item_id, str)
+                else False
+            )
+            self._out.emit(
+                {
+                    "type": "conversation.item.truncated",
+                    "session_id": session.session_id,
+                    "item_id": item_id,
+                    "content_index": (payload.get("content_index", 0) if isinstance(payload, dict) else 0),
+                    "audio_end_ms": audio_end_ms,
+                    "truncated": truncated,
+                }
+            )
+            return
+        self._out.emit_events([session.signal_turn(turn_event, event)])
+
+    async def on_session_update(self, payload: dict[str, object], *, realtime_event_id: str | None) -> None:
+        session = self._ctx.session
+        model_state = self._ctx.model_state
+        pending_turn_detection: PendingTurnDetectionUpdate | None = None
+
+        def reject_update() -> None:
+            if pending_turn_detection is not None:
+                pending_turn_detection.reject()
+
+        try:
+            pending_turn_detection = PendingTurnDetectionUpdate.prepare(
+                payload, backend_provider=self._vad_backend_provider()
+            )
+        except Exception as exc:
+            self._out.emit_error("unsupported_turn_detection", str(exc), event_id=realtime_event_id)
+            return
+        if not await self._wait_for_append_tail():
+            self._out.emit_error(
+                "session_update_aborted",
+                "session.update was not applied because the preceding append failed",
+                event_id=realtime_event_id,
+            )
+            reject_update()
+            return
+        try:
+            self._ctx.plugin.validate_client_extra_body(payload.get("extra_body"))
+        except DuplexRuntimeConfigError as exc:
+            self._out.emit_error(exc.code, str(exc), event_id=realtime_event_id)
+            reject_update()
+            return
+        candidate_config = deepcopy(session.config)
+        audio_started = session.playback.generated_ms > 0 or session.playback.sent_ms > 0
+        try:
+            candidate_config.apply_realtime_update(
+                payload,
+                session_id=session.session_id,
+                audio_started=audio_started,
+            )
+        except DuplexConfigError as exc:
+            self._out.emit_error(exc.code, str(exc) or "session.update was rejected", event_id=realtime_event_id)
+            reject_update()
+            return
+        if candidate_config.instructions != session.config.instructions and model_state.context_locked:
+            self._out.emit_error(
+                "instructions_update_unsupported",
+                "session.update cannot change instructions after the native duplex context is initialized",
+                event_id=realtime_event_id,
+            )
+            reject_update()
+            return
+        requests_audio = any(str(modality).lower() == "audio" for modality in candidate_config.modalities)
+        if (
+            requests_audio
+            and "ref_audio_data" not in session.runtime_config
+            and getattr(self._ctx.plugin, "requires_ref_audio", False)
+        ):
+            self._out.emit_error(
+                "ref_audio_required", "Native duplex audio output requires ref_audio", event_id=realtime_event_id
+            )
+            reject_update()
+            return
+        try:
+            candidate_runtime_config = self._ctx.plugin.runtime_config_for_update(
+                candidate_config,
+                dict(session.runtime_config),
+            )
+            # Validate the sampling policy for the candidate before adopting it.
+            self._ctx.plugin.configure_sampling_params(
+                runtime_config=dict(candidate_runtime_config),
+                defaults=tuple(self._ctx.stage_port.sampling_defaults()),
+            )
+        except (DuplexRuntimeConfigError, DuplexConfigError) as exc:
+            self._out.emit_error(exc.code, str(exc), event_id=realtime_event_id)
+            reject_update()
+            return
+        except Exception as exc:
+            self._out.emit_error("runtime_signal_failed", str(exc), event_id=realtime_event_id)
+            reject_update()
+            return
+        session.replace_config(candidate_config)
+        session.replace_runtime_config(candidate_runtime_config)
+        try:
+            session.touch_lease(DuplexLeaseActivity.SIGNAL)
+        except Exception:
+            pass
+        if pending_turn_detection is not None:
+            self._config, self._detector = pending_turn_detection.commit(self._detector)
+        projector = self._out.require_projector()
+        projector.apply_session_defaults(payload)
+        self._out.emit({"type": "session.updated", "session": session.as_public_dict()})
+
+    async def _on_conversation_item_create(self, event: dict[str, object]) -> None:
+        session = self._ctx.session
+        payload = event.get("payload")
+        item = payload.get("item") if isinstance(payload, dict) else None
+        item_type = item.get("type") if isinstance(item, dict) else None
+        if item_type == "function_call_output" and isinstance(item, dict):
+            if not await self._wait_for_append_tail():
+                return
+            try:
+                candidate_runtime_config = self._ctx.plugin.runtime_config_for_function_output(
+                    session.config,
+                    dict(session.runtime_config),
+                    item,
+                )
+            except DuplexRuntimeConfigError as exc:
+                self._out.emit_error(exc.code, str(exc))
+                return
+            if candidate_runtime_config is not None:
+                session.replace_runtime_config(candidate_runtime_config)
+            self._out.emit(
+                {
+                    "type": "conversation.item.created",
+                    "session_id": session.session_id,
+                    "item": item,
+                    "created": True,
+                }
+            )
+            self._ctx.services.spawn(
+                self._model.maybe_continue_response(
+                    expected_epoch=session.epoch,
+                    expected_model_turn_id=session.turn_id,
+                ),
+                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:
+            session.append_history_message(message)
+            session.register_history_item(item_id if isinstance(item_id, str) else None, message)
+            if message.get("role") == "user":
+                # A later response.create may answer this without any audio.
+                session.notify_new_user_item()
+        self._out.emit(
+            {
+                "type": "conversation.item.created",
+                "session_id": session.session_id,
+                "item": item,
+                "created": message is not None,
+            }
+        )
diff --git a/vllm_omni/engine/duplex/session/emitter.py b/vllm_omni/engine/duplex/session/emitter.py
new file mode 100644
index 000000000..508bc7ef1
--- /dev/null
+++ b/vllm_omni/engine/duplex/session/emitter.py
@@ -0,0 +1,249 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Everything one duplex session sends to its client.
+
+Emission is the hub of the session runner: near enough every path through the
+runner ends in an event, which is why this is a collaborator rather than a
+module of functions. It owns three things the rest of the runner should not
+have to think about --- the Realtime projection state, the epoch filter that
+drops output from a superseded turn, and the domain transitions an outbound
+terminal event applies to the session before it is projected.
+
+The one thing it cannot own is what happens *after* a terminal promotes
+deferred overlap audio: that re-enters the mailbox of the runner, so the
+runner injects it as ``promote_deferred_overlap``.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from vllm_omni.engine.duplex.config import DuplexSessionState
+from vllm_omni.engine.duplex.events import (
+    DOMAIN_TERMINAL_EVENTS,
+    MODEL_OUTPUT_EVENTS,
+    DuplexEvent,
+    error_event,
+)
+from vllm_omni.engine.duplex.realtime_events import (
+    RealtimeProjectionState,
+    discard_pending_input_audio,
+    project_internal_event,
+)
+from vllm_omni.engine.duplex.session import overlap_policy
+from vllm_omni.engine.duplex.session.context import DuplexSessionContext
+
+
+class SessionEmitter:
+    """Outbound events for one session."""
+
+    def __init__(
+        self,
+        ctx: DuplexSessionContext,
+        *,
+        promote_deferred_overlap: Callable[[dict[str, object], bool], None],
+    ) -> None:
+        self._ctx = ctx
+        self._promote_deferred_overlap = promote_deferred_overlap
+        self._projector: RealtimeProjectionState | None = ctx.session.projector
+
+    # ------------------------------------------------------------------ #
+    # Projection state                                                   #
+    # ------------------------------------------------------------------ #
+
+    @property
+    def projector(self) -> RealtimeProjectionState | None:
+        """The Realtime projection state, or ``None`` before anything needs it."""
+        return self._projector
+
+    @projector.setter
+    def projector(self, value: RealtimeProjectionState | None) -> None:
+        self._projector = value
+        self._ctx.session.projector = value
+
+    def require_projector(self) -> RealtimeProjectionState:
+        """The projection state, created on first use.
+
+        A session torn down before ``start()`` never builds one, so the lazy
+        path here is reachable rather than defensive.
+        """
+        projector = self._projector
+        if projector is None:
+            session = self._ctx.session
+            projector = RealtimeProjectionState(
+                session_id=session.session_id,
+                model=session.config.model,
+                initial_session_update=True,
+            )
+            self.projector = projector
+        return projector
+
+    # ------------------------------------------------------------------ #
+    # Sending                                                            #
+    # ------------------------------------------------------------------ #
+
+    def emit_events(self, events: list[DuplexEvent]) -> None:
+        for event in events:
+            self._ctx.manager.emit(self._ctx.session, event)
+
+    def emit_error(
+        self,
+        code: str,
+        message: str,
+        *,
+        event_id: object | None = None,
+        retryable: bool | None = None,
+    ) -> None:
+        """Send one typed ``error`` event (``event_id`` is the client event it answers)."""
+        extra = {} if retryable is None else {"retryable": retryable}
+        self.emit_events([error_event(code, message, event_id=event_id, extra=extra)])
+
+    def emit(self, payload: dict[str, object]) -> None:
+        """Apply the domain effects of an internal event, then project it to typed events and send them.
+
+        Only events with domain effects (response / cancel / close terminals) or
+        Realtime projection state (response items, content parts) still travel as
+        internal dictionaries; stateless events are constructed typed at the
+        emit site.
+        """
+        accepted, deferred_overlap_payload = self._apply_outbound_session_event(payload)
+        if not accepted:
+            return
+        self.emit_events(project_internal_event(self.require_projector(), payload))
+        if deferred_overlap_payload is not None and not self._ctx.run.closing:
+            precreate_response = self._ctx.model_state.deferred_precreate_response
+            self._ctx.model_state.deferred_precreate_response = False
+            self._promote_deferred_overlap(deferred_overlap_payload, precreate_response)
+
+    # ------------------------------------------------------------------ #
+    # Filtering and domain effects                                       #
+    # ------------------------------------------------------------------ #
+
+    def auto_responds(self) -> bool:
+        """Whether the session answers committed input without a ``response.create``."""
+        extra = getattr(self._ctx.session.config, "extra_body", None)
+        if not isinstance(extra, dict):
+            return False
+        return extra.get("auto_response") is True or extra.get("full_duplex") is True
+
+    def is_stale_model_output(self, payload: dict[str, object]) -> bool:
+        """Whether ``payload`` belongs to a turn the session has already moved past."""
+        session = self._ctx.session
+        event_type = payload.get("type")
+        if event_type in DOMAIN_TERMINAL_EVENTS:
+            return False
+        if event_type not in MODEL_OUTPUT_EVENTS:
+            return False
+        if self._ctx.run.closing and event_type != "response.listen":
+            return True
+        if session.state == DuplexSessionState.CLOSED and event_type != "response.listen":
+            return True
+        epoch = payload.get("epoch")
+        return isinstance(epoch, int) and epoch != session.epoch
+
+    def _apply_outbound_session_event(self, payload: dict[str, object]) -> tuple[bool, dict[str, object] | None]:
+        """Apply domain transitions before an event is projected (moved from serving)."""
+        session = self._ctx.session
+        model_state = self._ctx.model_state
+        payload_type = payload.get("type")
+        is_terminal = payload_type in DOMAIN_TERMINAL_EVENTS
+        if is_terminal:
+            payload_epoch = payload.get("epoch")
+            if isinstance(payload_epoch, int) and payload_epoch != session.epoch:
+                return False, None
+            if payload_type in {"response.done", "response.listen"} and (
+                self._ctx.run.closing or session.state == DuplexSessionState.CLOSED
+            ):
+                return False, None
+        elif self.is_stale_model_output(payload):
+            return False, None
+
+        if payload_type == "session.closed":
+            self._ctx.run.close_reason = self._ctx.run.close_reason or str(payload.get("reason") or "closed")
+            session.mark_closing()
+
+        if not is_terminal:
+            return True, None
+
+        terminal_status = payload.get("status")
+        terminal_status_details = payload.get("status_details")
+        if terminal_status is None and isinstance(terminal_status_details, dict):
+            terminal_status = terminal_status_details.get("type")
+        response_terminal = payload_type == "response.done" or (
+            payload_type == "response.listen" and session.active_response_id is not None
+        )
+        can_promote_overlap = response_terminal and terminal_status not in {"cancelled", "failed"}
+        deferred_overlap_payload: dict[str, object] | None = None
+        continuous_input_crosses_terminal = (
+            can_promote_overlap
+            and self.auto_responds()
+            and model_state.input_since_commit
+            and not model_state.deferred_response_create
+        )
+        if continuous_input_crosses_terminal:
+            session.reset_overlap_speech()
+            return True, None
+        realtime_input_still_open = (
+            can_promote_overlap and model_state.input_since_commit and not model_state.deferred_response_create
+        )
+        if realtime_input_still_open:
+            session.reset_overlap_speech()
+            return True, None
+        if can_promote_overlap and session.overlap_speech_ms > 0:
+            has_deferred_overlap = (
+                model_state.audio_buffer.has_pending() or model_state.committed_audio_payload is not None
+            )
+            should_promote_overlap = (
+                session.state == DuplexSessionState.OPEN
+                and has_deferred_overlap
+                and session.overlap_speech_ms > session.config.overlap_short_ack_ms
+            )
+            if should_promote_overlap:
+                flushed_reserved_bytes = model_state.audio_buffer.pending_byte_count
+                deferred_overlap_payload = model_state.audio_buffer.flush(
+                    chunk_period_ms=session.capabilities.chunk_period_ms or 1000
+                )
+                if model_state.committed_audio_payload is not None:
+                    if deferred_overlap_payload is not None:
+                        deferred_overlap_payload = overlap_policy.merge_audio_payloads(
+                            model_state.committed_audio_payload,
+                            deferred_overlap_payload,
+                        )
+                    else:
+                        deferred_overlap_payload = model_state.committed_audio_payload
+                if self.auto_responds() and deferred_overlap_payload is not None:
+                    deferred_overlap_payload = dict(deferred_overlap_payload)
+                    deferred_overlap_payload["force_listen"] = False
+                if deferred_overlap_payload is not None:
+                    model_state.retain_committed_audio(
+                        deferred_overlap_payload,
+                        operation_id=model_state.committed_audio_operation_id,
+                        reserved_bytes=flushed_reserved_bytes,
+                    )
+                model_state.input_since_commit = deferred_overlap_payload is not None
+                # Realtime path: defer the promoted response to the next terminal.
+                model_state.deferred_response_create = True
+                model_state.deferred_precreate_response = False
+                deferred_overlap_payload = None
+            else:
+                had_pending_overlap_audio = model_state.audio_buffer.has_pending()
+                model_state.audio_buffer.clear()
+                model_state.input_since_commit = False
+                model_state.speech_since_commit = False
+                if had_pending_overlap_audio and self._projector is not None:
+                    self.emit_events(discard_pending_input_audio(self._projector, session.overlap_speech_ms))
+                if payload_type in {"audio.cancelled", "input.cancelled", "session.closed"}:
+                    session.release_input_bytes(model_state.clear_committed_audio())
+
+        session.reset_overlap_speech()
+        if (
+            can_promote_overlap
+            and model_state.deferred_response_create
+            and model_state.committed_audio_payload is not None
+        ):
+            deferred_overlap_payload = model_state.committed_audio_payload
+            model_state.deferred_response_create = False
+            model_state.input_since_commit = False
+            model_state.speech_since_commit = False
+        return True, deferred_overlap_payload
diff --git a/vllm_omni/entrypoints/duplex/protocol.py b/vllm_omni/engine/duplex/session/engine_session.py
similarity index 57%
rename from vllm_omni/entrypoints/duplex/protocol.py
rename to vllm_omni/engine/duplex/session/engine_session.py
index ff91e0db5..f181aaaea 100644
--- a/vllm_omni/entrypoints/duplex/protocol.py
+++ b/vllm_omni/engine/duplex/session/engine_session.py
@@ -1,409 +1,100 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
+"""The one duplex session state, owned by the engine-side ``DuplexSessionRunner``.
+
+``DuplexEngineSession`` is the single session object: the input / response /
+playback / conversation ledgers, the lease, the identity fence, the stage
+request resources, the append sequencing, the model plugin's per-session state
+(``model_state``) and the Realtime projection state (``projector``). There is
+no cross-boundary fence protocol; ``session.fence`` is derived from the
+session's own epoch/turn and ``accepted_fence`` is the monotonic high-water
+mark of fences accepted for stage requests (``sync_fence()`` publishes the
+current identity there).
+"""
+
 from __future__ import annotations
 
 import copy
-from collections.abc import Mapping
+import time
+from collections.abc import Callable, Mapping
 from dataclasses import dataclass, field
-from enum import Enum
 from types import MappingProxyType
+from typing import TYPE_CHECKING, Any
 from uuid import uuid4
 
-import numpy as np
-
-from vllm_omni.entrypoints.duplex.audio import (
-    encode_float32_mono_wav_base64,
+from vllm_omni.engine.duplex.config import (
+    DuplexAssistantAudioTextMark,
+    DuplexCapabilities,
+    DuplexCommittedInput,
+    DuplexPlaybackCommitPolicy,
+    DuplexPlaybackCursor,
+    DuplexPlaybackView,
+    DuplexSessionConfig,
+    DuplexSessionState,
+    DuplexTurnEventType,
+    DuplexTurnState,
+    ResponseCreateOptions,
 )
-from vllm_omni.entrypoints.duplex.server_vad import (
-    ServerVADConfig,
-    parse_session_turn_detection,
+from vllm_omni.engine.duplex.contracts import DuplexFence
+from vllm_omni.engine.duplex.events import TurnEvent
+from vllm_omni.engine.duplex.session.lease import (
+    DuplexLeaseActivity,
+    DuplexLeaseConfig,
+    DuplexLeaseState,
 )
 
-
-class DuplexOverlapPolicy(str, Enum):
-    LISTEN_ONLY = "listen_only"
-    BARGE_IN_ON_SPEECH = "barge_in_on_speech"
+if TYPE_CHECKING:
+    from vllm_omni.engine.duplex.plugin import DuplexModelSessionState
+    from vllm_omni.engine.duplex.realtime_events import RealtimeProjectionState
 
 
-class DuplexPlaybackCommitPolicy(str, Enum):
-    COMMIT_ALL_ON_DONE = "commit_all_on_done"
-    ACK_ONLY = "ack_only"
+def _default_lease() -> DuplexLeaseState:
+    return DuplexLeaseState(config=DuplexLeaseConfig(), generation=0, last_activity=time.monotonic())
 
 
-class DuplexSessionState(str, Enum):
-    OPEN = "open"
-    CLOSING = "closing"
-    CLOSED = "closed"
+def _object_dict(**fields: object) -> dict[str, object]:
+    return dict(fields)
 
 
-# Canonical extra_body key for the per-session opt-in to a model-native
-# duplex runtime, plus the deprecated model-prefixed spelling it replaced.
-# Client payloads may still use the legacy key; it is folded into the
-# canonical one at ingestion so everything downstream (and every echo in
-# session.created/session.updated) sees only NATIVE_DUPLEX_KEY.
-NATIVE_DUPLEX_KEY = "native_duplex"
-LEGACY_NATIVE_DUPLEX_KEY = "minicpmo45_native_duplex"
+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 normalize_native_duplex_key(extra_body: dict[str, object]) -> dict[str, object]:
-    """Fold the deprecated alias into the canonical key (canonical wins)."""
-    if LEGACY_NATIVE_DUPLEX_KEY in extra_body:
-        legacy = extra_body.pop(LEGACY_NATIVE_DUPLEX_KEY)
-        extra_body.setdefault(NATIVE_DUPLEX_KEY, legacy)
-    return extra_body
+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 native_duplex_opt_in(extra_body: Mapping[str, object]) -> object:
-    """Read the opt-in flag, accepting the deprecated alias for raw dicts."""
-    if NATIVE_DUPLEX_KEY in extra_body:
-        return extra_body[NATIVE_DUPLEX_KEY]
-    return extra_body.get(LEGACY_NATIVE_DUPLEX_KEY)
+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()}
 
 
-class DuplexTurnState(str, Enum):
-    IDLE = "idle"
-    USER_SPEAKING = "user_speaking"
-    USER_COMMITTED = "user_committed"
-    ASSISTANT_GENERATING = "assistant_generating"
-    ASSISTANT_PLAYING = "assistant_playing"
-    BARGE_IN = "barge_in"
-
-
-class DuplexTurnEventType(str, Enum):
-    USER_STARTED = "user_started"
-    USER_COMMITTED = "user_committed"
-    ASSISTANT_STARTED = "assistant_started"
-    ASSISTANT_DONE = "assistant_done"
-    BARGE_IN = "barge_in"
-    PLAYBACK_ACK = "playback_ack"
-    TIMEOUT = "timeout"
-    CLOSE = "close"
-
-
-@dataclass
-class DuplexCapabilities:
-    """Runtime/model capabilities exposed by the duplex serving protocol.
-
-    These are intentionally explicit so the serving layer does not assume all
-    duplex models support the same input append, rollback, or turn policy.
-    ``supports_core_kv_lease`` is reserved for scheduler-owned KV lifecycle;
-    model-owned decoder/TTS state must use ``supports_model_internal_state``.
-    ``supports_core_resumable_request`` means the scheduler can resume the
-    same request id across streaming updates, but it is not a KV lease by
-    itself. Realtime support means this endpoint can speak the native Realtime
-    event schema for the supported audio duplex paths while keeping model- or
-    scheduler-specific limits explicit in the capability payload.
-    """
-
-    supports_session_adapter: bool = True
-    supports_model_native_turn_policy: bool = False
-    supports_external_turn_signal: bool = True
-    supports_client_commit: bool = True
-    supports_barge_in: bool = True
-    supports_playback_ack: bool = True
-    supports_input_append: bool = False
-    supports_replace_latest_chunk: bool = True
-    supports_reencode_context: bool = True
-    supports_rollback_to_checkpoint: bool = False
-    supports_turn_commit_only: bool = True
-    supports_kv_lease: bool = False
-    supports_core_kv_lease: bool = False
-    supports_model_internal_state: bool = False
-    supports_stage_resumption: bool = False
-    supports_scheduler_native_append: bool = False
-    supports_core_resumable_request: bool = False
-    supports_stage_connector_handoff: bool = False
-    supports_independent_io_streams: bool = False
-    supports_realtime_endpoint: bool = False
-    supports_multi_session: bool = False
-    supports_multi_session_same_replica: bool = False
-    supports_session_lease: bool = False
-    supports_session_resume: bool = False
-    session_admission_mode: str = "serving_managed"
-    supports_audio_truncate: bool = False
-    requires_model_runner_kv: bool = False
-    requires_native_stage_role: bool = False
-    implementation_level: str = "serving_session_adapter"
-    adapter_patterns: list[str] = field(default_factory=lambda: ["chunk_group_append"])
-    input_modes: list[str] = field(default_factory=lambda: ["turn_commit_only", "reencode_context"])
-    signal_sources: list[str] = field(default_factory=lambda: ["client_event", "server_policy", "model_native"])
-    stage_handoff_transport: str | None = None
-    chunk_period_ms: int | None = 1000
-    target_barge_in_latency_ms: int | None = 1000
-
-    def as_dict(self) -> dict[str, object]:
-        return {
-            "supports_session_adapter": self.supports_session_adapter,
-            "supports_model_native_turn_policy": self.supports_model_native_turn_policy,
-            "supports_external_turn_signal": self.supports_external_turn_signal,
-            "supports_client_commit": self.supports_client_commit,
-            "supports_barge_in": self.supports_barge_in,
-            "supports_playback_ack": self.supports_playback_ack,
-            "supports_input_append": self.supports_input_append,
-            "supports_replace_latest_chunk": self.supports_replace_latest_chunk,
-            "supports_reencode_context": self.supports_reencode_context,
-            "supports_rollback_to_checkpoint": self.supports_rollback_to_checkpoint,
-            "supports_turn_commit_only": self.supports_turn_commit_only,
-            "supports_kv_lease": self.supports_kv_lease,
-            "supports_core_kv_lease": self.supports_core_kv_lease,
-            "supports_model_internal_state": self.supports_model_internal_state,
-            "supports_stage_resumption": self.supports_stage_resumption,
-            "supports_scheduler_native_append": self.supports_scheduler_native_append,
-            "supports_core_resumable_request": self.supports_core_resumable_request,
-            "supports_stage_connector_handoff": self.supports_stage_connector_handoff,
-            "supports_independent_io_streams": self.supports_independent_io_streams,
-            "supports_realtime_endpoint": self.supports_realtime_endpoint,
-            "supports_multi_session": self.supports_multi_session,
-            "supports_multi_session_same_replica": self.supports_multi_session_same_replica,
-            "supports_session_lease": self.supports_session_lease,
-            "supports_session_resume": self.supports_session_resume,
-            "session_admission_mode": self.session_admission_mode,
-            "supports_audio_truncate": self.supports_audio_truncate,
-            "requires_model_runner_kv": self.requires_model_runner_kv,
-            "requires_native_stage_role": self.requires_native_stage_role,
-            "implementation_level": self.implementation_level,
-            "adapter_patterns": self.adapter_patterns,
-            "input_modes": self.input_modes,
-            "signal_sources": self.signal_sources,
-            "stage_handoff_transport": self.stage_handoff_transport,
-            "chunk_period_ms": self.chunk_period_ms,
-            "target_barge_in_latency_ms": self.target_barge_in_latency_ms,
-        }
-
-
-@dataclass
-class DuplexPlaybackCursor:
-    generated_ms: int = 0
-    sent_ms: int = 0
-    played_ms: int = 0
-    committed_ms: int = 0
-
-    def acknowledge(self, played_ms: int, committed_ms: int | None = None) -> None:
-        self.played_ms = max(self.played_ms, max(0, int(played_ms)))
-        if committed_ms is None:
-            committed_ms = self.played_ms
-        self.committed_ms = max(self.committed_ms, max(0, int(committed_ms)))
-
-    def truncate_committed(self, committed_ms: int) -> None:
-        self.committed_ms = max(0, min(max(self.sent_ms, self.generated_ms), int(committed_ms)))
-
-    def as_dict(self) -> dict[str, int]:
-        return {
-            "generated_ms": self.generated_ms,
-            "sent_ms": self.sent_ms,
-            "played_ms": self.played_ms,
-            "committed_ms": self.committed_ms,
-        }
-
-    def snapshot(self) -> DuplexPlaybackView:
-        return DuplexPlaybackView(**self.as_dict())
-
-
-@dataclass(frozen=True, slots=True)
-class DuplexPlaybackView:
-    generated_ms: int = 0
-    sent_ms: int = 0
-    played_ms: int = 0
-    committed_ms: int = 0
-
-    def as_dict(self) -> dict[str, int]:
-        return {
-            "generated_ms": self.generated_ms,
-            "sent_ms": self.sent_ms,
-            "played_ms": self.played_ms,
-            "committed_ms": self.committed_ms,
-        }
-
-
-@dataclass
-class DuplexAudioChunk:
-    data: str
-    format: str = "wav"
-    sample_rate_hz: int | None = None
-
-
-@dataclass
-class DuplexSessionConfig:
-    model: str | None = None
-    modalities: list[str] = field(default_factory=lambda: ["text", "audio"])
-    instructions: str | None = None
-    voice: str | None = None
-    ref_audio: str | None = None
-    response_format: str = "wav"
-    temperature: float | None = None
-    max_tokens: int | None = None
-    speed: float | None = None
-    use_tts_template: bool = True
-    idle_timeout_s: float = 300.0
-    overlap_policy: str = DuplexOverlapPolicy.LISTEN_ONLY.value
-    overlap_short_ack_ms: int = 700
-    overlap_barge_in_ms: int = 1200
-    overlap_silence_rms: float = 0.003
-    playback_commit_policy: str = DuplexPlaybackCommitPolicy.COMMIT_ALL_ON_DONE.value
-    turn_detection_configured: bool = False
-    server_vad: ServerVADConfig | None = None
-    extra_body: dict[str, object] = field(default_factory=dict)
-
-    def as_dict(self) -> dict[str, object]:
-        payload: dict[str, object] = {
-            "model": self.model,
-            "modalities": list(self.modalities),
-            "instructions": self.instructions,
-            "voice": self.voice,
-            "ref_audio": self.ref_audio,
-            "response_format": self.response_format,
-            "temperature": self.temperature,
-            "max_tokens": self.max_tokens,
-            "speed": self.speed,
-            "use_tts_template": self.use_tts_template,
-            "idle_timeout_s": self.idle_timeout_s,
-            "overlap_policy": self.overlap_policy,
-            "overlap_short_ack_ms": self.overlap_short_ack_ms,
-            "overlap_barge_in_ms": self.overlap_barge_in_ms,
-            "overlap_silence_rms": self.overlap_silence_rms,
-            "playback_commit_policy": self.playback_commit_policy,
-            "extra_body": dict(self.extra_body),
-        }
-        if self.turn_detection_configured:
-            payload["turn_detection"] = self.server_vad.as_dict() if self.server_vad is not None else None
-        return payload
-
-    @classmethod
-    def from_event(cls, event: dict[str, object]) -> DuplexSessionConfig:
-        payload = event.get("session")
-        if isinstance(payload, dict):
-            source = payload
-        else:
-            source = event
-
-        config = cls()
-        if isinstance(source.get("model"), str):
-            config.model = source["model"]
-        if isinstance(source.get("instructions"), str):
-            config.instructions = source["instructions"]
-        if isinstance(source.get("voice"), str):
-            config.voice = source["voice"]
-        if isinstance(source.get("ref_audio"), str):
-            config.ref_audio = source["ref_audio"]
-        if isinstance(source.get("response_format"), str):
-            config.response_format = source["response_format"]
-        if isinstance(source.get("use_tts_template"), bool):
-            config.use_tts_template = bool(source["use_tts_template"])
-        if isinstance(source.get("temperature"), int | float):
-            config.temperature = float(source["temperature"])
-        if isinstance(source.get("max_tokens"), int):
-            config.max_tokens = int(source["max_tokens"])
-        if isinstance(source.get("speed"), int | float):
-            config.speed = float(source["speed"])
-        if isinstance(source.get("idle_timeout_s"), int | float):
-            config.idle_timeout_s = float(source["idle_timeout_s"])
-        if isinstance(source.get("overlap_policy"), str):
-            config.overlap_policy = cls._normalize_overlap_policy(source["overlap_policy"])
-        if isinstance(source.get("overlap_short_ack_ms"), int | float):
-            config.overlap_short_ack_ms = max(0, int(source["overlap_short_ack_ms"]))
-        if isinstance(source.get("overlap_barge_in_ms"), int | float):
-            config.overlap_barge_in_ms = max(0, int(source["overlap_barge_in_ms"]))
-        if isinstance(source.get("overlap_silence_rms"), int | float):
-            config.overlap_silence_rms = max(0.0, float(source["overlap_silence_rms"]))
-        if isinstance(source.get("playback_commit_policy"), str):
-            config.playback_commit_policy = cls._normalize_playback_commit_policy(source["playback_commit_policy"])
-        if isinstance(source.get("modalities"), list) and all(isinstance(x, str) for x in source["modalities"]):
-            config.modalities = list(source["modalities"])
-        turn_detection_configured, server_vad = parse_session_turn_detection(source)
-        if isinstance(source.get("extra_body"), dict):
-            config.extra_body = normalize_native_duplex_key(dict(source["extra_body"]))
-            extra = config.extra_body
-            raw_realtime_session = extra.get("realtime_session_payload")
-            if not turn_detection_configured and isinstance(raw_realtime_session, dict):
-                turn_detection_configured, server_vad = parse_session_turn_detection(raw_realtime_session)
-            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"])
-        if turn_detection_configured:
-            config.turn_detection_configured = True
-            config.server_vad = server_vad
-        return config
-
-    @staticmethod
-    def _normalize_overlap_policy(value: str) -> str:
-        normalized = value.strip().lower()
-        if normalized in {policy.value for policy in DuplexOverlapPolicy}:
-            return normalized
-        return DuplexOverlapPolicy.LISTEN_ONLY.value
-
-    @staticmethod
-    def _normalize_playback_commit_policy(value: str) -> str:
-        normalized = value.strip().lower()
-        if normalized in {policy.value for policy in DuplexPlaybackCommitPolicy}:
-            return normalized
-        return DuplexPlaybackCommitPolicy.COMMIT_ALL_ON_DONE.value
-
-
-@dataclass(frozen=True)
-class ResponseCreateOptions:
-    instructions: str | None = None
-    voice: str | None = None
-    response_format: str | None = None
-    temperature: float | None = None
-    max_tokens: int | None = None
-    speed: float | None = None
-    modalities: tuple[str, ...] | None = None
-    extra_body: Mapping[str, object] = field(default_factory=dict)
-
-    def apply_to(self, config: DuplexSessionConfig) -> None:
-        for field_name in ("instructions", "voice", "response_format", "temperature", "max_tokens", "speed"):
-            value = getattr(self, field_name)
-            if value is not None:
-                setattr(config, field_name, value)
-        if self.modalities is not None:
-            config.modalities = list(self.modalities)
-        config.extra_body.update(self.extra_body)
-
-
-@dataclass
-class DuplexCommittedInput:
-    message: dict[str, object]
-    turn_id: int
-    epoch: int
-    input_commit_seq: int
-
-
-@dataclass
-class PendingServerVADTurn:
-    committed: DuplexCommittedInput
-    create_response: bool
-    item_id: str
-
-
-@dataclass
-class DuplexAssistantAudioTextMark:
-    text_chars: int
-    audio_end_ms: int
+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
-    pending_text: list[str] = field(default_factory=list)
-    pending_audio: list[DuplexAudioChunk] = field(default_factory=list)
     overlap_speech_ms: int = 0
     reserved_input_bytes: int = 0
     pending_turns: int = 0
-    turn_detection_config_locked: bool = False
-    vad_prefix_audio: list[np.ndarray] = field(default_factory=list)
-    vad_prefix_samples: int = 0
-    vad_utterance_audio: list[np.ndarray] = field(default_factory=list)
-    vad_speech_active: bool = False
-    active_server_vad_item_id: str | None = None
-    pending_server_vad_turn: PendingServerVADTurn | None = None
 
 
 @dataclass
@@ -433,6 +124,10 @@ class PlaybackLedger:
 @dataclass
 class ConversationHistory:
     messages: list[dict[str, object]] = field(default_factory=list)
+    #: User items added by ``conversation.item.create`` that no response has
+    #: answered yet. A turn can start from these alone, the way the Realtime
+    #: protocol allows, without any audio having been committed.
+    unanswered_user_items: int = 0
     item_ids: dict[str, dict[str, object]] = field(default_factory=dict)
     history_item_placeholders: dict[str, dict[str, object]] = field(default_factory=dict)
     item_audio_text_marks: dict[str, list[DuplexAssistantAudioTextMark]] = field(default_factory=dict)
@@ -448,21 +143,264 @@ class ConversationHistory:
     )
 
 
+class DuplexFenceMismatchError(RuntimeError):
+    def __init__(self, expected: DuplexFence, actual: DuplexFence) -> None:
+        super().__init__(f"duplex fence mismatch: expected {expected!r}, got {actual!r}")
+        self.expected = expected
+        self.actual = actual
+
+
 @dataclass
-class DuplexSession:
+class DuplexRequestResource:
+    stage_id: int
+    request_id: str
+    fence: DuplexFence
+    submitted: bool = False
+
+
+@dataclass
+class DuplexInputAppend:
+    seq: int
+    turn_seq: int
+    turn_id: int
+
+
+@dataclass(frozen=True)
+class DuplexAppendReservation:
+    fence: DuplexFence
+    base_fence: DuplexFence
+    base_input_seq: int
+    base_input_turn_seq: int
+    base_append_turn_key: tuple[int, int, int] | None
+    update: DuplexInputAppend
+
+
+@dataclass
+class DuplexEngineSession:
+    """The one session state (see module docstring).
+
+    Owned and mutated only by its ``DuplexSessionRunner`` on the orchestrator loop.
+    """
+
     session_id: str
     config: DuplexSessionConfig
     capabilities: DuplexCapabilities = field(default_factory=DuplexCapabilities)
-    incarnation: int = 0
     state: DuplexSessionState = DuplexSessionState.OPEN
     turn_state: DuplexTurnState = DuplexTurnState.IDLE
     epoch: int = 0
     turn_id: int = 0
+    lease: DuplexLeaseState = field(default_factory=_default_lease, repr=False)
+    _clock: Callable[[], float] = field(default=time.monotonic, repr=False)
+    _runtime_config: dict[str, object] = field(default_factory=dict, repr=False)
+    #: Bumped on every published session / runtime config change.
+    config_generation: int = 0
+    #: Stage request ids reserved or submitted for this session, keyed by ``(stage_id, request_id)``.
+    request_resources: dict[tuple[int, str], DuplexRequestResource] = field(default_factory=dict, repr=False)
+    #: Highest fence accepted for a stage request (monotonic; reset of the append
+    #: sequence happens when its epoch advances).
+    accepted_fence: DuplexFence = field(default=None, repr=False)  # type: ignore[assignment]
+    input_seq: int = 0
+    input_turn_seq: int = 0
+    _append_turn_key: tuple[int, int, int] | None = field(default=None, repr=False)
     _input: InputBufferState = field(default_factory=InputBufferState, repr=False)
     _response: ResponseState = field(default_factory=ResponseState, repr=False)
+    #: Stage snapshots that arrived while no response was open. A stage whose
+    #: output feeds the next stage rather than the client reports its metrics
+    #: before the response those tokens end up in exists, so they are held here
+    #: and folded into the first response that opens after them.
+    _pending_stage_metrics: list[dict[str, dict[str, object]]] = field(default_factory=list, repr=False)
     _playback: PlaybackLedger = field(default_factory=PlaybackLedger, repr=False)
     _conversation: ConversationHistory = field(default_factory=ConversationHistory, repr=False)
-    _runtime_config: dict[str, object] = field(default_factory=dict, repr=False)
+    model_state: DuplexModelSessionState | None = field(default=None, repr=False)
+    projector: RealtimeProjectionState | None = field(default=None, repr=False)
+    created_monotonic: float = field(default_factory=time.monotonic)
+
+    def __post_init__(self) -> None:
+        if self.accepted_fence is None:
+            self.accepted_fence = self.fence
+        else:
+            self.accept_fence(self.fence)
+        if self.config.initial_user_text:
+            # Seeded text is user input like any other: it waits for a response.
+            self.notify_new_user_item()
+
+    # ---- identity / fence ----
+
+    @property
+    def fence(self) -> DuplexFence:
+        return DuplexFence(self.session_id, epoch=self.epoch, turn_id=self.turn_id)
+
+    def sync_fence(self) -> DuplexFence:
+        """Publish the current (epoch, turn_id) identity as the accepted fence."""
+        fence = self.fence
+        self.accept_fence(fence)
+        return fence
+
+    def _validate_fence(self, fence: DuplexFence) -> None:
+        current = self.accepted_fence
+        if fence.session_id != self.session_id:
+            raise DuplexFenceMismatchError(current, fence)
+        if fence.epoch < current.epoch or (fence.epoch == current.epoch and fence.turn_id < current.turn_id):
+            raise DuplexFenceMismatchError(current, fence)
+
+    def accept_fence(self, fence: DuplexFence) -> None:
+        self._validate_fence(fence)
+        if fence.epoch != self.accepted_fence.epoch:
+            self.input_seq = 0
+            self.input_turn_seq = 0
+            self._append_turn_key = None
+        self.accepted_fence = fence
+
+    # ---- lease ----
+
+    @property
+    def lease_generation(self) -> int:
+        return self.lease.generation
+
+    def touch_lease(self, activity: DuplexLeaseActivity) -> None:
+        self._validate_fence(self.fence)
+        self.lease.touch(self._clock(), activity)
+
+    def detach_lease(self) -> None:
+        self._validate_fence(self.fence)
+        self.lease.detach(self._clock())
+
+    def resume_lease(self, *, expected_lease_generation: int) -> int:
+        self._validate_fence(self.fence)
+        return self.lease.resume(self._clock(), expected_generation=expected_lease_generation)
+
+    def begin_lease_operation(self, fence: DuplexFence, operation_id: str) -> None:
+        self._validate_fence(fence)
+        self.lease.begin_operation(self._clock(), operation_id)
+
+    def end_lease_operation(self, operation_id: str) -> None:
+        self._validate_fence(self.fence)
+        self.lease.end_operation(self._clock(), operation_id)
+
+    # ---- stage request resources ----
+
+    def reserve_stage_request(self, stage_id: int, request_id: str, *, fence: DuplexFence) -> None:
+        self._validate_fence(fence)
+        resource_key = (stage_id, request_id)
+        existing = self.request_resources.get(resource_key)
+        if existing is not None:
+            if existing.fence.session_id != fence.session_id or existing.fence.epoch != fence.epoch:
+                raise ValueError(f"Duplex request resource already reserved with different identity: {request_id}")
+            return
+        self.request_resources[resource_key] = DuplexRequestResource(
+            stage_id=stage_id,
+            request_id=request_id,
+            fence=fence,
+        )
+
+    def bind_stage_request(self, stage_id: int, request_id: str, *, fence: DuplexFence) -> None:
+        self.reserve_stage_request(stage_id, request_id, fence=fence)
+        self.accept_fence(fence)
+        resource = self.request_resources[(stage_id, request_id)]
+        resource.fence = fence
+        resource.submitted = True
+
+    def stage_request_submitted(self, stage_id: int, request_id: str) -> bool:
+        resource = self.request_resources.get((stage_id, request_id))
+        return resource is not None and resource.submitted
+
+    def resource_request_ids(
+        self,
+        fence: DuplexFence | None = None,
+        *,
+        submitted: bool | None = None,
+    ) -> list[str]:
+        return list(
+            dict.fromkeys(
+                resource.request_id
+                for resource in self.request_resources.values()
+                if (fence is None or resource.fence == fence) and (submitted is None or resource.submitted is submitted)
+            )
+        )
+
+    def release_all_requests(self) -> list[str]:
+        """Drop every reserved/submitted stage request; returns their ids for stage cleanup."""
+        stale = self.resource_request_ids()
+        self.request_resources.clear()
+        return stale
+
+    # ---- append sequencing ----
+
+    def prepare_append(self, fence: DuplexFence) -> DuplexAppendReservation:
+        self._validate_fence(fence)
+        same_epoch = fence.epoch == self.accepted_fence.epoch
+        input_seq = self.input_seq if same_epoch else 0
+        input_turn_seq = self.input_turn_seq if same_epoch else 0
+        append_turn_key = self._append_turn_key if same_epoch else None
+        turn_key = (fence.epoch, fence.turn_id, 0)
+        turn_seq = input_turn_seq + 1 if turn_key == append_turn_key else 1
+        return DuplexAppendReservation(
+            fence=fence,
+            base_fence=self.accepted_fence,
+            base_input_seq=self.input_seq,
+            base_input_turn_seq=self.input_turn_seq,
+            base_append_turn_key=self._append_turn_key,
+            update=DuplexInputAppend(
+                seq=input_seq + 1,
+                turn_seq=turn_seq,
+                turn_id=fence.turn_id,
+            ),
+        )
+
+    def commit_append(self, reservation: DuplexAppendReservation) -> DuplexInputAppend:
+        if (
+            self.accepted_fence != reservation.base_fence
+            or self.input_seq != reservation.base_input_seq
+            or self.input_turn_seq != reservation.base_input_turn_seq
+            or self._append_turn_key != reservation.base_append_turn_key
+        ):
+            raise RuntimeError("duplex append reservation is stale")
+        self.accept_fence(reservation.fence)
+        self.input_seq = reservation.update.seq
+        self.input_turn_seq = reservation.update.turn_seq
+        self._append_turn_key = (reservation.fence.epoch, reservation.fence.turn_id, 0)
+        return reservation.update
+
+    # ---- cancel / close of stage resources ----
+
+    def release_fence(self, fence: DuplexFence) -> list[str]:
+        stale = self.resource_request_ids(fence)
+        self.request_resources = {
+            resource_key: resource
+            for resource_key, resource in self.request_resources.items()
+            if resource.fence != fence
+        }
+        return stale
+
+    def cancel_fence(self, cancelled_fence: DuplexFence, next_fence: DuplexFence) -> list[str]:
+        stale = self.prepare_cancel_fence(cancelled_fence, next_fence)
+        self.release_fence(cancelled_fence)
+        return stale
+
+    def prepare_cancel_fence(self, cancelled_fence: DuplexFence, next_fence: DuplexFence) -> list[str]:
+        """Advance the cancellation fence without dropping cleanup records."""
+        current = self.accepted_fence
+        if cancelled_fence.session_id != self.session_id:
+            raise DuplexFenceMismatchError(current, cancelled_fence)
+        if next_fence.session_id != self.session_id or next_fence.epoch <= cancelled_fence.epoch:
+            raise DuplexFenceMismatchError(cancelled_fence, next_fence)
+        current_key = (current.epoch, current.turn_id)
+        cancelled_key = (cancelled_fence.epoch, cancelled_fence.turn_id)
+        next_key = (next_fence.epoch, next_fence.turn_id)
+        if cancelled_key > current_key:
+            raise DuplexFenceMismatchError(current, cancelled_fence)
+        if next_key > current_key:
+            self.accept_fence(next_fence)
+        return self.resource_request_ids(cancelled_fence)
+
+    def begin_close(self, *, reason: str) -> bool:
+        """Make close irreversible while retaining stage resources for cleanup retry."""
+        self.accept_fence(self.fence)
+        if self.lease.terminal_reason is not None:
+            return True
+        return self.lease.mark_terminal(reason)
+
+    # ---- configuration ----
 
     @property
     def response_config(self) -> DuplexSessionConfig:
@@ -480,19 +418,12 @@ class DuplexSession:
 
     def replace_runtime_config(self, runtime_config: Mapping[str, object]) -> None:
         self._runtime_config = dict(runtime_config)
+        self.config_generation += 1
 
     @property
     def input_commit_seq(self) -> int:
         return self._input.commit_seq
 
-    @property
-    def pending_text(self) -> tuple[str, ...]:
-        return tuple(self._input.pending_text)
-
-    @property
-    def pending_audio(self) -> tuple[DuplexAudioChunk, ...]:
-        return tuple(self._input.pending_audio)
-
     @property
     def history(self) -> tuple[dict[str, object], ...]:
         placeholders = {id(message) for message in self._conversation.history_item_placeholders.values()}
@@ -614,10 +545,6 @@ class DuplexSession:
     def playback(self) -> DuplexPlaybackView:
         return self._playback.current.snapshot()
 
-    @property
-    def response_playbacks(self) -> Mapping[str, DuplexPlaybackView]:
-        return MappingProxyType({key: value.snapshot() for key, value in self._playback.by_response.items()})
-
     @property
     def history_item_ids(self) -> Mapping[str, dict[str, object]]:
         return MappingProxyType({key: dict(value) for key, value in self._conversation.item_ids.items()})
@@ -631,10 +558,11 @@ class DuplexSession:
         return MappingProxyType(dict(self._conversation.pending_truncations_ms))
 
     def replace_config(self, config: DuplexSessionConfig) -> None:
+        previous_seed = self.config.initial_user_text
         self.config = config
-
-    def replace_capabilities(self, capabilities: DuplexCapabilities) -> None:
-        self.capabilities = capabilities
+        self.config_generation += 1
+        if config.initial_user_text and config.initial_user_text != previous_seed:
+            self.notify_new_user_item()
 
     def transition_turn(self, state: DuplexTurnState) -> None:
         self.turn_state = state
@@ -663,19 +591,19 @@ class DuplexSession:
         return active_turn_id is None or int(turn_id) == active_turn_id
 
     def append_history_message(self, message: dict[str, object]) -> None:
-        response_id = self.active_response_id
-        if response_id is not None:
-            self.reserve_history_item(f"item_{response_id}")
         self._conversation.messages.append(message)
 
-    def stage_pending_history_item(self, item_id: str, message: dict[str, object]) -> None:
-        self._conversation.pending_item_ids[item_id] = dict(message)
+    def notify_new_user_item(self) -> None:
+        """Record a user item that a later ``response.create`` may answer."""
+        self._conversation.unanswered_user_items += 1
 
-    def append_text(self, text: str) -> None:
-        if not text:
-            return
-        self._input.pending_text.append(text)
-        self.turn_state = DuplexTurnState.USER_SPEAKING
+    def unanswered_user_items(self) -> int:
+        """How many user items are waiting for a response."""
+        return self._conversation.unanswered_user_items
+
+    def reset_unanswered_user_items(self) -> None:
+        """A turn has started: the pending items are now its input."""
+        self._conversation.unanswered_user_items = 0
 
     @property
     def pending_input_bytes(self) -> int:
@@ -692,13 +620,6 @@ class DuplexSession:
         self._input.reserved_input_bytes += size
         return True
 
-    @property
-    def turn_detection_config_locked(self) -> bool:
-        return self._input.turn_detection_config_locked
-
-    def lock_turn_detection_config(self) -> None:
-        self._input.turn_detection_config_locked = True
-
     def release_input_bytes(self, size: int) -> None:
         self._input.reserved_input_bytes = max(0, self._input.reserved_input_bytes - max(0, int(size)))
 
@@ -714,200 +635,18 @@ class DuplexSession:
     def release_pending_turn(self) -> None:
         self._input.pending_turns = max(0, self._input.pending_turns - 1)
 
-    def clear_pending_turn_reservations(self) -> None:
-        self._input.pending_turns = 0
-
-    def append_audio(self, data: str, *, fmt: str = "wav", sample_rate_hz: int | None = None) -> None:
-        if not data:
-            return
-        self._input.pending_audio.append(DuplexAudioChunk(data=data, format=fmt, sample_rate_hz=sample_rate_hz))
-        self.turn_state = DuplexTurnState.USER_SPEAKING
-
-    def append_server_vad_frame(
-        self,
-        samples: np.ndarray,
-        *,
-        speech_started: bool,
-        speech_stopped: bool,
-        prefix_samples: int,
-    ) -> int:
-        """Store one detector frame while keeping commit-eligible audio session-owned.
-
-        Returns the number of raw float32 bytes released when the rolling
-        pre-speech prefix is trimmed.
-        """
-        # Session-owned audio must not retain the batch backing a detector frame.
-        frame = np.array(samples, dtype=np.float32, copy=True).reshape(-1)
-        released_samples = 0
-        if not self._input.vad_speech_active:
-            if speech_started:
-                self._input.vad_utterance_audio = [*self._input.vad_prefix_audio, frame]
-                self._input.vad_prefix_audio = []
-                self._input.vad_prefix_samples = 0
-                self._input.vad_speech_active = True
-            else:
-                self._input.vad_prefix_audio.append(frame)
-                self._input.vad_prefix_samples += frame.size
-                while self._input.vad_prefix_samples > prefix_samples and self._input.vad_prefix_audio:
-                    overflow = self._input.vad_prefix_samples - prefix_samples
-                    first = self._input.vad_prefix_audio[0]
-                    if first.size <= overflow:
-                        self._input.vad_prefix_audio.pop(0)
-                        self._input.vad_prefix_samples -= first.size
-                        released_samples += first.size
-                    else:
-                        self._input.vad_prefix_audio[0] = first[overflow:].copy()
-                        self._input.vad_prefix_samples -= overflow
-                        released_samples += overflow
-        else:
-            self._input.vad_utterance_audio.append(frame)
-
-        if speech_stopped:
-            self._input.vad_speech_active = False
-        if self._input.vad_speech_active or speech_started:
-            self.turn_state = DuplexTurnState.USER_SPEAKING
-        return released_samples * np.dtype(np.float32).itemsize
-
-    def stage_server_vad_audio_for_commit(self) -> bool:
-        if not self._input.vad_utterance_audio:
-            return False
-        samples = np.concatenate(self._input.vad_utterance_audio)
-        encoded = encode_float32_mono_wav_base64(samples, sample_rate_hz=16_000)
-        self._input.pending_audio.append(DuplexAudioChunk(data=encoded, format="wav", sample_rate_hz=16_000))
-        self._input.vad_utterance_audio.clear()
-        self._input.vad_speech_active = False
-        return True
-
-    def clear_server_vad_audio(self) -> None:
-        self._input.vad_prefix_audio.clear()
-        self._input.vad_prefix_samples = 0
-        self._input.vad_utterance_audio.clear()
-        self._input.vad_speech_active = False
-        self._input.active_server_vad_item_id = None
-
-    @property
-    def active_server_vad_item_id(self) -> str | None:
-        return self._input.active_server_vad_item_id
-
-    @property
-    def server_vad_utterance_bytes(self) -> int:
-        return sum(frame.nbytes for frame in self._input.vad_utterance_audio)
-
-    def discard_uncommitted_server_vad_utterance(self) -> int:
-        released = self.server_vad_utterance_bytes
-        self._input.vad_utterance_audio.clear()
-        self._input.vad_speech_active = False
-        self._input.active_server_vad_item_id = None
-        self._input.pending_text.clear()
-        return released
-
-    def begin_server_vad_speech(self, item_id: str) -> None:
-        self._input.active_server_vad_item_id = item_id
-
-    def finish_server_vad_speech(self) -> str | None:
-        item_id = self._input.active_server_vad_item_id
-        self._input.active_server_vad_item_id = None
-        return item_id
-
     def mark_user_input_activity(self) -> None:
         self.turn_state = DuplexTurnState.USER_SPEAKING
 
-    def mark_assistant_generating(self) -> None:
-        self.turn_state = DuplexTurnState.ASSISTANT_GENERATING
-
     def cancel_pending_input(self) -> dict[str, int]:
-        cancelled = {
-            "text_chunks": len(self._input.pending_text),
-            "audio_chunks": len(self._input.pending_audio),
-        }
-        self._input.pending_text.clear()
-        self._input.pending_audio.clear()
+        """Drop every pending reservation; the PCM buffer itself is model state cleared by the runner."""
+        cancelled = {"text_chunks": 0, "audio_chunks": 0}
         self._input.reserved_input_bytes = 0
         self._input.pending_turns = 0
-        self.clear_server_vad_audio()
         self.turn_state = DuplexTurnState.IDLE
         return cancelled
 
-    def commit_user_input(
-        self,
-        *,
-        append_history: bool = True,
-        retain_input_bytes: int = 0,
-    ) -> DuplexCommittedInput | None:
-        text = "".join(self._input.pending_text).strip()
-        audio_chunks = list(self._input.pending_audio)
-        if not text and not audio_chunks:
-            return None
-
-        content: str | list[dict[str, object]]
-        if audio_chunks:
-            content_items: list[dict[str, object]] = []
-            if text:
-                content_items.append({"type": "text", "text": text})
-            for chunk in audio_chunks:
-                content_items.append(
-                    {
-                        "type": "audio_url",
-                        "audio_url": {
-                            "url": f"data:audio/{chunk.format};base64,{chunk.data}",
-                        },
-                    }
-                )
-            content = content_items
-        else:
-            content = text
-
-        self._bind_active_response_to_input_commit(self._input.commit_seq + 1)
-        self._input.commit_seq += 1
-        message = {"role": "user", "content": content}
-        if append_history:
-            self._conversation.messages.append(message)
-        self._input.pending_text.clear()
-        self._input.pending_audio.clear()
-        self._input.reserved_input_bytes = max(0, int(retain_input_bytes))
-        self.turn_state = DuplexTurnState.USER_COMMITTED
-        return DuplexCommittedInput(
-            message=message,
-            turn_id=self.turn_id,
-            epoch=self.epoch,
-            input_commit_seq=self._input.commit_seq,
-        )
-
-    @property
-    def pending_server_vad_turn(self) -> PendingServerVADTurn | None:
-        return self._input.pending_server_vad_turn
-
-    def stage_server_vad_turn(
-        self,
-        committed: DuplexCommittedInput,
-        *,
-        create_response: bool,
-        item_id: str,
-    ) -> None:
-        if self._input.pending_server_vad_turn is not None:
-            raise RuntimeError("A Server VAD turn is already pending")
-        response_id = self.active_response_id
-        if response_id is not None:
-            # A pending user turn advances input_commit_seq before the active
-            # response completes. Reserve its current history position first.
-            self.reserve_history_item(f"item_{response_id}")
-        self._input.pending_server_vad_turn = PendingServerVADTurn(
-            committed=committed,
-            create_response=create_response,
-            item_id=item_id,
-        )
-
-    def activate_server_vad_turn(self) -> PendingServerVADTurn | None:
-        pending = self._input.pending_server_vad_turn
-        if pending is None:
-            return None
-        self._input.pending_server_vad_turn = None
-        self._conversation.messages.append(pending.committed.message)
-        self.register_history_item(pending.item_id, pending.committed.message)
-        self.turn_state = DuplexTurnState.USER_COMMITTED
-        return pending
-
-    def commit_native_audio_input(
+    def commit_audio_input(
         self,
         *,
         transcript: str | None = None,
@@ -921,12 +660,10 @@ class DuplexSession:
             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)
-        self._input.pending_text.clear()
-        self._input.pending_audio.clear()
         self.turn_state = DuplexTurnState.USER_COMMITTED
         return DuplexCommittedInput(
             message=message,
@@ -940,6 +677,7 @@ class DuplexSession:
         completed_turn_id = int(turn_id)
         if completed_turn_id >= self.turn_id:
             self.turn_id = completed_turn_id + 1
+            self.sync_fence()
 
     def _bind_active_response_to_input_commit(self, input_commit_seq: int) -> None:
         if self.active_response_id is not None and self._response.active_response_awaits_input_commit:
@@ -992,11 +730,40 @@ class DuplexSession:
         self._response.stage_metric_tpot_weighted_ms.clear()
         self._response.stage_metric_tpot_weight.clear()
 
+    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
+        (stage 0 feeding the TTS stage) reports its token metrics before the
+        response carrying those tokens is created. Dropping them would leave
+        every response without an engine-side token count; holding them keeps
+        the count whole, at the cost of attributing a turn the model never
+        spoke to the next response it does speak.
+        """
+        if not isinstance(stage_metrics, Mapping):
+            return
+        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:
+            self.accumulate_response_stage_metrics(snapshot)
+            return
+        self._pending_stage_metrics.append(snapshot)
+
     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 or not isinstance(stage_metrics, Mapping):
+        if self.active_response_id is None:
+            return copy.deepcopy(self._response.stage_metrics)
+        if self._pending_stage_metrics:
+            pending, self._pending_stage_metrics = self._pending_stage_metrics, []
+            for held in pending:
+                self.accumulate_response_stage_metrics(held)
+        if not isinstance(stage_metrics, Mapping):
             return copy.deepcopy(self._response.stage_metrics)
 
         additive_fields = (
@@ -1032,7 +799,9 @@ class DuplexSession:
             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)
@@ -1046,7 +815,8 @@ class DuplexSession:
             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)
                     )
@@ -1075,7 +845,7 @@ class DuplexSession:
 
     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):
@@ -1109,8 +879,12 @@ class DuplexSession:
         *,
         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)
@@ -1193,18 +967,11 @@ class DuplexSession:
         response_input_commit_seq = self._response.active_response_input_commit_seq
         if response_input_commit_seq is None:
             response_input_commit_seq = self.input_commit_seq
-        response_item_id = f"item_{response_id}" if response_id is not None else None
-        response_history_is_reserved = response_item_id is not None and (
-            response_item_id in self._conversation.item_ids
-            or response_item_id in self._conversation.history_item_placeholders
-        )
-        response_history_is_late = (
-            self.input_commit_seq > response_input_commit_seq and not response_history_is_reserved
-        )
+        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] = (
@@ -1220,9 +987,10 @@ class DuplexSession:
         else:
             committed_text = ""
         if commit_text and committed_text:
-            message = {"role": "assistant", "content": committed_text}
-            if response_item_id is not None and response_history_is_reserved:
-                self._store_history_item_message(response_item_id, message)
+            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)
             else:
                 self._conversation.messages.append(message)
         effective_playback_policy = playback_commit_policy or self.config.playback_commit_policy
@@ -1233,7 +1001,7 @@ class DuplexSession:
             and effective_playback_policy == DuplexPlaybackCommitPolicy.ACK_ONLY.value
         ):
             self.register_history_item(f"item_{response_id}", None)
-        elif response_id is not None and (not assistant_text or not commit_text):
+        elif response_id is not None and not assistant_text:
             self._discard_history_item_placeholder(f"item_{response_id}")
         self._response.assistant_text_buffer.clear()
         if not preserve_request:
@@ -1261,6 +1029,16 @@ class DuplexSession:
             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)
@@ -1292,11 +1070,6 @@ class DuplexSession:
             )
 
     def delete_history_item(self, item_id: str) -> bool:
-        removed_pending_turn = False
-        pending_server_vad_turn = self._input.pending_server_vad_turn
-        if pending_server_vad_turn is not None and pending_server_vad_turn.item_id == item_id:
-            self._input.pending_server_vad_turn = None
-            removed_pending_turn = True
         response_id = item_id.removeprefix("item_") if item_id.startswith("item_") else None
         message = self._conversation.item_ids.pop(item_id, None)
         self._conversation.item_audio_text_marks.pop(item_id, None)
@@ -1309,11 +1082,11 @@ class DuplexSession:
         if response_id is not None:
             self._conversation.assistant_response_snapshots.pop(response_id, None)
         if message is None:
-            return removed_pending_turn or pending is not None or removed_placeholder
-        try:
-            self._conversation.messages.remove(message)
-        except ValueError:
-            pass
+            return pending is not None or removed_placeholder
+        # 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(
@@ -1359,8 +1132,8 @@ class DuplexSession:
             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))
@@ -1394,6 +1167,7 @@ class DuplexSession:
             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,
@@ -1403,10 +1177,9 @@ class DuplexSession:
         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_"):
@@ -1490,12 +1263,20 @@ class DuplexSession:
         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 ""
@@ -1514,6 +1295,11 @@ class DuplexSession:
         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)))
@@ -1550,8 +1336,7 @@ class DuplexSession:
 
     def barge_in(self) -> int:
         self.epoch += 1
-        self._input.pending_text.clear()
-        self._input.pending_audio.clear()
+        self.sync_fence()
         self._response.assistant_text_buffer.clear()
         self._response.assistant_audio_text_marks.clear()
         self._response.active_request_id = None
@@ -1574,11 +1359,31 @@ class DuplexSession:
         self._response.active_response_turn_id = None
         self._response.active_response_input_commit_seq = None
         self._response.active_response_awaits_input_commit = False
-        self.clear_server_vad_audio()
-        self._input.pending_server_vad_turn = None
         self._clear_response_metrics()
         self._restore_response_config()
 
+    def signal_turn(self, event_type: str, payload: Mapping[str, object] | None = None) -> TurnEvent:
+        """Apply one external turn signal and return the typed ``turn.event``."""
+        payload = payload or {}
+        if event_type == DuplexTurnEventType.USER_STARTED.value:
+            self.transition_turn(DuplexTurnState.USER_SPEAKING)
+        elif event_type == DuplexTurnEventType.USER_COMMITTED.value:
+            self.transition_turn(DuplexTurnState.USER_COMMITTED)
+        elif event_type == DuplexTurnEventType.ASSISTANT_STARTED.value:
+            self.transition_turn(DuplexTurnState.ASSISTANT_GENERATING)
+        elif event_type == DuplexTurnEventType.ASSISTANT_DONE.value:
+            self.transition_turn(DuplexTurnState.IDLE)
+        elif event_type == DuplexTurnEventType.PLAYBACK_ACK.value:
+            self.acknowledge_playback(
+                _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)
+        elif event_type in {DuplexTurnEventType.CLOSE.value, DuplexTurnEventType.TIMEOUT.value}:
+            self.transition_session(DuplexSessionState.CLOSING)
+        return TurnEvent(event=event_type, turn_state=self.turn_state.value)
+
     def as_public_dict(self) -> dict[str, object]:
         payload: dict[str, object] = {
             "id": self.session_id,
@@ -1606,103 +1411,58 @@ class DuplexSession:
             "playback": self.playback.as_dict(),
             "capabilities": self.capabilities.as_dict(),
         }
-        if self.config.turn_detection_configured:
-            payload["turn_detection"] = self.config.server_vad.as_dict() if self.config.server_vad is not None else None
-        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
 
 
-class DuplexTurnController:
-    """Interaction controller that accepts signals from multiple sources."""
-
-    def signal(
-        self,
-        session: DuplexSession,
-        event_type: str,
-        payload: dict[str, object] | None = None,
-    ) -> dict[str, object]:
-        payload = payload or {}
-        if event_type == DuplexTurnEventType.USER_STARTED.value:
-            session.transition_turn(DuplexTurnState.USER_SPEAKING)
-        elif event_type == DuplexTurnEventType.USER_COMMITTED.value:
-            session.transition_turn(DuplexTurnState.USER_COMMITTED)
-        elif event_type == DuplexTurnEventType.ASSISTANT_STARTED.value:
-            session.transition_turn(DuplexTurnState.ASSISTANT_GENERATING)
-        elif event_type == DuplexTurnEventType.ASSISTANT_DONE.value:
-            session.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")
-            session.acknowledge_playback(
-                played_ms,
-                int(committed_ms) if isinstance(committed_ms, int | float) else None,
-            )
-        elif event_type == DuplexTurnEventType.BARGE_IN.value:
-            session.transition_turn(DuplexTurnState.BARGE_IN)
-        elif event_type in {DuplexTurnEventType.CLOSE.value, DuplexTurnEventType.TIMEOUT.value}:
-            session.transition_session(DuplexSessionState.CLOSING)
-        return {
-            "type": "turn.event",
-            "session_id": session.session_id,
-            "event": event_type,
-            "turn_state": session.turn_state.value,
-            "epoch": session.epoch,
-        }
-
-
-class DuplexSessionRegistry:
-    def __init__(self, capabilities: DuplexCapabilities | None = None) -> None:
-        self._capabilities = capabilities or DuplexCapabilities()
-        self._sessions: dict[str, DuplexSession] = {}
-        self._next_incarnation_by_session_id: dict[str, int] = {}
-
-    def create(self, config: DuplexSessionConfig | None = None, session_id: str | None = None) -> DuplexSession:
-        sid = session_id or f"duplex-{uuid4().hex}"
-        if sid in self._sessions:
-            raise ValueError(f"Duplex session already exists: {sid}")
-        incarnation = self._next_incarnation_by_session_id.get(sid, 0)
-        self._next_incarnation_by_session_id[sid] = incarnation + 1
-        session = DuplexSession(
-            session_id=sid,
-            config=config or DuplexSessionConfig(),
-            capabilities=self._capabilities,
-            incarnation=incarnation,
-        )
-        self._sessions[sid] = session
-        return session
-
-    def active_count(self) -> int:
-        return len(self._sessions)
-
-    def get(self, session_id: str) -> DuplexSession | None:
-        return self._sessions.get(session_id)
-
-    def close(self, session_id: str) -> DuplexSession | None:
-        session = self._sessions.pop(session_id, None)
-        if session is not None:
-            session.close()
-        return session
+__all__ = [
+    "ConversationHistory",
+    "DuplexAppendReservation",
+    "DuplexEngineSession",
+    "DuplexFenceMismatchError",
+    "DuplexInputAppend",
+    "DuplexRequestResource",
+    "InputBufferState",
+    "PlaybackLedger",
+    "ResponseState",
+]
diff --git a/vllm_omni/engine/duplex/session/helpers.py b/vllm_omni/engine/duplex/session/helpers.py
new file mode 100644
index 000000000..02ae1b7ca
--- /dev/null
+++ b/vllm_omni/engine/duplex/session/helpers.py
@@ -0,0 +1,222 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Small reads and payload builders over one duplex session.
+
+None of these hold state or decide anything: they answer a question about the
+session, or shape one of the wire payloads its events carry. They were methods
+on the runner only because that is where the session reference lived, which
+made every component that needed one a reason to reach back into the runner.
+
+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
+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
+
+    from vllm_omni.engine.duplex.session.context import DuplexSessionTasks
+    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 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:
+    """Whether the model still owns the turn.
+
+    Broader than ``active_response_id``: audio already sent but not yet played
+    back, and an append still in flight, both mean the turn is not free.
+    """
+    if session.active_response_id is not None:
+        return True
+    if assistant_playback_active(session):
+        return True
+    active_task = tasks.active_response_task
+    if active_task is not None and not active_task.done():
+        return True
+    return tasks.has_response_bound_append_tasks()
+
+
+def assistant_playback_active(session: DuplexEngineSession) -> bool:
+    """Whether the client is still playing audio the session has sent."""
+    return (
+        session.config.playback_commit_policy == DuplexPlaybackCommitPolicy.ACK_ONLY.value
+        and session.playback.sent_ms > session.playback.committed_ms
+    )
+
+
+def audio_payload_size_bytes(payload: Mapping[str, object]) -> int:
+    audio = payload.get("audio") or payload.get("data")
+    if not isinstance(audio, str):
+        return 0
+    try:
+        return len(base64.b64decode(audio, validate=True))
+    except (ValueError, binascii.Error):
+        return 0
+
+
+# --------------------------------------------------------------------------- #
+# Turn transitions                                                            #
+# --------------------------------------------------------------------------- #
+
+
+def advance_barge_in_epoch(session: DuplexEngineSession) -> tuple[int, dict[str, int]]:
+    """Start a new epoch for a barge-in, returning it with the playback it cut off."""
+    old_playback = session.playback.as_dict()
+    new_epoch = session.barge_in()
+    session.clear_playback_cursor()
+    return new_epoch, old_playback
+
+
+def commit_played_response_history(
+    session: DuplexEngineSession,
+    response_id: str | None,
+    committed_ms: int,
+) -> None:
+    """Truncate an interrupted response in history to what the client actually heard."""
+    if not response_id or committed_ms < 0:
+        return
+    session.truncate_history_item(
+        f"item_{response_id}",
+        audio_end_ms=committed_ms,
+        playback=session.playback_for_response(response_id),
+    )
+
+
+def commit_audio_input(
+    session: DuplexEngineSession,
+    *,
+    realtime_item_id: object | None = None,
+    transcript: object | None = None,
+    turn_id: int | None = None,
+) -> DuplexCommittedInput:
+    clean_transcript = transcript.strip() if isinstance(transcript, str) else None
+    committed = session.commit_audio_input(
+        transcript=clean_transcript or None,
+        turn_id=turn_id,
+    )
+    if isinstance(realtime_item_id, str) and realtime_item_id:
+        session.register_history_item(realtime_item_id, committed.message)
+    return committed
+
+
+# --------------------------------------------------------------------------- #
+# Payloads                                                                    #
+# --------------------------------------------------------------------------- #
+
+
+def barge_in_unsupported_error() -> ErrorEvent:
+    return error_event("barge_in_unsupported", "Barge-in is not supported by this duplex model")
+
+
+def overlap_decision_event(session: DuplexEngineSession, decision: dict[str, object]) -> OverlapDecision:
+    details: dict[str, object] = {
+        "type": "overlap.decision",
+        "session_id": session.session_id,
+        "epoch": session.epoch,
+        "policy": session.config.overlap_policy,
+        **decision,
+    }
+    action = decision.get("action")
+    reason = decision.get("reason")
+    return OverlapDecision(
+        policy=session.config.overlap_policy,
+        action=action if isinstance(action, str) else None,
+        reason=reason if isinstance(reason, str) else None,
+        details=details,
+    )
+
+
+def input_committed_payload(
+    session: DuplexEngineSession,
+    committed: DuplexCommittedInput,
+    *,
+    realtime_item_id: object | None = None,
+) -> dict[str, object]:
+    payload: dict[str, object] = {
+        "type": "input.committed",
+        "session_id": session.session_id,
+        "turn_id": committed.turn_id,
+        "epoch": committed.epoch,
+        "history_len": len(session.history),
+        "message": committed.message,
+    }
+    if isinstance(realtime_item_id, str) and realtime_item_id:
+        payload["realtime_item_id"] = realtime_item_id
+    return payload
+
+
+def audio_committed_payload(
+    session: DuplexEngineSession,
+    *,
+    committed: DuplexCommittedInput | None = None,
+    realtime_item_id: object | None = None,
+    transcript: object | None = None,
+) -> dict[str, object]:
+    message = committed.message if committed is not None else None
+    if not isinstance(message, dict):
+        input_audio_part: dict[str, object] = {
+            "type": "audio_url",
+            "audio_url": {"url": "native-duplex:input-audio"},
+        }
+        if isinstance(transcript, str) and transcript:
+            input_audio_part["transcript"] = transcript
+        message = {"role": "user", "content": [input_audio_part]}
+    payload: dict[str, object] = {
+        "type": "input.committed",
+        "session_id": session.session_id,
+        "turn_id": committed.turn_id if committed is not None else session.turn_id,
+        "epoch": committed.epoch if committed is not None else session.epoch,
+        "history_len": len(session.history),
+        "native_audio": True,
+        "message": message,
+    }
+    if isinstance(transcript, str) and transcript:
+        payload["transcript"] = transcript
+    if isinstance(realtime_item_id, str) and realtime_item_id:
+        payload["realtime_item_id"] = realtime_item_id
+    return payload
diff --git a/vllm_omni/engine/duplex/lease.py b/vllm_omni/engine/duplex/session/lease.py
similarity index 92%
rename from vllm_omni/engine/duplex/lease.py
rename to vllm_omni/engine/duplex/session/lease.py
index c38faacd1..aea204039 100644
--- a/vllm_omni/engine/duplex/lease.py
+++ b/vllm_omni/engine/duplex/session/lease.py
@@ -8,8 +8,6 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from enum import Enum
 
-from vllm_omni.engine.duplex.messages import DuplexFence
-
 
 class DuplexLeaseActivity(str, Enum):
     APPEND = "append"
@@ -111,19 +109,8 @@ class DuplexLeaseState:
         return True
 
 
-@dataclass(frozen=True)
-class DuplexSessionExpiry:
-    session_id: str
-    fence: DuplexFence
-    lease_generation: int
-    reason: str
-    submitted_request_ids: tuple[str, ...]
-    reserved_request_ids: tuple[str, ...]
-
-
 __all__ = [
     "DuplexLeaseActivity",
     "DuplexLeaseConfig",
     "DuplexLeaseState",
-    "DuplexSessionExpiry",
 ]
diff --git a/vllm_omni/engine/duplex/session/manager.py b/vllm_omni/engine/duplex/session/manager.py
new file mode 100644
index 000000000..e09881abe
--- /dev/null
+++ b/vllm_omni/engine/duplex/session/manager.py
@@ -0,0 +1,877 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Engine-side owner of duplex sessions: admission, lease reaping, command dispatch.
+
+``DuplexOrchestrator`` hosts exactly one manager. The whole session
+(``DuplexEngineSession``) lives here, owned by one ``DuplexSessionRunner`` per
+session on the orchestrator loop; nothing outside the engine holds session
+state.
+
+Control operations (open / close / resume / touch) arrive as correlated RPC
+messages and answer through ``result_sink``; session commands arrive one-way
+as ``DuplexSessionCommandMessage`` and are pushed onto the runner's ordered
+mailbox after backpressure admission; everything a session emits leaves
+through ``output_sink`` as ``DuplexSessionEventMessage``.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import concurrent.futures
+import time
+from collections.abc import Awaitable, Callable, Iterable
+from dataclasses import dataclass, replace
+from typing import TYPE_CHECKING
+
+from vllm.logger import init_logger
+
+from vllm_omni.engine.duplex.commands import AppendAudio, Commit, DuplexCommand
+from vllm_omni.engine.duplex.contracts import (
+    DuplexFence,
+    DuplexStagePort,
+    DuplexStageRequestContext,
+    duplex_resource_request_belongs_to_session,
+    duplex_resource_request_id,
+)
+from vllm_omni.engine.duplex.events import DuplexEvent, ErrorEvent, SessionClosed, SessionExpired, error_event
+from vllm_omni.engine.duplex.messages import (
+    CloseDuplexSessionMessage,
+    DuplexControlResultMessage,
+    DuplexSessionCommandMessage,
+    DuplexSessionError,
+    DuplexSessionEventMessage,
+    OpenDuplexSessionMessage,
+    ResumeDuplexSessionMessage,
+    TouchDuplexSessionMessage,
+)
+from vllm_omni.engine.duplex.plugin import DuplexModelPlugin, DuplexRuntimeConfigError, validate_duplex_plugin_sampling
+from vllm_omni.engine.duplex.session.engine_session import DuplexEngineSession, DuplexFenceMismatchError
+from vllm_omni.engine.duplex.session.lease import DuplexLeaseActivity, DuplexLeaseConfig, DuplexLeaseState
+from vllm_omni.engine.duplex.turn_detection import SileroVADBackendProvider
+
+if TYPE_CHECKING:
+    import janus
+    from vllm.config import ModelConfig
+
+    from vllm_omni.config.stage_config import DuplexSessionRuntimeConfig
+    from vllm_omni.engine.duplex.session.runner import DuplexSessionRunner
+    from vllm_omni.engine.messages import EngineQueueMessage
+
+logger = init_logger(__name__)
+
+
+@dataclass(frozen=True)
+class _PendingRequestCleanup:
+    session_id: str
+    lease_generation: int
+    request_ids: tuple[str, ...]
+    abort: bool
+
+
+@dataclass(frozen=True)
+class _PendingSessionCleanup:
+    """A close/expiry whose stage cleanup has not succeeded yet (retried by the reaper)."""
+
+    kind: str
+    session_id: str
+    lease_generation: int
+    reason: str
+    submitted_request_ids: tuple[str, ...]
+    reserved_request_ids: tuple[str, ...]
+
+
+class DuplexSessionManager:
+    _CONTROL_TYPES = (
+        OpenDuplexSessionMessage,
+        CloseDuplexSessionMessage,
+        ResumeDuplexSessionMessage,
+        TouchDuplexSessionMessage,
+    )
+    _MESSAGE_TYPES = (*_CONTROL_TYPES, DuplexSessionCommandMessage)
+
+    def __init__(
+        self,
+        *,
+        plugin: DuplexModelPlugin,
+        stage_port: DuplexStagePort,
+        output_sink: janus.AsyncQueue[EngineQueueMessage],
+        result_sink: janus.AsyncQueue[EngineQueueMessage],
+        runtime_config: DuplexSessionRuntimeConfig,
+        model_config: ModelConfig | None,
+        clock: Callable[[], float] | None = None,
+        executor: concurrent.futures.ThreadPoolExecutor | None = None,
+    ) -> None:
+        validate_duplex_plugin_sampling(plugin, sampling_defaults=tuple(stage_port.sampling_defaults()))
+        self.plugin = plugin
+        self.stage_port = stage_port
+        self.model_config = model_config
+        self.runtime_config = runtime_config
+        self._output_sink = output_sink
+        self._result_sink = result_sink
+        self._clock = clock or time.monotonic
+        self.executor = executor or concurrent.futures.ThreadPoolExecutor(
+            max_workers=4,
+            thread_name_prefix="duplex-session",
+        )
+        self._owns_executor = executor is None
+        self._lease_config = DuplexLeaseConfig(
+            idle_ttl_s=runtime_config.idle_ttl_s,
+            disconnect_grace_s=runtime_config.disconnect_grace_s,
+        )
+        #: One Silero backend for the whole engine: the ONNX graph is stateless
+        #: per call, so every session's detector can share it. Resolved lazily,
+        #: on the first session that actually turns server VAD on.
+        self.vad_backend_provider = SileroVADBackendProvider(
+            model_path=getattr(runtime_config, "server_vad_model_path", None)
+        )
+        self.runners: dict[str, DuplexSessionRunner] = {}
+        #: Sessions whose close/expiry began but whose stage cleanup has not finalized;
+        #: they keep their admission slot until finalized.
+        self._closing: dict[str, _PendingSessionCleanup] = {}
+        #: Session ids whose ``open`` passed the capacity check and is still awaiting the plugin.
+        self._admitting: set[str] = set()
+        #: Opens whose caller gave up (control RPC timeout / cancellation) before
+        #: admission finished. The open completes anyway -- it is already past
+        #: the capacity check -- so it must tear itself down on arrival instead
+        #: of holding a slot and a stage resource until idle expiry.
+        self._abandoned_opens: set[str] = set()
+        self._request_index: dict[str, str] = {}
+        self._session_control_tails: dict[str, asyncio.Task[None]] = {}
+        self._dispatched_control_tasks: set[asyncio.Task[None]] = set()
+        self._pending_request_cleanups: dict[tuple[str, int], _PendingRequestCleanup] = {}
+        self._request_cleanup_tasks: dict[tuple[str, int], asyncio.Task[None]] = {}
+        self._request_cleanups_in_progress: set[tuple[str, int]] = set()
+        #: Sessions retained for cleanup retry after their runner is gone.
+        self._session_snapshots: dict[str, DuplexEngineSession] = {}
+
+    # ------------------------------------------------------------------ #
+    # Views                                                              #
+    # ------------------------------------------------------------------ #
+
+    def active_count(self) -> int:
+        return len(self.runners)
+
+    def get(self, session_id: str) -> DuplexEngineSession | None:
+        runner = self.runners.get(session_id)
+        return runner.session if runner is not None else None
+
+    def sessions(self) -> dict[str, DuplexEngineSession]:
+        return {session_id: runner.session for session_id, runner in self.runners.items()}
+
+    def runner_for_request_id(self, request_id: str) -> DuplexSessionRunner | None:
+        session_id = self._request_index.get(request_id)
+        if session_id is None:
+            for candidate_id in self.runners:
+                if duplex_resource_request_belongs_to_session(request_id, candidate_id):
+                    session_id = candidate_id
+                    break
+        if session_id is None:
+            return None
+        return self.runners.get(session_id)
+
+    def register_request(self, request_id: str, session_id: str) -> None:
+        self._request_index[request_id] = session_id
+
+    def unregister_request(self, request_id: str) -> None:
+        self._request_index.pop(request_id, None)
+
+    def _unregister_session_requests(self, session_id: str) -> None:
+        for request_id in [rid for rid, sid in self._request_index.items() if sid == session_id]:
+            self._request_index.pop(request_id, None)
+
+    # ------------------------------------------------------------------ #
+    # Message routing                                                    #
+    # ------------------------------------------------------------------ #
+
+    def accepts(self, message: object) -> bool:
+        return isinstance(message, self._MESSAGE_TYPES)
+
+    def dispatch(self, message: object) -> None:
+        """Route one engine request-queue message without blocking the request handler."""
+        if isinstance(message, DuplexSessionCommandMessage):
+            self._dispatch_command(message)
+            return
+        if not isinstance(message, self._CONTROL_TYPES):
+            raise TypeError(f"Unsupported duplex control message: {type(message).__name__}")
+        session_id = message.session_id
+
+        async def handle_message() -> None:
+            await self.handle(message)
+
+        self._run_control(session_id, f"duplex-control-{session_id}-{message.control_id}", handle_message)
+
+    def _run_control(
+        self,
+        session_id: str,
+        name: str,
+        operation: Callable[[], Awaitable[None]],
+    ) -> asyncio.Task[None]:
+        """Run one control operation after the session's previous one (per-session order)."""
+        predecessor = self._session_control_tails.get(session_id)
+
+        async def run_ordered() -> None:
+            if predecessor is not None:
+                try:
+                    await predecessor
+                except BaseException:
+                    pass
+            await operation()
+
+        task = asyncio.create_task(run_ordered(), name=name)
+        self._session_control_tails[session_id] = task
+        self._track_task(task)
+
+        def discard(completed: asyncio.Task[None]) -> None:
+            if self._session_control_tails.get(session_id) is completed:
+                self._session_control_tails.pop(session_id, None)
+
+        task.add_done_callback(discard)
+        return task
+
+    def _track_task(self, task: asyncio.Task[None]) -> None:
+        """Keep a background task alive until it finishes and log an escaped exception."""
+        self._dispatched_control_tasks.add(task)
+
+        def done(completed: asyncio.Task[None]) -> None:
+            self._dispatched_control_tasks.discard(completed)
+            if not completed.cancelled() and completed.exception() is not None:
+                logger.error("duplex control task %s failed: %r", completed.get_name(), completed.exception())
+
+        task.add_done_callback(done)
+
+    async def handle(self, message: object) -> None:
+        if isinstance(message, OpenDuplexSessionMessage):
+            await self.open(message)
+        elif isinstance(message, CloseDuplexSessionMessage):
+            await self.close(message)
+        elif isinstance(message, ResumeDuplexSessionMessage):
+            await self.resume(message)
+        elif isinstance(message, TouchDuplexSessionMessage):
+            await self.touch(message)
+        elif isinstance(message, DuplexSessionCommandMessage):
+            self._dispatch_command(message)
+        else:
+            raise TypeError(f"Unsupported duplex control message: {type(message).__name__}")
+
+    def _dispatch_command(self, message: DuplexSessionCommandMessage) -> None:
+        """Admit one command: identity check, backpressure, then the runner's ordered mailbox.
+
+        Backpressure contract shared with the runner: a ``Commit`` that passes
+        admission holds one pending-turn reservation and an ``AppendAudio``
+        holds its wire-size byte reservation until the runner dequeues the
+        command (the runner then re-reserves the decoded size around its PCM
+        reservation), so the mailbox never holds more bytes than the session
+        limit even while the worker is busy.
+        """
+        runner = self.runners.get(message.session_id)
+        command = message.command
+        if runner is None:
+            self._emit_raw(
+                message.session_id,
+                self._error_event(
+                    "unknown_session",
+                    f"Unknown or closed duplex session: {message.session_id}",
+                    command=command,
+                ),
+            )
+            return
+        session = runner.session
+        if runner.closing:
+            self.emit(
+                session,
+                self._error_event(
+                    "session_closed", f"Duplex session is closing: {session.session_id}", command=command
+                ),
+            )
+            return
+        if isinstance(command, AppendAudio):
+            limit = int(self.runtime_config.max_pending_input_bytes_per_session)
+            if not session.reserve_input_bytes(len(command.audio), limit=limit):
+                self.emit(
+                    session,
+                    self._error_event(
+                        "input_backpressure",
+                        "Duplex session has too many pending input bytes",
+                        command=command,
+                    ),
+                )
+                return
+        elif isinstance(command, Commit):
+            if not session.reserve_pending_turn(limit=int(self.runtime_config.max_pending_turns_per_session)):
+                self.emit(
+                    session,
+                    self._error_event(
+                        "input_backpressure",
+                        "Duplex session has too many pending input turns",
+                        command=command,
+                    ),
+                )
+                return
+        runner.submit(command)
+
+    @staticmethod
+    def _error_event(code: str, message: str, *, command: DuplexCommand | None = None) -> ErrorEvent:
+        return error_event(code, message, event_id=command.event_id if command is not None else None)
+
+    # ------------------------------------------------------------------ #
+    # Emission                                                           #
+    # ------------------------------------------------------------------ #
+
+    def emit(self, session: DuplexEngineSession, event: DuplexEvent) -> None:
+        """Bind the session identity to one typed event and push it to the engine output queue."""
+        self._emit_raw(session.session_id, event, epoch=session.epoch)
+
+    def _emit_raw(
+        self,
+        session_id: str,
+        event: DuplexEvent,
+        *,
+        epoch: int | None = None,
+    ) -> None:
+        event = replace(event, session_id=session_id, epoch=epoch)
+        message = DuplexSessionEventMessage(session_id=session_id, event=event)
+        put_nowait = getattr(self._output_sink, "put_nowait", None)
+        if callable(put_nowait):
+            put_nowait(message)
+        else:  # pragma: no cover - sink without put_nowait
+            asyncio.ensure_future(self._output_sink.put(message))
+
+    async def _put_result(
+        self,
+        message: (
+            OpenDuplexSessionMessage
+            | CloseDuplexSessionMessage
+            | ResumeDuplexSessionMessage
+            | TouchDuplexSessionMessage
+        ),
+        *,
+        operation: str,
+        ok: bool,
+        session: DuplexEngineSession | None = None,
+        error: BaseException | None = None,
+    ) -> None:
+        error_code, error_message, error_retryable = (
+            self._control_error(error) if error is not None else (None, None, False)
+        )
+        result = DuplexControlResultMessage(
+            control_id=message.control_id,
+            operation=operation,
+            session_id=message.session_id,
+            ok=ok,
+            lease_generation=session.lease_generation if session is not None else None,
+            capabilities=session.capabilities if session is not None and ok else None,
+            public_session=session.as_public_dict() if session is not None and ok else None,
+            error_code=error_code,
+            error_message=error_message,
+            error_retryable=error_retryable,
+        )
+        await self._result_sink.put(result)
+
+    @staticmethod
+    def _control_error(error: BaseException) -> tuple[str, str, bool]:
+        """Map an exception to ``(code, message, retryable)`` for a control result."""
+        message = str(error)
+        retryable = False
+        if isinstance(error, DuplexSessionError):
+            code = error.code
+            retryable = error.retryable
+        elif isinstance(error, DuplexRuntimeConfigError):
+            code = error.code
+        elif isinstance(error, DuplexFenceMismatchError):
+            code = "stale_fence"
+        elif isinstance(error, KeyError):
+            code = "not_found"
+        elif isinstance(error, TypeError | ValueError):
+            code = "invalid_argument"
+        elif isinstance(error, TimeoutError):
+            code = "timeout"
+            retryable = True
+        else:
+            code = "failed_precondition"
+        return code, message, retryable
+
+    # ------------------------------------------------------------------ #
+    # Sampling / stage request helpers shared with the runner            #
+    # ------------------------------------------------------------------ #
+
+    def sampling_params_for(self, session: DuplexEngineSession) -> tuple[object, ...]:
+        defaults = tuple(self.stage_port.sampling_defaults())
+        configured = self.plugin.configure_sampling_params(
+            runtime_config=dict(session.runtime_config),
+            defaults=defaults,
+        )
+        if not isinstance(configured, tuple):
+            raise TypeError("duplex plugin must return sampling parameters as a tuple")
+        if len(configured) != len(defaults):
+            raise ValueError("duplex plugin must return one sampling parameter per stage")
+        return configured
+
+    @staticmethod
+    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,
+        session: DuplexEngineSession,
+        *,
+        stage_id: int,
+        fence: DuplexFence | None = None,
+    ) -> DuplexStageRequestContext | None:
+        """Reserve the session's stage request id and register it with the stage port."""
+        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, resumable=session.capabilities.supports_core_resumable_request
+        )
+        session.reserve_stage_request(stage_id, request_id, fence=effective_fence)
+        context = DuplexStageRequestContext(
+            request_id=request_id,
+            session_id=session.session_id,
+            fence=effective_fence,
+            stage_id=stage_id,
+            final_stage_id=self.stage_port.stage_count - 1,
+            config_generation=session.config_generation,
+            sampling_params=self.sampling_params_for(session),
+            session_config=session.config.as_dict(),
+            runtime_config=session.runtime_config,
+        )
+        self.stage_port.ensure_request(context)
+        self.register_request(request_id, session.session_id)
+        return context
+
+    # ------------------------------------------------------------------ #
+    # Control operations                                                 #
+    # ------------------------------------------------------------------ #
+
+    def _admission_count(self) -> int:
+        return len(set(self.runners) | set(self._closing) | self._admitting)
+
+    async def open(self, message: OpenDuplexSessionMessage) -> None:
+        from vllm_omni.engine.duplex.session.runner import DuplexSessionRunner
+
+        session_id = message.session_id
+        session: DuplexEngineSession | None = None
+        runner: DuplexSessionRunner | None = None
+        # Only the open that put the id in ``_admitting`` may take it out again:
+        # a duplicate open must not release the slot the first one is holding.
+        holds_admission_slot = False
+        try:
+            if session_id in self.runners or session_id in self._closing or session_id in self._admitting:
+                raise DuplexSessionError(f"Duplex session already exists: {session_id}", code="session_exists")
+            max_sessions = int(self.runtime_config.max_sessions)
+            if self._admission_count() >= max_sessions:
+                raise DuplexSessionError(
+                    f"duplex_session_capacity_exhausted: limit={max_sessions}",
+                    code="resource_exhausted",
+                    retryable=True,
+                )
+            # Hold the slot across the plugin await: opens of different
+            # sessions run concurrently and must not all pass the check above.
+            self._admitting.add(session_id)
+            holds_admission_slot = True
+            config = message.session_config
+            self.plugin.validate_client_extra_body(config.extra_body)
+            try:
+                runtime_config = await self.plugin.prepare_runtime_config(config, model_config=self.model_config)
+            except DuplexRuntimeConfigError:
+                raise
+            except ValueError as exc:
+                raise DuplexRuntimeConfigError(str(exc)) from exc
+            capabilities = self.plugin.capabilities(max_sessions=max_sessions)
+            session = DuplexEngineSession(
+                session_id=session_id,
+                config=config,
+                capabilities=capabilities,
+                lease=DuplexLeaseState(config=self._lease_config, generation=0, last_activity=self._clock()),
+                _clock=self._clock,
+                _runtime_config=dict(runtime_config),
+            )
+            # Validates the plugin's sampling policy for this runtime config before admission.
+            self.sampling_params_for(session)
+            session.model_state = self.plugin.create_session_state()
+            runner = DuplexSessionRunner(
+                session=session,
+                plugin=self.plugin,
+                stage_port=self.stage_port,
+                manager=self,
+                model_config=self.model_config,
+            )
+            self.runners[session_id] = runner
+            # Reserve the Stage0 request resource atomically with admission.
+            self.ensure_stage_request(session, stage_id=0)
+            runner.start()
+            await self._put_result(message, operation="open", ok=True, session=session)
+            if session_id in self._abandoned_opens:
+                # The caller timed out while we were admitting; hand the slot
+                # and the stage resource straight back.
+                self._abandoned_opens.discard(session_id)
+                await self._close_runner(runner, kind="close", reason="open_abandoned")
+        except Exception as exc:
+            error_code, _, _ = self._control_error(exc)
+            if error_code in {"resource_exhausted", "session_exists"}:
+                logger.info("open_duplex_session rejected: %s", exc)
+            else:
+                logger.exception("open_duplex_session failed: %s", exc)
+            if runner is not None and self.runners.get(session_id) is runner:
+                self.runners.pop(session_id, None)
+                try:
+                    await runner.shutdown()
+                except Exception:
+                    logger.exception("duplex open rollback: runner shutdown failed for %s", session_id)
+            if session is not None:
+                reserved = session.release_all_requests()
+                if reserved:
+                    try:
+                        await self.stage_port.cleanup(list(reserved))
+                    except Exception:
+                        logger.warning("duplex open rollback: request cleanup pending for %s", session_id)
+                self._unregister_session_requests(session_id)
+            await self._put_result(message, operation="open", ok=False, error=exc)
+        finally:
+            if holds_admission_slot:
+                self._admitting.discard(session_id)
+            self._abandoned_opens.discard(session_id)
+
+    def _require_runner(self, session_id: str) -> DuplexSessionRunner:
+        runner = self.runners.get(session_id)
+        if runner is None:
+            raise DuplexSessionError(f"Unknown duplex session: {session_id}", code="unknown_session")
+        if runner.closing:
+            raise DuplexSessionError(f"Duplex session is closing: {session_id}", code="session_closed")
+        return runner
+
+    async def close(self, message: CloseDuplexSessionMessage) -> None:
+        session_id = message.session_id
+        runner = self.runners.get(session_id)
+        if runner is None:
+            if session_id in self._admitting:
+                # The open is still awaiting the plugin. It cannot be cancelled
+                # from here, so leave a note it checks before returning.
+                self._abandoned_opens.add(session_id)
+            # Already closing, or closed and forgotten: ids are never reused
+            # (D16), so a repeated close is idempotent rather than an error.
+            await self._put_result(message, operation="close", ok=True)
+            return
+        session = runner.session
+        try:
+            await self._close_runner(runner, kind="close", reason=message.reason)
+        except Exception as exc:
+            # The session is closed either way; only the stage cleanup is
+            # outstanding and the reaper retries it while the slot stays held.
+            logger.warning("close_duplex_session: stage cleanup for %s remains pending: %s", session_id, exc)
+        await self._put_result(message, operation="close", ok=True, session=session)
+
+    def close_from_runner(self, runner: DuplexSessionRunner, reason: str) -> None:
+        """Finish a close the runner started from its command stream (``session.close``).
+
+        Runs on the orchestrator loop as a tracked task (the runner's worker
+        cannot await its own teardown): stage requests are aborted, the
+        admission slot is released and ``session.closed`` is emitted last.
+        """
+        session_id = runner.session.session_id
+        if self.runners.get(session_id) is not runner:
+            return
+
+        async def close_runner() -> None:
+            if self.runners.get(session_id) is runner:
+                await self._close_runner(runner, kind="close", reason=reason)
+
+        # Chained on the session's control tail so a control RPC issued after
+        # the wire close observes the closed session, never a half-torn one.
+        self._run_control(session_id, f"duplex-close-{session_id}", close_runner)
+
+    async def _close_runner(self, runner: DuplexSessionRunner, *, kind: str, reason: str) -> None:
+        """Begin an irreversible close, tear down the runner, then release stage resources.
+
+        The session keeps its admission slot (``_closing``) until stage cleanup
+        succeeded; a failed cleanup is retried by the reaper. For an explicit
+        close the ``session.closed`` event is emitted only after the cleanup
+        attempt, so a client that sees it can open a replacement session at
+        once (the runner used to emit it before the stage requests were
+        aborted, which let a prompt reopen hit ``resource_exhausted``).
+        """
+        session = runner.session
+        submitted = tuple(session.resource_request_ids(submitted=True))
+        reserved = tuple(session.resource_request_ids(submitted=False))
+        session.begin_close(reason=reason)
+        pending = _PendingSessionCleanup(
+            kind=kind,
+            session_id=session.session_id,
+            lease_generation=session.lease_generation,
+            reason=reason,
+            submitted_request_ids=submitted,
+            reserved_request_ids=reserved,
+        )
+        self._closing[session.session_id] = pending
+        if self.runners.get(session.session_id) is runner:
+            self.runners.pop(session.session_id, None)
+        emit_after_cleanup = kind in {"close", "expired"} and not runner.closed_emitted
+        try:
+            if kind == "expired":
+                await runner.expire(reason, emit_expired=not emit_after_cleanup)
+            else:
+                await runner.close(reason, emit_closed=not emit_after_cleanup)
+        except Exception:
+            logger.exception("duplex runner %s failed for session %s", kind, session.session_id)
+        session.close()
+        try:
+            await self._finalize_pending_cleanup(pending, session)
+        finally:
+            # ``emit_after_cleanup`` was decided before the teardown awaits; a
+            # runtime close racing them may have emitted the terminal already.
+            if emit_after_cleanup and not runner.closed_emitted:
+                runner.mark_closed_emitted()
+                terminal: DuplexEvent = (
+                    SessionExpired(reason=reason) if kind == "expired" else SessionClosed(reason=reason)
+                )
+                self.emit(session, terminal)
+
+    async def _finalize_pending_cleanup(
+        self,
+        pending: _PendingSessionCleanup,
+        session: DuplexEngineSession | None,
+    ) -> None:
+        if pending.submitted_request_ids:
+            await self.stage_port.cleanup(list(pending.submitted_request_ids), abort=True)
+        if pending.reserved_request_ids:
+            await self.stage_port.cleanup(list(pending.reserved_request_ids))
+        if session is not None:
+            session.release_all_requests()
+        self._unregister_session_requests(pending.session_id)
+        if self._closing.get(pending.session_id) is pending:
+            self._closing.pop(pending.session_id, None)
+        self._session_snapshots.pop(pending.session_id, None)
+
+    async def resume(self, message: ResumeDuplexSessionMessage) -> None:
+        session: DuplexEngineSession | None = None
+        try:
+            runner = self._require_runner(message.session_id)
+            session = runner.session
+            try:
+                session.resume_lease(expected_lease_generation=message.expected_lease_generation)
+            except ValueError as exc:
+                raise DuplexSessionError(str(exc), code="session_resume_conflict") from exc
+            await self._put_result(message, operation="resume", ok=True, session=session)
+        except Exception as exc:
+            logger.exception("resume_duplex_session failed: %s", exc)
+            await self._put_result(message, operation="resume", ok=False, session=session, error=exc)
+
+    async def touch(self, message: TouchDuplexSessionMessage) -> None:
+        session: DuplexEngineSession | None = None
+        try:
+            runner = self._require_runner(message.session_id)
+            session = runner.session
+            activity = DuplexLeaseActivity(message.activity)
+            if activity is DuplexLeaseActivity.DETACH:
+                session.detach_lease()
+            else:
+                session.touch_lease(activity)
+            await self._put_result(message, operation="touch", ok=True, session=session)
+        except DuplexSessionError as exc:
+            # A lease touch racing the session's own close is routine: the
+            # caller learns the session is gone from the result, not a fault.
+            logger.debug("touch_duplex_session skipped: %s", exc)
+            await self._put_result(message, operation="touch", ok=False, session=session, error=exc)
+        except Exception as exc:
+            logger.exception("touch_duplex_session failed: %s", exc)
+            await self._put_result(message, operation="touch", ok=False, session=session, error=exc)
+
+    # ------------------------------------------------------------------ #
+    # Lease expiry / reaper                                              #
+    # ------------------------------------------------------------------ #
+
+    async def reaper_loop(self, shutdown_event: asyncio.Event) -> None:
+        interval = float(self.runtime_config.reaper_interval_s)
+        while not shutdown_event.is_set():
+            try:
+                await asyncio.wait_for(shutdown_event.wait(), timeout=interval)
+            except TimeoutError:
+                try:
+                    await self.reap_expired()
+                except Exception:
+                    logger.exception("[DuplexSessionManager] expiry cleanup failed; retrying on next tick")
+
+    async def reap_expired(self, now: float | None = None) -> int:
+        completed = 0
+        effective_now = self._clock() if now is None else now
+        # Retry request cleanups recorded by the orchestrator error paths.
+        for key, request_cleanup in list(self._pending_request_cleanups.items()):
+            if key in self._request_cleanups_in_progress:
+                continue
+            try:
+                await self._complete_request_cleanup(key, request_cleanup)
+            except Exception as exc:
+                logger.warning(
+                    "duplex request cleanup remains pending for session %s: %s",
+                    request_cleanup.session_id,
+                    exc,
+                )
+                continue
+            completed += 1
+        # Retry closes/expiries whose stage cleanup failed.
+        for session_id, session_cleanup in list(self._closing.items()):
+            if session_id in self.runners:
+                continue
+            if session_cleanup.kind == "request_cleanup" and any(
+                key[0] == session_id for key in self._pending_request_cleanups
+            ):
+                # The stage cleanup is owned by the request-cleanup path (orchestrator
+                # or the retry above); ``finalize_closed_sessions`` releases the slot.
+                continue
+            try:
+                await self._finalize_pending_cleanup(session_cleanup, self._session_snapshots.get(session_id))
+            except Exception as exc:
+                logger.warning(
+                    "duplex %s cleanup remains pending for session %s: %s",
+                    session_cleanup.kind,
+                    session_id,
+                    exc,
+                )
+                continue
+            completed += 1
+        # Expire leases.
+        for session_id, runner in list(self.runners.items()):
+            lease = runner.session.lease
+            if lease.disconnect_grace_expired(effective_now):
+                reason = "disconnect_grace_expired"
+            elif lease.idle_expired(effective_now):
+                reason = "idle_ttl_expired"
+            else:
+                continue
+            self._session_snapshots[session_id] = runner.session
+            try:
+                await self._close_runner(runner, kind="expired", reason=reason)
+            except Exception as exc:
+                logger.warning("duplex expiry cleanup remains pending for session %s: %s", session_id, exc)
+                continue
+            completed += 1
+        return completed
+
+    # ------------------------------------------------------------------ #
+    # Request-triggered cleanup (orchestrator error paths)               #
+    # ------------------------------------------------------------------ #
+
+    def close_sessions_for_request_ids(
+        self,
+        request_ids: list[str],
+        *,
+        abort: bool = False,
+        cleanup_in_progress: bool = False,
+    ) -> dict[str, list[str]]:
+        request_id_set = set(request_ids)
+        closed: dict[str, list[str]] = {}
+        for session_id, runner in list(self.runners.items()):
+            session = runner.session
+            stale = session.resource_request_ids()
+            if request_id_set.isdisjoint(stale):
+                continue
+            if not session.begin_close(reason="request_cleanup"):
+                continue
+            closed[session_id] = stale
+            key = (session_id, session.lease_generation)
+            existing = self._pending_request_cleanups.get(key)
+            merged = tuple(dict.fromkeys([*(existing.request_ids if existing is not None else ()), *stale]))
+            self._pending_request_cleanups[key] = _PendingRequestCleanup(
+                session_id=session_id,
+                lease_generation=session.lease_generation,
+                request_ids=merged,
+                abort=abort or (existing.abort if existing is not None else False),
+            )
+            if cleanup_in_progress:
+                self._request_cleanups_in_progress.add(key)
+            # Tear the runner down in the background; the orchestrator owns the stage cleanup.
+            self._session_snapshots[session_id] = session
+            self._closing[session_id] = _PendingSessionCleanup(
+                kind="request_cleanup",
+                session_id=session_id,
+                lease_generation=session.lease_generation,
+                reason="request_cleanup",
+                submitted_request_ids=(),
+                reserved_request_ids=(),
+            )
+            self.runners.pop(session_id, None)
+            task = asyncio.create_task(runner.expire("request_cleanup"), name=f"duplex-request-cleanup-{session_id}")
+            self._track_task(task)
+        return closed
+
+    def defer_request_cleanups(self, session_ids: Iterable[str]) -> None:
+        session_id_set = set(session_ids)
+        active_keys = {key for key in self._request_cleanups_in_progress if key[0] in session_id_set}
+        self._request_cleanups_in_progress.difference_update(active_keys)
+
+    def finalize_closed_sessions(self, session_ids: Iterable[str]) -> None:
+        session_id_set = set(session_ids)
+        for key in list(self._pending_request_cleanups):
+            if key[0] not in session_id_set:
+                continue
+            self._pending_request_cleanups.pop(key, None)
+            self._request_cleanups_in_progress.discard(key)
+        for session_id in session_id_set:
+            session = self._session_snapshots.pop(session_id, None)
+            if session is not None and session.lease.terminal_reason is not None:
+                session.release_all_requests()
+                session.close()
+            self._closing.pop(session_id, None)
+            self._unregister_session_requests(session_id)
+
+    async def _complete_request_cleanup(
+        self,
+        key: tuple[str, int],
+        pending: _PendingRequestCleanup,
+    ) -> None:
+        task = self._request_cleanup_tasks.get(key)
+        if task is not None and task.done():
+            self._request_cleanup_tasks.pop(key, None)
+            task = None
+        if task is None:
+            task = asyncio.create_task(
+                self._run_request_cleanup(key, pending),
+                name=f"duplex-request-cleanup-{pending.session_id}",
+            )
+            self._request_cleanup_tasks[key] = task
+
+            def discard(completed: asyncio.Task[None]) -> None:
+                if self._request_cleanup_tasks.get(key) is completed:
+                    self._request_cleanup_tasks.pop(key, None)
+
+            task.add_done_callback(discard)
+        await asyncio.shield(task)
+
+    async def _run_request_cleanup(self, key: tuple[str, int], pending: _PendingRequestCleanup) -> None:
+        await self.stage_port.cleanup(list(pending.request_ids), abort=pending.abort)
+        if self._pending_request_cleanups.get(key) is pending:
+            self._pending_request_cleanups.pop(key, None)
+            self._request_cleanups_in_progress.discard(key)
+        self.finalize_closed_sessions([pending.session_id])
+
+    # ------------------------------------------------------------------ #
+    # Shutdown                                                           #
+    # ------------------------------------------------------------------ #
+
+    async def shutdown(self) -> None:
+        runners = list(self.runners.values())
+        self.runners.clear()
+        for runner in runners:
+            try:
+                await runner.shutdown()
+            except Exception:
+                logger.exception("duplex runner shutdown failed for %s", runner.session.session_id)
+        tasks = tuple(self._dispatched_control_tasks | set(self._request_cleanup_tasks.values()))
+        for task in tasks:
+            task.cancel()
+        if tasks:
+            await asyncio.gather(*tasks, return_exceptions=True)
+        self._session_control_tails.clear()
+        self._closing.clear()
+        self._session_snapshots.clear()
+        self._request_index.clear()
+        if self._owns_executor:
+            self.executor.shutdown(wait=False, cancel_futures=True)
+
+
+__all__ = ["DuplexSessionManager"]
diff --git a/vllm_omni/engine/duplex/session/model_channel.py b/vllm_omni/engine/duplex/session/model_channel.py
new file mode 100644
index 000000000..f244a6859
--- /dev/null
+++ b/vllm_omni/engine/duplex/session/model_channel.py
@@ -0,0 +1,1130 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""The model side of one duplex session.
+
+Everything between the session and the model runtime: planning an append with
+the plugin and submitting it to the stage port, turning the stage output that
+comes back into session events, and -- when the model chooses to keep listening
+-- offering it another unit of silence so the turn can continue.
+
+Those three read as separate concerns but they call each other in a cycle. An
+append submits and immediately projects its own first outputs; a projected
+output can schedule a continuation; a continuation is another append. Splitting
+them into three modules would mean three mutual imports and no fewer edges, so
+they are one component whose seam with the runner is narrow instead.
+
+That seam is three callbacks, for the three things this component triggers but
+does not own: closing the session, scheduling the continuation append as a
+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
+from typing import TYPE_CHECKING, Protocol
+
+import pybase64 as base64
+from vllm.logger import init_logger
+
+from vllm_omni.engine.duplex.config import DuplexSessionState
+from vllm_omni.engine.duplex.contracts import (
+    DuplexAppendPlan,
+    DuplexFence,
+    DuplexOutputContext,
+    DuplexOutputDecision,
+    DuplexStageSubmission,
+    duplex_data_plane_request_info,
+)
+from vllm_omni.engine.duplex.plugin import (
+    DuplexRuntimeConfigError,
+    coerce_int,
+)
+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
+from vllm_omni.engine.duplex.session.lease import DuplexLeaseActivity
+from vllm_omni.metrics.stats import OrchestratorAggregator, StageRequestStats
+from vllm_omni.outputs import OmniRequestOutput
+from vllm_omni.outputs.duplex import attach_duplex_output_decision
+
+if TYPE_CHECKING:
+    from vllm.outputs import RequestOutput
+
+logger = init_logger(__name__)
+
+
+class SilenceContinuationScheduler(Protocol):
+    """Runs one continuation append as a tracked task (see ``_schedule_silence_continuation``)."""
+
+    async def __call__(
+        self,
+        payload: dict[str, object],
+        *,
+        request_id: str,
+        owner_id: str,
+        response_id: str | None,
+        response_owned: bool,
+        expected_epoch: int | None,
+        expected_model_turn_id: int | None,
+    ) -> bool: ...
+
+
+class ModelChannel:
+    """Appends out to the model, events back from it, for one session."""
+
+    # One MiniCPM model unit (1 s at 16 kHz) is the compatibility default.
+    _SILENCE_UNIT_PAYLOAD_AUDIO = base64.b64encode(bytes(16000 * 4)).decode("ascii")
+    _RESPONSE_MAX_CONTINUATION_UNITS = 8
+    _AUTO_RESPONSE_MAX_CONTINUATION_UNITS = 64
+
+    def __init__(
+        self,
+        ctx: DuplexSessionContext,
+        out: SessionEmitter,
+        *,
+        close_from_runtime: Callable[[str], Awaitable[None]],
+        schedule_silence_continuation: SilenceContinuationScheduler,
+        abort_request: Callable[..., Awaitable[None]],
+    ) -> None:
+        self._ctx = ctx
+        self._out = out
+        self._close_from_runtime = close_from_runtime
+        self._schedule_silence_continuation = schedule_silence_continuation
+        self._abort_request = abort_request
+
+    @staticmethod
+    def should_commit_response_to_history(session: DuplexEngineSession, response_id: str | None) -> bool:
+        if response_id is not None and response_id != session.active_response_id:
+            return True
+        mode = session.response_config.extra_body.get("realtime_response_conversation")
+        return not isinstance(mode, str) or mode.strip().lower() != "none"
+
+    def response_created_payload(
+        self,
+        response_id: str,
+        *,
+        epoch: int,
+        request_id: str | None = None,
+    ) -> 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,
+            "response_id": response_id,
+            "epoch": epoch,
+            "modalities": list(response_config.modalities),
+        }
+        if request_id is not None:
+            payload["request_id"] = request_id
+        metadata = response_config.extra_body.get("realtime_response_metadata")
+        if not isinstance(metadata, dict):
+            metadata = response_config.extra_body.get("realtime_metadata")
+        if isinstance(metadata, dict):
+            payload["metadata"] = dict(metadata)
+        conversation = response_config.extra_body.get("realtime_response_conversation")
+        if isinstance(conversation, str):
+            payload["conversation"] = conversation
+        prompt = response_config.extra_body.get("realtime_response_prompt")
+        if isinstance(prompt, dict):
+            payload["prompt"] = dict(prompt)
+        return payload
+
+    # ------------------------------------------------------------------ #
+    # Submitting an append                                               #
+    # ------------------------------------------------------------------ #
+
+    async def append_runtime_input(
+        self,
+        payload: object,
+        *,
+        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,
+                final=final,
+                operation_id=operation_id,
+                expected_epoch=expected_epoch,
+            )
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:
+            logger.exception("Failed to append duplex runtime input: %s", exc)
+            self.send_runtime_error("runtime_append_failed", exc)
+            return False, False
+        if result is None:
+            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)
+        close_reason, emitted_response = await self._send_model_output_events(result, expected_epoch=expected_epoch)
+        emitted_response = emitted_response or request_id is not None
+        if close_reason is None and self._start_data_plane_stream(result):
+            emitted_response = True
+        if close_reason is not None:
+            await self._close_from_runtime(close_reason)
+            return False, emitted_response
+        return True, emitted_response
+
+    async def _append_via_data_plane(
+        self,
+        payload: object,
+        *,
+        final: bool,
+        operation_id: str | None,
+        expected_epoch: int | None,
+    ) -> dict[str, object] | None:
+        """Submit one planned append to the stage port and bind the resulting stage request."""
+        session = self._ctx.session
+        if self._ctx.stage_port.stage_count == 0:
+            raise RuntimeError("duplex_data_plane_has_no_stage")
+        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, resumable=session.capabilities.supports_core_resumable_request
+        )
+        try:
+            session.begin_lease_operation(fence, lease_operation_id)
+            operation_started = True
+            reservation = session.prepare_append(fence)
+            already_submitted = session.stage_request_submitted(stage_id, request_id)
+            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")
+            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=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,
+                payload=payload,
+                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(
+                context=request_context,
+                prompt=append_plan.prompt,
+                already_submitted=already_submitted,
+            )
+            submission_result = await self._ctx.stage_port.submit(submission)
+            try:
+                if submission_result.request_id != request_id or submission_result.stage_id != stage_id:
+                    raise RuntimeError("duplex stage adapter returned a mismatched submission result")
+                if expected_epoch is not None and session.epoch != expected_epoch:
+                    raise DuplexFenceMismatchError(session.fence, fence)
+                update = session.commit_append(reservation)
+                session.bind_stage_request(stage_id, request_id, fence=fence)
+            except BaseException:
+                try:
+                    await self._ctx.stage_port.cleanup([request_id])
+                except Exception as cleanup_exc:
+                    logger.warning(
+                        "duplex append compensation remains pending for session %s: %s",
+                        session.session_id,
+                        cleanup_exc,
+                    )
+                raise
+            session.touch_lease(DuplexLeaseActivity.APPEND)
+            return {
+                "ok": True,
+                "operation": "append",
+                "session_id": session.session_id,
+                "stage_results": [
+                    {
+                        "stage_id": stage_id,
+                        "replica_id": submission_result.replica_id,
+                        "result": {
+                            "supported": True,
+                            "data_plane_append": True,
+                            "request_id": request_id,
+                            "response_stage_id": request_context.final_stage_id,
+                            "seq": update.seq,
+                            "turn_id": update.turn_id,
+                            "turn_seq": update.turn_seq,
+                            "resumable": session.capabilities.supports_core_resumable_request,
+                        },
+                    }
+                ],
+            }
+        finally:
+            if operation_started and lease_operation_id in session.lease.active_operations:
+                try:
+                    session.end_lease_operation(lease_operation_id)
+                except Exception:
+                    session.lease.active_operations.discard(lease_operation_id)
+
+    def _start_data_plane_stream(self, result: object) -> bool:
+        """Bind the resumable stage request as the session's active data-plane stream."""
+        request_id, _ = duplex_data_plane_request_info(result) if isinstance(result, dict) else (None, None)
+        if request_id is None or self._data_plane_outputs_finished(result):
+            return False
+        session = self._ctx.session
+        session.bind_request(request_id)
+        if self._ctx.run.stream_request_id == request_id:
+            return False
+        self._ctx.run.stream_request_id = request_id
+        return True
+
+    def cancel_data_plane_stream(self) -> bool:
+        had_stream = self._ctx.run.stream_request_id is not None
+        self._ctx.run.stream_request_id = None
+        return had_stream
+
+    async def signal_cancel_fence(self, cancelled_fence: DuplexFence) -> bool:
+        """In-process equivalent of the old ``barge_in`` control signal."""
+        session = self._ctx.session
+        try:
+            next_fence = session.sync_fence()
+            if next_fence.epoch > cancelled_fence.epoch:
+                stale_request_ids = session.cancel_fence(cancelled_fence, next_fence)
+            else:
+                stale_request_ids = []
+            if stale_request_ids:
+                await self._ctx.stage_port.cleanup(list(stale_request_ids), abort=True)
+            session.touch_lease(DuplexLeaseActivity.SIGNAL)
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:
+            logger.exception("Failed to signal duplex runtime session: %s", exc)
+            self.send_runtime_error("runtime_signal_failed", exc)
+            return False
+        return True
+
+    def send_runtime_error(self, code: str, exc: BaseException) -> None:
+        if isinstance(exc, DuplexRuntimeConfigError):
+            code = exc.code
+        self._out.emit_error(code, str(exc), retryable=False)
+
+    @staticmethod
+    def _data_plane_outputs_finished(result: object) -> bool:
+        if not isinstance(result, dict):
+            return False
+        outputs = result.get("data_plane_outputs")
+        if not isinstance(outputs, list) or not outputs:
+            return False
+        return bool(getattr(outputs[-1], "finished", False))
+
+    def _runtime_data_plane_context(self) -> object:
+        session = self._ctx.session
+        response_config = session.response_config
+        return self._ctx.plugin.data_plane_context(
+            epoch=session.epoch,
+            turn_id=session.turn_id,
+            active_response_turn_id=session.active_response_turn_id,
+            active_response_id=session.active_response_id,
+            auto_responds=self._out.auto_responds(),
+            response_format=response_config.response_format,
+            speed=response_config.speed,
+            modalities=tuple(response_config.modalities),
+        )
+
+    # ------------------------------------------------------------------ #
+    # Stage outputs                                                      #
+    # ------------------------------------------------------------------ #
+
+    def decide_output(
+        self, stage_id: int, output: RequestOutput, context: DuplexOutputContext
+    ) -> DuplexOutputDecision | None:
+        """Pure plugin decision (no session mutation: this runs inline on the orchestrator loop)."""
+        decision = self._ctx.plugin.decide_output(
+            stage_id=stage_id,
+            final_stage_id=context.final_stage_id,
+            segment_finished=context.segment_finished,
+            segment_token_ids=context.segment_token_ids,
+            segment_output_metadata=dict(context.segment_output_metadata),
+            output=output,
+        )
+        if decision is not None and not isinstance(decision, DuplexOutputDecision):
+            raise TypeError("duplex plugin decide_output() must return DuplexOutputDecision or None")
+        return decision
+
+    @staticmethod
+    def stage_metrics_snapshot(stage_id: int, metrics: object, output: object) -> dict[str, dict[str, object]] | None:
+        if not isinstance(metrics, StageRequestStats):
+            return None
+        event = metrics
+        if event.stage_id is None:
+            event = replace(event, stage_id=stage_id)
+        if event.final_output_type is None:
+            final_output_type = getattr(output, "final_output_type", None)
+            if isinstance(final_output_type, str):
+                event = replace(event, final_output_type=final_output_type)
+        try:
+            merged = OrchestratorAggregator._merge_stage_metric_event(None, event)
+        except Exception:
+            return None
+        return {str(stage_id): merged}
+
+    def _build_stage_output(self, item: StageOutput) -> OmniRequestOutput:
+        output = item.output
+        finished = bool(getattr(output, "finished", False)) or item.context.segment_finished
+        if item.decision is not None:
+            engine_output = OmniRequestOutput.from_stage_output(
+                output,
+                request_id=item.request_id,
+                stage_id=item.stage_id,
+                final_output_type=item.decision.final_output_type,
+            )
+            # Set after construction, not as a keyword: ``from_stage_output``
+            # copies ``finished`` from the source last, and a resumable stage
+            # request never finishes -- only its segment does. The decision
+            # closes that segment, and the projector recognises a listen only
+            # on a finished output. The orchestrator queue used to re-assert
+            # ``finished`` on every direct-response message; the mailbox hands
+            # the raw stage output over, so it has to happen here.
+            engine_output.finished = True
+            engine_output = attach_duplex_output_decision(engine_output, item.decision)
+        elif isinstance(output, OmniRequestOutput):
+            engine_output = copy.copy(output)
+            if finished:
+                engine_output.finished = True
+        else:
+            final_output_type = getattr(output, "final_output_type", None)
+            engine_output = OmniRequestOutput.from_stage_output(
+                output,
+                request_id=item.request_id,
+                finished=finished,
+                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 {}
+            existing_stage_metrics = existing.get("stage_metrics")
+            merged_stage_metrics = (
+                {**existing_stage_metrics, **snapshot} if isinstance(existing_stage_metrics, dict) else snapshot
+            )
+            engine_output.metrics = {**existing, "stage_metrics": merged_stage_metrics}
+        return engine_output
+
+    async def on_stage_output_item(self, item: StageOutput) -> None:
+        session = self._ctx.session
+        if session.state == DuplexSessionState.CLOSED or self._ctx.run.closing:
+            return
+        expected_epoch = item.context.identity.fence.epoch
+        if session.epoch != expected_epoch:
+            return
+        if session.lease.terminal_reason is not None:
+            # Lease already closed/expired: the output belongs to a dead session.
+            return
+        session.touch_lease(DuplexLeaseActivity.MODEL_OUTPUT)
+        if self._ctx.plugin.data_plane.is_terminal(item.request_id):
+            return
+        if self._out.auto_responds():
+            active_request_id = session.active_request_id
+            if active_request_id is not None and active_request_id != item.request_id:
+                return
+        engine_output = self._build_stage_output(item)
+        drain_result = {"data_plane_outputs": [engine_output]}
+        close_reason, emitted_response = await self._send_model_output_events(
+            drain_result, expected_epoch=expected_epoch
+        )
+        if close_reason is not None:
+            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
+            # silence unit.
+            self._ctx.plugin.data_plane.close_stream(item.request_id)
+            if self._ctx.run.stream_request_id == item.request_id:
+                self._ctx.run.stream_request_id = None
+            self._ctx.services.spawn(
+                self.maybe_continue_response(expected_epoch=expected_epoch),
+                name="duplex-continue",
+            )
+
+    async def _send_model_output_events(
+        self,
+        result: object,
+        *,
+        expected_epoch: int | None = None,
+    ) -> tuple[str | None, bool]:
+        session = self._ctx.session
+        if expected_epoch is not None and session.epoch != expected_epoch:
+            return None, False
+        close_reason: str | None = None
+        emitted_response = False
+        request_id, _ = duplex_data_plane_request_info(result) if isinstance(result, dict) else (None, None)
+        if self._ctx.plugin.data_plane.is_terminal(request_id):
+            return None, False
+        if request_id is not None and session.active_request_id is None:
+            session.bind_request(request_id)
+        context = self._runtime_data_plane_context()
+        for model_result in self._ctx.plugin.data_plane.project(result, context=context):
+            close_reason_for_result, did_emit = await self._send_one_model_output_event(
+                model_result,
+                expected_epoch=expected_epoch,
+            )
+            emitted_response = emitted_response or did_emit
+            close_reason = close_reason or close_reason_for_result
+            if expected_epoch is not None and session.epoch != expected_epoch:
+                return None, emitted_response
+        return close_reason, emitted_response
+
+    def _fail_response_from_model_error(self, model_result: dict[str, object]) -> None:
+        """Report a data-plane error and fail the response it interrupted."""
+        session = self._ctx.session
+        response_id = session.active_response_id
+        self._out.emit_error(
+            str(model_result.get("error_code")),
+            str(model_result.get("error") or "Duplex native data-plane error"),
+        )
+        if response_id is None:
+            return
+        session.end_response(commit_text=False)
+        self._out.emit(
+            {
+                "type": "response.done",
+                "session_id": session.session_id,
+                "response_id": response_id,
+                "epoch": session.epoch,
+                "committed": False,
+                "status": "failed",
+                "status_details": {"type": "failed", "reason": model_result.get("error_code")},
+                "playback": session.playback.as_dict(),
+            }
+        )
+
+    def _complete_model_turn_without_output(
+        self,
+        model_result: dict[str, object],
+        *,
+        model_turn_id: int | None,
+        data_plane_request_id: object,
+    ) -> bool:
+        """The model ended its turn with nothing to say.
+
+        Returns whether an event was emitted: an auto-response session reports
+        the decision as a listen, a turn-based one simply releases the request.
+        """
+        session = self._ctx.session
+        data_plane = self._ctx.plugin.data_plane
+        auto_response = self._out.auto_responds()
+        if isinstance(data_plane_request_id, str):
+            if not auto_response and data_plane_request_id == session.active_request_id:
+                session.clear_request()
+            if not auto_response:
+                data_plane.mark_terminal(data_plane_request_id)
+        if model_turn_id is not None:
+            session.complete_model_turn(model_turn_id)
+        if not auto_response:
+            return False
+        self._ctx.model_state.clear_continuation()
+        payload = {
+            "type": "response.listen",
+            "session_id": session.session_id,
+            "epoch": session.epoch,
+            "reason": "model_turn_completed_without_output",
+            "model_listen": True,
+        }
+        self._attach_runtime_metadata(payload, model_result)
+        self._out.emit(payload)
+        return True
+
+    async def _on_model_listen(
+        self,
+        model_result: dict[str, object],
+        *,
+        model_turn_id: int | None,
+        data_plane_request_id: object,
+        expected_epoch: int | None,
+    ) -> tuple[str | None, bool]:
+        """The model chose to keep listening rather than speak.
+
+        Either it continues the current response with another unit, or the
+        response ends here: an auto-response session that has continuations
+        left schedules one, and anything else closes the turn out.
+        """
+        session = self._ctx.session
+        model_state = self._ctx.model_state
+        data_plane = self._ctx.plugin.data_plane
+        auto_response = self._out.auto_responds()
+        close_reason: str | None = None
+        emitted_response = False
+        self._end_active_response_before_future_model_turn(model_turn_id=model_turn_id)
+        if (
+            session.active_response_id is not None
+            and model_turn_id is not None
+            and not session.active_response_accepts_model_turn(model_turn_id)
+        ):
+            return close_reason, emitted_response
+        active_response_id = session.active_response_id
+        auto_continuations_remaining = active_response_id is None or self.response_continuations_remaining(
+            active_response_id
+        )
+        non_terminal_auto_listen = (
+            auto_response
+            and active_response_id is not None
+            and session.active_request_id is not None
+            and model_result.get("end_of_turn") is not True
+            and auto_continuations_remaining
+        )
+        if non_terminal_auto_listen:
+            self._ctx.services.spawn(
+                self.maybe_continue_response(expected_epoch=expected_epoch), name="duplex-continue"
+            )
+            return close_reason, emitted_response
+        if not auto_response and data_plane_request_id == session.active_request_id:
+            session.clear_request()
+        model_listen = model_result.get("model_listen")
+        if not isinstance(model_listen, bool):
+            model_listen = model_result.get("reason") in {None, "", "model_listen"}
+        response_id = session.active_response_id
+        if isinstance(data_plane_request_id, str) and not auto_response:
+            data_plane.mark_terminal(data_plane_request_id)
+        emitted_response = True
+        payload = {
+            "type": "response.listen",
+            "session_id": session.session_id,
+            "epoch": session.epoch,
+            "reason": model_result.get("reason") or "model_listen",
+            "model_listen": model_listen,
+        }
+        if response_id is not None:
+            payload["response_id"] = response_id
+        self._attach_runtime_metadata(payload, model_result)
+        self._out.emit(payload)
+        if model_result.get("abort_data_plane_request") is True and isinstance(data_plane_request_id, str):
+            await self._abort_request(data_plane_request_id, notify=False)
+        if response_id is not None:
+            if not auto_response and self.response_continuations_remaining(response_id):
+                self._ctx.services.spawn(
+                    self.maybe_continue_response(expected_epoch=expected_epoch), name="duplex-continue"
+                )
+                return close_reason, emitted_response
+            if auto_response:
+                model_state.clear_continuation()
+                if not auto_continuations_remaining:
+                    completed_turn_id = model_turn_id
+                    if completed_turn_id is None:
+                        completed_turn_id = session.active_response_turn_id
+                    if completed_turn_id is not None:
+                        session.complete_model_turn(completed_turn_id)
+            session.end_response(commit_text=False, preserve_request=auto_response)
+            self._out.emit(
+                {
+                    "type": "response.done",
+                    "session_id": session.session_id,
+                    "response_id": response_id,
+                    "epoch": session.epoch,
+                    "committed": False,
+                    "playback": session.playback.as_dict(),
+                }
+            )
+        return close_reason, emitted_response
+
+    async def _send_one_model_output_event(
+        self,
+        model_result: dict[str, object],
+        *,
+        expected_epoch: int | None = None,
+    ) -> tuple[str | None, bool]:
+        session = self._ctx.session
+        data_plane = self._ctx.plugin.data_plane
+        close_reason: str | None = None
+        emitted_response = False
+        if expected_epoch is not None and session.epoch != expected_epoch:
+            return close_reason, emitted_response
+        data_plane_request_id = model_result.get("data_plane_request_id")
+        if isinstance(data_plane_request_id, str) and data_plane.is_terminal(data_plane_request_id):
+            return close_reason, emitted_response
+        auto_response = self._out.auto_responds()
+        active_request_matches = session.active_request_id == data_plane_request_id or (
+            auto_response and session.active_request_id is None
+        )
+        if isinstance(data_plane_request_id, str) and not active_request_matches:
+            return close_reason, emitted_response
+        if isinstance(model_result.get("error_code"), str):
+            self._fail_response_from_model_error(model_result)
+            return close_reason, True
+        if model_result.get("function_call") is True:
+            self._out.emit(
+                {
+                    "type": "function_call.done",
+                    "session_id": session.session_id,
+                    "epoch": session.epoch,
+                    "call_id": model_result.get("call_id"),
+                    "name": model_result.get("name"),
+                    "arguments": model_result.get("arguments", ""),
+                }
+            )
+            return close_reason, True
+        if model_result.get("requires_stage_handoff") is True or model_result.get("requires_tts_stage") is True:
+            # Reserve the protocol response only when Stage1 emits text/audio.
+            return close_reason, False
+        is_listen = model_result.get("is_listen")
+        model_turn_id = coerce_int(model_result.get("model_turn_id"))
+        if model_result.get("is_buffering") is True or model_result.get("prefill_success") is False:
+            if model_result.get("data_plane_request_id") == session.active_request_id:
+                session.clear_request()
+            payload = {
+                "type": "response.listen",
+                "session_id": session.session_id,
+                "epoch": session.epoch,
+                "reason": model_result.get("reason") or "buffering",
+                "model_listen": False,
+                "buffering": True,
+            }
+            self._attach_runtime_metadata(payload, model_result)
+            self._out.emit(payload)
+            return close_reason, emitted_response
+        if is_listen is True:
+            return await self._on_model_listen(
+                model_result,
+                model_turn_id=model_turn_id,
+                data_plane_request_id=data_plane_request_id,
+                expected_epoch=expected_epoch,
+            )
+
+        text = model_result.get("text")
+        audio = model_result.get("audio_data", model_result.get("audio"))
+        end_of_turn = bool(model_result.get("end_of_turn", False))
+        has_text = isinstance(text, str) and bool(text)
+        has_audio = isinstance(audio, str) and bool(audio)
+        if not has_text and not has_audio and not end_of_turn:
+            tts_segment_ended = (
+                model_result.get("stage_role") == "tts" and model_result.get("abort_data_plane_request") is True
+            )
+            if (
+                tts_segment_ended
+                and auto_response
+                and (model_turn_id is not None or session.active_response_id is not None)
+            ):
+                self._ctx.services.spawn(
+                    self.maybe_continue_response(expected_epoch=expected_epoch, expected_model_turn_id=model_turn_id),
+                    name="duplex-continue",
+                )
+            return close_reason, emitted_response
+        if end_of_turn and not has_text and not has_audio and session.active_response_id is None:
+            emitted_response = self._complete_model_turn_without_output(
+                model_result,
+                model_turn_id=model_turn_id,
+                data_plane_request_id=data_plane_request_id,
+            )
+            return close_reason, emitted_response
+        if session.active_response_id is None and model_turn_id is not None and model_turn_id < session.turn_id:
+            # Late audio of a completed model turn must not reserve a second response.
+            return close_reason, emitted_response
+        self._end_active_response_before_future_model_turn(model_turn_id=model_turn_id)
+        if (
+            session.active_response_id is not None
+            and model_turn_id is not None
+            and not session.active_response_accepts_model_turn(model_turn_id)
+        ):
+            return close_reason, emitted_response
+        emitted_response = True
+        response_created = False
+        response_id = session.active_response_id
+        if response_id is None:
+            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(
+            stage_metrics if isinstance(stage_metrics, Mapping) else None
+        )
+        if response_created:
+            speak_payload = {
+                "type": "response.speak",
+                "session_id": session.session_id,
+                "response_id": response_id,
+                "epoch": session.epoch,
+                "text": text if isinstance(text, str) else "",
+                "end_of_turn": end_of_turn,
+                "model_speak": True,
+            }
+            self._attach_runtime_metadata(speak_payload, model_result, stage_metrics=response_stage_metrics)
+            self._out.emit(speak_payload)
+        previous_sent_ms = session.playback.sent_ms
+        text_chars_before_append = len("".join(session.assistant_text_buffer))
+        if isinstance(text, str):
+            session.append_assistant_text(text)
+        duration_ms = model_result.get("audio_duration_ms")
+        text_chars = len("".join(session.assistant_text_buffer))
+        mark_duration_ms = None
+        mark_text_chars: int | None = text_chars
+        if model_result.get("audio_text_mark") is False:
+            mark_text_chars = None
+        if isinstance(duration_ms, int | float):
+            mark_duration_ms = int(duration_ms)
+            if model_result.get("audio_duration_is_cumulative") is not True:
+                mark_duration_ms += session.playback.sent_ms
+        audio_text_marks = model_result.get("audio_text_marks")
+        audio_text_marks = self._normalize_audio_text_marks(
+            audio_text_marks if isinstance(audio_text_marks, list) else None,
+            audio_offset_ms=(
+                0
+                if model_result.get("audio_text_marks_are_cumulative") is True
+                or model_result.get("audio_duration_is_cumulative") is True
+                else previous_sent_ms
+            ),
+            text_offset_chars=(
+                0 if model_result.get("audio_text_marks_are_cumulative") is True else text_chars_before_append
+            ),
+        )
+        session.mark_audio_sent(
+            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",
+            "session_id": session.session_id,
+            "response_id": response_id,
+            "epoch": session.epoch,
+            "text": text if isinstance(text, str) else "",
+            "audio": audio if isinstance(audio, str) else "",
+            "format": (
+                model_result.get("audio_format")
+                if isinstance(model_result.get("audio_format"), str)
+                else session.response_config.response_format
+            ),
+            "end_of_turn": end_of_turn,
+            "model_speak": True,
+        }
+        if mark_duration_ms is not None:
+            payload["audio_duration_ms"] = mark_duration_ms
+        if audio_text_marks:
+            payload["audio_text_marks"] = audio_text_marks
+        elif mark_duration_ms is not None and mark_text_chars is not None:
+            payload["audio_text_marks"] = [
+                {"text_chars": max(0, int(mark_text_chars)), "audio_end_ms": max(0, int(mark_duration_ms))}
+            ]
+        payload["playback"] = session.playback.as_dict()
+        sample_rate_hz = model_result.get("sample_rate_hz") or model_result.get("audio_sample_rate_hz")
+        if isinstance(sample_rate_hz, int | float) and int(sample_rate_hz) > 0:
+            payload["sample_rate_hz"] = int(sample_rate_hz)
+        self._attach_runtime_metadata(payload, model_result, stage_metrics=response_stage_metrics)
+        self._out.emit(payload)
+        if (
+            not end_of_turn
+            and model_result.get("stage_role") == "tts"
+            and model_result.get("abort_data_plane_request") is True
+            and auto_response
+        ):
+            self._ctx.services.spawn(
+                self.maybe_continue_response(expected_epoch=expected_epoch), name="duplex-continue"
+            )
+        if end_of_turn:
+            data_plane_request_id = model_result.get("data_plane_request_id")
+            if isinstance(data_plane_request_id, str) and not auto_response:
+                data_plane.close_stream(data_plane_request_id)
+            if isinstance(data_plane_request_id, str):
+                if not auto_response and data_plane_request_id == session.active_request_id:
+                    session.clear_request()
+                if not auto_response:
+                    data_plane.mark_terminal(data_plane_request_id)
+            should_commit = self.should_commit_response_to_history(session, response_id)
+            committed_message = session.end_response(commit_text=should_commit, preserve_request=auto_response)
+            model_turn_id = coerce_int(model_result.get("model_turn_id"))
+            if model_turn_id is not None:
+                session.complete_model_turn(model_turn_id)
+            if should_commit:
+                session.register_history_item(f"item_{response_id}", committed_message)
+            self._out.emit(
+                {
+                    "type": "response.done",
+                    "session_id": session.session_id,
+                    "response_id": response_id,
+                    "epoch": session.epoch,
+                    "committed": committed_message is not None,
+                    "playback": session.playback.as_dict(),
+                }
+            )
+        return close_reason, emitted_response
+
+    def _end_active_response_before_future_model_turn(self, *, model_turn_id: int | None) -> None:
+        session = self._ctx.session
+        if not self._out.auto_responds():
+            return
+        response_id = session.active_response_id
+        active_turn_id = session.active_response_turn_id
+        if response_id is None or model_turn_id is None or active_turn_id is None:
+            return
+        if int(model_turn_id) <= int(active_turn_id):
+            return
+        session.complete_model_turn(int(model_turn_id) - 1)
+        should_commit = self.should_commit_response_to_history(session, response_id)
+        committed_message = session.end_response(commit_text=should_commit, preserve_request=True)
+        if should_commit:
+            session.register_history_item(f"item_{response_id}", committed_message)
+        self._out.emit(
+            {
+                "type": "response.done",
+                "session_id": session.session_id,
+                "response_id": response_id,
+                "epoch": session.epoch,
+                "committed": committed_message is not None,
+                "playback": session.playback.as_dict(),
+            }
+        )
+
+    @staticmethod
+    def _normalize_audio_text_marks(
+        audio_text_marks: list[object] | None,
+        *,
+        audio_offset_ms: int,
+        text_offset_chars: int,
+    ) -> list[dict[str, object]] | None:
+        if not audio_text_marks:
+            return None
+        normalized: list[dict[str, object]] = []
+        for raw_mark in audio_text_marks:
+            if not isinstance(raw_mark, dict):
+                continue
+            raw_text_chars = raw_mark.get("text_chars")
+            raw_audio_end_ms = raw_mark.get("audio_end_ms", raw_mark.get("audio_ms"))
+            if not isinstance(raw_text_chars, int | float) or not isinstance(raw_audio_end_ms, int | float):
+                continue
+            normalized.append(
+                {
+                    "text_chars": max(0, int(raw_text_chars) + int(text_offset_chars)),
+                    "audio_end_ms": max(0, int(raw_audio_end_ms) + int(audio_offset_ms)),
+                }
+            )
+        return normalized or None
+
+    @staticmethod
+    def _attach_runtime_metadata(
+        payload: dict[str, object],
+        model_result: dict[str, object],
+        *,
+        stage_metrics: Mapping[str, object] | None = None,
+    ) -> None:
+        metadata: dict[str, object] = {}
+        runtime_impl = model_result.get("runtime_impl")
+        if isinstance(runtime_impl, str) and runtime_impl:
+            metadata["runtime_impl"] = runtime_impl
+        owned_runtime = model_result.get("owned_runtime")
+        if isinstance(owned_runtime, bool):
+            metadata["owned_runtime"] = owned_runtime
+        model_turn_id = coerce_int(model_result.get("model_turn_id"))
+        if model_turn_id is not None:
+            metadata["model_turn_id"] = model_turn_id
+        for name in ("uses_model_runner_scheduler", "runner_kv_backed"):
+            value = model_result.get(name)
+            if isinstance(value, bool):
+                metadata[name] = value
+        effective_stage_metrics = stage_metrics if stage_metrics is not None else model_result.get("stage_metrics")
+        if isinstance(effective_stage_metrics, Mapping):
+            metadata["stage_metrics"] = {
+                str(stage_id): dict(values)
+                for stage_id, values in effective_stage_metrics.items()
+                if isinstance(values, Mapping)
+            }
+        if metadata:
+            payload["vllm_omni"] = metadata
+
+    # ------------------------------------------------------------------ #
+    # Silence continuation                                               #
+    # ------------------------------------------------------------------ #
+
+    def silence_unit_payload(self) -> dict[str, object]:
+        samples = int(self._ctx.plugin.silence_continuation_samples)
+        audio = (
+            self._SILENCE_UNIT_PAYLOAD_AUDIO
+            if samples == 16000
+            else base64.b64encode(bytes(samples * 4)).decode("ascii")
+        )
+        return {"type": "audio", "audio": audio, "format": "pcm_f32le", "sample_rate_hz": 16000}
+
+    def response_continuations_remaining(self, response_id: str) -> bool:
+        model_state = self._ctx.model_state
+        owner_id = f"response:{response_id}"
+        count = model_state.continuation_units if model_state.continuation_owner_id == owner_id else 0
+        limit = (
+            self._AUTO_RESPONSE_MAX_CONTINUATION_UNITS
+            if self._out.auto_responds()
+            else self._RESPONSE_MAX_CONTINUATION_UNITS
+        )
+        return count < limit
+
+    async def _finish_bounded_auto_response(
+        self,
+        *,
+        expected_epoch: int | None,
+        model_turn_id: int | None = None,
+    ) -> None:
+        session = self._ctx.session
+        model_state = self._ctx.model_state
+        response_id = session.active_response_id
+        response_epoch = session.epoch
+        response_turn_id = model_turn_id if model_turn_id is not None else session.active_response_turn_id
+        if expected_epoch is not None and response_epoch != expected_epoch:
+            return
+        model_state.clear_continuation()
+        payload: dict[str, object] = {
+            "type": "response.listen",
+            "session_id": session.session_id,
+            "epoch": response_epoch,
+            "reason": "continuation_limit",
+            "model_listen": False,
+        }
+        if response_id is not None:
+            payload["response_id"] = response_id
+        self._out.emit(payload)
+        if response_id is None:
+            if session.epoch == response_epoch and response_turn_id is not None:
+                session.complete_model_turn(response_turn_id)
+            return
+        if session.epoch != response_epoch or session.active_response_id != response_id:
+            return
+        if response_turn_id is not None:
+            session.complete_model_turn(response_turn_id)
+        session.end_response(commit_text=False, preserve_request=True)
+        self._out.emit(
+            {
+                "type": "response.done",
+                "session_id": session.session_id,
+                "response_id": response_id,
+                "epoch": response_epoch,
+                "committed": False,
+                "playback": session.playback.as_dict(),
+            }
+        )
+
+    def silence_continuation_is_stale(
+        self,
+        *,
+        request_id: str,
+        response_id: str | None,
+        response_owned: bool,
+        expected_epoch: int | None,
+        expected_model_turn_id: int | None,
+    ) -> bool:
+        session = self._ctx.session
+        stale_common_owner = (
+            session.state == DuplexSessionState.CLOSED
+            or session.active_request_id != request_id
+            or (expected_epoch is not None and session.epoch != expected_epoch)
+        )
+        stale_response_owner = response_owned and session.active_response_id != response_id
+        stale_model_turn_owner = not response_owned and (
+            session.active_response_id is not None or session.turn_id != expected_model_turn_id
+        )
+        return stale_common_owner or stale_response_owner or stale_model_turn_owner
+
+    async def maybe_continue_response(
+        self,
+        *,
+        expected_epoch: int | None,
+        expected_model_turn_id: int | None = None,
+    ) -> None:
+        session = self._ctx.session
+        model_state = self._ctx.model_state
+        response_id = session.active_response_id
+        if session.state == DuplexSessionState.CLOSED or self._ctx.run.closing:
+            model_state.clear_continuation()
+            return
+        request_id = session.active_request_id
+        if request_id is None:
+            model_state.clear_continuation()
+            return
+        if expected_epoch is not None and session.epoch != expected_epoch:
+            return
+        auto_response = self._out.auto_responds()
+        response_owned = response_id is not None
+        if response_owned:
+            owner_id = f"response:{response_id}"
+            payload_turn_id_value = (
+                session.active_response_turn_id if session.active_response_turn_id is not None else session.turn_id
+            )
+        else:
+            if not auto_response or expected_model_turn_id is None or session.turn_id != expected_model_turn_id:
+                model_state.clear_continuation()
+                return
+            owner_id = f"model-turn:{expected_model_turn_id}"
+            payload_turn_id_value = expected_model_turn_id
+        count = model_state.continuation_units if model_state.continuation_owner_id == owner_id else 0
+        continuation_limit = (
+            self._AUTO_RESPONSE_MAX_CONTINUATION_UNITS if auto_response else self._RESPONSE_MAX_CONTINUATION_UNITS
+        )
+        if count >= continuation_limit:
+            if auto_response:
+                await self._finish_bounded_auto_response(
+                    expected_epoch=expected_epoch,
+                    model_turn_id=payload_turn_id_value,
+                )
+            return
+        payload = self.silence_unit_payload()
+        if auto_response and count + 1 == continuation_limit:
+            payload["force_listen"] = True
+        payload["duplex_turn_id"] = payload_turn_id_value
+        try:
+            scheduled = await self._schedule_silence_continuation(
+                payload,
+                request_id=request_id,
+                owner_id=owner_id,
+                response_id=response_id,
+                response_owned=response_owned,
+                expected_epoch=expected_epoch,
+                expected_model_turn_id=expected_model_turn_id,
+            )
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:
+            logger.exception("Failed to schedule duplex native response continuation: %s", exc)
+            scheduled = False
+        if scheduled:
+            model_state.continuation_owner_id = owner_id
+            model_state.continuation_units = count + 1
diff --git a/vllm_omni/engine/duplex/session/overlap_policy.py b/vllm_omni/engine/duplex/session/overlap_policy.py
new file mode 100644
index 000000000..0aad04368
--- /dev/null
+++ b/vllm_omni/engine/duplex/session/overlap_policy.py
@@ -0,0 +1,388 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""How one duplex session reacts to input that arrives while it is speaking.
+
+Short acknowledgement, barge-in, or keep listening: the rules read the session
+config and the incoming append, and nothing else. Extracted from
+``DuplexSessionRunner`` because they were a decision function wearing a
+method's clothes -- the only runner state they ever touched was ``session`` --
+and because reaching them previously meant driving a whole append through the
+runner.
+"""
+
+from __future__ import annotations
+
+import binascii
+from collections.abc import Mapping
+
+import numpy as np
+import pybase64 as base64
+
+from vllm_omni.engine.duplex.config import DuplexOverlapPolicy
+from vllm_omni.engine.duplex.session.engine_session import DuplexEngineSession
+
+
+def decide(
+    session: DuplexEngineSession,
+    event: dict[str, object],
+    payload: dict[str, object],
+    *,
+    auto_responds: bool,
+) -> dict[str, object]:
+    duration_ms = input_audio_duration_ms(event, payload)
+    is_speech = input_looks_like_speech(session, event, payload)
+    if not session.capabilities.supports_barge_in and event_requests_barge_in(event):
+        return defer_unsupported_barge_in(session, duration_ms=duration_ms, is_speech=is_speech)
+    explicit = event.get("overlap_action") or event.get("overlap")
+    if isinstance(explicit, str):
+        normalized = explicit.strip().lower()
+        if normalized in {"barge_in", "interrupt", "cancel"}:
+            return {
+                "action": "barge_in",
+                "reason": "client_overlap_action",
+                "duration_ms": duration_ms,
+                "buffer_audio": True,
+            }
+        if normalized in {"listen", "continue", "continue_output", "ack"}:
+            session.reset_overlap_speech()
+            return {
+                "action": "listen",
+                "reason": "client_overlap_action",
+                "duration_ms": duration_ms,
+                "buffer_audio": (
+                    normalized == "listen" and is_speech and duration_ms > session.config.overlap_short_ack_ms
+                ),
+                "defer_runtime_append": True,
+            }
+        if normalized in {"drop", "ignore", "silence"}:
+            session.reset_overlap_speech()
+            return {
+                "action": "drop",
+                "reason": "client_overlap_action",
+                "duration_ms": duration_ms,
+                "buffer_audio": False,
+            }
+
+    if bool(event.get("force_barge_in", False)):
+        return {
+            "action": "barge_in",
+            "reason": "client_force_barge_in",
+            "duration_ms": duration_ms,
+            "buffer_audio": True,
+        }
+    if auto_responds:
+        if is_speech:
+            session.accumulate_overlap_speech(duration_ms)
+        speech_started = vad_speech_started(event, payload)
+        if (
+            session.capabilities.supports_barge_in
+            and is_speech
+            and session.config.overlap_policy == DuplexOverlapPolicy.BARGE_IN_ON_SPEECH.value
+            and speech_started is not False
+        ):
+            return {
+                "action": "barge_in",
+                "reason": ("server_vad_speech_started" if speech_started is True else "barge_in_on_speech"),
+                "cancel_reason": "turn_detected" if speech_started is True else "barge_in",
+                "duration_ms": duration_ms,
+                "overlap_speech_ms": session.overlap_speech_ms,
+                "buffer_audio": True,
+            }
+        return {
+            "action": "listen",
+            "reason": "auto_response_continuous",
+            "duration_ms": duration_ms,
+            "overlap_speech_ms": session.overlap_speech_ms,
+            "buffer_audio": True,
+            "defer_runtime_append": False,
+            "force_listen": event.get("force_listen") is True or payload.get("force_listen") is True,
+            "preserve_realtime_input": True,
+        }
+    if bool(event.get("force_listen", False)):
+        session.reset_overlap_speech()
+        return {
+            "action": "listen",
+            "reason": "client_force_listen",
+            "duration_ms": duration_ms,
+            "buffer_audio": is_speech,
+            "defer_runtime_append": True,
+        }
+
+    policy = session.config.overlap_policy
+    if not is_speech:
+        if session.overlap_speech_ms <= 0:
+            session.reset_overlap_speech()
+        return {
+            "action": "drop",
+            "reason": "silence_or_noise",
+            "duration_ms": duration_ms,
+            "overlap_speech_ms": session.overlap_speech_ms,
+            "buffer_audio": False,
+        }
+
+    if is_short_ack_transcript_hint(event, payload):
+        session.reset_overlap_speech()
+        return {
+            "action": "listen",
+            "reason": "short_ack_transcript",
+            "duration_ms": duration_ms,
+            "overlap_speech_ms": session.overlap_speech_ms,
+            "buffer_audio": False,
+            "defer_runtime_append": True,
+        }
+
+    if policy == DuplexOverlapPolicy.LISTEN_ONLY.value:
+        session.accumulate_overlap_speech(duration_ms)
+        return {
+            "action": "listen",
+            "reason": "policy_listen_only",
+            "duration_ms": duration_ms,
+            "overlap_speech_ms": session.overlap_speech_ms,
+            "buffer_audio": True,
+            "defer_runtime_append": True,
+        }
+
+    if policy == DuplexOverlapPolicy.BARGE_IN_ON_SPEECH.value and not session.capabilities.supports_barge_in:
+        return defer_unsupported_barge_in(session, duration_ms=duration_ms, is_speech=True)
+
+    session.accumulate_overlap_speech(duration_ms)
+    if policy == DuplexOverlapPolicy.BARGE_IN_ON_SPEECH.value:
+        speech_started = vad_speech_started(event, payload)
+        if speech_started is False:
+            return {
+                "action": "listen",
+                "reason": "server_vad_utterance_active",
+                "duration_ms": duration_ms,
+                "overlap_speech_ms": session.overlap_speech_ms,
+                "buffer_audio": True,
+                "defer_runtime_append": False,
+                "force_listen": True,
+                "preserve_realtime_input": True,
+            }
+        return {
+            "action": "barge_in",
+            "reason": ("server_vad_speech_started" if speech_started is True else "policy_barge_in_on_speech"),
+            "cancel_reason": "turn_detected" if speech_started is True else "barge_in",
+            "duration_ms": duration_ms,
+            "overlap_speech_ms": session.overlap_speech_ms,
+            "buffer_audio": True,
+        }
+
+    if (
+        duration_ms <= session.config.overlap_short_ack_ms
+        and session.overlap_speech_ms <= session.config.overlap_short_ack_ms
+    ):
+        return {
+            "action": "listen",
+            "reason": "short_ack",
+            "duration_ms": duration_ms,
+            "overlap_speech_ms": session.overlap_speech_ms,
+            "buffer_audio": True,
+            "defer_runtime_append": True,
+        }
+    if session.overlap_speech_ms >= session.config.overlap_barge_in_ms:
+        if not session.capabilities.supports_barge_in:
+            return {
+                "action": "listen",
+                "reason": "barge_in_unsupported",
+                "duration_ms": duration_ms,
+                "overlap_speech_ms": session.overlap_speech_ms,
+                "buffer_audio": True,
+                "defer_runtime_append": True,
+            }
+        return {
+            "action": "barge_in",
+            "reason": "long_overlap_speech",
+            "duration_ms": duration_ms,
+            "overlap_speech_ms": session.overlap_speech_ms,
+            "buffer_audio": True,
+        }
+    return {
+        "action": "listen",
+        "reason": "accumulating_overlap_speech",
+        "duration_ms": duration_ms,
+        "overlap_speech_ms": session.overlap_speech_ms,
+        "buffer_audio": True,
+        "defer_runtime_append": True,
+    }
+
+
+def vad_speech_started(event: Mapping[str, object], payload: Mapping[str, object]) -> bool | None:
+    for source in (event, payload):
+        vad = source.get("vad")
+        if isinstance(vad, Mapping) and isinstance(vad.get("speech_started"), bool):
+            return bool(vad["speech_started"])
+    return None
+
+
+def event_requests_barge_in(event: Mapping[str, object]) -> bool:
+    if event.get("force_barge_in") is True:
+        return True
+    explicit = event.get("overlap_action") or event.get("overlap")
+    return isinstance(explicit, str) and explicit.strip().lower() in {"barge_in", "interrupt", "cancel"}
+
+
+def defer_unsupported_barge_in(
+    session: DuplexEngineSession,
+    *,
+    duration_ms: int,
+    is_speech: bool,
+) -> dict[str, object]:
+    if is_speech:
+        session.accumulate_overlap_speech(duration_ms)
+    return {
+        "action": "listen",
+        "reason": "barge_in_unsupported",
+        "duration_ms": duration_ms,
+        "overlap_speech_ms": session.overlap_speech_ms,
+        "buffer_audio": is_speech,
+        "defer_runtime_append": True,
+    }
+
+
+def is_short_ack_transcript_hint(event: dict[str, object], payload: dict[str, object]) -> bool:
+    raw_text = event.get("transcript") or event.get("text") or payload.get("transcript") or payload.get("text")
+    if not isinstance(raw_text, str):
+        return False
+    normalized = raw_text.strip().lower()
+    if not normalized:
+        return False
+    compact = "".join(ch for ch in normalized if ch.isalnum() or "一" <= ch <= "鿿")
+    if compact in {
+        "嗯",
+        "嗯嗯",
+        "对",
+        "对的",
+        "好",
+        "好的",
+        "继续",
+        "继续说",
+        "可以",
+        "是的",
+        "yes",
+        "yeah",
+        "yep",
+        "ok",
+        "okay",
+        "continue",
+        "goon",
+        "right",
+    }:
+        return True
+    return normalized in {"go on", "keep going", "please continue"}
+
+
+def input_audio_duration_ms(event: dict[str, object], payload: dict[str, object]) -> int:
+    for key in ("duration_ms", "audio_duration_ms"):
+        value = event.get(key)
+        if isinstance(value, int | float):
+            return max(0, int(value))
+    fmt = payload.get("format")
+    sample_rate_hz = payload.get("sample_rate_hz")
+    audio = payload.get("audio")
+    if fmt == "pcm_f32le" and isinstance(sample_rate_hz, int) and sample_rate_hz > 0 and isinstance(audio, str):
+        try:
+            raw = base64.b64decode(audio, validate=True)
+        except (binascii.Error, ValueError):
+            return 0
+        return int((len(raw) // 4) * 1000 / sample_rate_hz)
+    return 0
+
+
+def merge_audio_payloads(first: dict[str, object], second: dict[str, object]) -> dict[str, object]:
+    if first.get("format") != "pcm_f32le" or second.get("format") != "pcm_f32le":
+        return second
+    first_rate = first.get("sample_rate_hz")
+    second_rate = second.get("sample_rate_hz")
+    if not isinstance(first_rate, int) or not isinstance(second_rate, int) or first_rate != second_rate:
+        return second
+    first_audio = first.get("audio")
+    second_audio = second.get("audio")
+    if not isinstance(first_audio, str) or not isinstance(second_audio, str):
+        return second
+    try:
+        first_raw = base64.b64decode(first_audio, validate=True)
+        second_raw = base64.b64decode(second_audio, validate=True)
+    except (binascii.Error, ValueError):
+        return second
+    merged = dict(second)
+    merged["audio"] = base64.b64encode(first_raw + second_raw).decode("ascii")
+    merged["sample_rate_hz"] = first_rate
+    merged_frames = [
+        frame
+        for source in (first.get("video_frames"), second.get("video_frames"))
+        if isinstance(source, list)
+        for frame in source
+        if isinstance(frame, str) and frame
+    ]
+    if merged_frames:
+        merged["video_frames"] = merged_frames
+    else:
+        merged.pop("video_frames", None)
+    merged["force_listen"] = bool(first.get("force_listen", False)) or bool(second.get("force_listen", False))
+    merged.pop("force_speak", None)
+    merged["is_speech"] = bool(first.get("is_speech", False)) or bool(second.get("is_speech", False))
+    return merged
+
+
+def should_force_listen_for_short_commit(
+    session: DuplexEngineSession, event: dict[str, object], payload: dict[str, object]
+) -> bool:
+    if event.get("force_listen") is True or payload.get("force_listen") is True:
+        return True
+    if event.get("force_barge_in") is True:
+        return False
+    if event.get("response_create") is not True:
+        return False
+    duration_ms = input_audio_duration_ms(event, payload)
+    return 0 < duration_ms <= session.config.overlap_short_ack_ms
+
+
+def should_force_listen_for_auto_response_overlap(
+    event: dict[str, object], payload: dict[str, object], *, auto_responds: bool
+) -> bool:
+    if not auto_responds:
+        return False
+    if event.get("force_barge_in") is True:
+        return False
+    return event.get("force_listen") is True or payload.get("force_listen") is True
+
+
+def input_looks_like_speech(session: DuplexEngineSession, event: dict[str, object], payload: dict[str, object]) -> bool:
+    for key in ("is_speech", "speech"):
+        value = event.get(key)
+        if isinstance(value, bool):
+            return value
+    vad = event.get("vad")
+    if isinstance(vad, dict):
+        value = vad.get("is_speech")
+        if isinstance(value, bool):
+            return value
+        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
+
+    fmt = payload.get("format")
+    audio = payload.get("audio")
+    if fmt in {"pcm_f32le", "pcm16"} and isinstance(audio, str):
+        try:
+            raw = base64.b64decode(audio, validate=True)
+        except (binascii.Error, ValueError):
+            return True
+        if fmt == "pcm_f32le":
+            if len(raw) < 4 or len(raw) % 4 != 0:
+                return True
+            samples = np.frombuffer(raw, dtype=np.float32)
+        else:
+            if len(raw) < 2 or len(raw) % 2 != 0:
+                return True
+            samples = np.frombuffer(raw, dtype=np.int16).astype(np.float32) / 32768.0
+        if samples.size == 0:
+            return False
+        rms = float(np.sqrt(np.mean(np.square(samples.astype(np.float32)))))
+        return rms >= session.config.overlap_silence_rms
+    return True
diff --git a/vllm_omni/engine/duplex/session/playback_ledger.py b/vllm_omni/engine/duplex/session/playback_ledger.py
new file mode 100644
index 000000000..c6843f64b
--- /dev/null
+++ b/vllm_omni/engine/duplex/session/playback_ledger.py
@@ -0,0 +1,137 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Applying one ``playback.ack`` to a duplex session.
+
+The client reports how much of a response it has actually played; the session
+uses that to commit or truncate the assistant item in conversation history, and
+to release the response's playback state once it is fully played.
+
+Extracted from ``DuplexSessionRunner`` because the only runner state it touched
+was ``session``. It returns the events it produces rather than emitting them,
+so the rules can be exercised without a runner.
+"""
+
+from __future__ import annotations
+
+from vllm_omni.engine.duplex.events import DuplexEvent, PlaybackAcknowledged, error_event
+from vllm_omni.engine.duplex.session.engine_session import DuplexEngineSession
+from vllm_omni.engine.duplex.session.lease import DuplexLeaseActivity
+
+
+def apply_playback_ack(session: DuplexEngineSession, event: dict[str, object]) -> list[DuplexEvent]:
+    """Apply one ``playback.ack`` and return the events it produces."""
+    played_ms = event.get("played_ms", event.get("audio_ms", 0))
+    committed_ms = event.get("committed_ms")
+    if not isinstance(played_ms, int | float):
+        return [error_event("bad_event", "playback.ack requires played_ms")]
+    try:
+        session.touch_lease(DuplexLeaseActivity.PLAYBACK_ACK)
+    except Exception:
+        pass
+    committed_cursor = int(committed_ms) if isinstance(committed_ms, int | float) else int(played_ms)
+    item_id = event.get("item_id")
+    response_id = event.get("response_id")
+    response_id = response_id if isinstance(response_id, str) and response_id else None
+    if not isinstance(item_id, str) or not item_id:
+        item_id = f"item_{response_id}" if response_id is not None else None
+    elif response_id is None and item_id.startswith("item_"):
+        response_id = item_id.removeprefix("item_")
+    if response_id is None and item_id is None and len(session.pending_history_item_ids) == 1:
+        item_id = next(iter(session.pending_history_item_ids))
+        if item_id.startswith("item_"):
+            response_id = item_id.removeprefix("item_")
+    if response_id is None and item_id is None and session.active_response_id is not None:
+        response_id = session.active_response_id
+        item_id = f"item_{response_id}"
+    if response_id is not None:
+        expected_item_id = f"item_{response_id}"
+        if item_id is None:
+            item_id = expected_item_id
+        elif item_id != expected_item_id:
+            return [error_event("playback_item_mismatch", "playback.ack item_id must match item_<response_id>.")]
+        if not session.has_assistant_response_item(response_id, item_id):
+            return [
+                error_event("playback_item_not_found", f"No assistant response item is registered for {response_id}.")
+            ]
+        if session.playback_ack_is_too_late(response_id, item_id):
+            return [
+                error_event("playback_ack_too_late", "playback.ack arrived after a later user input was committed.")
+            ]
+        session.reserve_history_item(item_id)
+    elif item_id is not None:
+        return [error_event("playback_item_not_found", "playback.ack requires a response-owned assistant item.")]
+    hard_truncate = event.get("truncate") is True
+    if hard_truncate:
+        playback = session.acknowledge_playback(int(played_ms), committed_cursor, response_id=response_id)
+        playback = session.truncate_playback_commit(committed_cursor, response_id=response_id)
+    else:
+        playback = session.acknowledge_playback(int(played_ms), committed_cursor, response_id=response_id)
+    committed_history = False
+    if isinstance(item_id, str) and item_id:
+        expected_item_id = f"item_{response_id}" if response_id is not None else None
+        if (
+            expected_item_id == item_id
+            and item_id not in session.history_item_ids
+            and item_id not in session.pending_history_item_ids
+        ):
+            session.register_history_item(item_id, None)
+        committed_history = session.truncate_history_item(
+            item_id,
+            audio_end_ms=committed_cursor,
+            playback=playback,
+            hard=hard_truncate,
+        )
+    elif session.pending_history_item_ids:
+        pending_ids = list(session.pending_history_item_ids)
+        if len(pending_ids) == 1:
+            item_id = pending_ids[0]
+            committed_history = session.truncate_history_item(
+                item_id,
+                audio_end_ms=committed_cursor,
+                playback=playback,
+                hard=hard_truncate,
+            )
+    elif session.active_response_id is not None:
+        item_id = f"item_{session.active_response_id}"
+        committed_history = session.truncate_history_item(
+            item_id,
+            audio_end_ms=committed_cursor,
+            playback=playback,
+            hard=hard_truncate,
+        )
+    elif session.last_assistant_full_message is not None:
+        if item_id is None and session.history_item_ids:
+            assistant_item_ids = [
+                known_item_id
+                for known_item_id, message in session.history_item_ids.items()
+                if message.get("role") == "assistant"
+            ]
+            if len(assistant_item_ids) == 1:
+                item_id = assistant_item_ids[0]
+        if isinstance(item_id, str) and item_id:
+            committed_history = session.truncate_history_item(
+                item_id,
+                audio_end_ms=committed_cursor,
+                playback=playback,
+                hard=hard_truncate,
+            )
+    events: list[DuplexEvent] = [
+        PlaybackAcknowledged(
+            details={
+                "type": "playback.acknowledged",
+                "session_id": session.session_id,
+                "epoch": session.epoch,
+                "item_id": item_id,
+                "played_ms": int(played_ms),
+                "committed_ms": committed_cursor,
+                "truncate": event.get("truncate") is True,
+                "playback": playback.as_dict(),
+                "history_committed": committed_history,
+            }
+        )
+    ]
+    if committed_history and committed_cursor >= max(playback.sent_ms, playback.generated_ms):
+        session.release_response_playback(response_id)
+        session.release_response_history_snapshot(response_id)
+    return events
diff --git a/vllm_omni/engine/duplex/session/runner.py b/vllm_omni/engine/duplex/session/runner.py
new file mode 100644
index 000000000..1ca248fef
--- /dev/null
+++ b/vllm_omni/engine/duplex/session/runner.py
@@ -0,0 +1,1879 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Engine-resident session runner: one ordered mailbox and one session state per duplex session.
+
+``DuplexSessionRunner`` owns the whole lifecycle of one session on the
+orchestrator loop (the session is never touched from another thread):
+
+* every mutation of ``DuplexEngineSession`` happens on this loop, through the
+  mailbox worker (commands, stage outputs, internal items) or through tracked
+  tasks that re-validate ``(epoch, turn_id)`` after each ``await``;
+* appends are planned with the model plugin and submitted to the stage port
+  in wire order on the per-session append tail (no RPC hop);
+* stage outputs are pushed in by ``DuplexOrchestrator._intercept_stage_output``
+  instead of being polled through request queues;
+* everything the session says leaves as typed events through
+  ``DuplexSessionManager.emit`` after terminal-acceptance / stale-epoch
+  filtering, so a cancelled epoch can never speak again.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import time
+import uuid
+from collections.abc import Awaitable, Callable, Mapping
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, TypeVar
+
+from vllm.logger import init_logger
+
+from vllm_omni.engine.duplex.commands import (
+    AckPlayback,
+    AppendAudio,
+    AppendText,
+    BargeIn,
+    CancelInput,
+    CancelResponse,
+    ClearInput,
+    ClearOutputAudio,
+    CloseSession,
+    Commit,
+    CreateItem,
+    CreateResponse,
+    DeleteItem,
+    DuplexCommand,
+    Heartbeat,
+    SignalTurn,
+    TruncateItem,
+    UpdateSession,
+)
+from vllm_omni.engine.duplex.config import (
+    DuplexConfigError,
+    DuplexOverlapPolicy,
+    DuplexPlaybackCommitPolicy,
+    DuplexSessionState,
+    ResponseCreateOptions,
+)
+from vllm_omni.engine.duplex.contracts import (
+    DuplexOutputContext,
+    DuplexOutputDecision,
+    DuplexStagePort,
+)
+from vllm_omni.engine.duplex.events import (
+    DuplexEvent,
+    InputCleared,
+    SessionExpired,
+    SessionHeartbeatAck,
+)
+from vllm_omni.engine.duplex.plugin import (
+    DuplexModelPlugin,
+    DuplexModelSessionState,
+    PcmAppendReservation,
+)
+from vllm_omni.engine.duplex.realtime_events import (
+    RealtimeProjectionState,
+    discard_pending_input_audio,
+    note_input_append,
+    resolve_cancel_response,
+    resolve_clear_output_audio,
+    resolve_commit,
+    resolve_create_item,
+    resolve_delete_item,
+    resolve_truncate_item,
+    retrieve_item_events,
+)
+from vllm_omni.engine.duplex.session import helpers, overlap_policy, playback_ledger
+from vllm_omni.engine.duplex.session.append_task import AppendAttempt
+from vllm_omni.engine.duplex.session.commit_policy import CommitAction, CommitSnapshot, decide_commit_action
+from vllm_omni.engine.duplex.session.context import (
+    DuplexRunState,
+    DuplexSessionContext,
+    DuplexSessionTasks,
+    StageOutput,
+)
+from vllm_omni.engine.duplex.session.control import SessionControl
+from vllm_omni.engine.duplex.session.emitter import SessionEmitter
+from vllm_omni.engine.duplex.session.engine_session import DuplexEngineSession
+from vllm_omni.engine.duplex.session.lease import DuplexLeaseActivity
+from vllm_omni.engine.duplex.session.model_channel import ModelChannel
+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
+    from vllm.outputs import RequestOutput
+
+    from vllm_omni.engine.duplex.session.manager import DuplexSessionManager
+
+logger = init_logger(__name__)
+
+_OffloadT = TypeVar("_OffloadT")
+
+
+@dataclass(frozen=True, slots=True)
+class _Internal:
+    """Runner-internal mailbox item (its payload runs through the dict-based handlers)."""
+
+    kind: str
+    payload: dict[str, object] = field(default_factory=dict)
+
+
+_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)."""
+
+    def __init__(
+        self,
+        *,
+        session: DuplexEngineSession,
+        plugin: DuplexModelPlugin,
+        stage_port: DuplexStagePort,
+        manager: DuplexSessionManager,
+        model_config: ModelConfig | None,
+    ) -> None:
+        self.session = session
+        self.plugin = plugin
+        self.stage_port = stage_port
+        self.manager = manager
+        self.model_config = model_config
+        if session.model_state is None:
+            session.model_state = plugin.create_session_state()
+        self.model_state: DuplexModelSessionState = session.model_state
+        self.tasks = DuplexSessionTasks()
+        self._mailbox: asyncio.Queue[DuplexCommand | StageOutput | _Internal] = asyncio.Queue()
+        self._worker: asyncio.Task[None] | None = None
+        self._worker_stopped = False
+        self._loop: asyncio.AbstractEventLoop | None = None
+        self._background_tasks: set[asyncio.Task[None]] = set()
+        #: Flags more than one component reads and writes (see session_context).
+        self.run = DuplexRunState()
+        self.ctx = DuplexSessionContext(
+            session=session,
+            model_state=self.model_state,
+            plugin=plugin,
+            stage_port=stage_port,
+            manager=manager,
+            tasks=self.tasks,
+            run=self.run,
+            services=self,
+        )
+        self.out = SessionEmitter(self.ctx, promote_deferred_overlap=self._promote_deferred_overlap_later)
+        self.model = ModelChannel(
+            self.ctx,
+            self.out,
+            close_from_runtime=self._close_from_runtime,
+            schedule_silence_continuation=self._schedule_silence_continuation,
+            abort_request=self._abort_request_background,
+        )
+        self.control = SessionControl(
+            self.ctx,
+            self.out,
+            self.model,
+            wait_for_append_tail=self._wait_for_append_tail,
+        )
+
+    # ------------------------------------------------------------------ #
+    # Public interface                                                   #
+    # ------------------------------------------------------------------ #
+
+    def start(self) -> None:
+        self._loop = asyncio.get_running_loop()
+        session = self.session
+        if self.out.projector is None:
+            default_payload = session.config.extra_body.get("realtime_session_payload")
+            self.out.projector = RealtimeProjectionState(
+                session_id=session.session_id,
+                model=session.config.model,
+                default_payload=default_payload if isinstance(default_payload, Mapping) else None,
+                initial_session_update=True,
+            )
+        # Every client speaks the Realtime protocol now; the old runner forced
+        # the ACK-only playback ledger for that path.
+        session.config.playback_commit_policy = DuplexPlaybackCommitPolicy.ACK_ONLY.value
+        self.control.init_turn_detection()
+        self._worker = self._loop.create_task(self._run(), name=f"duplex-session-{session.session_id}")
+        self.emit({"type": "session.created", "session": session.as_public_dict()})
+
+    def submit(self, command: DuplexCommand) -> None:
+        self._mailbox.put_nowait(command)
+
+    def on_stage_output(
+        self,
+        stage_id: int,
+        output: RequestOutput,
+        metrics: StageRequestStats | None,
+        *,
+        request_id: str,
+        context: DuplexOutputContext,
+    ) -> bool:
+        """Accept one stage output (orchestrator loop); return True when it must not be forwarded."""
+        decision: DuplexOutputDecision | None = None
+        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
+        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
+            # ``StageMetricsMessage``, a path session-owned requests no longer
+            # take. Hand them to the session instead of dropping them, on the
+            # mailbox so they stay ordered with this session's other work.
+            snapshot = self.model.stage_metrics_snapshot(stage_id, metrics, output)
+            if snapshot is not None and not self.run.closing and self.session.state != DuplexSessionState.CLOSED:
+                self._mailbox.put_nowait(_Internal("stage_metrics", {"stage_metrics": snapshot}))
+            return False
+        if self.run.closing or self.session.state == DuplexSessionState.CLOSED:
+            return True
+        self._mailbox.put_nowait(
+            StageOutput(
+                stage_id=stage_id,
+                output=output,
+                metrics=metrics,
+                request_id=request_id,
+                context=context,
+                decision=decision,
+            )
+        )
+        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.
+
+        Runs synchronously on the loop (no mailbox hop): the orchestrator
+        expires the session right after this call, so a queued item could be
+        cancelled with the worker and the client would only see
+        ``session.expired``. Emitting here keeps the order
+        ``error`` -> failed ``response.done`` -> ``session.expired``.
+        """
+        session = self.session
+        if session.state == DuplexSessionState.CLOSED:
+            return
+        self._emit_error(
+            "runtime_data_plane_stream_failed",
+            f"Stage-{stage_id} input processor failed: {type(exc).__name__}: {exc}",
+        )
+        response_id = session.active_response_id
+        if response_id is not None:
+            session.end_response(commit_text=False)
+            self.emit(
+                {
+                    "type": "response.done",
+                    "session_id": session.session_id,
+                    "response_id": response_id,
+                    "epoch": session.epoch,
+                    "committed": False,
+                    "status": "failed",
+                    "status_details": {"type": "failed", "reason": "runtime_data_plane_stream_failed"},
+                    "playback": session.playback.as_dict(),
+                }
+            )
+
+    @property
+    def closed_emitted(self) -> bool:
+        """Whether ``session.closed`` / ``session.expired`` already left this runner."""
+        return self.run.closed_emitted
+
+    def mark_closed_emitted(self) -> None:
+        """Claim the session's one terminal event for the caller.
+
+        The manager emits the deferred terminal itself, after the stage cleanup;
+        recording it here stops a late runtime close emitting a second one.
+        """
+        self.run.closed_emitted = True
+        self.run.closed_deferred = False
+
+    @property
+    def closing(self) -> bool:
+        """Whether an irreversible close has begun (commands and control ops are refused)."""
+        return self.run.closing or self.session.state != DuplexSessionState.OPEN
+
+    async def close(self, reason: str, *, emit_closed: bool = True) -> None:
+        """Graceful close: cancel work, release the data plane, emit ``session.closed``.
+
+        With ``emit_closed=False`` the manager emits ``session.closed`` itself
+        once the stage resources are released, so the event also means "the
+        admission slot is free again".
+        """
+        session = self.session
+        if session.state == DuplexSessionState.CLOSED and (self.run.closed_emitted or self.run.closed_deferred):
+            await self._stop_worker()
+            return
+        self._begin_close(reason)
+        self.model_state.audio_buffer.clear()
+        session.release_all_input_bytes()
+        self.model_state.input_since_commit = False
+        self.model_state.speech_since_commit = False
+        self.model_state.clear_committed_audio()
+        await self.tasks.cancel_append_tasks()
+        self.model.cancel_data_plane_stream()
+        await self._cancel_active_response(self.tasks.active_response_task, reason=reason, notify=False)
+        self.tasks.active_response_task = None
+        self._cleanup_duplex_session_state()
+        if not self.run.closed_emitted and not self.run.closed_deferred:
+            self.run.close_reason = self.run.close_reason or reason
+            if emit_closed:
+                self.run.closed_emitted = True
+                self.emit({"type": "session.closed", "session_id": session.session_id, "reason": reason})
+            else:
+                self.run.closed_deferred = True
+        session.close()
+        await self._stop_worker()
+
+    async def expire(self, reason: str, *, emit_expired: bool = True) -> None:
+        """Lease expiry / runtime cleanup: emit ``session.expired`` and tear down.
+
+        With ``emit_expired=False`` the manager emits the event after the stage
+        cleanup (see ``close``).
+        """
+        session = self.session
+        self._begin_close(reason)
+        if not self.run.closed_emitted:
+            if emit_expired:
+                # Also when the event was deferred: the manager only emits a
+                # deferred terminal for the teardown it drives itself, and an
+                # expiry that arrives first (a stage failure racing a wire
+                # ``session.close``) takes the runner away from it. Emitting
+                # here keeps "every session ends with one terminal event".
+                self.run.closed_emitted = True
+                self._emit_events([SessionExpired(reason=reason)])
+            else:
+                self.run.closed_deferred = True
+        await self.tasks.cancel_append_tasks()
+        self.model.cancel_data_plane_stream()
+        active_response_task = self.tasks.active_response_task
+        if active_response_task is not None and not active_response_task.done():
+            active_response_task.cancel()
+            await asyncio.gather(active_response_task, return_exceptions=True)
+        self.tasks.active_response_task = None
+        if session.active_response_id is not None:
+            session.end_response(commit_text=False)
+        self._cleanup_duplex_session_state()
+        session.close()
+        await self._stop_worker()
+
+    async def shutdown(self) -> None:
+        self.run.closing = True
+        self.run.closed_emitted = True
+        await self.tasks.cancel_append_tasks()
+        self.model.cancel_data_plane_stream()
+        active_response_task = self.tasks.active_response_task
+        if active_response_task is not None and not active_response_task.done():
+            active_response_task.cancel()
+            await asyncio.gather(active_response_task, return_exceptions=True)
+        self.session.close()
+        await self._stop_worker()
+
+    # ------------------------------------------------------------------ #
+    # Worker                                                             #
+    # ------------------------------------------------------------------ #
+
+    async def _run(self) -> None:
+        while not self._worker_stopped:
+            item = await self._mailbox.get()
+            try:
+                await self._handle_item(item)
+            except asyncio.CancelledError:
+                raise
+            except Exception as exc:
+                logger.exception("Duplex session %s failed handling %r: %s", self.session.session_id, item, exc)
+                self._emit_error("internal_error", str(exc))
+
+    async def _stop_worker(self) -> None:
+        worker = self._worker
+        self._worker = None
+        # Set even when the worker itself is stopping (a wire ``session.close``
+        # runs inside it): its loop exits after the current item instead of
+        # parking on the mailbox forever.
+        self._worker_stopped = True
+        for task in list(self._background_tasks):
+            task.cancel()
+        if self._background_tasks:
+            await asyncio.gather(*self._background_tasks, return_exceptions=True)
+        self._background_tasks.clear()
+        if worker is not None and worker is not asyncio.current_task() and not worker.done():
+            worker.cancel()
+            await asyncio.gather(worker, return_exceptions=True)
+
+    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)
+
+    async def offload(self, fn: Callable[..., _OffloadT], *args: object, **kwargs: object) -> _OffloadT:
+        loop = self._loop or asyncio.get_running_loop()
+        if kwargs:
+            return await loop.run_in_executor(self.manager.executor, lambda: fn(*args, **kwargs))
+        return await loop.run_in_executor(self.manager.executor, fn, *args)
+
+    async def _handle_item(self, item: DuplexCommand | StageOutput | _Internal) -> None:
+        session = self.session
+        if isinstance(item, StageOutput):
+            await self.model.on_stage_output_item(item)
+            return
+        if isinstance(item, _Internal):
+            await self._on_internal(item)
+            return
+        if self.run.closing or session.state == DuplexSessionState.CLOSED:
+            if isinstance(item, Commit):
+                session.release_pending_turn()
+            elif isinstance(item, AppendAudio):
+                session.release_input_bytes(len(item.audio))
+            return
+        await self._on_command(item)
+
+    async def _on_internal(self, item: _Internal) -> None:
+        if item.kind == "stage_metrics":
+            stage_metrics = item.payload.get("stage_metrics")
+            if isinstance(stage_metrics, Mapping):
+                self.session.stash_stage_metrics(stage_metrics)
+            return
+        if item.kind == "promote_deferred_overlap":
+            if self.run.closing or self.session.state != DuplexSessionState.OPEN:
+                return
+            payload = item.payload.get("payload")
+            if not isinstance(payload, dict):
+                return
+            await self._start_append(
+                payload,
+                final=True,
+                precreate_response=bool(item.payload.get("precreate_response", False)),
+                operation_id=self.model_state.committed_audio_operation_id,
+                retained_committed_payload=(payload if self.model_state.committed_audio_payload is payload else None),
+            )
+            return
+        if item.kind == "commit":
+            await self._on_commit(dict(item.payload))
+            return
+        if item.kind == "run_payload":
+            await self._run_internal_payload(dict(item.payload))
+            return
+        logger.warning("Unknown duplex runner internal item: %s", item.kind)
+
+    async def _run_internal_payload(self, payload: dict[str, object]) -> None:
+        """Run one internal event dictionary through the matching handler."""
+        event_type = payload.get("type")
+        if event_type == "input_audio_buffer.append":
+            await self._on_append_audio(payload)
+        elif event_type in {"input_audio_buffer.commit", "input.commit", "response.create"}:
+            await self._on_commit(payload)
+        elif event_type == "playback.ack":
+            self._emit_events(playback_ledger.apply_playback_ack(self.session, payload))
+        elif event_type in _CANCEL_EVENTS:
+            await self._on_cancel(payload)
+        elif event_type == "turn.signal":
+            await self.control.on_turn_signal(payload)
+        else:
+            self._emit_error("unknown_event", f"Unknown duplex event: {event_type}")
+
+    # ------------------------------------------------------------------ #
+    # Commands                                                           #
+    # ------------------------------------------------------------------ #
+
+    async def _on_command(self, command: DuplexCommand) -> None:
+        session = self.session
+        projector = self._require_projector()
+        if isinstance(command, AppendAudio):
+            # The manager reserved the wire size at admission; the handler
+            # re-reserves the decoded size around its PCM reservation.
+            session.release_input_bytes(len(command.audio))
+            await self._on_append_audio(command.payload())
+        elif isinstance(command, AppendText):
+            session.mark_user_input_activity()
+            self._emit_error(
+                "native_text_append_unsupported",
+                "The selected native duplex runtime accepts audio append only",
+                event_id=command.event_id,
+            )
+        elif isinstance(command, Commit):
+            session.release_pending_turn()
+            resolved = resolve_commit(projector, command)
+            self._emit_events(resolved.events)
+            if resolved.reset_vad:
+                self.control.reset_vad()
+            if resolved.payload is not None:
+                await self._on_commit(resolved.payload)
+        elif isinstance(command, CreateResponse):
+            await self._on_commit(command.payload())
+        elif isinstance(command, ClearInput):
+            self._on_clear_input()
+        elif isinstance(command, CancelResponse):
+            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):
+            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())
+        elif isinstance(command, SignalTurn):
+            if command.event == "conversation.item.retrieve":
+                self._emit_events(
+                    retrieve_item_events(
+                        projector,
+                        {
+                            **dict(command.signal_payload),
+                            **({"event_id": command.event_id} if command.event_id else {}),
+                        },
+                    )
+                )
+                return
+            payload = command.payload()
+            if command.event in _CANCEL_EVENTS:
+                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)
+            else:
+                await self.control.on_turn_signal(payload)
+        elif isinstance(command, UpdateSession):
+            await self.control.on_session_update(dict(command.patch), realtime_event_id=command.event_id)
+        elif isinstance(command, AckPlayback):
+            self._emit_events(playback_ledger.apply_playback_ack(self.session, command.payload()))
+        elif isinstance(command, Heartbeat):
+            self._on_heartbeat(command)
+        elif isinstance(command, CreateItem):
+            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):
+            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):
+            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)
+        else:
+            self._emit_error("unknown_event", f"Unknown duplex command: {type(command).__name__}")
+
+    async def _on_close_command(self, reason: str) -> None:
+        # A close requested through the ordered command stream (the client's
+        # ``session.close``) tears the runner down here; the manager then
+        # aborts the stage requests, frees the admission slot and emits
+        # ``session.closed`` exactly like a close through the control RPC.
+        # Mark the session closing before the first await so a concurrent
+        # resume / touch / command is refused instead of racing the teardown.
+        self._begin_close(reason)
+        await self.close(reason, emit_closed=False)
+        self.manager.close_from_runner(self, reason)
+
+    def _on_heartbeat(self, command: Heartbeat) -> None:
+        try:
+            self.session.touch_lease(DuplexLeaseActivity.HEARTBEAT)
+        except Exception as exc:
+            self._emit_error("runtime_touch_failed", str(exc), event_id=command.event_id)
+            return
+        self._emit_events([SessionHeartbeatAck()])
+
+    def _on_clear_input(self) -> None:
+        session = self.session
+        model_state = self.model_state
+        model_state.audio_buffer.clear()
+        session.release_all_input_bytes()
+        model_state.input_since_commit = False
+        model_state.speech_since_commit = False
+        model_state.clear_committed_audio()
+        session.cancel_pending_input()
+        projector = self.out.projector
+        if projector is not None:
+            from vllm_omni.engine.duplex.realtime_events import clear_input_buffer
+
+            clear_input_buffer(projector)
+        self._emit_events([InputCleared()])
+
+    # ------------------------------------------------------------------ #
+    # Emission (delegated to SessionEmitter)                             #
+    # ------------------------------------------------------------------ #
+
+    def emit(self, payload: dict[str, object]) -> None:
+        """Apply an internal event to the session, project it, and send it."""
+        self.out.emit(payload)
+
+    def _emit_events(self, events: list[DuplexEvent]) -> None:
+        self.out.emit_events(events)
+
+    def _emit_error(
+        self,
+        code: str,
+        message: str,
+        *,
+        event_id: object | None = None,
+        retryable: bool | None = None,
+    ) -> None:
+        self.out.emit_error(code, message, event_id=event_id, retryable=retryable)
+
+    def _require_projector(self) -> RealtimeProjectionState:
+        return self.out.require_projector()
+
+    def _is_stale_model_output(self, payload: dict[str, object]) -> bool:
+        return self.out.is_stale_model_output(payload)
+
+    def _promote_deferred_overlap_later(self, payload: dict[str, object], precreate_response: bool) -> None:
+        """Re-enter the mailbox so the promoted turn is handled in command order."""
+        self._mailbox.put_nowait(
+            _Internal(
+                "promote_deferred_overlap",
+                {"payload": payload, "precreate_response": precreate_response},
+            )
+        )
+
+    # ------------------------------------------------------------------ #
+    # Session lifecycle helpers                                          #
+    # ------------------------------------------------------------------ #
+
+    def _begin_close(self, reason: str) -> None:
+        self.run.closing = True
+        self.run.close_reason = self.run.close_reason or reason
+        self.session.mark_closing()
+
+    def _session_auto_responds(self) -> bool:
+        return self.out.auto_responds()
+
+    def _cleanup_duplex_session_state(self) -> None:
+        session = self.session
+        self.plugin.data_plane.close_session(session.session_id, active_request_id=session.active_request_id)
+        self.run.stream_request_id = None
+
+    # ------------------------------------------------------------------ #
+    # Append path (was the audio-append branch + start_native_append)    #
+    # ------------------------------------------------------------------ #
+
+    async def _barge_in_for_overlap(self, event: dict[str, object], decision: dict[str, object]) -> bool:
+        """Interrupt the model so the user's overlapping speech becomes the turn.
+
+        Cancels the active response and the data-plane stream, advances the
+        barge-in epoch so stale output is dropped, and reports what was cut.
+        Returns whether the append should continue: losing the fence race
+        means this append belongs to a superseded epoch and is abandoned.
+        """
+        session = self.session
+        model_state = self.model_state
+        event["force_barge_in"] = True
+        cancelled_fence = session.fence
+        playback_was_active = helpers.assistant_playback_active(self.session)
+        model_state.audio_buffer.clear_force_listen()
+        session.reset_overlap_speech()
+        model_state.input_since_commit = False
+        model_state.speech_since_commit = False
+        await self.tasks.cancel_append_tasks()
+        had_stream = self.run.stream_request_id is not None
+        cancel_reason = str(decision.get("cancel_reason") or "barge_in")
+        cancelled = await self._cancel_active_response(
+            self.tasks.active_response_task,
+            reason=cancel_reason,
+        )
+        had_stream = self.model.cancel_data_plane_stream() or had_stream
+        if not cancelled and had_stream:
+            old_epoch = session.epoch
+            old_response_id = session.active_response_id
+            committed_ms = session.playback.committed_ms
+            helpers.commit_played_response_history(session, old_response_id, committed_ms)
+            new_epoch, old_playback = helpers.advance_barge_in_epoch(session)
+            self.emit(
+                {
+                    "type": "audio.cancelled",
+                    "session_id": session.session_id,
+                    "response_id": old_response_id,
+                    "reason": cancel_reason,
+                    "cancelled_epoch": old_epoch,
+                    "epoch": new_epoch,
+                    "committed_ms": committed_ms,
+                    "playback": old_playback,
+                }
+            )
+            cancelled = True
+        if not cancelled and playback_was_active:
+            old_epoch = session.epoch
+            committed_ms = session.playback.committed_ms
+            helpers.commit_played_response_history(session, session.last_response_id, committed_ms)
+            new_epoch, old_playback = helpers.advance_barge_in_epoch(session)
+            self.emit(
+                {
+                    "type": "audio.cancelled",
+                    "session_id": session.session_id,
+                    "response_id": session.last_response_id,
+                    "reason": cancel_reason,
+                    "cancelled_epoch": old_epoch,
+                    "epoch": new_epoch,
+                    "committed_ms": committed_ms,
+                    "playback": old_playback,
+                }
+            )
+            cancelled = True
+        if session.epoch > cancelled_fence.epoch:
+            if not await self.model.signal_cancel_fence(cancelled_fence):
+                return False
+        self.tasks.active_response_task = None
+        return True
+
+    async def _on_append_audio(self, event: dict[str, object]) -> None:
+        session = self.session
+        model_state = self.model_state
+        session.mark_user_input_activity()
+        audio = event.get("audio") or event.get("data")
+        if not isinstance(audio, str):
+            self._emit_error("bad_event", "input_audio_buffer.append requires audio")
+            return
+        if not session.capabilities.supports_barge_in and overlap_policy.event_requests_barge_in(event):
+            self._emit_events([helpers.barge_in_unsupported_error()])
+            event = dict(event)
+            event.pop("force_barge_in", None)
+            for key in ("overlap_action", "overlap"):
+                value = event.get(key)
+                if isinstance(value, str) and value.strip().lower() in {"barge_in", "interrupt", "cancel"}:
+                    event.pop(key, None)
+        fmt = event.get("format") if isinstance(event.get("format"), str) else "pcm16"
+        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:
+            converted: tuple[object, object, int | float | None] = await self.offload(
+                convert_input_audio_with_rate,
+                audio,
+                fmt,
+                sample_rate_hz=sample_rate_hz,
+            )
+        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:
+            return
+
+        force_listen = bool(event.get("force_listen", False))
+        payload: dict[str, object] = {
+            "type": "audio",
+            "audio": audio,
+            "format": fmt,
+            "sample_rate_hz": sample_rate_hz,
+            "force_listen": force_listen,
+        }
+        video_frames = event.get("video_frames")
+        if isinstance(video_frames, list):
+            frames = [frame for frame in video_frames if isinstance(frame, str) and frame]
+            if frames:
+                payload["video_frames"] = frames
+        payload["is_speech"] = overlap_policy.input_looks_like_speech(self.session, event, payload)
+        auto_responds = self._session_auto_responds()
+        defer_append = False
+        buffer_overlap_audio = True
+        self._mark_pending_silence_superseded()
+        overlap_active = helpers.response_in_progress(self.session, self.tasks) and (
+            not auto_responds
+            or (
+                session.capabilities.supports_barge_in
+                and (
+                    session.config.overlap_policy == DuplexOverlapPolicy.BARGE_IN_ON_SPEECH.value
+                    or overlap_policy.event_requests_barge_in(event)
+                )
+            )
+        )
+        if overlap_active:
+            decision = overlap_policy.decide(self.session, event, payload, auto_responds=auto_responds)
+            self._emit_events([helpers.overlap_decision_event(self.session, decision)])
+            action = decision.get("action")
+            if action == "drop":
+                duration_ms = overlap_policy.input_audio_duration_ms(event, payload)
+                self._emit_events(discard_pending_input_audio(projector, duration_ms))
+                self._maybe_schedule_vad_commit(vad_result)
+                return
+            if action == "listen":
+                buffer_overlap_audio = bool(decision.get("buffer_audio", True))
+                defer_append = bool(decision.get("defer_runtime_append", True))
+                if not buffer_overlap_audio and decision.get("preserve_realtime_input") is not True:
+                    self._emit_events(
+                        discard_pending_input_audio(projector, overlap_policy.input_audio_duration_ms(event, payload))
+                    )
+                if decision.get("force_listen", True) is True:
+                    payload["force_listen"] = True
+            else:
+                if not await self._barge_in_for_overlap(event, decision):
+                    return
+                buffer_overlap_audio = True
+                defer_append = False
+        elif not auto_responds and not overlap_policy.input_looks_like_speech(self.session, event, payload):
+            # Turn-mode only: skip silent chunks so they don't open a response.
+            self.emit(
+                {
+                    "type": "response.listen",
+                    "session_id": session.session_id,
+                    "epoch": session.epoch,
+                    "reason": "silence_or_noise",
+                }
+            )
+            self._maybe_schedule_vad_commit(vad_result)
+            return
+        if overlap_policy.should_force_listen_for_auto_response_overlap(event, payload, auto_responds=auto_responds):
+            payload["force_listen"] = True
+        if not buffer_overlap_audio:
+            self._maybe_schedule_vad_commit(vad_result)
+            return
+        session.mark_user_input_activity()
+        model_state.input_since_commit = True
+        model_state.speech_since_commit = model_state.speech_since_commit or overlap_policy.input_looks_like_speech(
+            self.session, event, payload
+        )
+        raw_audio_bytes = helpers.audio_payload_size_bytes(payload)
+        try:
+            if not session.reserve_input_bytes(
+                raw_audio_bytes,
+                limit=int(self.manager.runtime_config.max_pending_input_bytes_per_session),
+            ):
+                self._emit_error("input_backpressure", "Duplex session pending input exceeds server limit")
+                return
+            # Full-duplex: emit each ~chunk_period of audio so the model runs
+            # per-chunk generation without an explicit response.create.
+            allow_emit = not defer_append and self._session_auto_responds()
+            pcm_reservation = model_state.audio_buffer.prepare_append(
+                payload,
+                operation_id=uuid.uuid4().hex,
+                chunk_period_ms=session.capabilities.chunk_period_ms or 1000,
+                allow_emit=allow_emit,
+            )
+        except ValueError as exc:
+            session.release_input_bytes(raw_audio_bytes)
+            self._emit_error("bad_event", str(exc))
+            return
+        if pcm_reservation is None:
+            self._maybe_schedule_vad_commit(vad_result)
+            return
+        if pcm_reservation.byte_count == 0:
+            session.release_input_bytes(raw_audio_bytes)
+        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:
+        """Server VAD ended the user turn: run the same commit the old translator synthesized."""
+        if vad_result is None or not vad_result.should_commit:
+            return
+        if self._session_auto_responds():
+            # A model-native session decides its own turns; server VAD is there
+            # to hear the user (speech_started / speech_stopped, barge-in), not
+            # to end the turn. Committing at the detector's stop cuts the
+            # utterance short: the model listens on that early final unit, the
+            # trailing silence lands in a second, near-empty turn, and the
+            # client's own commit then has nothing left to answer. The old
+            # translator synthesized this commit for turn-based server VAD only.
+            return
+        command = Commit(final=True, create_response=vad_result.create_response)
+        resolved = resolve_commit(self._require_projector(), command)
+        self._emit_events(resolved.events)
+        if resolved.reset_vad:
+            self.control.reset_vad()
+        if resolved.payload is not None:
+            self._mailbox.put_nowait(_Internal("commit", resolved.payload))
+
+    def _clear_completed_pending_silence(self) -> None:
+        task = self.model_state.pending_silence_task
+        if task is not None and task.done():
+            self.model_state.pending_silence_task = None
+            self.model_state.pending_silence_owner_id = None
+
+    def _mark_pending_silence_superseded(self) -> None:
+        task = self.model_state.pending_silence_task
+        if task is None:
+            return
+        if task.done():
+            self.model_state.pending_silence_task = None
+        # Do not cancel the task here: a silence append may already have
+        # reached the stage; before_append skips silence that has not started.
+        self.model_state.pending_silence_owner_id = None
+
+    def _real_input_waiting(self) -> bool:
+        self._clear_completed_pending_silence()
+        return self.model_state.audio_buffer.has_pending() or self.model_state.audio_buffer.has_reserved()
+
+    async def _start_append(
+        self,
+        payload: dict[str, object],
+        *,
+        final: bool,
+        precreate_response: bool = False,
+        pcm_reservation: PcmAppendReservation | None = None,
+        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_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:
+            session.bind_response_turn(append_turn_id)
+        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,
+            model=self.model,
+            fail_session=self._fail_session_from_append,
+            payload=payload,
+            epoch=append_epoch,
+            request_id=request_id,
+            final=final,
+            pcm_reservation=pcm_reservation,
+            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,
+        )
+
+        predecessor = self.tasks.append_tail
+        if predecessor is not None and predecessor.done():
+            try:
+                predecessor_ok = predecessor.result()
+            except (asyncio.CancelledError, Exception):
+                predecessor_ok = False
+            if not predecessor_ok:
+                # Appends queued behind a failed predecessor stop; a later
+                # command is an explicit retry and starts a new chain.
+                predecessor = None
+        task = asyncio.create_task(attempt.run_in_wire_order(predecessor))
+        task.add_done_callback(attempt.release_on_failure)
+        self.tasks.append_tail = task
+        self.tasks.track_append_task(
+            task,
+            epoch=append_epoch,
+            final=final,
+            response_bound=final or precreate_response,
+        )
+        if silence_continuation:
+            model_state.pending_silence_task = task
+            task.add_done_callback(attempt.clear_pending_silence)
+        # Let this wire-order effect start before the next mailbox item can cancel it.
+        await asyncio.sleep(0)
+        return task
+
+    def _fail_session_from_append(self, reason: str) -> None:
+        """An append task died: mark the session closing now, close it out next."""
+        self._begin_close(reason)
+        self.spawn(self._close_from_runtime(reason), name="duplex-runtime-close")
+
+    async def _wait_for_append_tail(self) -> bool:
+        predecessor = self.tasks.append_tail
+        if predecessor is None:
+            return True
+        try:
+            return await predecessor
+        except asyncio.CancelledError:
+            if helpers.task_is_cancelling(asyncio.current_task()):
+                raise
+            return False
+        except Exception:
+            return False
+
+    async def _schedule_silence_continuation(
+        self,
+        payload: object,
+        *,
+        request_id: str,
+        owner_id: str,
+        response_id: str | None,
+        response_owned: bool,
+        expected_epoch: int | None,
+        expected_model_turn_id: int | None,
+    ) -> bool:
+        session = self.session
+        model_state = self.model_state
+        self._clear_completed_pending_silence()
+        pending_silence = model_state.pending_silence_task
+        if pending_silence is not None and not pending_silence.done():
+            if pending_silence is asyncio.current_task():
+                return False
+            try:
+                if not await pending_silence:
+                    return False
+            except asyncio.CancelledError:
+                if helpers.task_is_cancelling(asyncio.current_task()):
+                    raise
+                return False
+            except Exception:
+                return False
+            self._clear_completed_pending_silence()
+            pending_silence = model_state.pending_silence_task
+            if pending_silence is not None and not pending_silence.done():
+                return False
+        append_tail = self.tasks.append_tail
+        if (append_tail is None or append_tail.done()) and self._real_input_waiting():
+            return False
+        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,
+                )
+            )
+
+        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
+        task = await self._start_append(
+            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
+
+    # ------------------------------------------------------------------ #
+    # Runtime-initiated close                                             #
+    # ------------------------------------------------------------------ #
+
+    async def _close_from_runtime(self, reason: str) -> None:
+        """A runtime failure closed the session from inside the engine."""
+        session = self.session
+        if session.state == DuplexSessionState.CLOSED:
+            return
+        self.run.runtime_closed = True
+        self._begin_close(reason)
+        self._cleanup_duplex_session_state()
+        # ``closed_deferred`` means a manager-driven close already promised the
+        # terminal after its stage cleanup. Emitting here too would give the
+        # session two terminal events: this path can run concurrently, when an
+        # append task abandoned by that close fails and calls back in.
+        if not self.run.closed_emitted and not self.run.closed_deferred:
+            self.run.closed_emitted = True
+            self.emit({"type": "session.closed", "session_id": session.session_id, "reason": reason})
+        session.close()
+        # The manager aborts the stage requests (if any) and frees the
+        # admission slot; a session without stage requests must not stay
+        # registered until its idle TTL.
+        self.manager.close_from_runner(self, reason)
+
+    # ------------------------------------------------------------------ #
+    # Cancel / barge-in                                                  #
+    # ------------------------------------------------------------------ #
+
+    async def _on_cancel(self, event: dict[str, object]) -> None:
+        session = self.session
+        model_state = self.model_state
+        event_type = str(event.get("type"))
+        if event_type == "barge_in" and not session.capabilities.supports_barge_in:
+            self._emit_events([helpers.barge_in_unsupported_error()])
+            return
+        cancel_reason = (
+            "output_audio_buffer_clear"
+            if event_type == "output_audio_buffer.clear"
+            else "client_cancelled"
+            if event_type == "response.cancel"
+            else "barge_in"
+        )
+        cancelled_fence = session.fence
+        if event_type == "response.cancel":
+            requested_response_id = event.get("response_id")
+            has_active_response_work = helpers.response_in_progress(self.session, self.tasks)
+            if (
+                isinstance(requested_response_id, str)
+                and session.active_response_id is not None
+                and requested_response_id != session.active_response_id
+            ):
+                self._emit_error(
+                    "response_not_active",
+                    f"Response is not active: {requested_response_id}",
+                    event_id=event.get("realtime_event_id"),
+                )
+                return
+            if not has_active_response_work:
+                if isinstance(requested_response_id, str):
+                    return
+                self._emit_error(
+                    "response_not_active",
+                    "response.cancel requires an active response",
+                    event_id=event.get("realtime_event_id"),
+                )
+                return
+        had_unbuffered_append = model_state.input_since_commit and not model_state.audio_buffer.has_pending()
+        playback_was_active = helpers.assistant_playback_active(self.session)
+        if event_type in {"input.cancel", "barge_in"}:
+            model_state.audio_buffer.clear()
+            session.release_all_input_bytes()
+            model_state.input_since_commit = False
+            model_state.speech_since_commit = False
+            model_state.clear_committed_audio()
+        had_append = await self.tasks.cancel_append_tasks(
+            response_bound_only=event_type in {"response.cancel", "output_audio_buffer.clear"},
+        )
+        if event_type == "response.cancel":
+            session.release_input_bytes(model_state.clear_committed_audio())
+        had_stream = self.run.stream_request_id is not None
+        cancelled = await self._cancel_active_response(self.tasks.active_response_task, reason=cancel_reason)
+        had_stream = self.model.cancel_data_plane_stream() or had_stream
+        if not cancelled and (had_stream or had_append or had_unbuffered_append):
+            old_epoch = session.epoch
+            old_response_id = session.active_response_id
+            committed_ms = session.playback.committed_ms
+            helpers.commit_played_response_history(session, old_response_id, committed_ms)
+            new_epoch, old_playback = helpers.advance_barge_in_epoch(session)
+            self.emit(
+                {
+                    "type": "audio.cancelled",
+                    "session_id": session.session_id,
+                    "response_id": old_response_id,
+                    "reason": cancel_reason,
+                    "cancelled_epoch": old_epoch,
+                    "epoch": new_epoch,
+                    "committed_ms": committed_ms,
+                    "playback": old_playback,
+                }
+            )
+            cancelled = True
+        if not cancelled and playback_was_active:
+            old_epoch = session.epoch
+            committed_ms = session.playback.committed_ms
+            helpers.commit_played_response_history(session, session.last_response_id, committed_ms)
+            new_epoch, old_playback = helpers.advance_barge_in_epoch(session)
+            self.emit(
+                {
+                    "type": "audio.cancelled",
+                    "session_id": session.session_id,
+                    "response_id": session.last_response_id,
+                    "reason": cancel_reason,
+                    "cancelled_epoch": old_epoch,
+                    "epoch": new_epoch,
+                    "committed_ms": committed_ms,
+                    "playback": old_playback,
+                }
+            )
+            cancelled = True
+        if not cancelled and event_type == "response.cancel":
+            old_epoch = session.epoch
+            old_response_id = session.active_response_id
+            committed_ms = session.playback.committed_ms
+            helpers.commit_played_response_history(session, old_response_id, committed_ms)
+            new_epoch, old_playback = helpers.advance_barge_in_epoch(session)
+            self.emit(
+                {
+                    "type": "audio.cancelled",
+                    "session_id": session.session_id,
+                    "response_id": old_response_id,
+                    "reason": cancel_reason,
+                    "cancelled_epoch": old_epoch,
+                    "epoch": new_epoch,
+                    "committed_ms": committed_ms,
+                    "playback": old_playback,
+                }
+            )
+            cancelled = True
+        if not cancelled and event_type == "output_audio_buffer.clear":
+            old_playback = session.playback.as_dict()
+            committed_ms = session.playback.committed_ms
+            session.clear_playback_cursor()
+            self.emit(
+                {
+                    "type": "audio.cancelled",
+                    "session_id": session.session_id,
+                    "response_id": event.get("response_id") or session.active_response_id,
+                    "reason": cancel_reason,
+                    "cancelled_epoch": session.epoch,
+                    "epoch": session.epoch,
+                    "committed_ms": committed_ms,
+                    "playback": old_playback,
+                }
+            )
+            self.tasks.active_response_task = None
+            return
+        if not cancelled:
+            self._cancel_pending_input(reason="barge_in")
+        if not await self.model.signal_cancel_fence(cancelled_fence):
+            return
+        self.tasks.active_response_task = None
+
+    async def _cancel_active_response(
+        self,
+        active_task: asyncio.Task[None] | None,
+        *,
+        reason: str,
+        notify: bool = True,
+    ) -> bool:
+        session = self.session
+        has_running_task = active_task is not None and not active_task.done()
+        if not has_running_task and session.active_request_id is None and session.active_response_id is None:
+            return False
+
+        old_epoch = session.epoch
+        old_request_id = session.active_request_id
+        old_response_id = session.active_response_id
+        committed_ms = session.playback.committed_ms
+        committed_message = session.end_response(
+            commit_text=self.model.should_commit_response_to_history(session, old_response_id),
+            playback_commit_policy=DuplexPlaybackCommitPolicy.ACK_ONLY.value,
+        )
+        if old_response_id is not None:
+            item_id = f"item_{old_response_id}"
+            if committed_message is not None:
+                session.register_history_item(item_id, committed_message)
+            elif committed_ms > 0 and not session.playback_ack_is_too_late(old_response_id, item_id):
+                session.truncate_history_item(item_id, audio_end_ms=committed_ms)
+        # The epoch bump is the atomic part: from here on every model output
+        # and append of the old epoch is dropped by the stale-epoch filter in
+        # ``emit`` / the append tail, whatever the awaits below interleave with.
+        new_epoch, old_playback = helpers.advance_barge_in_epoch(session)
+        if old_request_id is not None:
+            # Release projector/parser cursors so cancelled epochs do not
+            # accumulate until the whole session closes.
+            self.plugin.data_plane.close_stream(old_request_id)
+            await self._abort_request_background(old_request_id, notify=notify)
+        if has_running_task and active_task is not None:
+            active_task.cancel()
+            try:
+                await asyncio.wait_for(asyncio.gather(active_task, return_exceptions=True), timeout=0.25)
+            except TimeoutError:
+                pass
+        if notify:
+            self.emit(
+                {
+                    "type": "audio.cancelled",
+                    "session_id": session.session_id,
+                    "response_id": old_response_id,
+                    "reason": reason,
+                    "cancelled_epoch": old_epoch,
+                    "epoch": new_epoch,
+                    "committed_ms": committed_ms,
+                    "playback": old_playback,
+                }
+            )
+        return True
+
+    async def _abort_request_background(self, request_id: str, *, notify: bool) -> None:
+        try:
+            await self.stage_port.abort_requests([request_id])
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:
+            logger.exception("Failed to abort duplex request %s: %s", request_id, exc)
+            if notify and self.session.state != DuplexSessionState.CLOSED:
+                self.model.send_runtime_error("runtime_abort_failed", exc)
+
+    def _cancel_pending_input(self, *, reason: str) -> None:
+        session = self.session
+        cancelled = session.cancel_pending_input()
+        helpers.advance_barge_in_epoch(session)
+        self.emit(
+            {
+                "type": "input.cancelled",
+                "session_id": session.session_id,
+                "reason": reason,
+                "epoch": session.epoch,
+                "cancelled": cancelled,
+            }
+        )
+
+    # ------------------------------------------------------------------ #
+    # Commit / response.create                                           #
+    # ------------------------------------------------------------------ #
+
+    def _apply_response_create_options(self, response_payload: dict[str, object]) -> str | None:
+        session = self.session
+        try:
+            options = ResponseCreateOptions.from_realtime(
+                response_payload,
+                private_runtime_config_keys=self.plugin.private_runtime_config_keys,
+            )
+        except DuplexConfigError as exc:
+            return exc.code
+        try:
+            session.reserve_response_options(options)
+        except Exception:
+            return "response_already_active"
+        return None
+
+    async def _flush_and_submit_committed_turn(
+        self,
+        event: dict[str, object],
+        *,
+        event_type: str,
+        realtime_item_id: object,
+        should_create_response: bool,
+    ) -> bool:
+        """Flush the buffered turn and submit it, with no response yet running.
+
+        Returns whether the turn was flushed. An empty buffer falls through to
+        the bare acknowledgement at the end of ``_on_commit``.
+        """
+        session = self.session
+        model_state = self.model_state
+        commit_reservation = (
+            model_state.audio_buffer.prepare_commit(
+                operation_id=uuid.uuid4().hex,
+                chunk_period_ms=session.capabilities.chunk_period_ms or 1000,
+            )
+            if event_type in {"input.commit", "input_audio_buffer.commit"}
+            else None
+        )
+        flushed_buffer_reserved_bytes = model_state.audio_buffer.pending_byte_count if commit_reservation is None else 0
+        flushed = (
+            commit_reservation.payload
+            if commit_reservation is not None
+            else model_state.audio_buffer.flush(chunk_period_ms=session.capabilities.chunk_period_ms or 1000)
+        )
+        if model_state.committed_audio_payload is not None:
+            if flushed is not None:
+                flushed = overlap_policy.merge_audio_payloads(model_state.committed_audio_payload, flushed)
+            else:
+                flushed = model_state.committed_audio_payload
+        if commit_reservation is not None:
+            commit_reservation.commit()
+        if flushed is None:
+            return False
+        if overlap_policy.should_force_listen_for_short_commit(self.session, event, flushed):
+            flushed = dict(flushed)
+            flushed["force_listen"] = True
+        model_state.input_since_commit = False
+        committed = helpers.commit_audio_input(
+            session,
+            realtime_item_id=realtime_item_id,
+            transcript=event.get("transcript"),
+        )
+        self.emit(
+            helpers.audio_committed_payload(
+                session,
+                committed=committed,
+                realtime_item_id=realtime_item_id,
+                transcript=event.get("transcript"),
+            )
+        )
+        operation_id = commit_reservation.operation_id if commit_reservation is not None else uuid.uuid4().hex
+        reserved_bytes = (
+            commit_reservation.byte_count if commit_reservation is not None else flushed_buffer_reserved_bytes
+        )
+        model_state.retain_committed_audio(flushed, operation_id=operation_id, reserved_bytes=reserved_bytes)
+        if should_create_response:
+            await self._start_append(
+                flushed,
+                final=True,
+                precreate_response=True,
+                operation_id=model_state.committed_audio_operation_id,
+                retained_committed_payload=flushed,
+            )
+        else:
+            model_state.deferred_response_create = False
+        return True
+
+    async def _start_response_from_committed_audio(self) -> None:
+        """Answer a client ``response.create``.
+
+        A turn starts from committed input. Audio is the usual kind, but the
+        Realtime protocol also lets a client build the turn out of
+        ``conversation.item.create`` and ask for a response with no audio at
+        all; those items are input too. A model-native session still generates
+        per audio unit, so an item-only turn is primed with the model's own
+        silence unit -- the one continuations already use -- rather than with
+        anything this layer invents.
+
+        Refused only when nothing is waiting, or a response is already running,
+        rather than silently producing an empty turn.
+        """
+        session = self.session
+        model_state = self.model_state
+        if (
+            helpers.response_in_progress(self.session, self.tasks)
+            or self.tasks.append_tasks
+            or self.run.stream_request_id is not None
+        ):
+            if session.active_response_id is None and (
+                session.active_request_id is not None
+                or self.tasks.append_tasks
+                or self.run.stream_request_id is not None
+            ):
+                return
+            self._emit_error(
+                "response_already_active", "response.create cannot start while another response is active."
+            )
+            session.discard_response_options()
+            return
+        if model_state.committed_audio_payload is not None:
+            committed_payload = model_state.committed_audio_payload
+            operation_id = model_state.committed_audio_operation_id
+            if operation_id is None:
+                operation_id = uuid.uuid4().hex
+                model_state.committed_audio_operation_id = operation_id
+            session.reset_unanswered_user_items()
+            await self._start_append(
+                committed_payload,
+                final=True,
+                precreate_response=True,
+                operation_id=operation_id,
+                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
+            # here: opening a response anyway produces one the model never
+            # fills, which the caller only discovers when the session idles
+            # out. Text reaches such a model through the seeded opening turn
+            # (``DuplexSessionConfig.initial_user_text``) instead.
+            self._emit_error(
+                "text_only_turn_unsupported",
+                "This duplex model answers speech input only. Seed the session with "
+                "initial_user_text to ask it in text."
+                if session.capabilities.supports_chat_completions
+                else "This duplex model answers speech input only.",
+            )
+            session.reset_unanswered_user_items()
+            session.discard_response_options()
+            return
+        self._emit_error(
+            "response_create_without_input",
+            "Duplex response.create requires committed audio to answer.",
+        )
+        session.discard_response_options()
+
+    def _discard_short_overlap_ack(self) -> None:
+        """Drop a sub-threshold interjection made while the model is speaking.
+
+        Too short to be a turn, so it neither interrupts the response nor
+        becomes one: the buffered audio is discarded and the turn stays with
+        the model.
+        """
+        session = self.session
+        model_state = self.model_state
+        model_state.audio_buffer.clear()
+        session.release_all_input_bytes()
+        model_state.input_since_commit = False
+        model_state.speech_since_commit = False
+        model_state.clear_committed_audio()
+        self._emit_events(discard_pending_input_audio(self._require_projector(), session.overlap_speech_ms))
+        self.emit(
+            {
+                "type": "input.committed",
+                "session_id": session.session_id,
+                "turn_id": session.turn_id,
+                "epoch": session.epoch,
+                "empty": True,
+                "is_speech": False,
+                "overlap_ack": True,
+                "no_response": True,
+            }
+        )
+        session.reset_overlap_speech()
+        session.discard_response_options()
+
+    def _defer_commit_behind_active_response(
+        self,
+        event: dict[str, object],
+        *,
+        realtime_item_id: object,
+        should_create_response: bool,
+        precreate_response_requested: bool,
+    ) -> bool:
+        """Retain a commit that arrived while a response is still running.
+
+        The audio is kept so the turn is not lost, and the response it should
+        start is remembered; ``_maybe_promote_deferred_overlap`` replays it once
+        the active response ends. Returns whether the commit was deferred --
+        an empty buffer has nothing to retain and falls through.
+        """
+        session = self.session
+        model_state = self.model_state
+        commit_reservation = model_state.audio_buffer.prepare_commit(
+            operation_id=uuid.uuid4().hex,
+            chunk_period_ms=session.capabilities.chunk_period_ms or 1000,
+        )
+        deferred_payload = commit_reservation.payload
+        if deferred_payload is None:
+            commit_reservation.commit()
+            return False
+        retained_payload: dict[str, object]
+        if model_state.committed_audio_payload is not None:
+            retained_payload = overlap_policy.merge_audio_payloads(
+                model_state.committed_audio_payload,
+                deferred_payload,
+            )
+        else:
+            retained_payload = deferred_payload
+        model_state.retain_committed_audio(
+            retained_payload,
+            operation_id=commit_reservation.operation_id,
+            reserved_bytes=commit_reservation.byte_count,
+        )
+        commit_reservation.commit()
+        model_state.deferred_response_create = should_create_response
+        model_state.deferred_precreate_response = precreate_response_requested
+        model_state.input_since_commit = False
+        model_state.speech_since_commit = False
+        committed = helpers.commit_audio_input(
+            session,
+            realtime_item_id=realtime_item_id,
+            transcript=event.get("transcript"),
+        )
+        committed_payload = helpers.audio_committed_payload(
+            session,
+            committed=committed,
+            realtime_item_id=realtime_item_id,
+            transcript=event.get("transcript"),
+        )
+        committed_payload["overlap_deferred"] = True
+        committed_payload["response_create_deferred"] = should_create_response
+        self.emit(committed_payload)
+        return True
+
+    async def _commit_and_start_auto_response(self, event: dict[str, object], *, realtime_item_id: object) -> None:
+        """Commit the buffered turn and submit it, letting the model answer it."""
+        session = self.session
+        model_state = self.model_state
+        commit_reservation = model_state.audio_buffer.prepare_commit(
+            operation_id=uuid.uuid4().hex,
+            chunk_period_ms=session.capabilities.chunk_period_ms or 1000,
+        )
+        final_payload = commit_reservation.payload
+        if model_state.committed_audio_payload is not None:
+            if final_payload is not None:
+                final_payload = overlap_policy.merge_audio_payloads(model_state.committed_audio_payload, final_payload)
+            else:
+                final_payload = model_state.committed_audio_payload
+        commit_reservation.commit()
+        if final_payload is not None:
+            model_state.retain_committed_audio(
+                final_payload,
+                operation_id=commit_reservation.operation_id,
+                reserved_bytes=commit_reservation.byte_count,
+            )
+        model_state.deferred_response_create = False
+        model_state.input_since_commit = False
+        model_state.speech_since_commit = False
+        data_plane_turn_id = session.turn_id
+        committed = helpers.commit_audio_input(
+            session,
+            realtime_item_id=realtime_item_id,
+            transcript=event.get("transcript"),
+            turn_id=data_plane_turn_id,
+        )
+        self.emit(
+            helpers.audio_committed_payload(
+                session,
+                committed=committed,
+                realtime_item_id=realtime_item_id,
+                transcript=event.get("transcript"),
+            )
+        )
+        if final_payload is not None:
+            await self._start_append(
+                {**final_payload, "duplex_turn_id": data_plane_turn_id},
+                final=True,
+                precreate_response=False,
+                operation_id=commit_reservation.operation_id,
+                retained_committed_payload=final_payload,
+            )
+
+    def _commit_silent_input(self) -> None:
+        """Commit a turn the client itself marked as silence: drop it and keep listening."""
+        session = self.session
+        model_state = self.model_state
+        model_state.input_since_commit = False
+        model_state.speech_since_commit = False
+        model_state.audio_buffer.clear()
+        session.release_all_input_bytes()
+        model_state.clear_committed_audio()
+        self.emit(
+            {
+                "type": "input.committed",
+                "session_id": session.session_id,
+                "turn_id": session.turn_id,
+                "epoch": session.epoch,
+                "empty": True,
+                "is_speech": False,
+                "no_response": True,
+            }
+        )
+        self.emit(
+            {
+                "type": "response.listen",
+                "session_id": session.session_id,
+                "epoch": session.epoch,
+                "reason": "silence_or_noise",
+            }
+        )
+
+    async def _on_commit(self, event: dict[str, object]) -> None:
+        session = self.session
+        model_state = self.model_state
+        event_type = str(event.get("type"))
+        realtime_item_id = event.get("realtime_item_id")
+        realtime_validated_audio_commit = (
+            event_type == "input_audio_buffer.commit" and isinstance(realtime_item_id, str) and bool(realtime_item_id)
+        )
+        if event_type in {"input.commit", "input_audio_buffer.commit"} and not await self._wait_for_append_tail():
+            # resolve_commit has already applied this commit's side effects
+            # (speech_stopped emitted, input flags cleared), so returning
+            # silently leaves the client with those effects, no
+            # input_audio_buffer.committed and no error. The session.update
+            # path says so explicitly; this one now does too.
+            self._emit_error(
+                "commit_aborted",
+                "the commit was not applied because the preceding append failed",
+                event_id=event.get("realtime_event_id"),
+            )
+            return
+        if event_type == "input_audio_buffer.commit" and event.get("is_speech") is False:
+            self._commit_silent_input()
+            return
+        should_create_response = (
+            event_type == "response.create"
+            or bool(event.get("response_create", event_type == "input.commit"))
+            or (event_type == "input_audio_buffer.commit" and self._session_auto_responds())
+        )
+        precreate_response_requested = event_type == "response.create" or bool(
+            event.get("response_create", event_type == "input.commit")
+        )
+        if event_type == "response.create":
+            response_payload = event.get("response")
+            if isinstance(response_payload, dict):
+                response_options_error = self._apply_response_create_options(response_payload)
+                if response_options_error is not None:
+                    error_message = (
+                        "The selected native duplex runtime does not support generation "
+                        "overrides for instructions, voice, temperature, max tokens, tools, or "
+                        "tool_choice."
+                        if response_options_error == "unsupported_native_response_options"
+                        else "response.create cannot reserve options while another response is active."
+                    )
+                    self._emit_error(response_options_error, error_message, event_id=event.get("realtime_event_id"))
+                    return
+        if event_type == "input_audio_buffer.commit":
+            has_pending_audio = (
+                model_state.input_since_commit
+                or model_state.audio_buffer.has_pending()
+                or model_state.committed_audio_payload is not None
+                or realtime_validated_audio_commit
+            )
+            if not has_pending_audio and not self.tasks.append_tasks and self.run.stream_request_id is None:
+                self._emit_error(
+                    "input_audio_buffer_empty", "input_audio_buffer.commit requires a non-empty input audio buffer."
+                )
+                return
+            commit_action = decide_commit_action(
+                CommitSnapshot(
+                    auto_responds=self._session_auto_responds(),
+                    speech_since_commit=model_state.speech_since_commit,
+                    active_response_id=session.active_response_id,
+                    overlap_speech_ms=session.overlap_speech_ms,
+                    response_in_progress=helpers.response_in_progress(self.session, self.tasks),
+                    playback_active=helpers.assistant_playback_active(self.session),
+                )
+            )
+            if commit_action is CommitAction.DEFER_ACTIVE_RESPONSE:
+                if session.overlap_speech_ms <= session.config.overlap_short_ack_ms:
+                    self._discard_short_overlap_ack()
+                    return
+
+                if self._defer_commit_behind_active_response(
+                    event,
+                    realtime_item_id=realtime_item_id,
+                    should_create_response=should_create_response,
+                    precreate_response_requested=precreate_response_requested,
+                ):
+                    return
+            if commit_action is CommitAction.START_AUTO_RESPONSE:
+                await self._commit_and_start_auto_response(event, realtime_item_id=realtime_item_id)
+                return
+        if event_type == "response.create":
+            await self._start_response_from_committed_audio()
+            return
+        if not helpers.response_in_progress(self.session, self.tasks) and await self._flush_and_submit_committed_turn(
+            event,
+            event_type=event_type,
+            realtime_item_id=realtime_item_id,
+            should_create_response=should_create_response,
+        ):
+            return
+        # Nothing flushed (or a response is still in progress): acknowledge the
+        # commit without starting a new response.
+        had_uncommitted_audio = (
+            model_state.input_since_commit
+            or model_state.audio_buffer.has_pending()
+            or model_state.committed_audio_payload is not None
+            or realtime_validated_audio_commit
+        )
+        committed = None
+        if event_type in {"input_audio_buffer.commit", "input.commit"}:
+            model_state.input_since_commit = False
+            model_state.speech_since_commit = False
+        if event_type != "response.create":
+            committed = (
+                helpers.commit_audio_input(
+                    session,
+                    realtime_item_id=realtime_item_id,
+                    transcript=event.get("transcript"),
+                )
+                if had_uncommitted_audio
+                else None
+            )
+            self.emit(
+                helpers.audio_committed_payload(
+                    session,
+                    committed=committed,
+                    realtime_item_id=realtime_item_id,
+                    transcript=event.get("transcript"),
+                )
+            )
+            return
+        if committed is not None:
+            if isinstance(realtime_item_id, str):
+                session.register_history_item(realtime_item_id, committed.message)
+            self.emit(helpers.input_committed_payload(session, committed, realtime_item_id=realtime_item_id))
+        # NOTE(refactor): the old generic chat-completion fallback response
+        # (`_run_response`) is gone; a native session with a response already in
+        # progress only acknowledges the commit here.
+
+    # ------------------------------------------------------------------ #
+    # playback.ack (moved from OmniDuplexSessionHandler)                 #
+    # ------------------------------------------------------------------ #
+
+
+__all__ = ["DuplexSessionRunner"]
diff --git a/vllm_omni/engine/duplex/turn_detection.py b/vllm_omni/engine/duplex/turn_detection.py
new file mode 100644
index 000000000..6c5c84f8a
--- /dev/null
+++ b/vllm_omni/engine/duplex/turn_detection.py
@@ -0,0 +1,301 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Server-side turn detection (``turn_detection: server_vad``) for the session runner.
+
+Moved from the Realtime input translator: the runner owns one
+``ServerTurnDetector`` per session, feeds each appended chunk to it and emits
+``input_audio_buffer.speech_started`` / ``speech_stopped`` from the result.
+The two-phase ``session.update`` commit (prepare / commit / reject) that used
+to live on the translator is expressed by :class:`PendingTurnDetectionUpdate`.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+
+import numpy as np
+
+from vllm_omni.engine.duplex.vad import (
+    SILERO_VAD_MIN_THRESHOLD,
+    ServerVADUnavailableError,
+    SileroStreamingVAD,
+    SileroVADBackendProvider,
+    SileroVADConfig,
+    StreamingVADResult,
+)
+
+__all__ = [
+    "PendingTurnDetectionUpdate",
+    "SileroVADBackendProvider",
+    "ServerTurnDetector",
+    "ServerVADUnavailableError",
+    "TurnDetectionConfig",
+    "TurnDetectionResult",
+    "apply_turn_detection_result",
+    "configured_realtime_turn_detection",
+    "normalize_turn_detection_session_payload",
+    "validate_realtime_turn_detection",
+]
+
+
+def configured_realtime_turn_detection(session_payload: Mapping[str, object]) -> tuple[str | None, object]:
+    """Return ``(field_path, value)`` for the turn detection setting present in the payload."""
+    field = "turn_detection" if "turn_detection" in session_payload else None
+    selected = session_payload.get("turn_detection")
+    audio_config = session_payload.get("audio")
+    if isinstance(audio_config, dict):
+        audio_input = audio_config.get("input")
+        if isinstance(audio_input, dict) and "turn_detection" in audio_input:
+            field, selected = "audio.input.turn_detection", audio_input["turn_detection"]
+    return field, selected
+
+
+def _valid_vad_number(value: object, *, minimum: float, maximum: float | None = None, strict: bool = False) -> bool:
+    return (
+        isinstance(value, int | float)
+        and not isinstance(value, bool)
+        and np.isfinite(float(value))
+        and (float(value) > minimum if strict else float(value) >= minimum)
+        and (maximum is None or float(value) <= maximum)
+    )
+
+
+#: Every field a ``server_vad`` object may carry. Unknown keys are refused
+#: rather than ignored: a misspelled tuning knob that silently does nothing is
+#: worse than a rejected session, because the endpointing still *looks* applied.
+_SERVER_VAD_FIELDS = frozenset(
+    {
+        "type",
+        "threshold",
+        "prefix_padding_ms",
+        "silence_duration_ms",
+        "create_response",
+        "interrupt_response",
+        "min_speech_duration_ms",
+    }
+)
+
+
+def validate_realtime_turn_detection(session_payload: Mapping[str, object]) -> str | None:
+    """Validate the ``turn_detection`` object of a Realtime session payload (None when valid)."""
+    field, turn_detection = configured_realtime_turn_detection(session_payload)
+    if field is None:
+        if session_payload.get("overlap_policy") == "barge_in_on_speech":
+            return (
+                "overlap_policy='barge_in_on_speech' requires turn_detection.type='server_vad' on the Realtime endpoint"
+            )
+        return None
+    if turn_detection is not None and not isinstance(turn_detection, dict):
+        return f"{field} must be null or an object with type='server_vad'"
+    if isinstance(turn_detection, dict):
+        if turn_detection.get("type") != "server_vad":
+            return f"{field}.type must be 'server_vad'"
+        unknown = sorted(set(turn_detection) - _SERVER_VAD_FIELDS)
+        if unknown:
+            return f"Unknown {field} field(s): {', '.join(unknown)}"
+        threshold = turn_detection.get("threshold", 0.5)
+        if not _valid_vad_number(threshold, minimum=SILERO_VAD_MIN_THRESHOLD, strict=True, maximum=1):
+            return f"{field}.threshold must be greater than {SILERO_VAD_MIN_THRESHOLD} and at most 1"
+        for name in ("prefix_padding_ms", "silence_duration_ms", "min_speech_duration_ms"):
+            value = turn_detection.get(name)
+            if value is not None and not _valid_vad_number(value, minimum=0):
+                return f"{field}.{name} must be a non-negative number"
+        if turn_detection.get("interrupt_response", True) is not True:
+            return (
+                f"{field}.interrupt_response=false is unsupported; use turn_detection=null for model-owned listen/speak"
+            )
+    desired_policy = "barge_in_on_speech" if turn_detection is not None else "listen_only"
+    overlap_policy = session_payload.get("overlap_policy")
+    if isinstance(overlap_policy, str) and overlap_policy != desired_policy:
+        return f"overlap_policy={overlap_policy!r} conflicts with turn_detection; expected {desired_policy!r}"
+    return None
+
+
+@dataclass(frozen=True, slots=True)
+class TurnDetectionConfig:
+    """Normalized ``server_vad`` configuration (all fields filled with defaults)."""
+
+    threshold: float = 0.5
+    prefix_padding_ms: int = 300
+    silence_duration_ms: int = 500
+    min_speech_duration_ms: int = 96
+    create_response: bool = True
+    interrupt_response: bool = True
+
+    @classmethod
+    def from_realtime(cls, turn_detection: Mapping[str, object]) -> TurnDetectionConfig:
+        return cls(
+            threshold=float(turn_detection.get("threshold", 0.5)),
+            prefix_padding_ms=int(turn_detection.get("prefix_padding_ms", 300)),
+            silence_duration_ms=int(turn_detection.get("silence_duration_ms", 500)),
+            min_speech_duration_ms=int(turn_detection.get("min_speech_duration_ms", 96)),
+            create_response=bool(turn_detection.get("create_response", True)),
+            interrupt_response=bool(turn_detection.get("interrupt_response", True)),
+        )
+
+    @property
+    def overlap_policy(self) -> str:
+        return "barge_in_on_speech"
+
+    def build_detector(self, backend_provider: SileroVADBackendProvider | None = None) -> ServerTurnDetector:
+        return ServerTurnDetector(self, backend_provider=backend_provider)
+
+
+def normalize_turn_detection_session_payload(
+    session_payload: dict[str, object],
+) -> tuple[bool, TurnDetectionConfig | None]:
+    """Fill ``turn_detection`` defaults and derive ``overlap_policy`` in place.
+
+    Returns ``(configured, config)`` where ``configured`` is False when the
+    payload does not mention turn detection at all (nothing changes), and
+    ``config`` is ``None`` for ``turn_detection: null`` (model-owned turns,
+    ``overlap_policy`` forced to ``listen_only``).
+    """
+    field, configured = configured_realtime_turn_detection(session_payload)
+    if field is None:
+        return False, None
+    if configured is None:
+        session_payload["overlap_policy"] = "listen_only"
+        return True, None
+    assert isinstance(configured, dict)
+    merged = {
+        "type": "server_vad",
+        "interrupt_response": True,
+        "threshold": 0.5,
+        "prefix_padding_ms": 300,
+        "silence_duration_ms": 500,
+        "min_speech_duration_ms": 96,
+        **configured,
+    }
+    config = TurnDetectionConfig.from_realtime(merged)
+    session_payload["turn_detection"] = dict(merged)
+    session_payload["overlap_policy"] = config.overlap_policy
+    return True, config
+
+
+@dataclass(frozen=True, slots=True)
+class TurnDetectionResult:
+    is_speech: bool
+    speech_active: bool
+    speech_started: bool = False
+    speech_stopped: bool = False
+    speech_probability: float = 0.0
+    audio_start_ms: int | None = None
+    audio_end_ms: int | None = None
+    #: A ``speech_stopped`` under ``server_vad`` ends the user turn.
+    should_commit: bool = False
+    #: Whether the auto-commit should also request a response (``create_response``).
+    create_response: bool = True
+
+    def as_payload(self) -> dict[str, object]:
+        return {
+            "backend": "silero",
+            "is_speech": self.is_speech,
+            "speech_active": self.speech_active,
+            "speech_started": self.speech_started,
+            "speech_stopped": self.speech_stopped,
+            "speech_probability": self.speech_probability,
+        }
+
+
+class ServerTurnDetector:
+    """One Silero-backed streaming detector per session."""
+
+    def __init__(
+        self,
+        config: TurnDetectionConfig,
+        *,
+        backend_provider: SileroVADBackendProvider | None = None,
+    ) -> None:
+        self.config = config
+        self._vad = SileroStreamingVAD(
+            SileroVADConfig(
+                threshold=float(config.threshold),
+                prefix_padding_ms=int(config.prefix_padding_ms),
+                silence_duration_ms=int(config.silence_duration_ms),
+                min_speech_duration_ms=max(32, int(config.min_speech_duration_ms)),
+            ),
+            backend_provider=backend_provider,
+        )
+
+    @property
+    def vad(self) -> SileroStreamingVAD:
+        return self._vad
+
+    def reset(self) -> None:
+        self._vad.reset()
+
+    def process(
+        self,
+        base64_audio: str,
+        *,
+        fmt: str,
+        sample_rate_hz: int | None,
+        audio_end_ms: int | None = None,
+    ) -> TurnDetectionResult:
+        """Score one appended chunk. Raises ``ServerVADUnavailableError`` / ``ValueError`` like the VAD."""
+        result: StreamingVADResult = self._vad.process_base64(base64_audio, fmt=fmt, sample_rate_hz=sample_rate_hz)
+        stop_ms = result.speech_end_ms if result.speech_end_ms is not None else audio_end_ms
+        return TurnDetectionResult(
+            is_speech=result.is_speech,
+            speech_active=result.speech_active,
+            speech_started=result.speech_started,
+            speech_stopped=result.speech_stopped,
+            speech_probability=result.speech_probability,
+            audio_start_ms=result.speech_start_ms,
+            audio_end_ms=stop_ms,
+            should_commit=bool(result.speech_stopped and not result.speech_active),
+            create_response=self.config.create_response,
+        )
+
+
+def apply_turn_detection_result(payload: dict[str, object], result: TurnDetectionResult) -> None:
+    """Merge a detector result onto an internal ``input_audio_buffer.append`` payload.
+
+    Mirrors what the old translator attached: ``is_speech`` from the detector,
+    the ``vad`` hint block, and ``force_listen`` while speech is active.
+    """
+    payload["is_speech"] = result.is_speech
+    payload["vad"] = result.as_payload()
+    if result.speech_active:
+        payload["force_listen"] = True
+    if result.audio_start_ms is not None and result.speech_started:
+        payload["audio_start_ms"] = result.audio_start_ms
+    if result.audio_end_ms is not None and result.speech_stopped:
+        payload["audio_end_ms"] = result.audio_end_ms
+
+
+@dataclass
+class PendingTurnDetectionUpdate:
+    """A ``session.update`` turn-detection change awaiting the engine ACK (two-phase)."""
+
+    config: TurnDetectionConfig | None
+    detector: ServerTurnDetector | None
+
+    @classmethod
+    def prepare(
+        cls,
+        session_payload: dict[str, object],
+        *,
+        backend_provider: SileroVADBackendProvider | None = None,
+    ) -> PendingTurnDetectionUpdate | None:
+        """Normalize the payload in place and stage the new detector; None when not configured."""
+        configured, config = normalize_turn_detection_session_payload(session_payload)
+        if not configured:
+            return None
+        detector = config.build_detector(backend_provider) if config is not None else None
+        return cls(config=config, detector=detector)
+
+    def commit(
+        self, current: ServerTurnDetector | None
+    ) -> tuple[TurnDetectionConfig | None, ServerTurnDetector | None]:
+        """Adopt the staged detector; the replaced one is reset. Returns the new (config, detector)."""
+        if current is not None:
+            current.reset()
+        return self.config, self.detector
+
+    def reject(self) -> None:
+        if self.detector is not None:
+            self.detector.reset()
diff --git a/vllm_omni/engine/duplex/vad.py b/vllm_omni/engine/duplex/vad.py
new file mode 100644
index 000000000..9c19c4355
--- /dev/null
+++ b/vllm_omni/engine/duplex/vad.py
@@ -0,0 +1,494 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Silero server VAD for the engine-resident duplex session.
+
+The detector keeps the split upstream's serving-side ``server_vad`` module
+used, because the split is what makes one model serve many sessions: a
+**backend** scores one 512-sample frame and is otherwise stateless, and the
+per-stream state -- the partial frame, the model state, the endpoint counters --
+belongs to :class:`SileroStreamingVAD`, one per session.
+
+Two backends. :class:`SileroVADBackend` runs the pinned Silero v6.2 ONNX graph on
+CPU and is shared process-wide, which is why its state is passed in and out
+rather than held on the session object. :class:`TorchSileroBackend` loads the
+same model through the ``silero-vad`` package for environments that have no
+local ONNX artifact; torch keeps its state inside the module, so that one is per
+session.
+
+Endpointing follows Silero v6.2's streaming hysteresis: activation uses the
+configured threshold, while a turn can only *end* on frames below
+``max(threshold - 0.15, 0.01)``. Once a silence candidate exists, louder frames
+keep the elapsed-silence clock running but cannot themselves close the turn.
+"""
+
+from __future__ import annotations
+
+import binascii
+import hashlib
+import threading
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Protocol
+
+import numpy as np
+import pybase64 as base64
+from vllm.logger import init_logger
+
+logger = init_logger(__name__)
+
+SILERO_VAD_REPO_ID = "istupakov/silero-vad-onnx"
+SILERO_VAD_REVISION = "8b14476858ef240c50b3884bb38cc67290c1cc70"
+SILERO_VAD_FILENAME = "silero_vad.onnx"
+SILERO_VAD_SHA256 = "1a153a22f4509e292a94e67d6f9b85e8deb25b4988682b7e174c65279d8788e3"
+SILERO_VAD_MIN_THRESHOLD = 0.15
+
+_SAMPLE_RATE_HZ = 16_000
+_FRAME_SAMPLES = 512
+
+
+class ServerVADUnavailableError(RuntimeError):
+    pass
+
+
+@dataclass(frozen=True, slots=True)
+class SileroVADConfig:
+    threshold: float = 0.5
+    prefix_padding_ms: int = 300
+    silence_duration_ms: int = 500
+    min_speech_duration_ms: int = 96
+
+
+@dataclass(frozen=True, slots=True)
+class StreamingVADResult:
+    is_speech: bool
+    speech_active: bool
+    speech_started: bool = False
+    speech_stopped: bool = False
+    speech_probability: float = 0.0
+    speech_start_ms: int | None = None
+    speech_end_ms: int | None = None
+
+
+# --------------------------------------------------------------------------- #
+# Backends                                                                    #
+# --------------------------------------------------------------------------- #
+
+
+class SpeechDetectorBackend(Protocol):
+    """Scores one frame. Per-stream state is created here but owned by the caller."""
+
+    frame_samples: int
+
+    def new_state(self) -> object: ...
+
+    def infer(self, frame: np.ndarray, state: object) -> tuple[float, object]: ...
+
+
+@dataclass(frozen=True, slots=True)
+class _SileroVADState:
+    model_state: np.ndarray
+    context: np.ndarray
+
+
+class SileroVADBackend:
+    """Shared ONNX Runtime Silero v6.2 detector running on CPU."""
+
+    sample_rate_hz = _SAMPLE_RATE_HZ
+    frame_samples = _FRAME_SAMPLES
+    context_samples = 64
+    model_state_shape = (2, 1, 128)
+
+    def __init__(self, model_path: str | Path) -> None:
+        try:
+            import onnxruntime as ort
+        except ImportError as exc:  # pragma: no cover - platform packaging supplies ORT.
+            raise ServerVADUnavailableError("server_vad requires ONNX Runtime") from exc
+
+        session_options = ort.SessionOptions()
+        session_options.inter_op_num_threads = 1
+        session_options.intra_op_num_threads = 1
+
+        self.model_path = Path(model_path)
+        self._session = ort.InferenceSession(
+            str(self.model_path),
+            providers=["CPUExecutionProvider"],
+            sess_options=session_options,
+        )
+        input_names = {item.name for item in self._session.get_inputs()}
+        if not {"input", "sr", "state"} <= input_names:
+            raise ServerVADUnavailableError(f"Unsupported Silero ONNX input contract: {sorted(input_names)}")
+        self._warm_up()
+
+    def _warm_up(self) -> None:
+        self.infer(np.zeros(self.frame_samples, dtype=np.float32), self.new_state())
+
+    def new_state(self) -> _SileroVADState:
+        return _SileroVADState(
+            model_state=np.zeros(self.model_state_shape, dtype=np.float32),
+            context=np.zeros((1, self.context_samples), dtype=np.float32),
+        )
+
+    def infer(self, frame: np.ndarray, state: object) -> tuple[float, object]:
+        if not isinstance(state, _SileroVADState):
+            raise TypeError("Silero detector state must be created by SileroVADBackend.new_state()")
+        model_state = np.ascontiguousarray(state.model_state, dtype=np.float32)
+        context = np.ascontiguousarray(state.context, dtype=np.float32)
+        if model_state.shape != self.model_state_shape:
+            raise ValueError(f"Silero model state must have shape {self.model_state_shape}, got {model_state.shape}")
+        expected_context_shape = (1, self.context_samples)
+        if context.shape != expected_context_shape:
+            raise ValueError(f"Silero context must have shape {expected_context_shape}, got {context.shape}")
+
+        audio = np.ascontiguousarray(frame, dtype=np.float32).reshape(1, -1)
+        if audio.shape[1] != self.frame_samples:
+            raise ValueError(
+                f"Silero detector frame must contain exactly {self.frame_samples} samples, got {audio.shape[1]}"
+            )
+        model_input = np.concatenate((context, audio), axis=1)
+        # ONNX Runtime permits concurrent Run calls on one CPU session. Stream
+        # state is explicit, so independent sessions can safely share this one.
+        output = self._session.run(
+            None,
+            {
+                "input": model_input,
+                "state": model_state,
+                "sr": np.asarray(self.sample_rate_hz, dtype=np.int64),
+            },
+        )
+        if len(output) < 2:
+            raise ServerVADUnavailableError("Silero ONNX model did not return probability and model state")
+        probability = float(np.asarray(output[0]).reshape(-1)[0])
+        next_state = _SileroVADState(
+            model_state=np.ascontiguousarray(output[1], dtype=np.float32),
+            context=np.ascontiguousarray(model_input[:, -self.context_samples :], dtype=np.float32),
+        )
+        return probability, next_state
+
+
+class TorchSileroBackend:
+    """The same model through the ``silero-vad`` package, for hosts with no ONNX artifact.
+
+    Torch keeps the recurrent state inside the module, so unlike the ONNX
+    backend this one cannot be shared: each session gets its own instance and
+    ``new_state`` only resets it.
+    """
+
+    sample_rate_hz = _SAMPLE_RATE_HZ
+    frame_samples = _FRAME_SAMPLES
+
+    def __init__(self) -> None:
+        try:
+            import torch
+            from silero_vad import load_silero_vad
+        except ImportError as exc:
+            raise ServerVADUnavailableError(
+                "server_vad needs either a local Silero ONNX artifact (see "
+                "duplex_session.server_vad_model_path) or the optional 'silero-vad' "
+                "package; install vllm-omni[server-vad]"
+            ) from exc
+        self._torch = torch
+        self._model = load_silero_vad(onnx=False)
+
+    def new_state(self) -> object:
+        reset_states = getattr(self._model, "reset_states", None)
+        if callable(reset_states):
+            reset_states()
+        return None
+
+    def infer(self, frame: np.ndarray, state: object) -> tuple[float, object]:
+        tensor = self._torch.from_numpy(np.ascontiguousarray(frame, dtype=np.float32))
+        return float(self._model(tensor, self.sample_rate_hz).item()), state
+
+
+class SileroVADBackendProvider:
+    """Resolve, verify and load one detector backend per engine process.
+
+    ONNX is preferred and shared; the torch package is the fallback and is built
+    per call because its state is internal.
+    """
+
+    def __init__(self, *, model_path: str | None = None) -> None:
+        self.model_path = model_path
+        self._backend: SileroVADBackend | None = None
+        self._lock = threading.Lock()
+
+    def get(self) -> SpeechDetectorBackend:
+        """The shared ONNX backend, or a per-session torch one when it cannot be built.
+
+        An explicitly configured ``server_vad_model_path`` never falls back: the
+        operator named that artifact, so a missing file or a missing ONNX Runtime
+        is their error, not something to paper over with a different model.
+        """
+        if self._backend is not None:
+            return self._backend
+        with self._lock:
+            if self._backend is not None:
+                return self._backend
+            path = self._resolve_local_artifact()
+            if path is None:
+                # No pinned artifact: the torch package keeps state internally,
+                # so this instance belongs to one session only.
+                return TorchSileroBackend()
+            self._verify_checksum(path)
+            try:
+                self._backend = SileroVADBackend(path)
+            except ServerVADUnavailableError:
+                if self.model_path:
+                    raise
+                logger.warning(
+                    "Silero ONNX artifact %s found but ONNX Runtime is unavailable; "
+                    "falling back to the torch 'silero-vad' package (one model per session)",
+                    path,
+                )
+                return TorchSileroBackend()
+        return self._backend
+
+    def _resolve_local_artifact(self) -> Path | None:
+        if self.model_path:
+            path = Path(self.model_path).expanduser()
+            if path.is_file():
+                return path
+            # Explicitly configured: a missing file is an error, not a fallback.
+            raise ServerVADUnavailableError(f"Configured Silero VAD model does not exist: {path}")
+        try:
+            from vllm.transformers_utils.repo_utils import try_get_local_file
+
+            cached = try_get_local_file(
+                model=SILERO_VAD_REPO_ID,
+                file_name=SILERO_VAD_FILENAME,
+                revision=SILERO_VAD_REVISION,
+            )
+        except Exception:
+            return None
+        return cached if isinstance(cached, Path) and cached.is_file() else None
+
+    def _verify_checksum(self, path: Path) -> None:
+        digest = hashlib.sha256(path.read_bytes()).hexdigest()
+        if digest != SILERO_VAD_SHA256:
+            raise ServerVADUnavailableError(
+                f"Silero VAD checksum mismatch for {path}: expected {SILERO_VAD_SHA256}, got {digest}"
+            )
+
+
+# --------------------------------------------------------------------------- #
+# Per-session streaming detector                                              #
+# --------------------------------------------------------------------------- #
+
+
+class SileroStreamingVAD:
+    _SAMPLE_RATE_HZ = _SAMPLE_RATE_HZ
+    _WINDOW_SAMPLES = _FRAME_SAMPLES
+
+    def __init__(
+        self,
+        config: SileroVADConfig,
+        *,
+        backend: SpeechDetectorBackend | None = None,
+        backend_provider: SileroVADBackendProvider | None = None,
+        frame_scorer: Callable[[np.ndarray], float] | None = None,
+    ) -> None:
+        self.config = config
+        self._explicit_backend = backend
+        self._provider = backend_provider
+        self._frame_scorer = frame_scorer
+        self._backend: SpeechDetectorBackend | None = backend
+        self._detector_state: object = None
+        self._clear_stream_state()
+
+    def _clear_stream_state(self) -> None:
+        self._pending = np.empty(0, dtype=np.float32)
+        self._speech_active = False
+        self._candidate_samples = 0
+        self._candidate_start_sample: int | None = None
+        self._silence_samples = 0
+        self._processed_samples = 0
+        self._stream_start_ms = 0
+        self._resample_rate_hz: int | None = None
+        self._resample_remainder = 0
+
+    @property
+    def scratch_bytes(self) -> int:
+        """Bytes this detector holds between chunks (the partial frame only)."""
+        return int(self._pending.nbytes)
+
+    @property
+    def speech_active(self) -> bool:
+        return self._speech_active
+
+    def reset(self) -> None:
+        """Drop stream state while preserving the session-relative audio clock.
+
+        The clock survives so ``speech_start_ms`` after a barge-in still refers
+        to the session's timeline; ``_stream_start_ms`` then stops the prefix
+        padding reaching back into audio that was discarded.
+        """
+        stream_start_ms = round(self._processed_samples * 1000 / self._SAMPLE_RATE_HZ)
+        processed = self._processed_samples
+        self._clear_stream_state()
+        self._processed_samples = processed
+        self._stream_start_ms = stream_start_ms
+        if self._backend is not None:
+            self._detector_state = self._backend.new_state()
+
+    # ------------------------------------------------------------------ #
+    # Input                                                              #
+    # ------------------------------------------------------------------ #
+
+    def process_base64(
+        self,
+        audio: object,
+        *,
+        fmt: object,
+        sample_rate_hz: object,
+    ) -> StreamingVADResult:
+        if not isinstance(audio, str):
+            raise ValueError("Silero server VAD requires base64 audio")
+        try:
+            raw = base64.b64decode(audio, validate=True)
+        except (binascii.Error, ValueError) as exc:
+            raise ValueError("Silero server VAD received invalid base64 audio") from exc
+        rate = int(sample_rate_hz) if isinstance(sample_rate_hz, int | float) else self._SAMPLE_RATE_HZ
+        if rate <= 0:
+            raise ValueError("Silero server VAD requires a positive sample rate")
+
+        if fmt == "pcm_f32le":
+            if len(raw) % 4:
+                raise ValueError("Silero server VAD received an incomplete pcm_f32le frame")
+            samples = np.frombuffer(raw, dtype="<f4").astype(np.float32, copy=False)
+        elif fmt == "pcm16":
+            if len(raw) % 2:
+                raise ValueError("Silero server VAD received an incomplete pcm16 sample")
+            samples = np.frombuffer(raw, dtype="<i2").astype(np.float32) * np.float32(1.0 / 32768.0)
+        else:
+            raise ValueError("Silero server VAD requires pcm_f32le or pcm16 audio")
+
+        return self.process(self._to_16k(samples, rate))
+
+    def _to_16k(self, samples: np.ndarray, rate: int) -> np.ndarray:
+        """Resample to 16 kHz, carrying the fractional sample-count remainder.
+
+        A fallback path: the session runner already normalises input to 16 kHz
+        through ``convert_input_audio_with_rate`` before the detector sees it,
+        so this runs only for callers that feed the VAD directly.
+
+        Carrying the remainder keeps the *number* of output samples exact, so
+        frame boundaries cannot drift over a long stream. The interpolation
+        itself is per chunk and has no filter state, so sample values near a
+        chunk edge differ slightly from resampling the same audio in one go --
+        enough for the frame grid to stay put, not enough to call it a
+        streaming resampler.
+        """
+        if rate == self._SAMPLE_RATE_HZ:
+            self._resample_rate_hz = None
+            self._resample_remainder = 0
+            return samples
+        if self._resample_rate_hz is not None and rate != self._resample_rate_hz:
+            raise ValueError("server_vad input sample rate cannot change within a continuous audio stream")
+        self._resample_rate_hz = rate
+        numerator = samples.size * self._SAMPLE_RATE_HZ + self._resample_remainder
+        target_size, self._resample_remainder = divmod(numerator, rate)
+        if target_size == 0:
+            return np.empty(0, dtype=np.float32)
+        if samples.size == 1:
+            return np.full(target_size, samples[0], dtype=np.float32)
+        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)
+        return np.interp(target_x, source_x, samples).astype(np.float32)
+
+    # ------------------------------------------------------------------ #
+    # Endpointing                                                        #
+    # ------------------------------------------------------------------ #
+
+    def process(self, samples: np.ndarray) -> StreamingVADResult:
+        samples = np.asarray(samples, dtype=np.float32).reshape(-1)
+        if samples.size:
+            self._pending = np.concatenate((self._pending, samples))
+
+        started = False
+        stopped = False
+        start_ms: int | None = None
+        end_ms: int | None = None
+        max_probability = 0.0
+        contained_speech = self._speech_active
+        min_speech_samples = max(1, round(self.config.min_speech_duration_ms * self._SAMPLE_RATE_HZ / 1000))
+        min_silence_samples = max(1, round(self.config.silence_duration_ms * self._SAMPLE_RATE_HZ / 1000))
+        negative_threshold = max(self.config.threshold - SILERO_VAD_MIN_THRESHOLD, 0.01)
+
+        pending = self._pending
+        offset = 0
+        while pending.size - offset >= self._WINDOW_SAMPLES:
+            frame = np.ascontiguousarray(pending[offset : offset + self._WINDOW_SAMPLES], dtype=np.float32)
+            offset += self._WINDOW_SAMPLES
+            frame_start = self._processed_samples
+            self._processed_samples += self._WINDOW_SAMPLES
+            probability = min(1.0, max(0.0, self._score_frame(frame)))
+            max_probability = max(max_probability, probability)
+
+            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
+                # 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
+                self._speech_active = False
+                self._silence_samples = 0
+                stopped = True
+                # OpenAI defines audio_end_ms as the end of the audio sent to
+                # the model, trailing silence included.
+                end_ms = max(0, round(self._processed_samples * 1000 / self._SAMPLE_RATE_HZ))
+                continue
+
+            if probability >= self.config.threshold:
+                if self._candidate_samples == 0:
+                    self._candidate_start_sample = frame_start
+                self._candidate_samples += self._WINDOW_SAMPLES
+                if self._candidate_samples >= min_speech_samples:
+                    candidate_start = self._candidate_start_sample or 0
+                    detected_start_ms = round(candidate_start * 1000 / self._SAMPLE_RATE_HZ)
+                    self._speech_active = True
+                    self._candidate_samples = self._silence_samples = 0
+                    self._candidate_start_sample = None
+                    contained_speech = True
+                    started = True
+                    # Prefix audio from before the last reset is gone.
+                    start_ms = max(
+                        self._stream_start_ms,
+                        max(0, detected_start_ms - self.config.prefix_padding_ms),
+                    )
+            else:
+                self._candidate_samples = 0
+                self._candidate_start_sample = None
+
+        # Copy the residual once, after the frames are scored, so a large input
+        # chunk is neither pinned by a view nor re-copied for every frame.
+        self._pending = pending[offset:].copy()
+
+        return StreamingVADResult(
+            contained_speech, self._speech_active, started, stopped, max_probability, start_ms, end_ms
+        )
+
+    def _score_frame(self, frame: np.ndarray) -> float:
+        if self._frame_scorer is not None:
+            return float(self._frame_scorer(frame))
+        backend = self._require_backend()
+        probability, self._detector_state = backend.infer(frame, self._detector_state)
+        return float(probability)
+
+    def _require_backend(self) -> SpeechDetectorBackend:
+        if self._backend is None:
+            provider = self._provider or SileroVADBackendProvider()
+            self._backend = provider.get()
+            self._detector_state = self._backend.new_state()
+        return self._backend
diff --git a/vllm_omni/engine/duplex_omni_engine.py b/vllm_omni/engine/duplex_omni_engine.py
new file mode 100644
index 000000000..56ca3e352
--- /dev/null
+++ b/vllm_omni/engine/duplex_omni_engine.py
@@ -0,0 +1,299 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""DuplexOmniEngine: the duplex engine sibling of ``AsyncOmniEngine``.
+
+It is deliberately small. The engine base owns the stage processes, the
+orchestrator thread and the correlated RPC transport; this class only knows
+how duplex session messages enter the engine (open/close/resume/touch through
+correlated RPC, session commands one-way) and which orchestrator to build
+(``DuplexOrchestrator`` with the model plugin loaded).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import queue
+import uuid
+from typing import TYPE_CHECKING, Any
+
+from vllm.logger import init_logger
+
+from vllm_omni.config.stage_config import DuplexSessionRuntimeConfig
+from vllm_omni.engine.async_omni_engine import AsyncOmniEngine
+from vllm_omni.engine.duplex.config import DuplexCapabilities, DuplexSessionConfig
+from vllm_omni.engine.duplex.messages import (
+    CloseDuplexSessionMessage,
+    DuplexControlResultMessage,
+    DuplexSessionCommandMessage,
+    DuplexSessionError,
+    OpenDuplexSessionMessage,
+    ResumeDuplexSessionMessage,
+    TouchDuplexSessionMessage,
+)
+from vllm_omni.engine.duplex.plugin import DuplexModelPlugin, EncodeAudio, load_duplex_plugin
+from vllm_omni.engine.messages import EngineQueueMessage
+from vllm_omni.engine.orchestrator import OrchestratorBase
+
+if TYPE_CHECKING:
+    from vllm_omni.engine.duplex.commands import DuplexCommand
+
+logger = init_logger(__name__)
+
+_DEFAULT_CONTROL_TIMEOUT_S = 10.0
+_COMMAND_PUT_TIMEOUT_S = 30.0
+
+
+class DuplexOmniEngine(AsyncOmniEngine):
+    """Engine for full-duplex models; sessions run inside ``DuplexOrchestrator``."""
+
+    plugin: DuplexModelPlugin | None = None
+    #: Set by ``_validate_deployment`` from the deploy config before any stage starts.
+    duplex_session_config: DuplexSessionRuntimeConfig
+
+    # Any: **kwargs is forwarded verbatim to ``OmniEngineBase.__init__``.
+    def __init__(self, model: str, *, duplex_audio_encoder: EncodeAudio, **kwargs: Any) -> None:
+        # Injected by ``DuplexOmni`` (entrypoint layer): the engine package
+        # knows how to hand model audio to the plugin, not how to encode it.
+        self._audio_encoder = duplex_audio_encoder
+        super().__init__(model, **kwargs)
+
+    # ---- orchestrator construction (orchestrator thread) ----
+
+    def _validate_deployment(self) -> None:
+        """Load the plugin and check the scheduler contract before any stage process starts."""
+        pipeline_config = self.pipeline_config
+        plugin_path = getattr(pipeline_config, "duplex_plugin", None) if pipeline_config is not None else None
+        if pipeline_config is None:
+            raise ValueError(
+                f"{self.model!r}: the model pipeline could not be resolved (models with custom HF code "
+                "such as MiniCPM-o need trust_remote_code=True)"
+            )
+        if not plugin_path:
+            raise ValueError(f"{self.model!r} is not a duplex model: the pipeline declares no duplex_plugin")
+        deploy_config = self.deploy_config
+        if deploy_config is None:
+            raise ValueError("DuplexOmniEngine requires a deploy config with session_mode: duplex (none resolved)")
+        if getattr(deploy_config, "session_mode", "turn") != "duplex":
+            raise ValueError(
+                "DuplexOmniEngine requires a deploy config with session_mode: duplex "
+                f"(got {getattr(deploy_config, 'session_mode', None)!r})"
+            )
+        self.duplex_session_config = deploy_config.duplex_session
+        self.plugin = load_duplex_plugin(plugin_path, self._audio_encoder)
+
+    # Any: signature of the ``OmniEngineBase._create_orchestrator`` seam it overrides.
+    def _create_orchestrator(self, **orchestrator_kwargs: Any) -> OrchestratorBase:
+        from vllm_omni.engine.duplex_orchestrator import DuplexOrchestrator
+
+        assert self.plugin is not None, "_validate_deployment() must run before the orchestrator is created"
+        stage0_vllm_config = self.stage_pools[0].stage_vllm_config if self.stage_pools else None
+        model_config = getattr(stage0_vllm_config, "model_config", None)
+        return DuplexOrchestrator(
+            plugin=self.plugin,
+            duplex_session_config=self.duplex_session_config,
+            model_config=model_config,
+            **orchestrator_kwargs,
+        )
+
+    # ---- deployment facts ----
+
+    @property
+    def duplex_capabilities(self) -> DuplexCapabilities:
+        if self.plugin is None:
+            raise RuntimeError("duplex plugin is not loaded")
+        return self.plugin.capabilities(max_sessions=self.duplex_session_config.max_sessions)
+
+    # ---- session message surface ----
+
+    def _execute_control(
+        self,
+        message: EngineQueueMessage,
+        *,
+        control_id: str,
+        operation: str,
+        session_id: str,
+        timeout: float | None,
+    ) -> DuplexControlResultMessage:
+        try:
+            result = self.rpc_client.execute(
+                ("duplex", control_id),
+                message,
+                timeout=timeout,
+                timeout_message=f"duplex {operation} timed out for session {session_id}",
+                # Block rather than surface a raw queue.Full: the handlers below
+                # promise a typed DuplexSessionError, and a momentarily full
+                # request queue is backpressure, not a failed control op.
+                block_on_submit=True,
+            )
+        except TimeoutError as exc:
+            raise DuplexSessionError(str(exc), code="timeout", retryable=True, session_id=session_id) from exc
+        except RuntimeError as exc:
+            # The RPC router is closed or the orchestrator reported a terminal error.
+            raise DuplexSessionError(str(exc), code="engine_error", session_id=session_id) from exc
+        if not isinstance(result, DuplexControlResultMessage):
+            raise DuplexSessionError(
+                f"unexpected duplex control result: {type(result).__name__}",
+                code="internal_error",
+                session_id=session_id,
+            )
+        if not result.ok:
+            raise DuplexSessionError(
+                result.error_message or f"duplex {operation} failed",
+                code=result.error_code or "internal_error",
+                retryable=result.error_retryable,
+                session_id=session_id,
+            )
+        return result
+
+    def _open_session(
+        self,
+        session_id: str,
+        session_config: DuplexSessionConfig,
+        *,
+        timeout: float | None = _DEFAULT_CONTROL_TIMEOUT_S,
+    ) -> DuplexControlResultMessage:
+        control_id = uuid.uuid4().hex
+        return self._execute_control(
+            OpenDuplexSessionMessage(
+                control_id=control_id,
+                session_id=session_id,
+                session_config=session_config,
+            ),
+            control_id=control_id,
+            operation="open",
+            session_id=session_id,
+            timeout=timeout,
+        )
+
+    async def open_session_async(
+        self,
+        session_id: str,
+        session_config: DuplexSessionConfig,
+        *,
+        timeout: float | None = _DEFAULT_CONTROL_TIMEOUT_S,
+    ) -> DuplexControlResultMessage:
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(None, lambda: self._open_session(session_id, session_config, timeout=timeout))
+
+    def _close_session(
+        self,
+        session_id: str,
+        *,
+        reason: str = "client_close",
+        timeout: float | None = _DEFAULT_CONTROL_TIMEOUT_S,
+    ) -> DuplexControlResultMessage:
+        control_id = uuid.uuid4().hex
+        return self._execute_control(
+            CloseDuplexSessionMessage(
+                control_id=control_id,
+                session_id=session_id,
+                reason=reason,
+            ),
+            control_id=control_id,
+            operation="close",
+            session_id=session_id,
+            timeout=timeout,
+        )
+
+    async def close_session_async(
+        self,
+        session_id: str,
+        *,
+        reason: str = "client_close",
+        timeout: float | None = _DEFAULT_CONTROL_TIMEOUT_S,
+    ) -> DuplexControlResultMessage:
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self._close_session(session_id, reason=reason, timeout=timeout),
+        )
+
+    def _resume_session(
+        self,
+        session_id: str,
+        *,
+        expected_lease_generation: int,
+        timeout: float | None = _DEFAULT_CONTROL_TIMEOUT_S,
+    ) -> DuplexControlResultMessage:
+        control_id = uuid.uuid4().hex
+        return self._execute_control(
+            ResumeDuplexSessionMessage(
+                control_id=control_id,
+                session_id=session_id,
+                expected_lease_generation=expected_lease_generation,
+            ),
+            control_id=control_id,
+            operation="resume",
+            session_id=session_id,
+            timeout=timeout,
+        )
+
+    async def resume_session_async(
+        self,
+        session_id: str,
+        *,
+        expected_lease_generation: int,
+        timeout: float | None = _DEFAULT_CONTROL_TIMEOUT_S,
+    ) -> DuplexControlResultMessage:
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self._resume_session(
+                session_id,
+                expected_lease_generation=expected_lease_generation,
+                timeout=timeout,
+            ),
+        )
+
+    def _touch_session(
+        self,
+        session_id: str,
+        *,
+        activity: str,
+        timeout: float | None = _DEFAULT_CONTROL_TIMEOUT_S,
+    ) -> DuplexControlResultMessage:
+        control_id = uuid.uuid4().hex
+        return self._execute_control(
+            TouchDuplexSessionMessage(
+                control_id=control_id,
+                session_id=session_id,
+                activity=activity,
+            ),
+            control_id=control_id,
+            operation="touch",
+            session_id=session_id,
+            timeout=timeout,
+        )
+
+    async def touch_session_async(
+        self,
+        session_id: str,
+        *,
+        activity: str,
+        timeout: float | None = _DEFAULT_CONTROL_TIMEOUT_S,
+    ) -> DuplexControlResultMessage:
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self._touch_session(session_id, activity=activity, timeout=timeout),
+        )
+
+    def _submit_command(self, session_id: str, command: DuplexCommand) -> None:
+        """One-way: enqueue a session command in caller order (blocks only on queue backpressure)."""
+        if not self.is_alive():
+            raise DuplexSessionError("engine is not alive", code="engine_dead", session_id=session_id)
+        message = DuplexSessionCommandMessage(session_id=session_id, command=command)
+        try:
+            self.request_queue.sync_q.put(message, timeout=_COMMAND_PUT_TIMEOUT_S)
+        except queue.Full as exc:
+            raise DuplexSessionError(
+                "engine request queue is full", code="engine_backpressure", retryable=True, session_id=session_id
+            ) from exc
+
+    async def submit_command_async(self, session_id: str, command: DuplexCommand) -> None:
+        loop = asyncio.get_running_loop()
+        await loop.run_in_executor(None, lambda: self._submit_command(session_id, command))
+
+
+__all__ = ["DuplexOmniEngine"]
diff --git a/vllm_omni/engine/duplex_orchestrator.py b/vllm_omni/engine/duplex_orchestrator.py
new file mode 100644
index 000000000..9814927d1
--- /dev/null
+++ b/vllm_omni/engine/duplex_orchestrator.py
@@ -0,0 +1,389 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""DuplexOrchestrator: the duplex sibling of ``Orchestrator``.
+
+It hosts the ``DuplexSessionManager`` (admission, leases, session runners) on
+the orchestrator loop and implements the ``DuplexStagePort`` the runners use
+to submit resumable Stage0 requests. Generic stage forwarding, prewarm and
+cleanup stay in ``OrchestratorBase``; this class only fills the template seams
+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
+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,
+    DuplexRequestIdentity,
+    DuplexStagePort,
+    DuplexStageRequestContext,
+    DuplexStageSubmission,
+    DuplexStageSubmissionResult,
+)
+from vllm_omni.engine.duplex.plugin import DuplexModelPlugin
+from vllm_omni.engine.duplex.session.engine_session import DuplexFenceMismatchError
+from vllm_omni.engine.duplex.session.manager import DuplexSessionManager
+from vllm_omni.engine.messages import EngineQueueMessage, OutputMessage
+from vllm_omni.engine.orchestrator import (
+    Orchestrator,
+    OrchestratorRequestState,
+    build_engine_core_request_from_tokens,
+)
+
+if TYPE_CHECKING:
+    from vllm.config import ModelConfig
+    from vllm.outputs import RequestOutput
+
+    from vllm_omni.metrics.stats import StageRequestStats
+
+logger = init_logger(__name__)
+
+
+@dataclass
+class DuplexOrchestratorRequestState(OrchestratorRequestState):
+    """Request bookkeeping for a session-owned (resumable duplex) stage request."""
+
+    session_id: str = ""
+    fence: DuplexFence | None = None
+    stage_fences: dict[int, DuplexFence] = field(default_factory=dict)
+    config_generation: int = -1
+
+
+class DuplexOrchestrator(Orchestrator, DuplexStagePort):
+    """Stage management for a duplex deployment; owns one ``DuplexSessionManager``.
+
+    Extends the turn-based orchestrator rather than sitting beside it, so one
+    engine serves both a duplex session and an ordinary request. The
+    dependency runs duplex -> turn-based and never the reverse, which is what
+    keeps ``Orchestrator`` free of duplex code.
+    """
+
+    def __init__(
+        self,
+        # Any: ``*args`` / ``**kwargs`` are forwarded verbatim to ``OrchestratorBase.__init__``.
+        *args: Any,
+        plugin: DuplexModelPlugin,
+        duplex_session_config: DuplexSessionRuntimeConfig,
+        model_config: ModelConfig | None = None,
+        **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(
+            plugin=plugin,
+            stage_port=self,
+            output_sink=self.output_async_queue,
+            result_sink=self.rpc_async_queue,
+            runtime_config=self.duplex_session_config,
+            model_config=model_config,
+        )
+
+    # ------------------------------------------------------------------ #
+    # Template seams                                                     #
+    # ------------------------------------------------------------------ #
+
+    async def _dispatch_message(self, msg: EngineQueueMessage) -> bool:
+        if self.session_manager.accepts(msg):
+            self.session_manager.dispatch(msg)
+            return True
+        # Not a session message: it is an ordinary turn-based request.
+        return await super()._dispatch_message(msg)
+
+    # Any: ``Coroutine``'s send/yield parameters, as in the ``OrchestratorBase`` seam.
+    def _background_tasks(self) -> list[Coroutine[Any, Any, None]]:
+        return [self.session_manager.reaper_loop(self._shutdown_event)]
+
+    async def _shutdown_extensions(self) -> None:
+        await self.session_manager.shutdown()
+
+    def _on_stage_submitted(
+        self,
+        stage_id: int,
+        request_id: str,
+        replica_id: int,
+        req_state: OrchestratorRequestState,
+    ) -> None:
+        del replica_id
+        if not isinstance(req_state, DuplexOrchestratorRequestState) or req_state.fence is None:
+            return
+        runner = self.session_manager.runner_for_request_id(request_id)
+        if runner is None:
+            return
+        fence = req_state.fence
+        req_state.stage_fences[stage_id] = fence
+        try:
+            runner.session.bind_stage_request(stage_id, request_id, fence=fence)
+        except DuplexFenceMismatchError:
+            # The session already advanced past this request's epoch (cancel
+            # raced the submit); the cancel path aborts the stale request id.
+            logger.debug("[DuplexOrchestrator] stale stage binding ignored for %s stage-%s", request_id, stage_id)
+            return
+        req_state.stage_submit_ts[stage_id] = _time.time()
+        self._register_running_request(req_state)
+        self.session_manager.register_request(request_id, req_state.session_id)
+
+    async def _intercept_stage_output(
+        self,
+        stage_id: int,
+        replica_id: int,
+        output: RequestOutput,
+        req_state: OrchestratorRequestState,
+        stage_metrics: StageRequestStats | None,
+        submit_ts: float | None,
+    ) -> bool:
+        del replica_id, submit_ts
+        if not isinstance(req_state, DuplexOrchestratorRequestState) or req_state.fence is None:
+            return False
+        request_id = output.request_id
+        runner = self.session_manager.runner_for_request_id(request_id)
+        if runner is None:
+            # Session gone: nothing may forward or reach a client.
+            return True
+        segment = req_state.streaming.segment(stage_id)
+        context = DuplexOutputContext(
+            identity=DuplexRequestIdentity(
+                session_id=req_state.session_id,
+                fence=req_state.stage_fences.get(stage_id, req_state.fence),
+            ),
+            final_stage_id=req_state.final_stage_id,
+            segment_finished=req_state.streaming.enabled and segment.finished,
+            segment_token_ids=tuple(segment.token_ids),
+            segment_output_metadata=segment.output_metadata,
+        )
+        return runner.on_stage_output(
+            stage_id,
+            output,
+            stage_metrics,
+            request_id=request_id,
+            context=context,
+        )
+
+    async def _handle_forward_failure(
+        self,
+        req_id: str,
+        next_stage_id: int,
+        req_state: OrchestratorRequestState,
+        exc: BaseException,
+    ) -> bool:
+        if not req_state.session_owned:
+            return False
+        runner = self.session_manager.runner_for_request_id(req_id)
+        if runner is not None:
+            runner.on_stage_failure(next_stage_id, exc)
+        await self._cleanup_request_ids(
+            [req_id, *self._cfg_tracker.cleanup_parent(req_id)],
+            abort=True,
+            release_owners=True,
+        )
+        return True
+
+    async def _cleanup_request_ids(
+        self,
+        request_ids: list[str],
+        *,
+        abort: bool = False,
+        release_owners: bool = False,
+    ) -> list[OutputMessage]:
+        if not request_ids:
+            return []
+        cleanup_ids = list(dict.fromkeys(request_ids))
+        closing_session_ids: list[str] = []
+        if release_owners:
+            closed_sessions = self.session_manager.close_sessions_for_request_ids(
+                cleanup_ids,
+                abort=abort,
+                cleanup_in_progress=True,
+            )
+            closing_session_ids.extend(closed_sessions)
+            for session_id, stale_request_ids in closed_sessions.items():
+                logger.info(
+                    "[DuplexOrchestrator] closed duplex session %s while cleaning failed request ids %s",
+                    session_id,
+                    stale_request_ids,
+                )
+                cleanup_ids.extend(stale_request_ids)
+            cleanup_ids = list(dict.fromkeys(cleanup_ids))
+        try:
+            outputs = await super()._cleanup_request_ids(cleanup_ids, abort=abort)
+        except BaseException:
+            if closing_session_ids:
+                self.session_manager.defer_request_cleanups(closing_session_ids)
+            raise
+        if closing_session_ids:
+            self.session_manager.finalize_closed_sessions(closing_session_ids)
+        for request_id in cleanup_ids:
+            self.session_manager.unregister_request(request_id)
+        return outputs
+
+    # ------------------------------------------------------------------ #
+    # DuplexStagePort                                                    #
+    # ------------------------------------------------------------------ #
+
+    @property
+    def stage_count(self) -> int:
+        return len(self.stage_pools)
+
+    def sampling_defaults(self) -> tuple[object, ...]:
+        defaults = []
+        for pool in self.stage_pools:
+            client = pool.stage_client
+            if client is None:
+                # Every replica of this stage was evicted (engine core died); a
+                # session cannot be admitted until the deployment is restarted.
+                raise RuntimeError(f"stage {pool.stage_id} has no live replica")
+            defaults.append(client.default_sampling_params)
+        return tuple(defaults)
+
+    @staticmethod
+    def _sync_bridge_state(
+        request_state: OrchestratorRequestState,
+        context: DuplexStageRequestContext,
+    ) -> None:
+        duplex_state = request_state.streaming.bridge_states.setdefault("duplex", {})
+        if not isinstance(duplex_state, dict):
+            duplex_state = {}
+            request_state.streaming.bridge_states["duplex"] = duplex_state
+        previous_epoch = duplex_state.get("epoch")
+        current_model_turn_id = duplex_state.get("model_turn_id")
+        if (
+            not isinstance(current_model_turn_id, int)
+            or previous_epoch != context.fence.epoch
+            or current_model_turn_id < context.fence.turn_id
+        ):
+            # A safety boundary can close a response before the model emits
+            # its normal turn_eos. Catch up the engine-owned identity when the
+            # next fenced append starts.
+            duplex_state["model_turn_id"] = context.fence.turn_id
+        duplex_state.update(
+            {
+                "session_id": context.session_id,
+                "fence": context.fence,
+                "epoch": context.fence.epoch,
+                "turn_id": context.fence.turn_id,
+                "session_config": dict(context.session_config),
+                "runtime_config": dict(context.runtime_config),
+            }
+        )
+
+    def ensure_request(self, context: DuplexStageRequestContext) -> None:
+        request_state = self.request_states.get(context.request_id)
+        if request_state is None:
+            request_state = DuplexOrchestratorRequestState(
+                request_id=context.request_id,
+                prompt=None,
+                sampling_params_list=list(context.sampling_params),
+                final_stage_id=context.final_stage_id,
+                session_owned=True,
+                session_id=context.session_id,
+                fence=context.fence,
+                config_generation=context.config_generation,
+            )
+            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:
+                request_state.sampling_params_list = list(context.sampling_params)
+                request_state.config_generation = context.config_generation
+            request_state.session_id = context.session_id
+            request_state.fence = context.fence
+        else:
+            raise RuntimeError(f"request {context.request_id} is not session-owned")
+        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}")
+        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:
+            replica_id = await pool.submit_update(context.request_id, request_state, request)
+        else:
+            replica_id = await pool.submit_initial(context.request_id, request_state, request, prompt_text=None)
+            if self.async_chunk and context.stage_id == 0:
+                prewarmed = await self._prewarm_async_chunk_stages(
+                    context.request_id,
+                    request,
+                    request_state,
+                )
+                if not prewarmed:
+                    # The prewarm already failed the request, aborted it and
+                    # popped its state; the runner turns this into an append
+                    # error instead of writing onto an orphaned object.
+                    raise RuntimeError(
+                        f"async-chunk prewarm failed for duplex request {context.request_id}; the request was aborted"
+                    )
+        request_state.stage_fences[context.stage_id] = context.fence
+        request_state.stage_submit_ts[context.stage_id] = _time.time()
+        self._register_running_request(request_state)
+        return DuplexStageSubmissionResult(
+            request_id=context.request_id,
+            stage_id=context.stage_id,
+            replica_id=replica_id,
+        )
+
+    async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
+        await self._cleanup_request_ids(request_ids, abort=abort)
+
+    async def abort_requests(self, request_ids: list[str]) -> None:
+        if request_ids:
+            await self._abort_request_ids(list(dict.fromkeys(request_ids)))
+
+
+__all__ = ["DuplexOrchestrator", "DuplexOrchestratorRequestState"]
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
new file mode 100644
index 000000000..e22bfb241
--- /dev/null
+++ b/vllm_omni/engine/omni_engine_base.py
@@ -0,0 +1,1235 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""OmniEngineBase: process/thread ownership and transport shared by every Omni engine."""
+
+from __future__ import annotations
+
+import asyncio
+import concurrent.futures
+import json
+import queue
+import threading
+import time
+import uuid
+import weakref
+from collections.abc import Mapping
+from dataclasses import asdict
+from pathlib import Path
+from typing import Any, cast
+
+import janus
+import torch
+from vllm import envs as vllm_envs
+from vllm.logger import init_logger
+from vllm.v1.engine.input_processor import InputProcessor
+
+from vllm_omni.config.config_factory import StageConfigFactory, with_trust_remote_code_override
+from vllm_omni.config.resolver import OmniConfigResolution, resolve_omni_config
+from vllm_omni.config.stage_config import (
+    _DEPLOY_DIR,
+    DuplexSessionRuntimeConfig,
+    PipelineConfig,
+    load_deploy_config,
+)
+from vllm_omni.diffusion.data import (
+    DiffusionParallelConfig,
+    parse_attention_config,
+)
+from vllm_omni.diffusion.io_support import get_diffusion_output_type
+from vllm_omni.engine.async_engine_utils import (
+    SHUTDOWN_ENQUEUE_TIMEOUT_S,
+    SHUTDOWN_JOIN_TIMEOUT_S,
+    enqueue_orchestrator_shutdown,
+    is_abort_transport_shutdown,
+    is_janus_sync_queue_shutdown,
+    shutdown_runtime_after_orchestrator,
+    weak_shutdown_async_omni_engine,
+)
+from vllm_omni.engine.messages import (
+    AbortRequestMessage,
+    AbortResultMessage,
+    CollectiveRPCRequestMessage,
+    CollectiveRPCResultMessage,
+    EngineQueueMessage,
+    ErrorMessage,
+    OutputMessage,
+)
+from vllm_omni.engine.orchestrator import OrchestratorBase
+from vllm_omni.engine.rpc_result_router import CorrelatedRpcClient
+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 prepare_stage_config_inputs
+from vllm_omni.inputs.data import OmniSamplingParams
+from vllm_omni.metrics.prometheus import OmniRequestCounter
+
+logger = init_logger(__name__)
+
+_STARTUP_POLL_INTERVAL_S = 1.0
+_REQUEST_QUEUE_MAXSIZE = 256
+_ConfigResolutionResult = OmniConfigResolution | tuple[str | None, list[Any], str | None]
+
+
+def load_and_resolve_stage_configs(
+    model: str,
+    kwargs: dict[str, Any],
+    *,
+    trust_remote_code: bool | None,
+    deploy_config_path: str | None,
+    stage_overrides: Mapping[str, Mapping[str, Any]] | None,
+    strategy_config_path: str | None,
+) -> OmniConfigResolution:
+    """Compatibility seam delegating to the single config resolver."""
+    return resolve_omni_config(
+        model,
+        trust_remote_code=trust_remote_code,
+        cli_overrides=kwargs,
+        deploy_config_path=deploy_config_path,
+        stage_overrides=stage_overrides,
+        strategy_config_path=strategy_config_path,
+    )
+
+
+class OmniEngineBase:
+    """Generic engine: launches an orchestrator in a background thread.
+
+    Shared by ``AsyncOmniEngine`` (turn-based requests) and ``DuplexOmniEngine``
+    (duplex sessions). Subclasses construct their orchestrator in
+    ``_create_orchestrator``.
+
+    All stage clients, input/output processors, and stage-to-stage transfer
+    logic live inside the Orchestrator coroutine (running in its own thread
+    with a dedicated asyncio event loop). This class communicates with it
+    via janus queues (sync side for callers, async side for orchestrator).
+
+    Args:
+        model: Model name or path
+        init_timeout: Total timeout waiting for orchestrator startup (seconds).
+        stage_init_timeout: Timeout for stage initialization (seconds)
+        **kwargs: Additional arguments
+    """
+
+    # Class-level defaults so tests that bypass __init__ via object.__new__
+    # don't AttributeError when stage-init / forward paths touch these attrs.
+    _log_stats: bool = False
+    _coordinator_runtime: Any = None
+    _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
+
+    def __init__(
+        self,
+        model: str,
+        stage_init_timeout: int = 300,
+        init_timeout: int = 600,
+        single_stage_mode: bool = False,
+        transfer_emitter: Any = None,
+        prom_metrics: Any = None,
+        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
+        self.tokenizer = tokenizer
+        # Cached by get_diffusion_od_config().
+        self._diffusion_od_config_view: Any = None
+        startup_timeout = int(init_timeout)
+        # Forwarded into Orchestrator so its _forward_to_next_stage path can
+        # emit per-edge transfer_tx_s / transfer_size_bytes histograms.
+        # Optional: when None, Orchestrator silently skips TX emit (existing
+        # RX path still works via OrchestratorAggregator).
+        self._transfer_emitter = transfer_emitter
+        self._prom_metrics = prom_metrics
+        # Drives upstream EngineCore + scheduler stats production. When False
+        # the engine skips SchedulerStats / IterationStats; the per-(stage,
+        # replica) vllm:* wrap stays registered but reads zero. Respects the
+        # --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}")
+
+        # ------------------------------------------------------------------ #
+        # Single-stage mode detection                                        #
+        # ------------------------------------------------------------------ #
+        # Single-stage mode is enabled when the caller explicitly passes      #
+        # single_stage_mode=True, or when a stage_id is provided in the args. #
+        _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 = (
+            int(_stage_id_kwarg) if single_stage_mode and isinstance(_stage_id_kwarg, int) else None
+        )
+        self._omni_master_address: str | None = kwargs.get("omni_master_address")
+        self._omni_master_port: int | None = kwargs.get("omni_master_port")
+
+        # New omni-coordinator flags. Consumed only in single_stage_mode.
+        # ``omni_dp_size_local`` is process-local: each invocation (head and
+        # every headless) launches that many replicas for its own stage.
+        self._omni_dp_size_local: int = int(kwargs.get("omni_dp_size_local") or 1)
+        if self._omni_dp_size_local < 1:
+            raise ValueError(f"--omni-dp-size-local must be >= 1, got {self._omni_dp_size_local}")
+        self._omni_lb_policy: str = str(kwargs.get("omni_lb_policy") or "random")
+        self._omni_heartbeat_timeout: float = float(kwargs.get("omni_heartbeat_timeout") or 30.0)
+        if self._omni_heartbeat_timeout <= 0:
+            raise ValueError(f"--omni-heartbeat-timeout must be > 0, got {self._omni_heartbeat_timeout}")
+        # Concurrent same-device stage init (admission + SH/EX phase locks).
+        # Sourced from the parallel_stage_init orchestrator/CLI arg (config,
+        # not an env var); default False preserves serial init.
+        self._parallel_stage_init: bool = bool(kwargs.get("parallel_stage_init") or False)
+
+        if single_stage_mode:
+            logger.info(
+                "[OmniEngine] Single-stage mode enabled (stage_id_filter=%s, master=%s:%s)",
+                self._single_stage_id_filter,
+                self._omni_master_address,
+                self._omni_master_port,
+            )
+
+        # Keep the historical tuple return from _resolve_stage_configs while
+        # retaining the richer resolver result for pipeline-wide settings.
+        # Overrides of that private seam fall back to the factory below.
+        deploy_config_path = kwargs.get("deploy_config")
+        # ``trust_remote_code`` is tri-state (bool | None): ``None`` means "not
+        # specified" so stage-config resolution can defer to the deploy yaml's
+        # per-stage value (see ``with_trust_remote_code_override``). The
+        # restriction path below loads the top-level HF config via vLLM's
+        # ``get_config``, which needs a real bool, so collapse ``None`` to the
+        # default ``False`` here (#5495).
+        pipeline_config = StageConfigFactory.get_pipeline_config(
+            model=model,
+            trust_remote_code=bool(trust_remote_code),
+            deploy_config_path=deploy_config_path,
+        )
+        self.pipeline_config = pipeline_config
+        self.endpoint_restrictions = pipeline_config.endpoint_restrictions if pipeline_config is not None else ()
+        # The resolved deploy profile (explicit --deploy-config or the pipeline
+        # default). Duplex engines read ``deploy_config.duplex_session`` and
+        # ``session_mode`` from it; the turn-based engine only keeps it for
+        # introspection.
+        self.deploy_config = None
+        #: Path ``self.deploy_config`` was parsed from, so the duplex runtime
+        #: config below can reuse it instead of re-reading the same yaml.
+        self._deploy_config_source: str | None = None
+        deploy_config_source: str | Path | None = deploy_config_path
+        if deploy_config_source is None and pipeline_config is not None:
+            default_name = getattr(pipeline_config, "default_deploy_config_name", None)
+            if default_name:
+                deploy_config_source = _DEPLOY_DIR / default_name
+        elif isinstance(deploy_config_source, str) and not Path(deploy_config_source).exists():
+            candidate = _DEPLOY_DIR / deploy_config_source
+            if candidate.exists():
+                deploy_config_source = candidate
+        if deploy_config_source is not None:
+            try:
+                self.deploy_config = load_deploy_config(deploy_config_source)
+                self._deploy_config_source = str(deploy_config_source)
+            except Exception:
+                if deploy_config_path is not None:
+                    # The caller named this file: failing to load it is their error.
+                    raise
+                logger.warning(
+                    "[OmniEngine] Could not load the pipeline's default deploy config %s",
+                    deploy_config_source,
+                    exc_info=True,
+                )
+
+        # Subclasses check deployment invariants here, before any stage
+        # process is launched (a failure is cheap at this point).
+        self._validate_deployment()
+
+        # Tri-state: None means "not specified" — the deploy yaml's per-stage
+        # trust_remote_code stays in effect. An explicit True/False here is a
+        # global override (precedence: caller > deploy yaml > default False);
+        # the merge rule lives in with_trust_remote_code_override.
+        kwargs = with_trust_remote_code_override(kwargs, trust_remote_code)
+        self._config_resolution: OmniConfigResolution | None = None
+        self.config_path, self.stage_configs = self._resolve_stage_configs(
+            model,
+            kwargs,
+            trust_remote_code=trust_remote_code,
+        )
+        if self._config_resolution is None:
+            # Same model, trust_remote_code and deploy path as the resolution
+            # above, so reuse it rather than paying for the HF config again.
+            self._set_pipeline_runtime_config(self.pipeline_config, self.config_path)
+        else:
+            self._set_pipeline_runtime_config(
+                self._config_resolution.pipeline_config,
+                self._config_resolution.config_path,
+            )
+
+        self.num_stages = len(self.stage_configs)
+        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
+        self.prompt_transform_func: Any | None = None
+        self.prompt_expand_func: Any | None = None
+        self.supported_tasks: tuple[str, ...] = ("generate",)
+        self.default_sampling_params_list: list[OmniSamplingParams] = []
+        self.stage_metadata: list[StageRuntimeInfo] = []
+        # Janus queues are constructed eagerly here (not deferred to the
+        # orchestrator thread) so the master server's ROUTER thread always
+        # sees a non-None ``self.request_queue`` when on_register fires.
+        # ``async_q`` lazily binds to whatever event loop first awaits on
+        # it (the orchestrator loop), so cross-thread use stays correct.
+        self.request_queue: janus.Queue[EngineQueueMessage] = janus.Queue(maxsize=_REQUEST_QUEUE_MAXSIZE)
+        self.output_queue: janus.Queue[EngineQueueMessage] = janus.Queue()
+        self.rpc_output_queue: janus.Queue[EngineQueueMessage] = janus.Queue()
+        self._shutdown_called = False
+        self._weak_finalizer: weakref.finalize | None = None
+        self._correlated_rpc_client: CorrelatedRpcClient | None = None
+        self._running_counter = OmniRequestCounter()
+        self._engines_waiting_counter = OmniRequestCounter()
+
+        logger.info(f"[OmniEngine] Launching Orchestrator thread with {self.num_stages} stages")
+
+        # Launch orchestrator background thread
+        startup_future: concurrent.futures.Future = concurrent.futures.Future()
+
+        self.orchestrator_thread = threading.Thread(
+            target=self._bootstrap_orchestrator,
+            args=(
+                stage_init_timeout,
+                startup_future,
+            ),
+            daemon=True,
+            name="orchestrator",
+        )
+        self.orchestrator_thread.start()
+        self._wait_for_orchestrator_init(startup_future, startup_timeout)
+        self._correlated_rpc_client = CorrelatedRpcClient(
+            self.request_queue.sync_q,
+            self.rpc_output_queue.sync_q,
+        )
+
+        # Stage runtime fields are assigned directly on self by the bootstrap thread.
+        self._weak_finalizer = weakref.finalize(
+            self,
+            weak_shutdown_async_omni_engine,
+            self.orchestrator_thread,
+            self.request_queue,
+            self.output_queue,
+            self.rpc_output_queue,
+            self._correlated_rpc_client,
+        )
+
+        logger.info(f"[OmniEngine] Orchestrator ready with {self.num_stages} stages")
+
+    def get_diffusion_od_config(self) -> Any:
+        """Expose the diffusion ``model_class_name`` to client-side model-extras.
+
+        The worker holds the full config; here we just resolve the pipeline class
+        name from the model config (cached). ``model_class_name`` may be ``None``.
+        """
+        if self._diffusion_od_config_view is None:
+            from types import SimpleNamespace
+
+            from vllm_omni.diffusion.data import resolve_model_class_name
+            from vllm_omni.diffusion.model_metadata import get_diffusion_model_metadata
+
+            model_class_name = resolve_model_class_name(self.model)
+            metadata = get_diffusion_model_metadata(model_class_name)
+            self._diffusion_od_config_view = SimpleNamespace(
+                model_class_name=model_class_name,
+                supports_multimodal_inputs=metadata.supports_multimodal_inputs,
+                max_multimodal_image_inputs=metadata.max_multimodal_image_inputs,
+                supports_mixed_reference_inputs=metadata.supports_mixed_reference_inputs,
+            )
+        return self._diffusion_od_config_view
+
+    def _initialize_stages(self, stage_init_timeout: int) -> None:
+        """Initialize stage clients/processors via StageRuntime and assign to self."""
+        self._runtime = create_stage_runtime(
+            stage_configs=self.stage_configs,
+            model=self.model,
+            config_path=self.config_path,
+            single_stage_mode=self.single_stage_mode,
+            stage_init_timeout=stage_init_timeout,
+            async_chunk=self.async_chunk,
+            tokenizer=self.tokenizer,
+            parallel_stage_init=self._parallel_stage_init,
+            single_stage_id_filter=self._single_stage_id_filter,
+            omni_master_address=self._omni_master_address,
+            omni_master_port=self._omni_master_port,
+            omni_dp_size_local=self._omni_dp_size_local,
+            omni_heartbeat_timeout=self._omni_heartbeat_timeout,
+            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()
+
+        self.num_stages = len(self.stage_configs)
+        self.stage_pools = self._runtime.stage_pools
+        self.stage_clients = [
+            cast(StageClient, pool.stage_client) for pool in self.stage_pools if pool.stage_client is not None
+        ]
+        self.stage_vllm_configs = [pool.stage_vllm_config for pool in self.stage_pools]
+        self.output_processors = [pool.output_processor for pool in self.stage_pools]
+        self.input_processor = (
+            build_stage0_input_processor(self.stage_vllm_configs[0])
+            if self.stage_vllm_configs and self.stage_vllm_configs[0] is not None
+            else None
+        )
+        self.prompt_transform_func = (
+            getattr(self.stage_clients[0], "prompt_transform_func", None) if self.stage_clients else None
+        )
+        self.prompt_expand_func = next(
+            (
+                getattr(client, "prompt_expand_func", None)
+                for client in self.stage_clients
+                if getattr(client, "prompt_expand_func", None) is not None
+            ),
+            None,
+        )
+        self.default_sampling_params_list = [client.default_sampling_params for client in self.stage_clients]
+        self.stage_metadata = [
+            StageRuntimeInfo(
+                final_output=client.final_output,
+                final_output_type=client.final_output_type,
+                stage_type=client.stage_type,
+                model_stage=getattr(client, "model_stage", None),
+            )
+            for client in self.stage_clients
+        ]
+        supported_tasks: set[str] = set()
+        if any(getattr(client, "is_comprehension", False) for client in self.stage_clients):
+            supported_tasks.add("generate")
+        if any(meta.final_output_type == "audio" for meta in self.stage_metadata):
+            supported_tasks.add("speech")
+        self.supported_tasks = tuple(supported_tasks) if supported_tasks else ("generate",)
+
+    def _bootstrap_orchestrator(
+        self,
+        stage_init_timeout: int,
+        startup_future: concurrent.futures.Future,
+    ) -> None:
+        """Create loop, initialize stages, then run Orchestrator."""
+
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+        async def _run_orchestrator() -> None:
+            self._initialize_stages(stage_init_timeout)
+
+            pd_config = self._detect_pd_config()
+
+            membership_controller = self._runtime.create_membership_controller()
+
+            orchestrator = self._create_orchestrator(
+                request_async_queue=self.request_queue.async_q,
+                output_async_queue=self.output_queue.async_q,
+                rpc_async_queue=self.rpc_output_queue.async_q,
+                stage_pools=self.stage_pools,
+                async_chunk=self.async_chunk,
+                pd_config=pd_config,
+                membership_controller=membership_controller,
+                running_counter=self._running_counter,
+                engines_waiting_counter=self._engines_waiting_counter,
+                transfer_emitter=self._transfer_emitter,
+                prom_metrics=self._prom_metrics,
+                log_stats=self._log_stats,
+                enable_orch_monitor=self._enable_orch_monitor,
+            )
+            if not startup_future.done():
+                startup_future.set_result(asyncio.get_running_loop())
+            await orchestrator.run()
+
+        try:
+            loop.run_until_complete(_run_orchestrator())
+        except Exception as e:
+            if not startup_future.done():
+                wrapped = RuntimeError(f"Orchestrator initialization failed: {e}")
+                wrapped.__cause__ = e
+                startup_future.set_exception(wrapped)
+            logger.exception("[OmniEngine] Orchestrator thread crashed")
+            error_text = str(e) or "Orchestrator thread crashed"
+            try:
+                error_msg = ErrorMessage(error=error_text, fatal=True)
+                if self.output_queue is not None:
+                    self.output_queue.sync_q.put_nowait(error_msg)
+                if self.rpc_output_queue is not None:
+                    self.rpc_output_queue.sync_q.put_nowait(error_msg)
+            except Exception:
+                pass
+            raise
+        finally:
+            try:
+                pending = [task for task in asyncio.all_tasks(loop) if not task.done()]
+                for task in pending:
+                    task.cancel()
+                if pending:
+                    loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
+                loop.run_until_complete(loop.shutdown_asyncgens())
+                if hasattr(loop, "shutdown_default_executor"):
+                    loop.run_until_complete(loop.shutdown_default_executor())
+            except Exception:
+                logger.exception("[OmniEngine] Failed during orchestrator loop cleanup")
+            finally:
+                asyncio.set_event_loop(None)
+                loop.close()
+
+    def _validate_deployment(self) -> None:
+        """Seam: check ``pipeline_config`` / ``deploy_config`` before stages start (default: nothing)."""
+
+    def _create_orchestrator(self, **orchestrator_kwargs: Any) -> OrchestratorBase:
+        """Construct this engine's orchestrator (runs on the orchestrator thread after stage init)."""
+        raise NotImplementedError
+
+    def _wait_for_orchestrator_init(self, startup_future: concurrent.futures.Future, startup_timeout: int) -> None:
+        """
+        Wait for orchestrator startup future to return ready. Raises exception on any failures to the init process.
+        """
+        deadline = time.monotonic() + startup_timeout
+        while True:
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                logger.warning(
+                    "[OmniEngine] Orchestrator startup timed out after %ss. "
+                    "Multi-stage deployments that initialize stages sequentially on one device "
+                    "or load checkpoints from slow storage may need larger --init-timeout and "
+                    "--stage-init-timeout values.",
+                    startup_timeout,
+                )
+                self._try_shutdown("[OmniEngine] Failed to cleanup after orchestrator startup timeout")
+                raise TimeoutError(f"Orchestrator did not become ready within {startup_timeout}s")
+            try:
+                startup_future.result(
+                    timeout=min(remaining, _STARTUP_POLL_INTERVAL_S),
+                )
+                break
+            except concurrent.futures.TimeoutError:
+                if not self.orchestrator_thread.is_alive():
+                    self._try_shutdown("[OmniEngine] Failed to cleanup after orchestrator startup failure")
+                    if startup_future.done():
+                        startup_future.result()  # re-raises the real exception
+                    raise RuntimeError("Orchestrator thread died during startup")
+            except Exception:
+                self._try_shutdown("[OmniEngine] Failed to cleanup after orchestrator startup failure")
+                raise
+
+    @staticmethod
+    def _get_default_cache_config(cache_backend: str | None) -> dict[str, Any] | None:
+        if cache_backend == "cache_dit":
+            return {
+                "Fn_compute_blocks": 1,
+                "Bn_compute_blocks": 0,
+                "max_warmup_steps": 4,
+                "residual_diff_threshold": 0.24,
+                "max_continuous_cached_steps": 3,
+                "enable_taylorseer": False,
+                "taylorseer_order": 1,
+                "scm_steps_mask_policy": None,
+                "scm_steps_policy": "dynamic",
+            }
+        if cache_backend == "tea_cache":
+            return {
+                "rel_l1_thresh": 0.2,
+            }
+        if cache_backend == "mag_cache":
+            return {
+                "mag_threshold": 0.24,
+                "mag_max_skip_steps": 5,
+                "mag_retention_ratio": 0.1,
+            }
+        if cache_backend == "step_cache":
+            return {
+                "step_cache_dit_enabled": True,
+                "velocity_sim_thresholds": [0.95, 0.93],
+                "velocity_skip_countdowns": [4, 2],
+                "step_cache_dit_min_history": 2,
+                "step_cache_dit_max_history": 2,
+            }
+        return None
+
+    @staticmethod
+    def _normalize_cache_config(cache_backend: str | None, cache_config: Any | None) -> Any | None:
+        if isinstance(cache_config, str):
+            try:
+                cache_config = json.loads(cache_config)
+            except json.JSONDecodeError:
+                logger.warning("Invalid cache_config JSON, using defaults.")
+                cache_config = None
+        if cache_config is None and cache_backend not in (None, "", "none"):
+            cache_config = OmniEngineBase._get_default_cache_config(cache_backend)
+        return cache_config
+
+    def _detect_pd_config(self) -> dict[str, Any] | None:
+        """Detect PD (Prefill-Decode) disaggregation config from stage_configs.
+        Returns a dict with 'pd_pair' and 'bootstrap_addr', or None.
+        """
+        pd_pair = PDDisaggregationMixin.detect_pd_separation_from_stage_configs(self.stage_configs)
+        if pd_pair is None:
+            return None
+        prefill_idx, decode_idx = pd_pair
+
+        # Extract bootstrap address from prefill stage engine_args
+        bootstrap_addr: str | None = None
+        try:
+            prefill_cfg = self.stage_configs[prefill_idx]
+            ea = getattr(prefill_cfg, "engine_args", None)
+            kv_cfg = getattr(ea, "kv_transfer_config", None) if ea is not None else None
+            if kv_cfg is not None:
+                port = vllm_envs.VLLM_MOONCAKE_BOOTSTRAP_PORT
+                kv_ip = getattr(kv_cfg, "kv_ip", None) or "127.0.0.1"
+                bootstrap_addr = f"http://{kv_ip}:{port}"
+        except Exception as exc:
+            logger.warning("[OmniEngine] Could not extract PD bootstrap address: %s", exc)
+
+        logger.info(
+            "[OmniEngine] PD disaggregation detected: prefill=stage-%d, decode=stage-%d, bootstrap=%s",
+            prefill_idx,
+            decode_idx,
+            bootstrap_addr,
+        )
+        prefill_engine_id: str | None = None
+        try:
+            prefill_client = self.stage_clients[prefill_idx]
+            kv_cfg = getattr(getattr(prefill_client, "vllm_config", None), "kv_transfer_config", None)
+            prefill_engine_id = getattr(kv_cfg, "engine_id", None)
+        except Exception as exc:
+            logger.warning("[OmniEngine] Could not extract prefill engine_id: %s", exc)
+
+        return {
+            "pd_pair": (prefill_idx, decode_idx),
+            "bootstrap_addr": bootstrap_addr,
+            "prefill_engine_id": prefill_engine_id,
+        }
+
+    @staticmethod
+    def _create_default_diffusion_stage_cfg(kwargs: dict[str, Any]) -> list:
+        """Create a default single-stage diffusion config from kwargs."""
+        # We temporally create a default config for diffusion stage.
+        # In the future, we should merge the default config with the user-provided config.
+        normalized_kwargs = dict(kwargs)
+        default_sampling_params = normalized_kwargs.get("default_sampling_params")
+        if isinstance(default_sampling_params, str):
+            try:
+                default_sampling_params = json.loads(default_sampling_params)
+            except json.JSONDecodeError:
+                logger.warning("Invalid default_sampling_params JSON, ignoring stage defaults.")
+                default_sampling_params = None
+        if not isinstance(default_sampling_params, dict):
+            default_sampling_params = None
+        stage_default_sampling_params = default_sampling_params.get("0", {}) if default_sampling_params else {}
+        if normalized_kwargs.get("dtype") is None:
+            normalized_kwargs["dtype"] = "auto"
+
+        # TODO: hack, convert dtype to string to avoid non-premitive omegaconf create error.
+        if "dtype" in normalized_kwargs and not isinstance(normalized_kwargs["dtype"], str):
+            if not isinstance(normalized_kwargs["dtype"], torch.dtype):
+                raise TypeError(
+                    f"Provided dtype must be a string or torch.dtype, got {type(normalized_kwargs['dtype']).__name__}"
+                )
+            normalized_kwargs["dtype"] = str(normalized_kwargs["dtype"]).removeprefix("torch.")
+
+        cache_backend = normalized_kwargs.get("cache_backend", "none")
+        cache_config = OmniEngineBase._normalize_cache_config(
+            cache_backend,
+            normalized_kwargs.get("cache_config", None),
+        )
+
+        parallel_config = normalized_kwargs.get("parallel_config")
+        if isinstance(parallel_config, dict):
+            parallel_config = DiffusionParallelConfig.from_dict(parallel_config)
+        if parallel_config is None:
+            ulysses_degree = normalized_kwargs.get("ulysses_degree") or 1
+            ring_degree = normalized_kwargs.get("ring_degree") or 1
+            allgather_degree = normalized_kwargs.get("allgather_degree") or 1
+            ulysses_mode = normalized_kwargs.get("ulysses_mode") or "strict"
+            ulysses_a2a_permute = bool(normalized_kwargs.get("ulysses_a2a_permute", False))
+            sequence_parallel_size = normalized_kwargs.get("sequence_parallel_size")
+            pipeline_parallel_size = normalized_kwargs.get("pipeline_parallel_size") or 1
+            data_parallel_size = normalized_kwargs.get("data_parallel_size")
+            tensor_parallel_size = normalized_kwargs.get("tensor_parallel_size") or 1
+            cfg_parallel_size = normalized_kwargs.get("cfg_parallel_size") or 1
+            pipeline_parallel_size = normalized_kwargs.get("pipeline_parallel_size") or 1
+            vae_patch_parallel_size = normalized_kwargs.get("vae_patch_parallel_size") or 1
+            vae_parallel_mode = normalized_kwargs.get("vae_parallel_mode") or "tile"
+            text_encoder_tp_size = normalized_kwargs.get("text_encoder_tp_size") or 1
+            enable_expert_parallel = normalized_kwargs.get("enable_expert_parallel") or False
+            use_hsdp = normalized_kwargs.get("use_hsdp", False)
+            hsdp_shard_size = normalized_kwargs.get("hsdp_shard_size", -1)
+            hsdp_replicate_size = normalized_kwargs.get("hsdp_replicate_size", 1)
+            if sequence_parallel_size is None:
+                sequence_parallel_size = allgather_degree if allgather_degree > 1 else ulysses_degree * ring_degree
+
+            parallel_config = DiffusionParallelConfig(
+                pipeline_parallel_size=pipeline_parallel_size,
+                data_parallel_size=data_parallel_size,
+                tensor_parallel_size=tensor_parallel_size,
+                enable_expert_parallel=enable_expert_parallel,
+                sequence_parallel_size=sequence_parallel_size,
+                ulysses_degree=ulysses_degree,
+                ring_degree=ring_degree,
+                allgather_degree=allgather_degree,
+                ulysses_mode=ulysses_mode,
+                ulysses_a2a_permute=ulysses_a2a_permute,
+                cfg_parallel_size=cfg_parallel_size,
+                vae_patch_parallel_size=vae_patch_parallel_size,
+                vae_parallel_mode=vae_parallel_mode,
+                text_encoder_tp_size=text_encoder_tp_size,
+                use_hsdp=use_hsdp,
+                hsdp_shard_size=hsdp_shard_size,
+                hsdp_replicate_size=hsdp_replicate_size,
+            )
+
+        num_gpus = normalized_kwargs.get("num_gpus")
+        if num_gpus is not None:
+            num_gpus = int(num_gpus)
+            parallel_config.resolve_data_parallel_size(num_gpus)
+
+        num_devices = max(1, int(parallel_config.world_size))
+        devices = ",".join(str(i) for i in range(num_devices))
+        model_class_name = kwargs.get("model_class_name", None)
+        final_output_type = get_diffusion_output_type(model_class_name)
+
+        attention_config = None
+        if (
+            kwargs.get("diffusion_attention_config") is not None
+            or kwargs.get("diffusion_attention_backend") is not None
+            or kwargs.get("fastvideo_vsa_topk") is not None
+        ):
+            attention_config = parse_attention_config(
+                kwargs.get("diffusion_attention_config"),
+                attention_backend=kwargs.get("diffusion_attention_backend"),
+                fastvideo_vsa_topk=kwargs.get("fastvideo_vsa_topk"),
+            )
+
+        extras = dict(kwargs.get("extras") or {})
+        for key, default in (
+            ("auxiliary_text_encoder", None),
+            ("default_llama_model_id", "meta-llama/Meta-Llama-3.1-8B-Instruct"),
+        ):
+            top_level_value = kwargs.get(key)
+            if top_level_value is not None:
+                extras[key] = top_level_value
+            else:
+                extras.setdefault(key, default)
+
+        stage_engine_args = {
+            "max_num_seqs": kwargs.get("max_num_seqs") or 1,
+            "parallel_config": parallel_config,
+            # Default-stage construction bypasses the structured projection.
+            # Runner selection remains owned by the selected engine/platform.
+            "engine_backend": kwargs.get("engine_backend", "default"),
+            "model_class_name": kwargs.get("model_class_name", None),
+            "task_type": kwargs.get("task_type", None),
+            "model_config": kwargs.get("model_config", None),
+            "additional_config": kwargs.get("additional_config", None),
+            "step_execution": kwargs.get("step_execution", False),
+            "request_batch_max_wait_ms": kwargs.get("request_batch_max_wait_ms", 0.0),
+            "vae_use_slicing": kwargs.get("vae_use_slicing", False),
+            "vae_use_tiling": kwargs.get("vae_use_tiling", False),
+            "cache_backend": cache_backend,
+            "cache_config": cache_config,
+            "enable_cache_dit_summary": kwargs.get("enable_cache_dit_summary", False),
+            "diffusion_offload_config": kwargs.get("diffusion_offload_config", None),
+            "enable_cpu_offload": kwargs.get("enable_cpu_offload", False),
+            "enable_layerwise_offload": kwargs.get("enable_layerwise_offload", False),
+            "enable_distributed_layerwise_offload": kwargs.get("enable_distributed_layerwise_offload", False),
+            "dlo_use_allgather": kwargs.get("dlo_use_allgather", True),
+            "dlo_resident_layers": kwargs.get("dlo_resident_layers", 0),
+            "host_weight_runtime_mode": kwargs.get("host_weight_runtime_mode", "disabled"),
+            "host_weight_runtime_root": kwargs.get("host_weight_runtime_root"),
+            "dlo_host_registration_limit_gib": kwargs.get("dlo_host_registration_limit_gib", 0.0),
+            "enforce_eager": False if kwargs.get("enforce_eager") is None else kwargs.get("enforce_eager"),
+            "diffusion_compile_granularity": (
+                "regional"
+                if kwargs.get("diffusion_compile_granularity") is None
+                else kwargs["diffusion_compile_granularity"]
+            ),
+            "diffusion_compile_dynamic": (
+                True if kwargs.get("diffusion_compile_dynamic") is None else kwargs["diffusion_compile_dynamic"]
+            ),
+            "fa_deterministic": bool(kwargs.get("fa_deterministic", False)),
+            "boundary_ratio": kwargs.get("boundary_ratio", None),
+            "flow_shift": kwargs.get("flow_shift", None),
+            "diffusion_load_format": kwargs.get("diffusion_load_format", "default"),
+            "lora_path": kwargs.get("lora_path", None),
+            "lora_scale": kwargs.get("lora_scale", 1.0),
+            "lora_backend": kwargs.get("lora_backend", "peft"),
+            "custom_pipeline_args": kwargs.get("custom_pipeline_args", None),
+            "worker_extension_cls": kwargs.get("worker_extension_cls", None),
+            "trust_remote_code": (False if kwargs.get("trust_remote_code") is None else kwargs["trust_remote_code"]),
+            "distributed_executor_backend": kwargs.get("distributed_executor_backend"),
+            "enable_sleep_mode": kwargs.get("enable_sleep_mode", False),
+            "enable_prompt_embed_cache": kwargs.get("enable_prompt_embed_cache", False),
+            "prompt_embed_cache_size": kwargs.get("prompt_embed_cache_size", 32),
+            "enable_multithread_weight_load": kwargs.get("enable_multithread_weight_load", True),
+            "num_weight_load_threads": kwargs.get("num_weight_load_threads", 4),
+            "quantization": kwargs.get("quantization", None),
+            "quantization_config": kwargs.get("quantization_config", None),
+            "diffusion_kv_cache_dtype": kwargs.get("diffusion_kv_cache_dtype", None),
+            "diffusion_kv_cache_skip_steps": kwargs.get("diffusion_kv_cache_skip_steps", None),
+            "diffusion_kv_cache_skip_layers": kwargs.get("diffusion_kv_cache_skip_layers", None),
+            **({"diffusion_attention_config": attention_config} if attention_config is not None else {}),
+            "force_cutlass_fp8": bool(kwargs.get("force_cutlass_fp8", False)),
+            "enable_diffusion_pipeline_profiler": kwargs.get("enable_diffusion_pipeline_profiler", False),
+            "streaming_output": kwargs.get("diffusion_streaming_output", False),
+            "enable_ar_profiler": kwargs.get("enable_ar_profiler", False),
+            "extras": extras,
+            **(
+                {
+                    "profiler_config": asdict(kwargs["profiler_config"])
+                    if hasattr(kwargs["profiler_config"], "__dataclass_fields__")
+                    else kwargs["profiler_config"]
+                }
+                if kwargs.get("profiler_config") is not None
+                else {}
+            ),
+        }
+        if num_gpus is not None:
+            stage_engine_args["num_gpus"] = num_gpus
+        # Only set dtype if it was already explicitly passed and normalized
+        if "dtype" in normalized_kwargs:
+            stage_engine_args["dtype"] = normalized_kwargs["dtype"]
+
+        # New split fields for diffusers adapter kwargs.
+        if kwargs.get("diffusers_load_kwargs") is not None:
+            stage_engine_args["diffusers_load_kwargs"] = kwargs["diffusers_load_kwargs"]
+        if kwargs.get("diffusers_call_kwargs") is not None:
+            stage_engine_args["diffusers_call_kwargs"] = kwargs["diffusers_call_kwargs"]
+
+        default_stage_cfg = [
+            {
+                "stage_id": 0,
+                "stage_type": "diffusion",
+                "runtime": {
+                    "process": True,
+                    "devices": devices,
+                },
+                "engine_args": stage_engine_args,
+                "engine_input_source": [],
+                "default_sampling_params": stage_default_sampling_params,
+                "final_output": True,
+                "final_output_type": final_output_type,
+            }
+        ]
+        default_stage_cfg[0]["engine_args"]["model_stage"] = "diffusion"
+        return default_stage_cfg
+
+    def _apply_strategy_lb_policy(self, derived: str | None, kwargs: dict[str, Any]) -> None:
+        """Apply a strategy-derived ``omni_lb_policy`` to the engine.
+
+        Precedence: an explicit ``--omni-lb-policy`` always wins. ``"random"`` is
+        the engine default and is treated as "unset" (indistinguishable from no
+        flag), so a strategy value overrides it. If the user explicitly passed a
+        non-default policy that conflicts with the strategy-derived one, raise so
+        the mismatch is not silently ignored.
+        """
+        if not derived:
+            return
+        explicit = kwargs.get("omni_lb_policy")
+        user_set = explicit is not None and str(explicit) != "random"
+        if user_set:
+            if str(explicit) != str(derived):
+                raise ValueError(
+                    f"Conflicting load-balancer policy: --omni-lb-policy={explicit!r} was given "
+                    f"but the composable-parallel strategy derived omni_lb_policy={derived!r}. "
+                    "Drop --omni-lb-policy to use the strategy value, or make them match."
+                )
+            return
+        if self._omni_lb_policy != str(derived):
+            logger.info(
+                "[composable_parallel] applying strategy-derived omni_lb_policy=%r (was %r).",
+                derived,
+                self._omni_lb_policy,
+            )
+            self._omni_lb_policy = str(derived)
+
+    @staticmethod
+    def _create_default_diffusion_stage_cfg(kwargs: dict[str, Any]) -> list[dict[str, Any]]:
+        """Compatibility seam for the factory-owned diffusion fallback."""
+        return StageConfigFactory.create_default_diffusion(kwargs)
+
+    def _set_pipeline_runtime_config(
+        self,
+        pipeline_config: PipelineConfig | None,
+        config_path: str | None,
+    ) -> None:
+        """Initialize engine-wide settings resolved from pipeline metadata."""
+        self.endpoint_restrictions = pipeline_config.endpoint_restrictions if pipeline_config is not None else ()
+        # No duplex_runtime_extension / duplex_serving_adapter / duplex_control
+        # here: the pre-framework wiring they named is gone, and design rule 3
+        # in docs/design/fullduplex.md keeps duplex vocabulary out of the base.
+        self.duplex_session_config = DuplexSessionRuntimeConfig()
+        if config_path is not None:
+            if self.deploy_config is not None and self._deploy_config_source == str(config_path):
+                # Already parsed in __init__; the same yaml twice is pure cost.
+                self.duplex_session_config = self.deploy_config.duplex_session
+            else:
+                self.duplex_session_config = load_deploy_config(config_path).duplex_session
+
+    def _resolve_stage_configs(
+        self,
+        model: str,
+        kwargs: dict[str, Any],
+        *,
+        trust_remote_code: bool | None,
+    ) -> tuple[str, list[Any]]:
+        """Resolve stage configs and inject defaults shared by orchestrator/headless."""
+
+        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,
+            load_and_resolve_stage_configs(
+                model,
+                kwargs,
+                trust_remote_code=trust_remote_code,
+                deploy_config_path=deploy_config_path,
+                stage_overrides=stage_overrides,
+                strategy_config_path=strategy_config_path,
+            ),
+        )
+        if isinstance(resolution, OmniConfigResolution):
+            self._config_resolution = resolution
+            config_path = resolution.config_path
+            stage_configs = list(resolution.stage_configs)
+            strategy_lb_policy = resolution.omni_lb_policy
+        else:
+            # Compatibility for overrides of the historical tuple-returning
+            # seam. Production always receives OmniConfigResolution above.
+            config_path, stage_configs, strategy_lb_policy = resolution
+
+        # A strategy.yaml may derive a pipeline-wide load-balancer policy. It is
+        # an orchestrator-level knob (read once at construction), so apply it here
+        # rather than as a per-stage config field.
+        self._apply_strategy_lb_policy(strategy_lb_policy, kwargs)
+
+        return cast(str, config_path), stage_configs
+
+    # ==================== Public API ====================
+
+    def try_get_output(self, timeout: float = 0.001) -> EngineQueueMessage | None:
+        """Read one output message from the Orchestrator output queue."""
+        try:
+            return self.output_queue.sync_q.get(timeout=timeout)
+        except queue.Empty:
+            if not self.is_alive():
+                raise RuntimeError("Orchestrator died unexpectedly. See logs above.")
+            return None
+
+    async def try_get_output_async(self) -> EngineQueueMessage | None:
+        """Async read from the Orchestrator output queue."""
+        try:
+            return self.output_queue.sync_q.get_nowait()
+        except queue.Empty:
+            if not self.is_alive():
+                raise RuntimeError("Orchestrator died unexpectedly. See logs above.")
+            return None
+
+    async def get_output_blocking_async(self, timeout: float = 1.0) -> EngineQueueMessage | None:
+        """Blocking-wait read from the Orchestrator output queue.
+
+        Waits up to ``timeout`` seconds in a dedicated drain thread for the
+        next message (condition-variable wakeup instead of a poll cadence);
+        returns ``None`` on timeout so the caller keeps its liveness check,
+        mirroring ``try_get_output_async``'s contract. Used by the serving
+        final-output drain when ``VLLM_OMNI_EVENT_DRIVEN_ORCH`` is on.
+        """
+        executor = self._output_drain_executor
+        if executor is None:
+            executor = concurrent.futures.ThreadPoolExecutor(
+                max_workers=1,
+                thread_name_prefix="omni-output-drain",
+            )
+            self._output_drain_executor = executor
+
+        sync_q = self.output_queue.sync_q
+
+        def _drain_get() -> EngineQueueMessage | None:
+            # Exceptions are swallowed to a None sentinel: the queue may be
+            # closed mid-shutdown, and an exception left on an executor future
+            # after task cancellation would warn as never-retrieved.
+            try:
+                return sync_q.get(timeout=timeout)
+            except queue.Empty:
+                return None
+            except Exception:
+                return None
+
+        loop = asyncio.get_running_loop()
+        msg = await loop.run_in_executor(executor, _drain_get)
+        if msg is None and not self.is_alive():
+            raise RuntimeError("Orchestrator died unexpectedly. See logs above.")
+        return msg
+
+    def get_stage_metadata(self, stage_id: int) -> StageRuntimeInfo:
+        """Get cached metadata for a stage."""
+        return self.stage_metadata[stage_id]
+
+    def abort(self, request_ids: list[str]) -> None:
+        """Fire-and-forget abort: enqueue and return without waiting.
+
+        Prefer :meth:`abort_async` when the caller needs acknowledgment that
+        stage aborts, binding release, and orchestrator request cleanup finished.
+        """
+        if not request_ids or getattr(self, "_shutdown_called", False):
+            return
+        if self.request_queue is None:
+            raise RuntimeError("request_queue is not initialized")
+        try:
+            self.request_queue.sync_q.put(AbortRequestMessage(request_ids=request_ids))
+        except Exception as exc:
+            if getattr(self, "_shutdown_called", False) and is_janus_sync_queue_shutdown(exc):
+                return
+            raise
+
+    async def abort_async(
+        self,
+        request_ids: list[str],
+        timeout: float | None = None,
+    ) -> list[OutputMessage]:
+        """Abort requests and wait for orchestrator acknowledgment.
+
+        Unlike :meth:`abort`, this generates an ``rpc_id``, correlates the
+        :class:`AbortResultMessage` via :class:`CorrelatedRpcClient`, and
+        raises if the orchestrator reports failure or times out.
+
+        Returns:
+            Final-stage AR abort ``OutputMessage`` list carrying partial
+            tokens generated before abort (empty for diffusion / no OP state).
+        """
+        if not request_ids or getattr(self, "_shutdown_called", False):
+            return []
+        if self.request_queue is None:
+            raise RuntimeError("request_queue is not initialized")
+        transport = self._correlated_rpc_client
+        if transport is None:
+            raise RuntimeError("correlated RPC client is not initialized")
+
+        rpc_id = uuid.uuid4().hex
+        msg = AbortRequestMessage(request_ids=request_ids, rpc_id=rpc_id)
+
+        def _wait() -> AbortResultMessage:
+            result_msg = transport.execute(
+                ("abort", rpc_id),
+                msg,
+                timeout=timeout,
+                timeout_message=f"abort timed out after {timeout} seconds",
+                block_on_submit=True,
+            )
+            if not isinstance(result_msg, AbortResultMessage):
+                raise RuntimeError(f"unexpected abort result type: {type(result_msg).__name__}")
+            return result_msg
+
+        loop = asyncio.get_running_loop()
+        try:
+            result_msg = await loop.run_in_executor(None, _wait)
+        except Exception as exc:
+            if getattr(self, "_shutdown_called", False) and is_abort_transport_shutdown(exc):
+                return []
+            raise
+        if not result_msg.success:
+            raise RuntimeError(result_msg.error or "abort failed")
+        return list(result_msg.abort_outputs or [])
+
+    def collective_rpc(
+        self,
+        method: str,
+        timeout: float | None = None,
+        args: tuple[Any, ...] = (),
+        kwargs: dict[str, Any] | None = None,
+        stage_ids: list[int] | None = None,
+    ) -> list[Any]:
+        """Send a control RPC to the Orchestrator and wait for aggregated results.
+
+        This uses a dedicated RPC output queue so control-plane messages do not
+        race with the normal request output polling loop.
+        """
+        rpc_id = uuid.uuid4().hex
+        msg = CollectiveRPCRequestMessage(
+            rpc_id=rpc_id,
+            method=method,
+            timeout=timeout,
+            args=tuple(args),
+            kwargs=kwargs or {},
+            stage_ids=stage_ids,
+        )
+
+        transport = self._correlated_rpc_client
+        if transport is None:
+            raise RuntimeError("correlated RPC client is not initialized")
+        result_msg = transport.execute(
+            ("collective", rpc_id),
+            msg,
+            timeout=timeout,
+            timeout_message=f"collective_rpc timed out after {timeout} seconds",
+            block_on_submit=True,
+        )
+        if not isinstance(result_msg, CollectiveRPCResultMessage):
+            raise RuntimeError(f"unexpected collective RPC result type: {type(result_msg).__name__}")
+        return list(result_msg.results)
+
+    async def collective_rpc_async(
+        self,
+        method: str,
+        timeout: float | None = None,
+        args: tuple[Any, ...] = (),
+        kwargs: dict[str, Any] | None = None,
+        stage_ids: list[int] | None = None,
+    ) -> list[Any]:
+        """Async wrapper around collective_rpc()."""
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.collective_rpc(
+                method=method,
+                timeout=timeout,
+                args=args,
+                kwargs=kwargs,
+                stage_ids=stage_ids,
+            ),
+        )
+
+    @property
+    def rpc_client(self) -> CorrelatedRpcClient:
+        """The correlated RPC transport (available once the orchestrator is up)."""
+        if self._correlated_rpc_client is None:
+            raise RuntimeError("engine RPC transport is not initialized")
+        return self._correlated_rpc_client
+
+    def is_alive(self) -> bool:
+        """Whether the orchestrator thread is alive."""
+        return bool(self.orchestrator_thread.is_alive())
+
+    def shutdown(self) -> None:
+        """Send shutdown message and wait for the Orchestrator thread to exit."""
+        if getattr(self, "_shutdown_called", False):
+            return
+        self._shutdown_called = True
+        finalizer = getattr(self, "_weak_finalizer", None)
+        if finalizer is not None and finalizer.alive:
+            finalizer.detach()
+
+        logger.info("[OmniEngine] Shutting down Orchestrator")
+        request_queue_closed = False
+        shutdown_enqueued = enqueue_orchestrator_shutdown(
+            self.request_queue,
+            timeout=SHUTDOWN_ENQUEUE_TIMEOUT_S,
+        )
+        if self.request_queue is not None and not shutdown_enqueued:
+            logger.error(
+                "[OmniEngine] Failed to enqueue orchestrator shutdown; "
+                "closing the request queue to wake the request handler"
+            )
+            try:
+                self.request_queue.close()
+                request_queue_closed = True
+            except Exception:
+                logger.exception("[OmniEngine] Failed to close the request queue")
+
+        if self._correlated_rpc_client is not None:
+            try:
+                self._correlated_rpc_client.close()
+            except Exception:
+                logger.exception("[OmniEngine] Failed to close correlated RPC client")
+
+        orchestrator_stopped = False
+        try:
+            if self.is_alive():
+                self.orchestrator_thread.join(timeout=SHUTDOWN_JOIN_TIMEOUT_S)
+            orchestrator_stopped = not self.is_alive()
+            if not orchestrator_stopped:
+                logger.error(
+                    "[OmniEngine] Orchestrator did not stop within %.1f seconds; continuing cleanup",
+                    SHUTDOWN_JOIN_TIMEOUT_S,
+                )
+        except Exception:
+            logger.exception("[OmniEngine] Failed to join Orchestrator thread")
+
+        for q in (self.request_queue, self.output_queue, self.rpc_output_queue):
+            try:
+                if not (q is self.request_queue and request_queue_closed):
+                    q.close()
+            except Exception:
+                pass
+
+        if self._output_drain_executor is not None:
+            # Any in-flight blocking get bails out within its ≤1 s timeout
+            # (or immediately via the queue close above), so don't wait.
+            self._output_drain_executor.shutdown(wait=False)
+            self._output_drain_executor = None
+
+        if hasattr(self, "_runtime") and self._runtime is not None and orchestrator_stopped:
+            try:
+                self._runtime.shutdown()
+            except Exception:
+                logger.exception("[OmniEngine] Failed to shutdown StageRuntime")
+        elif hasattr(self, "_runtime") and self._runtime is not None:
+            logger.warning("[OmniEngine] Deferring StageRuntime shutdown until the Orchestrator exits")
+            threading.Thread(
+                target=shutdown_runtime_after_orchestrator,
+                args=(self.orchestrator_thread, self._runtime),
+                daemon=True,
+                name="omni-stage-runtime-shutdown",
+            ).start()
+
+        # ── Release CuMem allocator memory pool ──────────────────────────────
+        # When enable_sleep_mode is in use, the CuMem (CUDA Virtual Memory
+        # Management) allocator holds model weights in a singleton memory pool
+        # that lives in the parent process.  Killing the engine-core subprocess
+        # does NOT release this pool — the weights stay resident on the GPU
+        # and can cause CUDA OOM for subsequent engine instances (especially
+        # large models like BAGEL-7B-MoT whose weights alone consume ~134 GiB).
+        #
+        # CuMemAllocator.sleep() is NOT idempotent — calling it on already-
+        # slept entries causes CUDA_ERROR_INVALID_VALUE at cumem_allocator
+        # cuMemRelease (double-free of the memory handle).  Use release_pools()
+        # instead, which is the designed cleanup path: it drops MemPool refs
+        # and lets the destructor/free path handle asleep entries correctly
+        # (returns a null handle so the C extension skips unmap/release).
+        try:
+            from vllm.device_allocator.cumem import CuMemAllocator, cumem_available
+
+            if cumem_available:
+                allocator = CuMemAllocator.get_instance()
+                allocator.release_pools()
+                logger.debug("[OmniEngine] Released CuMem memory pool during shutdown")
+        except Exception:
+            pass
+
+    def _try_shutdown(self, *args, **kwargs) -> None:
+        try:
+            self.shutdown()
+        except Exception:
+            logger.exception(*args, **kwargs)
diff --git a/vllm_omni/engine/orchestrator.py b/vllm_omni/engine/orchestrator.py
index 299e1dd07..e69ebc7ae 100644
--- a/vllm_omni/engine/orchestrator.py
+++ b/vllm_omni/engine/orchestrator.py
@@ -18,7 +18,7 @@ import asyncio
 import os
 import shutil
 import time as _time
-from collections.abc import Awaitable, Callable
+from collections.abc import Awaitable, Callable, Coroutine
 from dataclasses import dataclass, field
 from http import HTTPStatus
 from typing import Any
@@ -30,31 +30,15 @@ from vllm.logger import init_logger
 from vllm.outputs import CompletionOutput, RequestOutput
 from vllm.pooling_params import PoolingParams
 from vllm.sampling_params import RequestOutputKind, SamplingParams
-from vllm.v1.engine import EngineCoreOutputs
+from vllm.v1.engine import EngineCoreOutputs, FinishReason
 from vllm.v1.engine.exceptions import EngineDeadError
 from vllm.v1.metrics.stats import IterationStats
 
-from vllm_omni.config.stage_config import DuplexSessionRuntimeConfig
+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.duplex.contracts import (
-    DuplexControlPlanePort,
-    DuplexOutputContext,
-    DuplexOutputDecision,
-    DuplexRequestIdentity,
-    DuplexRuntimeExtension,
-    DuplexStageRequestContext,
-    DuplexStageSubmission,
-    DuplexStageSubmissionResult,
-)
-from vllm_omni.engine.duplex.control_plane import DuplexControlPlane
-from vllm_omni.engine.duplex.lease import DuplexLeaseConfig
-from vllm_omni.engine.duplex.messages import DuplexFence
-from vllm_omni.engine.duplex.session import (
-    DuplexSessionRuntimeManager,
-    DuplexSessionRuntimeState,
-)
+from vllm_omni.engine.errors import NativeKVHandoffError
 from vllm_omni.engine.membership_controller import MembershipController
 from vllm_omni.engine.messages import (
     AbortRequestMessage,
@@ -81,7 +65,6 @@ from vllm_omni.metrics.prometheus import OmniRequestCounter
 from vllm_omni.metrics.stat_logger import OmniPrometheusStatLogger
 from vllm_omni.metrics.utils import DIFFUSION_METRICS_ONLY_REQUEST_ID
 from vllm_omni.outputs import OmniRequestOutput
-from vllm_omni.outputs.duplex import attach_duplex_output_decision
 
 logger = init_logger(__name__)
 
@@ -209,6 +192,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
@@ -223,11 +208,13 @@ class OrchestratorRequestState:
 
     # Per-request pipeline timing accumulator (milliseconds)
     pipeline_timings: dict[str, float] = field(default_factory=dict)
-    duplex_identity: DuplexRequestIdentity | None = None
-    duplex_stage_fences: dict[int, DuplexFence] = field(default_factory=dict)
-    duplex_config_generation: int = -1
+    # A session-owned request's lifetime belongs to a session (duplex), not to
+    # its own ``finished`` flag: no synthetic terminal, no client emission of
+    # stage-0 segment ends, no terminal re-forward, no cleanup on finish.
+    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
@@ -278,143 +265,14 @@ class StreamingInputState:
         return segment if segment is not None else StreamingSegmentState()
 
 
-class _OrchestratorDuplexStagePort:
-    """Adapts generic stage pools to the model-neutral duplex control plane."""
+class OrchestratorBase:
+    """Stage-management loop shared by the turn-based and duplex orchestrators.
 
-    def __init__(
-        self,
-        *,
-        stage_pools: list[StagePool],
-        request_states: dict[str, OrchestratorRequestState],
-        running_counter: OmniRequestCounter | None,
-        cleanup_request_ids: Callable[..., Any],
-        async_chunk: bool,
-        prewarm_async_chunk_stages: Callable[
-            [str, Any, OrchestratorRequestState],
-            Awaitable[bool],
-        ],
-    ) -> None:
-        self._stage_pools = stage_pools
-        self._request_states = request_states
-        self._running_counter = running_counter
-        self._cleanup_request_ids = cleanup_request_ids
-        self._async_chunk = async_chunk
-        self._prewarm_async_chunk_stages = prewarm_async_chunk_stages
-
-    @property
-    def stage_count(self) -> int:
-        return len(self._stage_pools)
-
-    def sampling_defaults(self) -> tuple[object, ...]:
-        return tuple(pool.stage_client.default_sampling_params for pool in self._stage_pools)
-
-    @staticmethod
-    def _sync_bridge_state(
-        request_state: OrchestratorRequestState,
-        context: DuplexStageRequestContext,
-    ) -> None:
-        duplex_state = request_state.streaming.bridge_states.setdefault("duplex", {})
-        if not isinstance(duplex_state, dict):
-            duplex_state = {}
-            request_state.streaming.bridge_states["duplex"] = duplex_state
-        previous_epoch = duplex_state.get("epoch")
-        current_model_turn_id = duplex_state.get("model_turn_id")
-        if (
-            not isinstance(current_model_turn_id, int)
-            or previous_epoch != context.fence.epoch
-            or current_model_turn_id < context.fence.turn_id
-        ):
-            # A serving-side safety boundary can close a Realtime response
-            # before the model emits its normal turn_eos. Catch up the
-            # engine-owned identity when the next fenced append starts.
-            duplex_state["model_turn_id"] = context.fence.turn_id
-        duplex_state.update(
-            {
-                "session_id": context.session_id,
-                "fence": context.fence,
-                "incarnation": context.fence.incarnation,
-                "epoch": context.fence.epoch,
-                "turn_id": context.fence.turn_id,
-                "response_seq": context.fence.response_seq,
-                "session_config": dict(context.session_config),
-                "runtime_config": dict(context.runtime_config),
-            }
-        )
-
-    def ensure_request(self, context: DuplexStageRequestContext) -> None:
-        request_state = self._request_states.get(context.request_id)
-        if request_state is None:
-            request_state = OrchestratorRequestState(
-                request_id=context.request_id,
-                prompt=None,
-                sampling_params_list=list(context.sampling_params),
-                final_stage_id=context.final_stage_id,
-                duplex_config_generation=context.config_generation,
-            )
-            request_state.streaming.enabled = True
-            self._request_states[context.request_id] = request_state
-        elif request_state.duplex_config_generation != context.config_generation:
-            request_state.sampling_params_list = list(context.sampling_params)
-            request_state.duplex_config_generation = context.config_generation
-        request_state.duplex_identity = DuplexRequestIdentity(
-            session_id=context.session_id,
-            fence=context.fence,
-        )
-        self._sync_bridge_state(request_state, context)
-
-    async def submit(self, submission: DuplexStageSubmission) -> DuplexStageSubmissionResult:
-        context = submission.context
-        request_state = self._request_states.get(context.request_id)
-        if request_state is None:
-            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,
-        )
-        request.external_req_id = request.request_id
-        pool = self._stage_pools[context.stage_id]
-        if submission.already_submitted:
-            replica_id = await pool.submit_update(context.request_id, request_state, request)
-        else:
-            replica_id = await pool.submit_initial(context.request_id, request_state, request, prompt_text=None)
-            if self._async_chunk and context.stage_id == 0:
-                prewarmed = await self._prewarm_async_chunk_stages(
-                    context.request_id,
-                    request,
-                    request_state,
-                )
-                if not prewarmed:
-                    # The prewarm already failed the request, aborted it, and
-                    # popped its state. Falling through would write fences and
-                    # a submit timestamp onto that orphaned object and
-                    # re-increment the running counter the cleanup just
-                    # released, then hand the control plane a success result
-                    # for a request that no longer exists. Raise instead:
-                    # ``DuplexControlPlane.handle_append`` turns this into an
-                    # error result for the append.
-                    raise RuntimeError(
-                        f"async-chunk prewarm failed for duplex request {context.request_id}; the request was aborted"
-                    )
-        request_state.duplex_stage_fences[context.stage_id] = context.fence
-        request_state.stage_submit_ts[context.stage_id] = _time.time()
-        if not request_state.running_counter_registered and self._running_counter is not None:
-            self._running_counter.increment()
-            request_state.running_counter_registered = True
-        return DuplexStageSubmissionResult(
-            request_id=context.request_id,
-            stage_id=context.stage_id,
-            replica_id=replica_id,
-        )
-
-    async def cleanup(self, request_ids: list[str], *, abort: bool = False) -> None:
-        await self._cleanup_request_ids(request_ids, abort=abort)
-
-
-class Orchestrator:
-    """Runs inside a background thread's asyncio event loop."""
+    Runs inside a background thread's asyncio event loop. Subclasses fill the
+    template seams (``_dispatch_message``, ``_background_tasks``,
+    ``_shutdown_extensions``, ``_on_stage_submitted``, ``_intercept_stage_output``,
+    ``_handle_forward_failure``, ``_cleanup_request_ids``).
+    """
 
     # Class-level defaults so tests that bypass __init__ via object.__new__
     # don't AttributeError when transfer / counter emit paths access them.
@@ -423,7 +281,6 @@ class Orchestrator:
     _transfer_emitter: Any = None
     _prom_metrics: Any = None
     _stat_logger: OmniPrometheusStatLogger | None = None
-    duplex_control_plane: DuplexControlPlanePort | None = None
 
     def __init__(
         self,
@@ -441,9 +298,6 @@ class Orchestrator:
         prom_metrics: Any = None,
         log_stats: bool = False,
         enable_orch_monitor: bool = False,
-        duplex_runtime_extension: DuplexRuntimeExtension | None = None,
-        enable_duplex_control: bool = False,
-        duplex_session_config: DuplexSessionRuntimeConfig | None = None,
     ) -> None:
         self.request_async_queue = request_async_queue
         self.output_async_queue = output_async_queue
@@ -484,32 +338,6 @@ class Orchestrator:
         self._cfg_tracker = CfgCompanionTracker()
         self._stage_input_processors: dict[int, Any] = {}
 
-        self.duplex_control_plane: DuplexControlPlanePort | None = None
-        self._duplex_reaper_interval_s = 1.0
-        if enable_duplex_control:
-            runtime_session_config = duplex_session_config or DuplexSessionRuntimeConfig()
-            self._duplex_reaper_interval_s = runtime_session_config.reaper_interval_s
-
-            self.duplex_control_plane = DuplexControlPlane(
-                extension=duplex_runtime_extension,
-                stage_port=_OrchestratorDuplexStagePort(
-                    stage_pools=self.stage_pools,
-                    request_states=self.request_states,
-                    running_counter=self._running_counter,
-                    cleanup_request_ids=self._cleanup_request_ids,
-                    async_chunk=self.async_chunk,
-                    prewarm_async_chunk_stages=self._prewarm_async_chunk_stages,
-                ),
-                result_sink=self.rpc_async_queue,
-                lifecycle_sink=self.output_async_queue,
-                lease_config=DuplexLeaseConfig(
-                    idle_ttl_s=runtime_session_config.idle_ttl_s,
-                    disconnect_grace_s=runtime_session_config.disconnect_grace_s,
-                ),
-                max_sessions=runtime_session_config.max_sessions,
-                completed_append_limit=runtime_session_config.completed_append_cache_size,
-            )
-
         self._shutdown_event = asyncio.Event()
         self._stages_shutdown = False
         self._event_driven_orch = _event_driven_orch_enabled()
@@ -587,17 +415,6 @@ class Orchestrator:
             logger.exception("[Orchestrator] OmniPrometheusStatLogger init failed; metrics wrap disabled")
             self._stat_logger = None
 
-    @property
-    def duplex_sessions(self) -> DuplexSessionRuntimeManager:
-        if self.duplex_control_plane is None:
-            raise RuntimeError("duplex control plane is disabled")
-        return self.duplex_control_plane.sessions
-
-    def _require_duplex_control_plane(self) -> DuplexControlPlanePort:
-        if self.duplex_control_plane is None:
-            raise RuntimeError("duplex control plane is disabled")
-        return self.duplex_control_plane
-
     async def run(self) -> None:
         """Main entry point for the Orchestrator event loop."""
         logger.info("[Orchestrator] Starting event loop")
@@ -619,8 +436,8 @@ class Orchestrator:
             membership_watcher = self._membership.start()
 
         tasks = [request_task, output_task]
-        if self.duplex_control_plane is not None:
-            tasks.append(asyncio.create_task(self._duplex_reaper_loop(), name="orchestrator-duplex-reaper"))
+        for index, coro in enumerate(self._background_tasks()):
+            tasks.append(asyncio.create_task(coro, name=f"orchestrator-background-{index}"))
         if membership_watcher is not None:
             tasks.append(membership_watcher)
 
@@ -654,8 +471,7 @@ class Orchestrator:
                 await asyncio.gather(*tasks, return_exceptions=True)
             except Exception:
                 pass
-            if self.duplex_control_plane is not None:
-                await self.duplex_control_plane.shutdown()
+            await self._shutdown_extensions()
 
             if self._membership is not None:
                 await self._membership.drain_tasks(timeout=10.0)
@@ -679,18 +495,10 @@ class Orchestrator:
             msg = await self.request_async_queue.get()
             msg_type = msg.type
 
-            if msg_type == "add_request":
-                await self._handle_add_request(msg)
-            elif msg_type == "streaming_update":
-                await self._handle_streaming_update(msg)
-            elif msg_type == "add_companion_request":
-                await self._handle_add_companion(msg)
-            elif self.duplex_control_plane is not None and self.duplex_control_plane.accepts(msg):
-                self.duplex_control_plane.dispatch(msg)
-            elif msg_type == "abort":
+            if await self._dispatch_message(msg):
+                continue
+            if msg_type == "abort":
                 await self._handle_abort(msg)
-            elif msg_type == "interaction":
-                await self._handle_interaction(msg)
             elif msg_type == "collective_rpc":
                 await self._handle_collective_rpc(msg)
             elif isinstance(msg, RegisterRemoteReplicaMessage):
@@ -716,183 +524,58 @@ class Orchestrator:
             else:
                 logger.warning("[Orchestrator] Unknown message type: %s", msg_type)
 
-    async def _duplex_reaper_loop(self) -> None:
-        while not self._shutdown_event.is_set():
-            try:
-                await asyncio.wait_for(
-                    self._shutdown_event.wait(),
-                    timeout=self._duplex_reaper_interval_s,
-                )
-            except TimeoutError:
-                plane = self.duplex_control_plane
-                if plane is not None:
-                    try:
-                        await plane.reap_expired()
-                    except Exception:
-                        logger.exception("[Orchestrator] Duplex expiry cleanup failed; retrying on next tick")
+    # ---- Template seams filled by the turn-based / duplex subclasses ----
 
-    async def _handle_add_request(self, msg: StageSubmissionMessage) -> None:
-        """Handle an add_request message from the main thread."""
-        stage_id = 0
-        request_id = msg.request_id
-        prompt = msg.prompt
-        original_prompt = msg.original_prompt
-        sampling_params_list = msg.sampling_params_list
-        if not sampling_params_list:
-            raise ValueError(f"Missing sampling params for stage 0. Got {len(sampling_params_list)} stage params.")
-        final_stage_id = msg.final_stage_id
-        final_output_stage_ids = set(msg.final_output_stage_ids or [final_stage_id])
+    async def _dispatch_message(self, msg: EngineQueueMessage) -> bool:
+        """Handle a subclass-specific request-queue message; return True when consumed."""
+        del msg
+        return False
 
-        if not self.stage_pools[stage_id].live_replica_ids():
-            # Stage 0 lost all replicas between the HTTP-layer errored check and
-            # dispatch. Runs before request state / running counter registration,
-            # so the helper's cleanup is a no-op here.
-            await self._fail_request_dead_stage(request_id, stage_id)
-            return
+    def _background_tasks(self) -> list[Coroutine[Any, Any, None]]:
+        """Extra coroutines gathered with the request/output handlers in ``run()``."""
+        return []
 
-        logger.debug(
-            "[Orchestrator] _handle_add_request: stage=%s req=%s "
-            "prompt_type=%s original_prompt_type=%s final_stage=%s "
-            "num_sampling_params=%d",
-            stage_id,
-            request_id,
-            type(prompt).__name__,
-            type(original_prompt).__name__,
-            final_stage_id,
-            len(sampling_params_list),
-        )
+    async def _shutdown_extensions(self) -> None:
+        """Runs in ``run()``'s ``finally`` after task cancellation, before membership drain."""
 
-        req_state = OrchestratorRequestState(
-            request_id=request_id,
-            prompt=original_prompt,
-            sampling_params_list=sampling_params_list,
-            final_stage_id=final_stage_id,
-            final_output_stage_ids=final_output_stage_ids,
-            request_timestamp=float(msg.request_timestamp or _time.time()),
-            mm_features=getattr(prompt, "mm_features", None),
-            request_artifact_dirs=set(msg.request_artifact_dirs or ()),
-        )
-        self.request_states[request_id] = req_state
-        self._register_running_request(req_state)
-        req_state.streaming.enabled = bool(getattr(prompt, "resumable", False))
-        req_state.stage_submit_ts[stage_id] = _time.time()
-        enqueue_ts = msg.enqueue_ts
-        if enqueue_ts > 0:
-            req_state.pipeline_timings["queue_wait_ms"] = (_time.perf_counter() - enqueue_ts) * 1000.0
-        preprocess_ms = msg.preprocess_ms
-        if preprocess_ms > 0:
-            req_state.pipeline_timings["preprocess_ms"] = preprocess_ms
-        if not await self._dispatch_or_fail_request(
-            lambda: self.stage_pools[stage_id].submit_initial(
-                request_id,
-                req_state,
-                prompt,
-                prompt_text=msg.output_prompt_text,
-            ),
-            req_id=request_id,
-            stage_id=stage_id,
-            operation="add_request",
-        ):
-            return
+    def _on_stage_submitted(
+        self,
+        stage_id: int,
+        request_id: str,
+        replica_id: int,
+        req_state: OrchestratorRequestState,
+    ) -> None:
+        """Called after every successful ``submit_initial`` / ``submit_update``."""
+        del stage_id, request_id, replica_id, req_state
 
-        if self.async_chunk and stage_id == 0 and final_stage_id > 0:
-            await self._prewarm_async_chunk_stages(request_id, prompt, req_state)
+    async def _intercept_stage_output(
+        self,
+        stage_id: int,
+        replica_id: int,
+        output: Any,
+        req_state: OrchestratorRequestState,
+        stage_metrics: Any,
+        submit_ts: float | None,
+    ) -> bool:
+        """Offer a processed output to the subclass before forwarding.
 
-    async def _handle_streaming_update(self, msg: StageSubmissionMessage) -> None:
-        """Handle a streaming_update message for an existing request."""
-        stage_id = 0
-        request_id = msg.request_id
-        request = msg.prompt
-        final_stage_id = msg.final_stage_id
-        req_state = self.request_states.get(request_id)
-        if req_state is None:
-            # Streaming updates always follow the first-chunk add_request
-            # through the same ordered submission queue, so an unknown id
-            # here can only mean the request already finished or was
-            # aborted (e.g. the client disconnected). Re-adding it would
-            # resurrect a headless session that keeps cycling through the
-            # stages with nobody consuming its outputs (issue #4271).
-            logger.warning(
-                "[Orchestrator] streaming_update for unknown req=%s; dropping (request finished or aborted)",
-                request_id,
-            )
-            return
+        Return True when the output must not be forwarded to the next stage
+        (the subclass consumed it). Client emission for session-owned requests
+        is already suppressed by ``OrchestratorRequestState.session_owned``.
+        """
+        del stage_id, replica_id, output, req_state, stage_metrics, submit_ts
+        return False
 
-        if msg.sampling_params_list:
-            req_state.sampling_params_list = msg.sampling_params_list
-
-        req_state.streaming.enabled = True
-        req_state.stage_submit_ts[stage_id] = _time.time()
-        if not await self._dispatch_or_fail_request(
-            lambda: self.stage_pools[stage_id].submit_update(
-                request_id,
-                req_state,
-                request,
-                prompt_text=msg.output_prompt_text,
-            ),
-            req_id=request_id,
-            stage_id=stage_id,
-            operation="streaming_update",
-        ):
-            return
-
-        if self.async_chunk and stage_id == 0 and final_stage_id > 0:
-            await self._prewarm_async_chunk_stages(request_id, request, req_state)
-
-    async def _handle_add_companion(self, msg: AddCompanionRequestMessage) -> None:
-        """Handle an add_companion_request message: submit companion to stage 0."""
-        companion_id = msg.companion_id
-        parent_id = msg.parent_id
-        role = msg.role
-        companion_prompt = msg.prompt
-        sampling_params_list = msg.sampling_params_list
-
-        parent_state = self.request_states.get(parent_id)
-        if parent_state is None:
-            logger.info(
-                "[Orchestrator] Dropping CFG companion %s (role=%s): parent %s is no longer active",
-                companion_id,
-                role,
-                parent_id,
-            )
-            return
-
-        self._cfg_tracker.register_companion(parent_id, role, companion_id)
-
-        companion_state = OrchestratorRequestState(
-            request_id=companion_id,
-            prompt=companion_prompt,
-            sampling_params_list=sampling_params_list,
-            final_stage_id=0,
-            final_output_stage_ids={0},
-            request_timestamp=parent_state.request_timestamp,
-        )
-        self.request_states[companion_id] = companion_state
-        companion_state.stage_submit_ts[0] = _time.time()
-        # A dead-stage failure is attributed to the parent request; its cleanup
-        # also releases this companion.
-        if not await self._dispatch_or_fail_request(
-            lambda: self.stage_pools[0].submit_initial(
-                companion_id,
-                companion_state,
-                companion_prompt,
-                prompt_text=msg.companion_prompt_text,
-                affinity_request_id=parent_id,
-            ),
-            req_id=parent_id,
-            stage_id=0,
-            operation=f"companion {companion_id}",
-            dispatch_req_id=companion_id,
-        ):
-            return
-
-        logger.info(
-            "[Orchestrator] CFG companion submitted: %s (role=%s, parent=%s, stage-0 replica-%s)",
-            companion_id,
-            role,
-            parent_id,
-            self.stage_pools[0].get_bound_replica_id(companion_id),
-        )
+    async def _handle_forward_failure(
+        self,
+        req_id: str,
+        next_stage_id: int,
+        req_state: OrchestratorRequestState,
+        exc: BaseException,
+    ) -> bool:
+        """Return True when a next-stage input-processing failure was absorbed (else it re-raises)."""
+        del req_id, next_stage_id, req_state, exc
+        return False
 
     async def _handle_abort(self, msg: AbortRequestMessage) -> None:
         """Handle an abort message from the main thread.
@@ -934,44 +617,6 @@ class Orchestrator:
             for output_msg in abort_outputs:
                 await self.output_async_queue.put(output_msg)
 
-    async def _handle_interaction(self, msg: InteractionMessage) -> None:
-        """Handle a midway interaction for an active streaming diffusion request."""
-        stage_id = 0
-        request_id = msg.request_id
-        event_id = msg.interaction.get("event_id")
-        req_state = self.request_states.get(request_id)
-        if req_state is None:
-            logger.info("[Orchestrator] Dropping interaction for inactive req %s", request_id)
-            await self.output_async_queue.put(
-                ErrorMessage(
-                    error=f"No active request for interaction: {request_id}",
-                    fatal=False,
-                    request_id=request_id,
-                    event_id=event_id,
-                    stage_id=stage_id,
-                )
-            )
-            return
-
-        try:
-            await self.stage_pools[stage_id].submit_interaction(request_id, msg.interaction)
-        except Exception as exc:
-            logger.info(
-                "[Orchestrator] Failed interaction for req %s: %s",
-                request_id,
-                exc,
-                exc_info=True,
-            )
-            await self.output_async_queue.put(
-                ErrorMessage(
-                    error=f"Failed interaction for request {request_id}: {exc}",
-                    fatal=False,
-                    request_id=request_id,
-                    event_id=event_id,
-                    stage_id=stage_id,
-                )
-            )
-
     async def _abort_request_ids(self, request_ids: list[str]) -> list[OutputMessage]:
         """Forward abort requests to all stage pools.
 
@@ -1120,22 +765,24 @@ class Orchestrator:
                     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)
         iteration_stats = IterationStats() if (self._stat_logger is not None and raw_outputs.outputs) else None
         processed = await pool.process_llm_raw_outputs(
             replica_id,
@@ -1143,6 +790,11 @@ class Orchestrator:
             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,
@@ -1199,7 +851,8 @@ class Orchestrator:
                                 idle = False
                                 continue
 
-                            pool.record_output_timestamps([diffusion_output])
+                            if not is_diffusion_request_started_output(diffusion_output):
+                                pool.record_output_timestamps([diffusion_output])
                             processed = [diffusion_output]
                         else:
                             raw_outputs = await pool.poll_llm_raw_output(replica_id, timeout_s=0.001)
@@ -1441,7 +1094,8 @@ class Orchestrator:
                         if self._absorb_diffusion_metrics(stage_id, replica_id, payload):
                             self._orch_monitor.note_loop(idle=False)
                             continue
-                        pool.record_output_timestamps([payload])
+                        if not is_diffusion_request_started_output(payload):
+                            pool.record_output_timestamps([payload])
                         processed = [payload]
                     else:
                         processed = await self._process_llm_stage_outputs(
@@ -1536,7 +1190,7 @@ class Orchestrator:
         await self._cleanup_request_ids(
             [parent_id, *self._cfg_tracker.cleanup_parent(parent_id)],
             abort=True,
-            close_duplex_sessions=True,
+            release_owners=True,
         )
 
     def _update_stage_replica_waiting(self, stage_id: int, replica_id: int, n_waiting: int) -> None:
@@ -1612,6 +1266,13 @@ class Orchestrator:
             await self._cleanup_request_ids(
                 [req_id, *self._cfg_tracker.cleanup_parent(req_id)],
                 abort=True,
+                # A session-owned request has an owner that outlives the stage
+                # request: without this the runner and its admission slot
+                # survive the replica that was serving them, and the client is
+                # told nothing -- the request-scoped ErrorMessage has no
+                # frontend request_states entry to land in. No-op for
+                # turn-based requests, which have no owner.
+                release_owners=True,
             )
 
     async def _fail_request_dead_stage(self, req_id: str, stage_id: int) -> None:
@@ -1639,6 +1300,7 @@ class Orchestrator:
         await self._cleanup_request_ids(
             [req_id, *self._cfg_tracker.cleanup_parent(req_id)],
             abort=True,
+            release_owners=True,
         )
 
     async def _fail_request_client_error(
@@ -1649,7 +1311,7 @@ class Orchestrator:
         *,
         status_code: int = HTTPStatus.BAD_REQUEST.value,
         error_type: str = DEFAULT_CLIENT_ERROR_TYPE,
-        close_duplex_sessions: bool = False,
+        release_owners: bool = False,
     ) -> None:
         """Fail one request with a non-fatal client error (400 by default).
 
@@ -1669,7 +1331,7 @@ class Orchestrator:
         await self._cleanup_request_ids(
             [req_id, *self._cfg_tracker.cleanup_parent(req_id)],
             abort=True,
-            close_duplex_sessions=close_duplex_sessions,
+            release_owners=release_owners,
         )
 
     async def _dispatch_or_fail_request(
@@ -1706,6 +1368,16 @@ class Orchestrator:
         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.
@@ -1764,7 +1436,7 @@ class Orchestrator:
         request_ids: list[str],
         *,
         abort: bool = False,
-        close_duplex_sessions: bool = False,
+        release_owners: bool = False,
     ) -> list[OutputMessage]:
         """Release pool bindings and logical request state for the given ids.
 
@@ -1775,10 +1447,14 @@ class Orchestrator:
         loss, membership unregister) funnels through here, so tracker state
         cannot outlive its requests.
 
+        ``release_owners`` asks the subclass to also release any session that
+        owns these requests (error paths pass True); the base ignores it.
+
         Returns:
             Final-stage AR abort ``OutputMessage`` list when ``abort=True``;
             otherwise an empty list.
         """
+        del release_owners
         if not request_ids:
             return []
 
@@ -1805,42 +1481,18 @@ class Orchestrator:
                 if cid not in batch:
                     batch.add(cid)
                     cleanup_ids.append(cid)
-        closing_session_ids: list[str] = []
-        if close_duplex_sessions and self.duplex_control_plane is not None:
-            closed_sessions = self.duplex_control_plane.close_sessions_for_request_ids(
-                cleanup_ids,
-                abort=abort,
-                cleanup_in_progress=True,
-            )
-            closing_session_ids.extend(closed_sessions)
-            for session_id, stale_request_ids in closed_sessions.items():
-                logger.info(
-                    "[Orchestrator] closed duplex session %s while cleaning failed request ids %s",
-                    session_id,
-                    stale_request_ids,
-                )
-                cleanup_ids.extend(stale_request_ids)
-            cleanup_ids = list(dict.fromkeys(cleanup_ids))
-
         abort_outputs: list[OutputMessage] = []
-        try:
-            if abort:
-                abort_outputs = await self._abort_request_ids(cleanup_ids)
-            self._release_request_bindings(cleanup_ids)
-            for request_id in cleanup_ids:
-                self._pd_kv_params.pop(request_id, None)
-                req_state = self.request_states.pop(request_id, None)
-                if req_state is not None:
-                    cleanup_request_artifact_dirs(getattr(req_state, "request_artifact_dirs", ()))
-                if req_state is not None and req_state.running_counter_registered and self._running_counter is not None:
-                    self._running_counter.decrement()
-                    req_state.running_counter_registered = False
-        except BaseException:
-            if closing_session_ids and self.duplex_control_plane is not None:
-                self.duplex_control_plane.defer_request_cleanups(closing_session_ids)
-            raise
-        if closing_session_ids and self.duplex_control_plane is not None:
-            self.duplex_control_plane.finalize_closed_sessions(closing_session_ids)
+        if abort:
+            abort_outputs = await self._abort_request_ids(cleanup_ids)
+        self._release_request_bindings(cleanup_ids)
+        for request_id in cleanup_ids:
+            self._pd_kv_params.pop(request_id, None)
+            req_state = self.request_states.pop(request_id, None)
+            if req_state is not None:
+                cleanup_request_artifact_dirs(getattr(req_state, "request_artifact_dirs", ()))
+            if req_state is not None and req_state.running_counter_registered and self._running_counter is not None:
+                self._running_counter.decrement()
+                req_state.running_counter_registered = False
         return abort_outputs
 
     async def _apply_raw_terminal_stage_finish(
@@ -1857,37 +1509,88 @@ class Orchestrator:
         ``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
 
+    async def _report_duplex_session_request_error(
+        self,
+        stage_id: int,
+        replica_id: int | None,
+        eco: Any,
+        req_state: OrchestratorRequestState,
+    ) -> None:
+        """Turn a scheduler-side error finish of a duplex session request into a request error.
+
+        A duplex session request is resumable, so its terminal outputs are
+        deliberately not turned into processed outputs
+        (``_finish_raw_terminal_requests`` skips duplex sessions), and vLLM's
+        output processor may already have dropped the request state by the
+        time the raw ``FinishReason.ERROR`` output arrives. Without this the
+        session never learns that its request is gone: the next append
+        re-creates the request from scratch and the session silently loses
+        its context. Deliver the error to the request's consumer instead so
+        the serving layer can fail and close the session.
+        """
+        if not req_state.session_owned:
+            return
+        if getattr(eco, "finish_reason", None) != FinishReason.ERROR:
+            return
+        if getattr(eco, "is_segment_finished", False):
+            return
+        stop_reason = getattr(eco, "stop_reason", None)
+        error = stop_reason if isinstance(stop_reason, str) and stop_reason else "duplex session request failed"
+        logger.error(
+            "[Orchestrator] Duplex session request %s failed at stage-%s replica-%s: %s",
+            req_state.request_id,
+            stage_id,
+            replica_id,
+            error,
+        )
+        await self.output_async_queue.put(
+            ErrorMessage(
+                error=error,
+                fatal=False,
+                request_id=req_state.request_id,
+                stage_id=stage_id,
+            )
+        )
+
     async def _finish_raw_terminal_requests(
         self,
         stage_id: int,
         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 self._is_duplex_session_request(req_state):
+            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
@@ -1934,28 +1637,6 @@ class Orchestrator:
         params.cfg_kv_request_ids = companion_request_ids
         return params
 
-    def _duplex_session_for_req_state(self, req_state: OrchestratorRequestState) -> DuplexSessionRuntimeState | None:
-        if self.duplex_control_plane is None:
-            return None
-        return self.duplex_control_plane.session_for_identity(req_state.duplex_identity)
-
-    def _record_duplex_stage_submission(
-        self,
-        stage_id: int,
-        request_id: str,
-        replica_id: int,
-        req_state: OrchestratorRequestState,
-    ) -> None:
-        del replica_id
-        identity = req_state.duplex_identity
-        session = self._duplex_session_for_req_state(req_state)
-        if identity is None or session is None:
-            return
-        req_state.duplex_stage_fences[stage_id] = identity.fence
-        session.bind_stage_request(stage_id, request_id, fence=identity.fence)
-        req_state.stage_submit_ts[stage_id] = _time.time()
-        self._register_running_request(req_state)
-
     def _register_running_request(self, req_state: OrchestratorRequestState) -> None:
         if req_state.running_counter_registered or self._running_counter is None:
             return
@@ -1983,39 +1664,41 @@ class Orchestrator:
             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)
-        # Duplex stage-0 segment boundaries are not client-visible outputs:
-        # direct decisions are emitted by the model runtime extension below,
-        # while spoken content flows through the next stage. Forwarding
-        # the raw stage-0 output as well injects one cumulative-text,
-        # no-audio message per unit that every downstream consumer must
-        # filter out again (the official implementation returns exactly one
-        # result per audio chunk).
-        is_duplex_stage0_segment = (
-            stage_id == 0 and self._is_duplex_session_request(req_state) and req_state.streaming.segment(0).finished
-        )
-        if self.stage_pools[stage_id].final_output and not is_duplex_stage0_segment:
-            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
-                        or (
-                            self._is_duplex_session_request(req_state)
-                            and req_state.streaming.segment(stage_id).finished
-                        )
-                    ),
-                    stage_submit_ts=submit_ts,
-                )
+        if req_state.session_owned:
+            # Session-owned outputs are delivered through the session interceptor.
+            pass
+        elif self.stage_pools[stage_id].final_output:
+            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(
@@ -2033,16 +1716,7 @@ class Orchestrator:
                 self._pd_kv_params[req_id] = kv_params if isinstance(kv_params, dict) else dict(kv_params)
             req_state.pd_prefill_multimodal_output = getattr(output, "multimodal_output", None)
 
-        duplex_output_decision = self._duplex_output_decision(stage_id, output, req_state)
-        if duplex_output_decision is not None:
-            await self._emit_duplex_direct_output(
-                stage_id,
-                req_id,
-                output,
-                duplex_output_decision,
-                stage_metrics,
-                submit_ts,
-            )
+        if await self._intercept_stage_output(stage_id, replica_id, output, req_state, stage_metrics, submit_ts):
             return
 
         if (
@@ -2079,7 +1753,7 @@ class Orchestrator:
                     and self.request_states.get(req_id) is req_state
                     and finished
                     and not final_only_finished
-                    and not self._is_duplex_session_request(req_state)
+                    and not req_state.session_owned
                 ):
                     # For streaming sessions, send the terminal (resumable=False) update only on a finish
                     await self._forward_to_next_stage(
@@ -2092,7 +1766,13 @@ class Orchestrator:
                         is_final_update=True,
                     )
 
-        if request_finished and not self._is_duplex_session_request(req_state):
+        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)])
 
     def _next_stage_already_submitted(self, stage_id: int, req_state: OrchestratorRequestState) -> bool:
@@ -2148,6 +1828,7 @@ class Orchestrator:
         *,
         mm_features: list | None = None,
         resumable: bool = False,
+        payload_sender_info: dict[str, Any] | None = None,
     ) -> Any:
         next_pool = self.stage_pools[next_stage_id]
         if self._next_stage_input_is_tokens(next_input):
@@ -2160,6 +1841,7 @@ class Orchestrator:
                 resumable=resumable,
             )
             request.external_req_id = request.request_id
+            request.payload_sender_info = payload_sender_info
             return request
 
         processor = self._get_stage_input_processor(next_stage_id)
@@ -2181,94 +1863,9 @@ class Orchestrator:
         )
         request = self._upgrade_processed_stage_request(request, next_input)
         request.external_req_id = req_id
+        request.payload_sender_info = payload_sender_info
         return request
 
-    @staticmethod
-    def _duplex_output_context(
-        req_state: OrchestratorRequestState,
-        *,
-        # Required: segment state is stage-keyed, so a caller that omitted this
-        # would silently read "no boundary" rather than the intended stage's.
-        stage_id: int | None,
-    ) -> DuplexOutputContext | None:
-        identity = req_state.duplex_identity
-        if identity is None:
-            return None
-        fence = req_state.duplex_stage_fences.get(stage_id, identity.fence) if stage_id is not None else identity.fence
-        segment = req_state.streaming.segment(stage_id)
-        return DuplexOutputContext(
-            identity=DuplexRequestIdentity(
-                session_id=identity.session_id,
-                fence=fence,
-            ),
-            final_stage_id=req_state.final_stage_id,
-            segment_finished=req_state.streaming.enabled and segment.finished,
-            segment_token_ids=tuple(segment.token_ids),
-            segment_output_metadata=segment.output_metadata,
-        )
-
-    @staticmethod
-    def _is_duplex_session_request(req_state: OrchestratorRequestState) -> bool:
-        return req_state.duplex_identity is not None
-
-    @staticmethod
-    def _duplex_fence_for_req_state(
-        req_state: OrchestratorRequestState,
-        *,
-        stage_id: int | None = None,
-    ) -> DuplexFence | None:
-        context = Orchestrator._duplex_output_context(req_state, stage_id=stage_id)
-        return context.identity.fence if context is not None else None
-
-    def _duplex_output_decision(
-        self,
-        stage_id: int,
-        output: Any,
-        req_state: OrchestratorRequestState,
-    ) -> DuplexOutputDecision | None:
-        if self.duplex_control_plane is None:
-            return None
-        context = self._duplex_output_context(req_state, stage_id=stage_id)
-        decision = self.duplex_control_plane.decide_output(
-            stage_id,
-            output,
-            context,
-        )
-        return decision
-
-    async def _emit_duplex_direct_output(
-        self,
-        stage_id: int,
-        req_id: str,
-        output: Any,
-        decision: DuplexOutputDecision,
-        stage_metrics: Any,
-        submit_ts: float | None,
-    ) -> None:
-        action = getattr(decision.action, "value", decision.action)
-        if action != "direct_response":
-            raise ValueError(f"Unsupported duplex output action: {action}")
-        engine_output = attach_duplex_output_decision(
-            OmniRequestOutput.from_stage_output(
-                output,
-                request_id=req_id,
-                finished=True,
-                stage_id=stage_id,
-                final_output_type=decision.final_output_type,
-            ),
-            decision,
-        )
-        await self.output_async_queue.put(
-            OutputMessage(
-                request_id=req_id,
-                stage_id=stage_id,
-                engine_outputs=engine_output,
-                metrics=stage_metrics,
-                finished=True,
-                stage_submit_ts=submit_ts,
-            )
-        )
-
     @staticmethod
     def _completion_multimodal_output(output: Any, completion: Any) -> dict[str, Any]:
         mm_output = getattr(output, "multimodal_output", None)
@@ -2639,15 +2236,16 @@ class Orchestrator:
                     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._record_duplex_stage_submission(
+            self._on_stage_submitted(
                 next_logical,
                 req_id,
                 replica_id,
@@ -2700,7 +2298,7 @@ class Orchestrator:
                     replica_id = await next_pool.submit_update(req_id, req_state, request)
                 else:
                     replica_id = await next_pool.submit_initial(req_id, req_state, request, prompt_text=None)
-                self._record_duplex_stage_submission(
+                self._on_stage_submitted(
                     next_logical,
                     req_id,
                     replica_id,
@@ -2745,7 +2343,7 @@ class Orchestrator:
                 str(exc),
                 status_code=exc.status_code,
                 error_type=exc.error_type,
-                close_duplex_sessions=self._is_duplex_session_request(req_state),
+                release_owners=req_state.session_owned,
             )
             return
         except Exception as exc:
@@ -2754,21 +2352,8 @@ class Orchestrator:
                 req_id,
                 next_logical,
             )
-            if not self._is_duplex_session_request(req_state):
+            if not await self._handle_forward_failure(req_id, next_logical, req_state, exc):
                 raise
-            await self.output_async_queue.put(
-                ErrorMessage(
-                    request_id=req_id,
-                    stage_id=next_logical,
-                    error=f"Stage-{next_logical} input processor failed: {type(exc).__name__}: {exc}",
-                    error_type=type(exc).__name__,
-                )
-            )
-            await self._cleanup_request_ids(
-                [req_id, *self._cfg_tracker.cleanup_parent(req_id)],
-                abort=True,
-                close_duplex_sessions=True,
-            )
             return
         finally:
             req_state.streaming.source_token_decoder = previous_decoder
@@ -2829,13 +2414,14 @@ class Orchestrator:
                 params=params,
                 mm_features=mm_features,
                 resumable=next_stage_resumable,
+                payload_sender_info=self._build_payload_sender_info(src_stage_id, request_id=req_id),
             )
 
             if already_submitted:
                 replica_id = await next_pool.submit_update(req_id, req_state, request)
             else:
                 replica_id = await next_pool.submit_initial(req_id, req_state, request, prompt_text=None)
-            self._record_duplex_stage_submission(
+            self._on_stage_submitted(
                 next_logical,
                 req_id,
                 replica_id,
@@ -2893,7 +2479,7 @@ class Orchestrator:
                 0,
                 "async_chunk requires prompt_token_ids on the stage-0 request; "
                 "an embeds-only prompt cannot prewarm downstream stages",
-                close_duplex_sessions=True,
+                release_owners=True,
             )
             return False
 
@@ -2910,12 +2496,12 @@ class Orchestrator:
             _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,
@@ -2928,8 +2514,6 @@ class Orchestrator:
                     operation="async-chunk prewarm",
                 )
             else:
-                import copy
-
                 from vllm_omni.distributed.omni_connectors.adapter import compute_talker_prompt_ids_length
 
                 try:
@@ -2952,7 +2536,9 @@ class Orchestrator:
 
                 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 = {}
 
@@ -2967,6 +2553,7 @@ class Orchestrator:
                     model_config=next_pool.stage_vllm_config.model_config,
                     resumable=downstream_resumable,
                 )
+                request.payload_sender_info = self._build_payload_sender_info(next_stage_id - 1, request_id=request_id)
                 request.external_req_id = request.request_id
                 submitted = await self._dispatch_or_fail_request(
                     lambda: next_pool.submit_initial(
@@ -2988,7 +2575,7 @@ class Orchestrator:
             # The guard swallows submit_initial's return value; the pool binding
             # it recorded carries the same replica.
             bound_replica_id = next_pool.get_bound_replica_id(request_id)
-            self._record_duplex_stage_submission(
+            self._on_stage_submitted(
                 next_stage_id,
                 request_id,
                 bound_replica_id if bound_replica_id is not None else 0,
@@ -3011,6 +2598,67 @@ class Orchestrator:
 
         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],
@@ -3043,6 +2691,23 @@ class Orchestrator:
 
         return sender_infos or None
 
+    def _build_payload_sender_info(
+        self,
+        sender_stage_id: int,
+        *,
+        request_id: str | None = None,
+    ) -> dict[str, Any] | None:
+        if sender_stage_id < 0 or sender_stage_id >= len(self.stage_pools):
+            return None
+        sender_pool = self.stage_pools[sender_stage_id]
+        sender_stage = sender_pool.get_bound_client(request_id) if request_id is not None else None
+        if sender_stage is None:
+            sender_stage = sender_pool.stage_client
+        get_sender_info = getattr(sender_stage, "get_payload_sender_info", None)
+        if not callable(get_sender_info):
+            return None
+        return get_sender_info()
+
     # ---- Shutdown / lifecycle ----
 
     def _shutdown_stages(self) -> None:
@@ -3056,3 +2721,223 @@ class Orchestrator:
         for pool in self.stage_pools:
             for replica_id in pool.live_replica_ids():
                 pool.shutdown_replica(replica_id)
+
+
+class Orchestrator(OrchestratorBase):
+    """Turn-based orchestrator: admits ``add_request`` / streaming / companion / interaction messages."""
+
+    async def _dispatch_message(self, msg: EngineQueueMessage) -> bool:
+        msg_type = msg.type
+        if msg_type == "add_request":
+            await self._handle_add_request(msg)
+        elif msg_type == "streaming_update":
+            await self._handle_streaming_update(msg)
+        elif msg_type == "add_companion_request":
+            await self._handle_add_companion(msg)
+        elif msg_type == "interaction":
+            await self._handle_interaction(msg)
+        else:
+            return False
+        return True
+
+    async def _handle_add_request(self, msg: StageSubmissionMessage) -> None:
+        """Handle an add_request message from the main thread."""
+        stage_id = 0
+        request_id = msg.request_id
+        prompt = msg.prompt
+        original_prompt = msg.original_prompt
+        sampling_params_list = msg.sampling_params_list
+        if not sampling_params_list:
+            raise ValueError(f"Missing sampling params for stage 0. Got {len(sampling_params_list)} stage params.")
+        final_stage_id = msg.final_stage_id
+        final_output_stage_ids = set(msg.final_output_stage_ids or [final_stage_id])
+
+        if not self.stage_pools[stage_id].live_replica_ids():
+            # Stage 0 lost all replicas between the HTTP-layer errored check and
+            # dispatch. Runs before request state / running counter registration,
+            # so the helper's cleanup is a no-op here.
+            await self._fail_request_dead_stage(request_id, stage_id)
+            return
+
+        logger.debug(
+            "[Orchestrator] _handle_add_request: stage=%s req=%s "
+            "prompt_type=%s original_prompt_type=%s final_stage=%s "
+            "num_sampling_params=%d",
+            stage_id,
+            request_id,
+            type(prompt).__name__,
+            type(original_prompt).__name__,
+            final_stage_id,
+            len(sampling_params_list),
+        )
+
+        req_state = OrchestratorRequestState(
+            request_id=request_id,
+            prompt=original_prompt,
+            sampling_params_list=sampling_params_list,
+            final_stage_id=final_stage_id,
+            final_output_stage_ids=final_output_stage_ids,
+            request_timestamp=float(msg.request_timestamp or _time.time()),
+            mm_features=getattr(prompt, "mm_features", None),
+            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()
+        enqueue_ts = msg.enqueue_ts
+        if enqueue_ts > 0:
+            req_state.pipeline_timings["queue_wait_ms"] = (_time.perf_counter() - enqueue_ts) * 1000.0
+        preprocess_ms = msg.preprocess_ms
+        if preprocess_ms > 0:
+            req_state.pipeline_timings["preprocess_ms"] = preprocess_ms
+        if not await self._dispatch_or_fail_request(
+            lambda: self.stage_pools[stage_id].submit_initial(
+                request_id,
+                req_state,
+                prompt,
+                prompt_text=msg.output_prompt_text,
+            ),
+            req_id=request_id,
+            stage_id=stage_id,
+            operation="add_request",
+        ):
+            return
+
+        if self.async_chunk and stage_id == 0 and final_stage_id > 0:
+            await self._prewarm_async_chunk_stages(request_id, prompt, req_state)
+
+    async def _handle_streaming_update(self, msg: StageSubmissionMessage) -> None:
+        """Handle a streaming_update message for an existing request."""
+        stage_id = 0
+        request_id = msg.request_id
+        request = msg.prompt
+        final_stage_id = msg.final_stage_id
+        req_state = self.request_states.get(request_id)
+        if req_state is None:
+            # Streaming updates always follow the first-chunk add_request
+            # through the same ordered submission queue, so an unknown id
+            # here can only mean the request already finished or was
+            # aborted (e.g. the client disconnected). Re-adding it would
+            # resurrect a headless session that keeps cycling through the
+            # stages with nobody consuming its outputs (issue #4271).
+            logger.warning(
+                "[Orchestrator] streaming_update for unknown req=%s; dropping (request finished or aborted)",
+                request_id,
+            )
+            return
+
+        if msg.sampling_params_list:
+            req_state.sampling_params_list = msg.sampling_params_list
+
+        req_state.streaming.enabled = True
+        req_state.stage_submit_ts[stage_id] = _time.time()
+        if not await self._dispatch_or_fail_request(
+            lambda: self.stage_pools[stage_id].submit_update(
+                request_id,
+                req_state,
+                request,
+                prompt_text=msg.output_prompt_text,
+            ),
+            req_id=request_id,
+            stage_id=stage_id,
+            operation="streaming_update",
+        ):
+            return
+
+        if self.async_chunk and stage_id == 0 and final_stage_id > 0:
+            await self._prewarm_async_chunk_stages(request_id, request, req_state)
+
+    async def _handle_add_companion(self, msg: AddCompanionRequestMessage) -> None:
+        """Handle an add_companion_request message: submit companion to stage 0."""
+        companion_id = msg.companion_id
+        parent_id = msg.parent_id
+        role = msg.role
+        companion_prompt = msg.prompt
+        sampling_params_list = msg.sampling_params_list
+
+        parent_state = self.request_states.get(parent_id)
+        if parent_state is None:
+            logger.info(
+                "[Orchestrator] Dropping CFG companion %s (role=%s): parent %s is no longer active",
+                companion_id,
+                role,
+                parent_id,
+            )
+            return
+
+        self._cfg_tracker.register_companion(parent_id, role, companion_id)
+
+        companion_state = OrchestratorRequestState(
+            request_id=companion_id,
+            prompt=companion_prompt,
+            sampling_params_list=sampling_params_list,
+            final_stage_id=0,
+            final_output_stage_ids={0},
+            request_timestamp=parent_state.request_timestamp,
+        )
+        self.request_states[companion_id] = companion_state
+        companion_state.stage_submit_ts[0] = _time.time()
+        # A dead-stage failure is attributed to the parent request; its cleanup
+        # also releases this companion.
+        if not await self._dispatch_or_fail_request(
+            lambda: self.stage_pools[0].submit_initial(
+                companion_id,
+                companion_state,
+                companion_prompt,
+                prompt_text=msg.companion_prompt_text,
+                affinity_request_id=parent_id,
+            ),
+            req_id=parent_id,
+            stage_id=0,
+            operation=f"companion {companion_id}",
+            dispatch_req_id=companion_id,
+        ):
+            return
+
+        logger.info(
+            "[Orchestrator] CFG companion submitted: %s (role=%s, parent=%s, stage-0 replica-%s)",
+            companion_id,
+            role,
+            parent_id,
+            self.stage_pools[0].get_bound_replica_id(companion_id),
+        )
+
+    async def _handle_interaction(self, msg: InteractionMessage) -> None:
+        """Handle a midway interaction for an active streaming diffusion request."""
+        stage_id = 0
+        request_id = msg.request_id
+        event_id = msg.interaction.get("event_id")
+        req_state = self.request_states.get(request_id)
+        if req_state is None:
+            logger.info("[Orchestrator] Dropping interaction for inactive req %s", request_id)
+            await self.output_async_queue.put(
+                ErrorMessage(
+                    error=f"No active request for interaction: {request_id}",
+                    fatal=False,
+                    request_id=request_id,
+                    event_id=event_id,
+                    stage_id=stage_id,
+                )
+            )
+            return
+
+        try:
+            await self.stage_pools[stage_id].submit_interaction(request_id, msg.interaction)
+        except Exception as exc:
+            logger.info(
+                "[Orchestrator] Failed interaction for req %s: %s",
+                request_id,
+                exc,
+                exc_info=True,
+            )
+            await self.output_async_queue.put(
+                ErrorMessage(
+                    error=f"Failed interaction for request {request_id}: {exc}",
+                    fatal=False,
+                    request_id=request_id,
+                    event_id=event_id,
+                    stage_id=stage_id,
+                )
+            )
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_client.py b/vllm_omni/engine/stage_client.py
index 2a3c26177..7ee949146 100644
--- a/vllm_omni/engine/stage_client.py
+++ b/vllm_omni/engine/stage_client.py
@@ -94,6 +94,8 @@ class StagePoolLLMClient(StagePoolClient, Protocol):
         kv_transfer_port_offset: int = ...,
     ) -> dict[str, Any] | None: ...
 
+    def get_payload_sender_info(self) -> dict[str, Any] | None: ...
+
 
 class StagePoolDiffusionClient(StagePoolClient, Protocol):
     """Pool-facing API for diffusion stages."""
diff --git a/vllm_omni/engine/stage_engine_core_client.py b/vllm_omni/engine/stage_engine_core_client.py
index 87baaed5f..e87d19bb4 100644
--- a/vllm_omni/engine/stage_engine_core_client.py
+++ b/vllm_omni/engine/stage_engine_core_client.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 """
 Stage Engine Core Client for vLLM-Omni multi-stage runtime.
 
@@ -16,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 (
@@ -210,6 +213,7 @@ class StageEngineCoreClientBase(StageClientBase):
                 )
             raise
 
+        self._payload_sender_info = self._build_payload_sender_info()
         self._initialize_kv_sender_endpoint()
 
         logger.info(
@@ -228,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:
@@ -291,6 +298,39 @@ class StageEngineCoreClientBase(StageClientBase):
             return None
         return connector_config
 
+    def _build_payload_sender_info(self) -> dict[str, Any] | None:
+        model_config = getattr(self.vllm_config, "model_config", None)
+        connector_config = getattr(model_config, "stage_connector_config", None)
+        if not isinstance(connector_config, dict):
+            return None
+        extra = connector_config.get("extra")
+        if not isinstance(extra, dict):
+            return None
+        if isinstance(extra.get("outgoing"), dict):
+            extra = extra["outgoing"]
+        elif extra.get("role") != "sender":
+            return None
+        base_port = extra.get("zmq_port", 50051)
+        if base_port is None:
+            return None
+        sender_host = self._resolve_sender_host_from_config(extra)
+        if sender_host is None:
+            return None
+        from vllm_omni.distributed.omni_connectors.utils.initialization import compute_connector_zmq_port
+
+        return {
+            "host": sender_host,
+            "zmq_port": compute_connector_zmq_port(
+                int(os.path.expandvars(str(base_port))),
+                purpose="request_forwarding",
+                from_stage=int(extra.get("from_stage", self.stage_id)),
+                replica_id=self.replica_id,
+            ),
+        }
+
+    def get_payload_sender_info(self) -> dict[str, Any] | None:
+        return dict(self._payload_sender_info) if self._payload_sender_info is not None else None
+
     def _resolve_sender_host_from_config(self, connector_config: dict[str, Any]) -> str | None:
         host = connector_config.get("sender_host") or connector_config.get("host")
         if host in {None, "", "auto", "*", "0.0.0.0", "::"}:
diff --git a/vllm_omni/engine/stage_engine_core_proc.py b/vllm_omni/engine/stage_engine_core_proc.py
index e483e1bd4..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,11 +105,17 @@ 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)
         scheduler_request.additional_information = request.additional_information
         scheduler_request.external_req_id = getattr(request, "external_req_id", request.request_id)
+        scheduler_request.payload_sender_info = request.payload_sender_info
         return scheduler_request, current_wave
 
     @staticmethod
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 de97f7aa3..faaf6b707 100644
--- a/vllm_omni/engine/stage_init_utils.py
+++ b/vllm_omni/engine/stage_init_utils.py
@@ -50,6 +50,9 @@ from vllm_omni.config.omni_config import (
 )
 from vllm_omni.config.stage_config import StageType
 from vllm_omni.diffusion.data import OmniDiffusionConfig
+from vllm_omni.distributed.omni_connectors.utils.config import (
+    TRANSFER_ENGINE_CONNECTOR_NAMES,
+)
 from vllm_omni.engine.arg_utils import OmniEngineArgs
 from vllm_omni.entrypoints.stage_utils import _to_dict, set_stage_devices
 from vllm_omni.entrypoints.utils import filter_dataclass_kwargs
@@ -399,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
@@ -486,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
@@ -501,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))
@@ -700,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":
@@ -875,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)
@@ -886,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
@@ -930,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")
@@ -945,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)
         )
@@ -1083,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(
@@ -1100,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 (
@@ -1148,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(
@@ -1327,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,
@@ -1347,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(
@@ -1388,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.
@@ -1442,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.
 
@@ -1449,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
@@ -1712,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.
 
@@ -1766,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",
@@ -1777,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,
         )
 
@@ -1795,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)
@@ -1882,17 +1926,37 @@ def get_stage_connector_spec(
 
     stage_connectors_cfg = get_stage_connector_config(omni_transfer_config, stage_id)
     for cfg in stage_connectors_cfg.values():
-        return dict(cfg.get("spec", {}))
+        connector_spec = dict(cfg.get("spec", {}))
+        if connector_spec.get("name") == "NixlConnector":
+            # A middle worker uses one connector for both directions. Preserve
+            # the incoming edge and carry the outgoing bind config separately.
+            for (source, target), outgoing in getattr(omni_transfer_config, "connectors", {}).items():
+                if source == str(stage_id):
+                    if outgoing.name != "NixlConnector":
+                        raise ValueError("A NIXL middle stage requires NIXL on its outgoing edge")
+                    extra = dict(connector_spec.get("extra", {}))
+                    extra["outgoing"] = {**(outgoing.extra or {}), "from_stage": int(source), "to_stage": int(target)}
+                    connector_spec["extra"] = extra
+                    break
+        if connector_spec.get("name") not in TRANSFER_ENGINE_CONNECTOR_NAMES:
+            extra = dict(connector_spec.get("extra", {}))
+            extra.pop("from_stage", None)
+            extra.pop("to_stage", None)
+            connector_spec["extra"] = extra
+        return connector_spec
 
     # A producer does not consume connector data itself. Keep its connector
     # for both async-chunk and terminal full-payload sends, but mark it
     # sender-only so the scheduler does not park orchestrator-provided inputs
     # waiting for an upstream payload.
     target_stage = str(stage_id)
-    for (from_stage, _to_stage), spec in getattr(omni_transfer_config, "connectors", {}).items():
+    for (from_stage, to_stage), spec in getattr(omni_transfer_config, "connectors", {}).items():
         if from_stage == target_stage:
             extra = dict(spec.extra or {})
             extra.setdefault("role", "sender")
+            if spec.name in TRANSFER_ENGINE_CONNECTOR_NAMES:
+                extra["from_stage"] = int(from_stage)
+                extra["to_stage"] = int(to_stage)
             return {"name": spec.name, "extra": extra}
     return {}
 
@@ -1903,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 0012039e0..1291e68f0 100644
--- a/vllm_omni/entrypoints/async_omni.py
+++ b/vllm_omni/entrypoints/async_omni.py
@@ -20,31 +20,17 @@ from vllm import TokensPrompt
 from vllm.engine.protocol import EngineClient, StreamingInput
 from vllm.logger import init_logger
 from vllm.lora.request import LoRARequest
-from vllm.outputs import CompletionOutput, PoolingRequestOutput
-from vllm.plugins.io_processors import get_io_processor
+from vllm.outputs import PoolingRequestOutput
 from vllm.pooling_params import PoolingParams
 from vllm.renderers.inputs.preprocess import extract_prompt_components
 from vllm.sampling_params import RequestOutputKind, SamplingParams
 from vllm.tasks import SupportedTask
-from vllm.utils import random_uuid
-from vllm.v1.engine.exceptions import EngineDeadError
 
 from vllm_omni.diffusion.data import CuMemTag, OmniACK, OmniSleepTask, OmniWakeTask
-from vllm_omni.engine.duplex.lease import DuplexLeaseActivity
-from vllm_omni.engine.duplex.messages import (
-    DuplexFence,
-    DuplexSessionLifecycleMessage,
-)
-from vllm_omni.engine.messages import ErrorMessage, OutputMessage
+from vllm_omni.engine.async_omni_engine import AsyncOmniEngine
+from vllm_omni.engine.messages import ErrorMessage
+from vllm_omni.entrypoints.async_omni_base import ABORT_TIMEOUT_S, AsyncOmniBase
 from vllm_omni.entrypoints.client_request_state import ClientRequestState
-from vllm_omni.entrypoints.duplex_request_client import (
-    DuplexRequestClient,
-    DuplexRequestOutputPort,
-)
-from vllm_omni.entrypoints.omni_base import (
-    OmniBase,
-    OmniEngineDeadError,
-)
 from vllm_omni.errors import client_error_metadata
 from vllm_omni.inputs.data import OmniSamplingParams
 from vllm_omni.metrics.stats import OrchestratorAggregator as OrchestratorMetrics
@@ -58,72 +44,9 @@ if TYPE_CHECKING:
     from vllm_omni.inputs.data import OmniInteractionPrompt, OmniPromptType
 
 logger = init_logger(__name__)
-_FINAL_OUTPUT_IDLE_SLEEP_S = 0.001
-# Blocking-wait interval for the event-driven final-output drain
-# (VLLM_OMNI_EVENT_DRIVEN_ORCH=1): a message wakes the drain immediately via
-# the janus queue's condition variable; this timeout only bounds how often the
-# orchestrator liveness check runs while the pipeline is idle.
-_FINAL_OUTPUT_BLOCKING_WAIT_S = 1.0
 
 
-class AsyncEventResolver:
-    """
-    A generic signal aggregator designed for synchronized handshakes in
-    distributed or multi-stage environments. Supports waiting for a specified
-    number (expected_count) of worker signals in both inline and multiprocess modes.
-    """
-
-    def __init__(self, orchestrator=None):
-        self._pending_tasks: dict[str, dict] = {}
-        self.orchestrator = orchestrator
-        self._lock = asyncio.Lock()
-
-    def watch_task(self, task_id: str, expected_count: int = 1) -> asyncio.Future:
-        loop = asyncio.get_running_loop()
-        fut = loop.create_future()
-        self._pending_tasks[task_id] = {
-            "future": fut,
-            "expected_count": expected_count,
-            "received": [],
-            "start_time": time.time(),
-        }
-        return fut
-
-    async def resolve(self, ack: OmniACK):
-        tid = getattr(ack, "task_id", None)
-
-        if tid is None and isinstance(ack, dict):
-            tid = ack.get("task_id")
-
-        async with self._lock:
-            task_info = self._pending_tasks.get(tid)
-            if task_info is None:
-                logger.warning(f"Received stray ACK for task_id {tid}. Task might have timed out.")
-                return
-
-            task_info["received"].append(ack)
-            current_count = len(task_info["received"])
-            expected = task_info["expected_count"]
-
-            orchestrator = self.orchestrator
-            if orchestrator and hasattr(orchestrator, "metrics") and orchestrator.metrics:
-                freed = getattr(ack, "freed_bytes", 0)
-                if freed == 0 and isinstance(ack, dict):
-                    freed = ack.get("freed_bytes", 0)
-                orchestrator.metrics.record_vram_reclaimed(freed)
-
-            logger.info(f"[Resolver] Task {tid} progress: {current_count}/{expected} ACKs received.")
-
-            if current_count >= expected:
-                self._pending_tasks.pop(tid)
-                fut = task_info["future"]
-                if not fut.done():
-                    elapsed = time.time() - task_info["start_time"]
-                    logger.info(f"[Resolver] Task {tid} completed successfully in {elapsed:.2f}s.")
-                    fut.set_result(task_info["received"])
-
-
-class AsyncOmni(EngineClient, OmniBase):
+class AsyncOmni(AsyncOmniBase, EngineClient):
     """Asynchronous unified entry point for multi-stage pipelines using AsyncOmniEngine.
 
     This is the refactored version that uses AsyncOmniEngine instead of
@@ -152,8 +75,13 @@ class AsyncOmni(EngineClient, OmniBase):
         ...     print(output)
     """
 
-    def __init__(self, *args: Any, model: str = "", **kwargs: Any) -> None:
-        OmniBase.__init__(self, model=model, **kwargs)
+    def _create_engine(self, **engine_kwargs: Any) -> AsyncOmniEngine:
+        return AsyncOmniEngine(**engine_kwargs)
+
+    def __init__(self, model: str = "", *args: Any, **kwargs: Any) -> None:
+        tts_max_instructions_length = kwargs.get("tts_max_instructions_length", None)
+        AsyncOmniBase.__init__(self, *args, model=model, **kwargs)
+        self.tts_max_instructions_length = tts_max_instructions_length
         self._pause_cond: asyncio.Condition = asyncio.Condition()
         self._paused: bool = False
         # In-flight EngineCore submits (non-streaming add_request, or each
@@ -170,294 +98,6 @@ class AsyncOmni(EngineClient, OmniBase):
         self._sleeping_tags: set[str] = set()
         self._stage_sleeping_tags: dict[int, set[str]] = {}
         self._level2_sleeping: bool = False
-        self._duplex_request_client: DuplexRequestClient | None = None
-        self.duplex_lifecycle_events: asyncio.Queue[DuplexSessionLifecycleMessage] = asyncio.Queue()
-        self.final_output_task: asyncio.Task | None = None
-        self.event_resolver = AsyncEventResolver(orchestrator=self)
-        self.config_path = self.engine.config_path
-        self.tts_max_instructions_length = kwargs.get("tts_max_instructions_length", None)
-        self.input_processor = self.engine.input_processor
-        self.endpoint_restrictions = self.engine.endpoint_restrictions
-        self.duplex_session_config = self.engine.duplex_session_config
-        self.duplex_serving_adapter_path = self.engine.duplex_serving_adapter_path
-
-        stage_index = self._get_comprehension_stage_index()
-        if stage_index is None:
-            self.io_processor = None
-        else:
-            vllm_config = self.engine.stage_vllm_configs[stage_index]
-            io_processor_plugin = vllm_config.model_config.io_processor_plugin
-            renderer = self.renderer
-            if renderer is None:
-                from vllm.renderers import renderer_from_config
-
-                renderer = renderer_from_config(vllm_config)
-            self.io_processor = get_io_processor(vllm_config, renderer, io_processor_plugin)
-
-    def _resolve_transfer_replica(self, stage_id: int, request_id: str) -> int | None:
-        """Look up the sticky-routed replica for (stage_id, request_id).
-
-        Used as the ``replica_resolver`` callback by ``OrchestratorAggregator``
-        to label transfer_* metrics without plumbing replica ids through
-        ``TransferEdgeStats`` / ``StageRequestStats`` / connector adapters.
-        Returns None when stage_id is out of range or the request hasn't been
-        bound to a replica yet — the metric emit then defensive-skips.
-        """
-        pools = getattr(self.engine, "stage_pools", None)
-        if pools is None or not (0 <= stage_id < len(pools)):
-            return None
-        return pools[stage_id].get_bound_replica_id(request_id)
-
-    def _get_comprehension_stage_index(self) -> int | None:
-        fallback_idx: int | None = None
-        for idx, stage_client in enumerate(self.engine.stage_clients):
-            stage_vllm_config = self.engine.stage_vllm_configs[idx]
-            if stage_vllm_config is None:
-                continue
-            if fallback_idx is None:
-                fallback_idx = idx
-            if stage_client.is_comprehension:
-                return idx
-        return fallback_idx
-
-    @property
-    def renderer(self):
-        """Return the renderer from the engine input processor when available."""
-        if self.input_processor is None:
-            return None
-        return self.input_processor.renderer
-
-    @property
-    def vllm_config(self):
-        """Return the vLLM config for the comprehension stage when present."""
-        stage_index = self._get_comprehension_stage_index()
-        if stage_index is None:
-            return None
-        return self.engine.stage_vllm_configs[stage_index]
-
-    async def get_vllm_config(self) -> Any:
-        """Compatibility helper for call sites expecting async vllm config access."""
-        return self.vllm_config
-
-    def get_diffusion_od_config(self) -> Any | None:
-        """Return the diffusion-stage config when the pipeline has one."""
-        saw_diffusion_stage = False
-        for stage_client in self.engine.stage_clients:
-            if getattr(stage_client, "stage_type", None) != "diffusion":
-                continue
-
-            saw_diffusion_stage = True
-
-            od_config = getattr(stage_client, "od_config", None)
-            if od_config is not None:
-                return od_config
-
-            inner_engine = getattr(stage_client, "_engine", None)
-            od_config = getattr(inner_engine, "od_config", None)
-            if od_config is not None:
-                return od_config
-
-        # Out-of-process diffusion clients don't carry od_config (it lives in the
-        # worker); fall back to the engine's model_class_name resolution.
-        if saw_diffusion_stage:
-            return self.engine.get_diffusion_od_config()
-
-        return None
-
-    @property
-    def model_config(self):
-        """Return the model config for the comprehension stage when present."""
-        vllm_config = self.vllm_config
-        if vllm_config is None:
-            return None
-        return vllm_config.model_config
-
-    @staticmethod
-    def _get_unique_request_id(external_request_id: str):
-        """Get a random new request ID for this request; at the server level,
-        this is usually set by the calling entrypoint, but in direct calls, we
-        need to set it explicitly since we do not allow empty IDs.
-
-        NOTE: in the upstream vLLM, this is done in the InputProcessor's
-        `assign_request_id`.
-        """
-        uuid = random_uuid()
-        prefix = "" if not external_request_id else f"{external_request_id}-"
-        return f"{prefix}{uuid:.8}"
-
-    async def open_duplex_session_async(
-        self,
-        session_id: str,
-        *,
-        session_mode: str = "duplex",
-        capabilities: dict[str, object] | None = None,
-        session_config: dict[str, object] | None = None,
-        runtime_config: dict[str, object] | None = None,
-        fence: DuplexFence,
-        timeout: float | None = 10.0,
-    ) -> dict[str, object]:
-        """Open an engine-level duplex session when the backend supports it."""
-        return await self._get_duplex_request_client().open(
-            session_id,
-            session_mode=session_mode,
-            capabilities=capabilities,
-            session_config=session_config,
-            runtime_config=runtime_config,
-            fence=fence,
-            timeout=timeout,
-        )
-
-    async def append_duplex_input_async(
-        self,
-        session_id: str,
-        *,
-        mode: str,
-        payload: object,
-        operation_id: str | None = None,
-        final: bool = False,
-        expected_epoch: int | None = None,
-        fence: DuplexFence,
-        timeout: float | None = 10.0,
-        collect_outputs: bool = True,
-    ) -> dict[str, object]:
-        """Append input to an engine-level duplex session."""
-        return await self._get_duplex_request_client().append(
-            session_id,
-            mode=mode,
-            payload=payload,
-            operation_id=operation_id,
-            final=final,
-            expected_epoch=expected_epoch,
-            fence=fence,
-            timeout=timeout,
-            collect_outputs=collect_outputs,
-        )
-
-    async def collect_duplex_data_plane_outputs_async(
-        self,
-        request_id: str,
-        *,
-        response_stage_id: int | None = None,
-        timeout: float | None = 10.0,
-    ) -> list[OmniRequestOutput]:
-        """Collect the next duplex data-plane output batch for a live request."""
-        return await self._get_duplex_request_client().collect_registered_outputs(
-            request_id,
-            response_stage_id=response_stage_id,
-            timeout=timeout,
-        )
-
-    async def signal_duplex_turn_async(
-        self,
-        session_id: str,
-        *,
-        event: str,
-        fence: DuplexFence,
-        next_fence: DuplexFence | None = None,
-        session_config: dict[str, object] | None = None,
-        runtime_config: dict[str, object] | None = None,
-        timeout: float | None = 10.0,
-    ) -> dict[str, object]:
-        """Send a turn/control signal to an engine-level duplex session."""
-        return await self._get_duplex_request_client().signal(
-            session_id,
-            event=event,
-            fence=fence,
-            next_fence=next_fence,
-            session_config=session_config,
-            runtime_config=runtime_config,
-            timeout=timeout,
-        )
-
-    async def close_duplex_session_async(
-        self,
-        session_id: str,
-        *,
-        reason: str = "client_close",
-        fence: DuplexFence,
-        timeout: float | None = 10.0,
-    ) -> dict[str, object]:
-        """Close an engine-level duplex session."""
-        return await self._get_duplex_request_client().close(
-            session_id,
-            reason=reason,
-            fence=fence,
-            timeout=timeout,
-        )
-
-    async def touch_duplex_session_async(
-        self,
-        session_id: str,
-        *,
-        fence: DuplexFence,
-        activity: DuplexLeaseActivity,
-        timeout: float | None = 10.0,
-    ) -> dict[str, object]:
-        return await self._get_duplex_request_client().touch(
-            session_id,
-            fence=fence,
-            activity=activity,
-            timeout=timeout,
-        )
-
-    async def resume_duplex_session_async(
-        self,
-        session_id: str,
-        *,
-        fence: DuplexFence,
-        expected_lease_generation: int,
-        timeout: float | None = 10.0,
-    ) -> dict[str, object]:
-        return await self._get_duplex_request_client().resume(
-            session_id,
-            fence=fence,
-            expected_lease_generation=expected_lease_generation,
-            timeout=timeout,
-        )
-
-    def _get_duplex_request_client(self) -> DuplexRequestClient:
-        client = getattr(self, "_duplex_request_client", None)
-        if client is None:
-            engine = getattr(self, "engine", None)
-            client = DuplexRequestClient(
-                engine,
-                DuplexRequestOutputPort(
-                    request_states=getattr(self, "request_states", {}),
-                    num_stages=getattr(engine, "num_stages", 1),
-                    log_stats=getattr(self, "log_stats", False),
-                    start_output_handler=self._final_output_handler,
-                    process_single_result=self._process_single_result,
-                ),
-            )
-            self._duplex_request_client = client
-        return client
-
-    @staticmethod
-    def _duplex_data_plane_request_info(result: dict[str, object]) -> tuple[str | None, int | None]:
-        return DuplexRequestClient.request_info(result)
-
-    async def _collect_duplex_data_plane_outputs(
-        self,
-        request_id: str,
-        req_state: ClientRequestState,
-        *,
-        response_stage_id: int | None,
-        timeout: float | None,
-    ) -> list[OmniRequestOutput]:
-        return await self._get_duplex_request_client().collect_outputs(
-            request_id,
-            req_state,
-            response_stage_id=response_stage_id,
-            timeout=timeout,
-        )
-
-    @classmethod
-    def _is_direct_duplex_data_plane_response(cls, output: object) -> bool:
-        return DuplexRequestClient.is_direct_response(output)
-
-    @classmethod
-    def _duplex_multimodal_output(cls, output: object) -> dict[str, object]:
-        return DuplexRequestClient.multimodal_output(output)
 
     # ==================== Generate Method ====================
 
@@ -596,6 +236,7 @@ class AsyncOmni(EngineClient, OmniBase):
             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
@@ -661,12 +302,12 @@ class AsyncOmni(EngineClient, OmniBase):
 
         except (asyncio.CancelledError, GeneratorExit):
             self._record_request_failure_once(request_id, reason="client_disconnect")
-            await self._abort_internal_requests(request_id)
+            await self._abort_internal_requests(request_id, timeout=ABORT_TIMEOUT_S)
             logger.info(f"[AsyncOmni] Request {request_id} aborted.")
             raise
         except Exception as e:
             self._record_request_failure_once(request_id, reason="stage_error")
-            await self._abort_internal_requests(request_id)
+            await self._abort_internal_requests(request_id, timeout=ABORT_TIMEOUT_S)
             logger.info(f"[AsyncOmni] Request {request_id} failed (input error): {e}")
             raise
         finally:
@@ -854,198 +495,6 @@ class AsyncOmni(EngineClient, OmniBase):
         """
         raise NotImplementedError("AsyncOmni.encode is not implemented.")
 
-    # ==================== Processing Methods ====================
-
-    async def _process_orchestrator_results(
-        self,
-        request_id: str,
-        metrics: OrchestratorMetrics,
-        final_stage_id_for_e2e: int,
-        req_start_ts: dict[str, float],
-        wall_start_ts: float,
-    ) -> AsyncGenerator[OmniRequestOutput, None]:
-        """Read results from the Orchestrator (via the request's asyncio.Queue)
-        and yield OmniRequestOutput objects.
-
-        The Orchestrator handles all stage-to-stage transfers. This method
-        only processes final outputs that arrive on the per-request queue.
-        """
-        req_state = self.request_states.get(request_id)
-        if req_state is None:
-            return
-
-        while True:
-            result = await req_state.queue.get()
-
-            if isinstance(result, ErrorMessage):
-                logger.error(
-                    "[AsyncOmni] Orchestrator error for req=%s stage-%s: %s",
-                    request_id,
-                    result.stage_id,
-                    result.error,
-                )
-                if result.fatal:
-                    raise OmniEngineDeadError(
-                        result.error,
-                        error_stage_id=result.stage_id,
-                    )
-                self._raise_nonfatal_error_message(result)
-
-            if not isinstance(result, OutputMessage):
-                logger.warning("[AsyncOmni] Dropping unexpected per-request message %r", result)
-                continue
-
-            stage_id = result.stage_id
-
-            self._check_engine_output_error(result, request_id, stage_id)
-
-            # Process the result (constructs OmniRequestOutput)
-            output_to_yield = self._process_single_result(
-                result,
-                stage_id,
-                metrics,
-                req_start_ts,
-                wall_start_ts,
-                final_stage_id_for_e2e,
-            )
-
-            if output_to_yield:
-                # Set the external request ID back to the user yielded input
-                output_to_yield.request_id = req_state.external_request_id or output_to_yield.request_id
-                logger.debug(
-                    "[AsyncOmni] req=%s stage-%s yielding final_output_type=%s",
-                    request_id,
-                    stage_id,
-                    getattr(output_to_yield, "final_output_type", None),
-                )
-                yield output_to_yield
-
-            # The Orchestrator sets "finished" when the final stage is done
-            if result.finished:
-                break
-
-    # ==================== Output Handler ====================
-
-    def _final_output_handler(self) -> None:
-        """Start the final output handler if not already running.
-
-        This handler reads messages from the Orchestrator output queue and
-        routes them to per-request asyncio.Queues.
-        """
-        if self.final_output_task is not None:
-            return
-
-        engine = self.engine
-
-        # Event-driven drain (VLLM_OMNI_EVENT_DRIVEN_ORCH=1): block on the
-        # queue's condition variable in a dedicated thread instead of the
-        # get_nowait + 1 ms sleep cadence. Same flag as the orchestrator-side
-        # event-driven loop (vllm_omni/engine/orchestrator.py).
-        from vllm_omni.engine.orchestrator import _event_driven_orch_enabled
-
-        event_driven_drain = _event_driven_orch_enabled() and hasattr(engine, "get_output_blocking_async")
-
-        async def _final_output_loop():
-            """Background coroutine that dispatches final outputs to request queues."""
-            try:
-                while True:
-                    if event_driven_drain:
-                        msg = await engine.get_output_blocking_async(timeout=_FINAL_OUTPUT_BLOCKING_WAIT_S)
-                        if msg is None:
-                            # Timed out with the orchestrator alive; loop for
-                            # the periodic liveness check.
-                            continue
-                    else:
-                        msg = await engine.try_get_output_async()
-                        if msg is None:
-                            await asyncio.sleep(_FINAL_OUTPUT_IDLE_SLEEP_S)
-                            continue
-
-                    if isinstance(msg, dict) and msg.get("type") == "ack":
-                        ack_data = msg.get("ack")
-                        tid = getattr(ack_data, "task_id", "unknown")
-                        logger.info(f"[{self._name}] Intercepted wrapped ACK for task {tid}")
-                        await self.event_resolver.resolve(ack_data)
-                        continue
-                    if isinstance(msg, OmniACK):
-                        logger.info(f"[{self._name}] Intercepted raw ACK object: {msg.task_id}")
-                        await self.event_resolver.resolve(msg)
-                        continue
-                    if hasattr(msg, "task_id"):
-                        tid = getattr(msg, "task_id")
-                        logger.info(f"[{self._name}] Intercepted task-ID object: {tid}")
-                        await self.event_resolver.resolve(msg)
-                        continue
-
-                    if getattr(msg, "type", None) == "duplex_session_lifecycle":
-                        await self.duplex_lifecycle_events.put(msg)
-                        continue
-
-                    if isinstance(msg, ErrorMessage):
-                        # Route request-scoped errors to that request's queue and
-                        # keep the loop alive. A request whose stage replica died
-                        # and was evicted gets a fatal error delivered here; only
-                        # that request fails (its consumer raises), the server
-                        # stays up for other stages/requests (#4285). A fatal
-                        # error without a request_id is a genuine engine-wide
-                        # death and falls through to the except handler below.
-                        if msg.request_id is not None:
-                            req_state = self.request_states.get(msg.request_id)
-                            if req_state is not None:
-                                await req_state.queue.put(msg)
-                            else:
-                                logger.warning(
-                                    "[%s] dropping error for unknown req %s",
-                                    self._name,
-                                    msg.request_id,
-                                )
-                            continue
-                        if not msg.fatal:
-                            continue
-
-                    should_continue, _, stage_id, req_state = self._handle_output_message(msg)
-                    if should_continue:
-                        continue
-
-                    req_state.stage_id = stage_id
-
-                    # Route to the per-request queue
-                    await req_state.queue.put(msg)
-
-            except asyncio.CancelledError:
-                raise
-            except OmniEngineDeadError as e:
-                logger.error("[AsyncOmni] Engine dead: %s", e)
-                for req_state in list(self.request_states.values()):
-                    error_msg = ErrorMessage(
-                        error=str(e),
-                        fatal=True,
-                        request_id=req_state.request_id,
-                        stage_id=e.error_stage_id,
-                    )
-                    await req_state.queue.put(error_msg)
-            except EngineDeadError as e:
-                logger.error("[AsyncOmni] Engine dead: %s", e)
-                for req_state in list(self.request_states.values()):
-                    error_msg = ErrorMessage(
-                        error=str(e),
-                        fatal=True,
-                        request_id=req_state.request_id,
-                    )
-                    await req_state.queue.put(error_msg)
-            except Exception as e:
-                logger.exception("[AsyncOmni] final_output_loop failed.")
-                for req_state in list(self.request_states.values()):
-                    error_msg = ErrorMessage(
-                        request_id=req_state.request_id,
-                        error=str(e),
-                    )
-                    await req_state.queue.put(error_msg)
-                self.final_output_task = None
-
-        self.final_output_task = asyncio.create_task(_final_output_loop())
-        logger.debug("[AsyncOmni] Final output handler started")
-
     # ==================== Control Methods ====================
 
     async def collective_rpc(
@@ -1120,14 +569,14 @@ class AsyncOmni(EngineClient, OmniBase):
             return all(bool(item) for item in result)
         return bool(result)
 
-    async def abort(self, request_id: str | Iterable[str]) -> None:
+    async def abort(self, request_id: str | Iterable[str], *, timeout: float | None = None) -> None:
         """Abort request(s) via the Orchestrator."""
         request_ids = [request_id] if isinstance(request_id, str) else list(request_id)
         # Map the external user request IDs to internal IDs used by the Orchestrator.
         # NOTE: If the user request_id matches multiple requests, all of them will be
         # aborted. This is also what happens in this case in vLLM's output processor.
         internal_ids = [s.request_id for s in self.request_states.values() if s.external_request_id in request_ids]
-        await self._abort(internal_ids)
+        await self._abort(internal_ids, timeout=timeout)
 
     async def submit_interaction_async(
         self,
@@ -1169,86 +618,6 @@ class AsyncOmni(EngineClient, OmniBase):
         if self.log_stats:
             logger.info("[AsyncOmni] Queued interaction for request %s", request_id)
 
-    async def _abort_internal_requests(self, request_id: str | Iterable[str]):
-        """Abort request(s) via the Orchestrator given internal request IDs,
-        which take the format <external_request_id>-<UUID>.
-        """
-        request_ids = [request_id] if isinstance(request_id, str) else list(request_id)
-        # Request IDs are already internal, so we just need to get the matching states.
-        internal_req_ids = [rid for rid in request_ids if rid in self.request_states]
-        await self._abort(internal_req_ids)
-
-    async def _abort(self, request_ids: list[str]) -> None:
-        """Abort request IDs via the engine and enqueue terminal abort outputs.
-
-        Waits for orchestrator abort acknowledgment, enqueues any AR terminal
-        abort outputs (partial tokens) into each request's asyncio queue, then
-        cancels the input pump. Frontend ``request_states`` stay registered so
-        ``generate()`` can consume the terminal message in
-        ``_process_orchestrator_results`` and run normal cleanup.
-
-        When ``abort_async`` returns no output for an active request (OP not
-        registered yet, unbound replica, or orchestrator id drop), enqueue a
-        synthetic finished abort so ``generate()`` cannot hang on ``queue.get``.
-        """
-        abort_outputs = await self.engine.abort_async(request_ids) or []
-        delivered: set[str] = set()
-        for output_msg in abort_outputs:
-            req_id = getattr(output_msg, "request_id", None)
-            if req_id is None:
-                continue
-            state = self.request_states.get(req_id)
-            if state is None:
-                logger.debug("[AsyncOmni] Dropping abort output for unknown req %s", req_id)
-                continue
-            await state.queue.put(output_msg)
-            delivered.add(req_id)
-        for rid in request_ids:
-            state = self.request_states.get(rid)
-            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))
-                    delivered.add(rid)
-        for rid in request_ids:
-            self._record_request_failure_once(rid, reason="client_abort")
-            state = self.request_states.get(rid)
-            input_stream_task = getattr(state, "input_stream_task", None)
-            if input_stream_task is not None and not input_stream_task.done():
-                input_stream_task.cancel()
-        if self.log_stats:
-            logger.info("[AsyncOmni] Aborted request(s) %s", ",".join(request_ids))
-
-    @staticmethod
-    def _synthetic_abort_output_message(request_id: 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",
-            outputs=[
-                CompletionOutput(
-                    index=0,
-                    text="",
-                    token_ids=[],
-                    cumulative_logprob=None,
-                    logprobs=None,
-                    finish_reason="abort",
-                    stop_reason=None,
-                )
-            ],
-        )
-        return OutputMessage(
-            request_id=request_id,
-            stage_id=0,
-            replica_id=None,
-            engine_outputs=engine_output,
-            metrics=None,
-            finished=True,
-            stage_submit_ts=None,
-        )
-
     def _split_stage_ids_by_type(self, stage_ids: list[int] | None = None) -> tuple[list[int], list[int]]:
         """Split stage ids into AR/LLM (EngineCore) vs diffusion (worker RPC)."""
         n_stages = len(self.engine.stage_clients)
@@ -1678,42 +1047,6 @@ class AsyncOmni(EngineClient, OmniBase):
 
     # ==================== Properties ====================
 
-    @property
-    def is_running(self) -> bool:
-        """Check if the engine is running."""
-        orchestrator_alive = self.engine.is_alive()
-        task_alive = self.final_output_task is not None and not self.final_output_task.done()
-        return orchestrator_alive and task_alive
-
-    @property
-    def errored(self) -> bool:
-        """Whether the engine is in a process-fatal error state.
-
-        Delegates to ``OmniBase.errored``, which is true only when the
-        orchestrator thread is dead; per-stage liveness is reported via
-        ``check_health`` instead.  Redeclared here to satisfy the
-        ``EngineClient`` abstract-property requirement (Python's ABC
-        mechanism does not resolve abstract methods from sibling MRO
-        entries).
-        """
-        return OmniBase.errored.fget(self)  # type: ignore[union-attr]
-
-    @property
-    def _name(self) -> str:
-        return "AsyncOrchestrator"
-
-    @property
-    def is_stopped(self) -> bool:
-        """EngineClient abstract property implementation."""
-        return self.errored
-
-    @property
-    def dead_error(self) -> BaseException:
-        """EngineClient abstract property implementation."""
-        return OmniEngineDeadError()
-
-    # ==================== EngineClient Interface ====================
-
     async def get_input_preprocessor(self) -> InputProcessor:
         """Get input preprocessor."""
         return self.input_processor
@@ -1774,16 +1107,3 @@ class AsyncOmni(EngineClient, OmniBase):
     async def get_supported_tasks(self) -> tuple[SupportedTask, ...]:
         """Return the task set exposed by the orchestrator-backed engine."""
         return tuple(self.engine.supported_tasks)
-
-    async def check_health(self) -> None:
-        """Check engine health by verifying the Orchestrator process is alive."""
-        OmniBase.check_health(self)
-
-    # ==================== Shutdown ====================
-
-    def shutdown(self, timeout: float | None = None) -> None:
-        """Shutdown the engine."""
-        if self.final_output_task is not None:
-            self.final_output_task.cancel()
-            self.final_output_task = None
-        OmniBase.shutdown(self)
diff --git a/vllm_omni/entrypoints/async_omni_base.py b/vllm_omni/entrypoints/async_omni_base.py
new file mode 100644
index 000000000..e9bf2c77e
--- /dev/null
+++ b/vllm_omni/entrypoints/async_omni_base.py
@@ -0,0 +1,577 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""AsyncOmniBase: the asyncio-side foundation shared by ``AsyncOmni`` and ``DuplexOmni``.
+
+Owns the engine output pump (one consumer of the engine output queue that
+routes messages to per-request queues, ACK resolvers, or a subclass hook),
+engine-dead fan-out, health/shutdown, and the config accessors. Turn-based
+request handling lives in ``AsyncOmni``; duplex sessions in ``DuplexOmni``.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import time
+from collections.abc import AsyncGenerator, Iterable
+from typing import Any
+
+from vllm.logger import init_logger
+from vllm.outputs import CompletionOutput
+from vllm.plugins.io_processors import get_io_processor
+from vllm.utils import random_uuid
+from vllm.v1.engine.exceptions import EngineDeadError
+
+from vllm_omni.diffusion.data import OmniACK
+from vllm_omni.engine.messages import ErrorMessage, OutputMessage
+from vllm_omni.entrypoints.omni_base import (
+    OmniBase,
+    OmniEngineDeadError,
+)
+from vllm_omni.metrics.stats import OrchestratorAggregator as OrchestratorMetrics
+from vllm_omni.outputs import OmniRequestOutput
+
+logger = init_logger(__name__)
+_FINAL_OUTPUT_IDLE_SLEEP_S = 0.001
+# Blocking-wait interval for the event-driven final-output drain
+# (VLLM_OMNI_EVENT_DRIVEN_ORCH=1): a message wakes the drain immediately via
+# the janus queue's condition variable; this timeout only bounds how often the
+# orchestrator liveness check runs while the pipeline is idle.
+_FINAL_OUTPUT_BLOCKING_WAIT_S = 1.0
+# Shared DELETE / generate() cleanup abort bound. Env is the documented knob.
+ABORT_TIMEOUT_S = float(os.environ.get("VLLM_OMNI_ABORT_TIMEOUT", 2.0))
+
+
+class AsyncEventResolver:
+    """
+    A generic signal aggregator designed for synchronized handshakes in
+    distributed or multi-stage environments. Supports waiting for a specified
+    number (expected_count) of worker signals in both inline and multiprocess modes.
+    """
+
+    def __init__(self, orchestrator=None):
+        self._pending_tasks: dict[str, dict] = {}
+        self.orchestrator = orchestrator
+        self._lock = asyncio.Lock()
+
+    def watch_task(self, task_id: str, expected_count: int = 1) -> asyncio.Future:
+        loop = asyncio.get_running_loop()
+        fut = loop.create_future()
+        self._pending_tasks[task_id] = {
+            "future": fut,
+            "expected_count": expected_count,
+            "received": [],
+            "start_time": time.time(),
+        }
+        return fut
+
+    async def resolve(self, ack: OmniACK):
+        tid = getattr(ack, "task_id", None)
+
+        if tid is None and isinstance(ack, dict):
+            tid = ack.get("task_id")
+
+        async with self._lock:
+            task_info = self._pending_tasks.get(tid)
+            if task_info is None:
+                logger.warning(f"Received stray ACK for task_id {tid}. Task might have timed out.")
+                return
+
+            task_info["received"].append(ack)
+            current_count = len(task_info["received"])
+            expected = task_info["expected_count"]
+
+            orchestrator = self.orchestrator
+            if orchestrator and hasattr(orchestrator, "metrics") and orchestrator.metrics:
+                freed = getattr(ack, "freed_bytes", 0)
+                if freed == 0 and isinstance(ack, dict):
+                    freed = ack.get("freed_bytes", 0)
+                orchestrator.metrics.record_vram_reclaimed(freed)
+
+            logger.info(f"[Resolver] Task {tid} progress: {current_count}/{expected} ACKs received.")
+
+            if current_count >= expected:
+                self._pending_tasks.pop(tid)
+                fut = task_info["future"]
+                if not fut.done():
+                    elapsed = time.time() - task_info["start_time"]
+                    logger.info(f"[Resolver] Task {tid} completed successfully in {elapsed:.2f}s.")
+                    fut.set_result(task_info["received"])
+
+
+class AsyncOmniBase(OmniBase):
+    """Shared asyncio foundation of the async entrypoints (see module docstring)."""
+
+    def __init__(self, *args: Any, model: str = "", **kwargs: Any) -> None:
+        OmniBase.__init__(self, model=model, **kwargs)
+        self.final_output_task: asyncio.Task | None = None
+        self.event_resolver = AsyncEventResolver(orchestrator=self)
+        self.config_path = self.engine.config_path
+        self.input_processor = self.engine.input_processor
+        self.endpoint_restrictions = self.engine.endpoint_restrictions
+
+        stage_index = self._get_comprehension_stage_index()
+        if stage_index is None:
+            self.io_processor = None
+        else:
+            vllm_config = self.engine.stage_vllm_configs[stage_index]
+            io_processor_plugin = vllm_config.model_config.io_processor_plugin
+            renderer = self.renderer
+            if renderer is None:
+                from vllm.renderers import renderer_from_config
+
+                renderer = renderer_from_config(vllm_config)
+            self.io_processor = get_io_processor(vllm_config, renderer, io_processor_plugin)
+
+    # ==================== Subclass seam ====================
+
+    def _route_engine_message(self, msg: Any) -> bool:
+        """Consume an engine output message the subclass owns (return True when consumed)."""
+        del msg
+        return False
+
+    def _on_engine_dead(self, error: str) -> None:
+        """Seam: the output pump is ending because the engine died (default: nothing).
+
+        ``DuplexOmni`` ends every session handle here; turn-based requests are
+        already failed through their per-request queues.
+        """
+        del error
+
+    def _resolve_transfer_replica(self, stage_id: int, request_id: str) -> int | None:
+        """Look up the sticky-routed replica for (stage_id, request_id).
+
+        Used as the ``replica_resolver`` callback by ``OrchestratorAggregator``
+        to label transfer_* metrics without plumbing replica ids through
+        ``TransferEdgeStats`` / ``StageRequestStats`` / connector adapters.
+        Returns None when stage_id is out of range or the request hasn't been
+        bound to a replica yet — the metric emit then defensive-skips.
+        """
+        pools = getattr(self.engine, "stage_pools", None)
+        if pools is None or not (0 <= stage_id < len(pools)):
+            return None
+        return pools[stage_id].get_bound_replica_id(request_id)
+
+    def _get_comprehension_stage_index(self) -> int | None:
+        fallback_idx: int | None = None
+        for idx, stage_client in enumerate(self.engine.stage_clients):
+            stage_vllm_config = self.engine.stage_vllm_configs[idx]
+            if stage_vllm_config is None:
+                continue
+            if fallback_idx is None:
+                fallback_idx = idx
+            if stage_client.is_comprehension:
+                return idx
+        return fallback_idx
+
+    @property
+    def renderer(self):
+        """Return the renderer from the engine input processor when available."""
+        if self.input_processor is None:
+            return None
+        return self.input_processor.renderer
+
+    @property
+    def vllm_config(self):
+        """Return the vLLM config for the comprehension stage when present."""
+        stage_index = self._get_comprehension_stage_index()
+        if stage_index is None:
+            return None
+        return self.engine.stage_vllm_configs[stage_index]
+
+    async def get_vllm_config(self) -> Any:
+        """Compatibility helper for call sites expecting async vllm config access."""
+        return self.vllm_config
+
+    def get_diffusion_od_config(self) -> Any | None:
+        """Return the diffusion-stage config when the pipeline has one."""
+        saw_diffusion_stage = False
+        for stage_client in self.engine.stage_clients:
+            if getattr(stage_client, "stage_type", None) != "diffusion":
+                continue
+
+            saw_diffusion_stage = True
+
+            od_config = getattr(stage_client, "od_config", None)
+            if od_config is not None:
+                return od_config
+
+            inner_engine = getattr(stage_client, "_engine", None)
+            od_config = getattr(inner_engine, "od_config", None)
+            if od_config is not None:
+                return od_config
+
+        # Out-of-process diffusion clients don't carry od_config (it lives in the
+        # worker); fall back to the engine's model_class_name resolution.
+        if saw_diffusion_stage:
+            return self.engine.get_diffusion_od_config()
+
+        return None
+
+    @property
+    def model_config(self):
+        """Return the model config for the comprehension stage when present."""
+        vllm_config = self.vllm_config
+        if vllm_config is None:
+            return None
+        return vllm_config.model_config
+
+    @staticmethod
+    def _get_unique_request_id(external_request_id: str):
+        """Get a random new request ID for this request; at the server level,
+        this is usually set by the calling entrypoint, but in direct calls, we
+        need to set it explicitly since we do not allow empty IDs.
+
+        NOTE: in the upstream vLLM, this is done in the InputProcessor's
+        `assign_request_id`.
+        """
+        uuid = random_uuid()
+        prefix = "" if not external_request_id else f"{external_request_id}-"
+        return f"{prefix}{uuid:.8}"
+
+    # ==================== Processing Methods ====================
+
+    async def _process_orchestrator_results(
+        self,
+        request_id: str,
+        metrics: OrchestratorMetrics,
+        final_stage_id_for_e2e: int,
+        req_start_ts: dict[str, float],
+        wall_start_ts: float,
+    ) -> AsyncGenerator[OmniRequestOutput, None]:
+        """Read results from the Orchestrator (via the request's asyncio.Queue)
+        and yield OmniRequestOutput objects.
+
+        The Orchestrator handles all stage-to-stage transfers. This method
+        only processes final outputs that arrive on the per-request queue.
+        """
+        req_state = self.request_states.get(request_id)
+        if req_state is None:
+            return
+
+        while True:
+            result = await req_state.queue.get()
+
+            if isinstance(result, ErrorMessage):
+                logger.error(
+                    "[AsyncOmni] Orchestrator error for req=%s stage-%s: %s",
+                    request_id,
+                    result.stage_id,
+                    result.error,
+                )
+                if result.fatal:
+                    raise OmniEngineDeadError(
+                        result.error,
+                        error_stage_id=result.stage_id,
+                    )
+                self._raise_nonfatal_error_message(result)
+
+            if not isinstance(result, OutputMessage):
+                logger.warning("[AsyncOmni] Dropping unexpected per-request message %r", result)
+                continue
+
+            stage_id = result.stage_id
+
+            self._check_engine_output_error(result, request_id, stage_id)
+
+            # Process the result (constructs OmniRequestOutput)
+            output_to_yield = self._process_single_result(
+                result,
+                stage_id,
+                metrics,
+                req_start_ts,
+                wall_start_ts,
+                final_stage_id_for_e2e,
+            )
+
+            if output_to_yield:
+                # Set the external request ID back to the user yielded input
+                output_to_yield.request_id = req_state.external_request_id or output_to_yield.request_id
+                logger.debug(
+                    "[AsyncOmni] req=%s stage-%s yielding final_output_type=%s",
+                    request_id,
+                    stage_id,
+                    getattr(output_to_yield, "final_output_type", None),
+                )
+                yield output_to_yield
+
+            # The Orchestrator sets "finished" when the final stage is done
+            if result.finished:
+                break
+
+    # ==================== Output Handler ====================
+
+    def _final_output_handler(self) -> None:
+        """Start the final output handler if not already running.
+
+        This handler reads messages from the Orchestrator output queue and
+        routes them to per-request asyncio.Queues.
+        """
+        if self.final_output_task is not None:
+            return
+
+        engine = self.engine
+
+        # Event-driven drain (VLLM_OMNI_EVENT_DRIVEN_ORCH=1): block on the
+        # queue's condition variable in a dedicated thread instead of the
+        # get_nowait + 1 ms sleep cadence. Same flag as the orchestrator-side
+        # event-driven loop (vllm_omni/engine/orchestrator.py).
+        from vllm_omni.engine.orchestrator import _event_driven_orch_enabled
+
+        event_driven_drain = _event_driven_orch_enabled() and hasattr(engine, "get_output_blocking_async")
+
+        async def _final_output_loop():
+            """Background coroutine that dispatches final outputs to request queues."""
+            try:
+                while True:
+                    if event_driven_drain:
+                        msg = await engine.get_output_blocking_async(timeout=_FINAL_OUTPUT_BLOCKING_WAIT_S)
+                        if msg is None:
+                            # Timed out with the orchestrator alive; loop for
+                            # the periodic liveness check.
+                            continue
+                    else:
+                        msg = await engine.try_get_output_async()
+                        if msg is None:
+                            await asyncio.sleep(_FINAL_OUTPUT_IDLE_SLEEP_S)
+                            continue
+
+                    if self._route_engine_message(msg):
+                        continue
+
+                    if isinstance(msg, dict) and msg.get("type") == "ack":
+                        ack_data = msg.get("ack")
+                        tid = getattr(ack_data, "task_id", "unknown")
+                        logger.info(f"[{self._name}] Intercepted wrapped ACK for task {tid}")
+                        await self.event_resolver.resolve(ack_data)
+                        continue
+                    if isinstance(msg, OmniACK):
+                        logger.info(f"[{self._name}] Intercepted raw ACK object: {msg.task_id}")
+                        await self.event_resolver.resolve(msg)
+                        continue
+                    if hasattr(msg, "task_id"):
+                        tid = getattr(msg, "task_id")
+                        logger.info(f"[{self._name}] Intercepted task-ID object: {tid}")
+                        await self.event_resolver.resolve(msg)
+                        continue
+
+                    if isinstance(msg, ErrorMessage):
+                        # Route request-scoped errors to that request's queue and
+                        # keep the loop alive. A request whose stage replica died
+                        # and was evicted gets a fatal error delivered here; only
+                        # that request fails (its consumer raises), the server
+                        # stays up for other stages/requests (#4285). A fatal
+                        # error without a request_id is a genuine engine-wide
+                        # death and falls through to the except handler below.
+                        if msg.request_id is not None:
+                            req_state = self.request_states.get(msg.request_id)
+                            if req_state is not None:
+                                await req_state.queue.put(msg)
+                            else:
+                                logger.warning(
+                                    "[%s] dropping error for unknown req %s",
+                                    self._name,
+                                    msg.request_id,
+                                )
+                            continue
+                        if not msg.fatal:
+                            continue
+
+                    should_continue, _, stage_id, req_state = self._handle_output_message(msg)
+                    if should_continue:
+                        continue
+
+                    req_state.stage_id = stage_id
+
+                    # Route to the per-request queue
+                    await req_state.queue.put(msg)
+
+            except asyncio.CancelledError:
+                raise
+            except OmniEngineDeadError as e:
+                logger.error("[%s] Engine dead: %s", self._name, e)
+                for req_state in list(self.request_states.values()):
+                    error_msg = ErrorMessage(
+                        error=str(e),
+                        fatal=True,
+                        request_id=req_state.request_id,
+                        stage_id=e.error_stage_id,
+                    )
+                    await req_state.queue.put(error_msg)
+                self._on_engine_dead(str(e))
+            except EngineDeadError as e:
+                logger.error("[%s] Engine dead: %s", self._name, e)
+                for req_state in list(self.request_states.values()):
+                    error_msg = ErrorMessage(
+                        error=str(e),
+                        fatal=True,
+                        request_id=req_state.request_id,
+                    )
+                    await req_state.queue.put(error_msg)
+                self._on_engine_dead(str(e))
+            except Exception as e:
+                logger.exception("[%s] final_output_loop failed.", self._name)
+                for req_state in list(self.request_states.values()):
+                    error_msg = ErrorMessage(
+                        request_id=req_state.request_id,
+                        error=str(e),
+                    )
+                    await req_state.queue.put(error_msg)
+                self.final_output_task = None
+                self._on_engine_dead(str(e))
+
+        self.final_output_task = asyncio.create_task(_final_output_loop())
+        logger.debug("[AsyncOmni] Final output handler started")
+
+    async def _abort_internal_requests(
+        self,
+        request_id: str | Iterable[str],
+        *,
+        timeout: float = ABORT_TIMEOUT_S,
+    ):
+        """Abort request(s) via the Orchestrator given internal request IDs,
+        which take the format <external_request_id>-<UUID>.
+        """
+        request_ids = [request_id] if isinstance(request_id, str) else list(request_id)
+        # Request IDs are already internal, so we just need to get the matching states.
+        internal_req_ids = [rid for rid in request_ids if rid in self.request_states]
+        try:
+            # Unbind generate() if abort_async blocks in the executor.
+            await asyncio.wait_for(self._abort(internal_req_ids, timeout=timeout), timeout=timeout)
+        except TimeoutError:
+            logger.warning(
+                "[AsyncOmni] Timed out aborting %s after %.1fs; "
+                "engine abort is best-effort until the current batch drains",
+                ",".join(internal_req_ids),
+                timeout,
+            )
+        except Exception:
+            logger.exception("[AsyncOmni] Cleanup abort failed for %s", ",".join(internal_req_ids))
+
+    async def _abort(self, request_ids: list[str], *, timeout: float | None = None) -> None:
+        """Abort request IDs via the engine and enqueue terminal abort outputs.
+
+        Waits for orchestrator abort acknowledgment, enqueues any AR terminal
+        abort outputs (partial tokens) into each request's asyncio queue, then
+        cancels the input pump. Frontend ``request_states`` stay registered so
+        ``generate()`` can consume the terminal message in
+        ``_process_orchestrator_results`` and run normal cleanup.
+
+        When ``abort_async`` returns no output for an active request (OP not
+        registered yet, unbound replica, or orchestrator id drop), enqueue a
+        synthetic finished abort so ``generate()`` cannot hang on ``queue.get``.
+        """
+        abort_outputs = await self.engine.abort_async(request_ids, timeout=timeout) or []
+        delivered: set[str] = set()
+        for output_msg in abort_outputs:
+            req_id = getattr(output_msg, "request_id", None)
+            if req_id is None:
+                continue
+            state = self.request_states.get(req_id)
+            if state is None:
+                logger.debug("[AsyncOmni] Dropping abort output for unknown req %s", req_id)
+                continue
+            await state.queue.put(output_msg)
+            delivered.add(req_id)
+        for rid in request_ids:
+            state = self.request_states.get(rid)
+            if state is not None and rid not in delivered:
+                queue = getattr(state, "queue", None)
+                if queue is not None:
+                    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")
+            state = self.request_states.get(rid)
+            input_stream_task = getattr(state, "input_stream_task", None)
+            if input_stream_task is not None and not input_stream_task.done():
+                input_stream_task.cancel()
+        if self.log_stats:
+            logger.info("[AsyncOmni] Aborted request(s) %s", ",".join(request_ids))
+
+    @staticmethod
+    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=stage_id,
+            final_output_type=final_output_type,
+            outputs=[
+                CompletionOutput(
+                    index=0,
+                    text="",
+                    token_ids=[],
+                    cumulative_logprob=None,
+                    logprobs=None,
+                    finish_reason="abort",
+                    stop_reason=None,
+                )
+            ],
+        )
+        return OutputMessage(
+            request_id=request_id,
+            stage_id=stage_id,
+            replica_id=None,
+            engine_outputs=engine_output,
+            metrics=None,
+            finished=True,
+            stage_submit_ts=None,
+        )
+
+    @property
+    def is_running(self) -> bool:
+        """Check if the engine is running."""
+        orchestrator_alive = self.engine.is_alive()
+        task_alive = self.final_output_task is not None and not self.final_output_task.done()
+        return orchestrator_alive and task_alive
+
+    @property
+    def _name(self) -> str:
+        return type(self).__name__
+
+    @property
+    def is_stopped(self) -> bool:
+        """EngineClient abstract property implementation."""
+        return self.errored
+
+    @property
+    def dead_error(self) -> BaseException:
+        """EngineClient abstract property implementation."""
+        return OmniEngineDeadError()
+
+    # ==================== EngineClient Interface ====================
+
+    async def check_health(self) -> None:
+        """Check engine health by verifying the Orchestrator process is alive."""
+        OmniBase.check_health(self)
+
+    # ==================== Shutdown ====================
+
+    def shutdown(self, timeout: float | None = None) -> None:
+        """Shutdown the engine."""
+        if self.final_output_task is not None:
+            self.final_output_task.cancel()
+            self.final_output_task = None
+        OmniBase.shutdown(self)
diff --git a/vllm_omni/entrypoints/cli/benchmark/cli_args.py b/vllm_omni/entrypoints/cli/benchmark/cli_args.py
index 21f528954..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")
@@ -206,8 +278,10 @@ def add_seed_tts_cli_args(parser: argparse.ArgumentParser) -> None:
         "--seed-tts-turns-per-session",
         type=int,
         default=1,
-        help="Group this many Seed-TTS target texts into one Realtime session. "
-        "The first row's reference audio and transcript are reused for every turn.",
+        help="Group this many Seed-TTS target texts into one benchmark request. "
+        "The first row's reference audio and transcript are reused for every turn. "
+        "A model-native duplex session takes its target text once, in the session "
+        "context, so each turn runs in its own session.",
     )
     group.add_argument(
         "--seed-tts-root",
@@ -264,6 +338,7 @@ _OMNI_BENCH_DATASET_CHOICES = (
     "seed-tts-design",
     "ttsd",
     "sound-effect",
+    "videomme",
 )
 
 
@@ -330,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/benchmark/omni_duplex_eval.py b/vllm_omni/entrypoints/cli/benchmark/omni_duplex_eval.py
index a43a5ec71..c3e55abb7 100644
--- a/vllm_omni/entrypoints/cli/benchmark/omni_duplex_eval.py
+++ b/vllm_omni/entrypoints/cli/benchmark/omni_duplex_eval.py
@@ -1,22 +1,55 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
+"""CLI for Omni-DuplexEval generate / evaluate / summarize.
+
+``generate`` still writes per-sample timed sentences and ``*.meta.json``.
+Duplex performance metrics are written to ``<response-root>/duplex_metrics.json``.
+Skipped samples keep previously recorded rows; incoming ``(split, sample_id)``
+rows replace the matching ones, then ``duplex_stream_*`` is recomputed.
+"""
+
 import argparse
 import asyncio
 import concurrent.futures
 import json
 from pathlib import Path
 
-from vllm_omni.benchmarks.duplex.omni_duplex_eval_dataset import DEFAULT_DATASET, load_samples
+from vllm_omni.benchmarks.duplex.omni_duplex_eval_dataset import DEFAULT_DATASET, DuplexSample, load_samples
 from vllm_omni.benchmarks.duplex.omni_duplex_eval_eval import evaluate_sample, summarize_scores
 from vllm_omni.benchmarks.duplex.omni_duplex_eval_judge import DuplexJudge
-from vllm_omni.benchmarks.duplex.omni_duplex_eval_runner import generate_sample
+from vllm_omni.benchmarks.duplex.omni_duplex_eval_runner import GenerateSampleResult, generate_sample
+from vllm_omni.benchmarks.duplex_session_metrics import (
+    DUPLEX_METRICS_FILENAME,
+    merge_duplex_metrics_report,
+    read_duplex_metrics_report,
+)
 from vllm_omni.entrypoints.cli.benchmark.base import OmniBenchmarkSubcommandBase
 
 
 def _common(parser: argparse.ArgumentParser) -> None:
-    parser.add_argument("--dataset", default=DEFAULT_DATASET)
-    parser.add_argument("--split", default="all")
+    parser.add_argument(
+        "--dataset",
+        default=DEFAULT_DATASET,
+        help=(
+            "Hugging Face dataset id, a JSON/JSONL manifest, or a local Hugging Face "
+            "dataset mirror. A local directory must use a single configuration whose "
+            "data files are named after the RTD_*/PR_* splits "
+            "(data/<SPLIT>-00000-of-00001.parquet); a single .parquet file is also "
+            "accepted. --split filters the rows by their preserved split identity, so "
+            "rows without identity fail loudly."
+        ),
+    )
+    parser.add_argument(
+        "--split",
+        default="all",
+        help=(
+            "Restrict to one split (e.g. RTD_OCR) or 'all'. A mistyped split name "
+            "raises a clear error listing the splits actually observed in the data. "
+            "Rows from a manifest or an iterable without split/subset/config identity "
+            "keep the requested split as an override rather than being rejected."
+        ),
+    )
     parser.add_argument("--family", choices=("all", "rtd", "pr"), default="all")
     parser.add_argument("--media-root")
     parser.add_argument("--limit", type=int)
@@ -54,6 +87,26 @@ def add_cli_args(parser: argparse.ArgumentParser) -> None:
     summarize.add_argument("--score-root", required=True)
 
 
+def _write_duplex_metrics(response_root: str | Path, results: list[GenerateSampleResult]) -> Path:
+    request_metrics = [metric for result in results for metric in result.request_metrics]
+    session_metrics = [result.session_metrics for result in results if result.session_metrics]
+    path = Path(response_root) / DUPLEX_METRICS_FILENAME
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        json.dumps(
+            merge_duplex_metrics_report(
+                read_duplex_metrics_report(path),
+                request_metrics=request_metrics,
+                session_metrics=session_metrics,
+            ),
+            ensure_ascii=False,
+            indent=2,
+        ),
+        encoding="utf-8",
+    )
+    return path
+
+
 def run(args: argparse.Namespace) -> int:
     if args.action == "summarize":
         print(json.dumps(summarize_scores(args.score_root), ensure_ascii=False, indent=2))
@@ -67,16 +120,18 @@ def run(args: argparse.Namespace) -> int:
         limit=args.limit,
         ids=args.ids,
     )
+    if not samples:
+        raise ValueError("no samples selected; check --dataset/--split/--family/--ids/--limit")
     if args.action == "generate":
         if args.concurrency < 1:
             raise ValueError("--concurrency must be at least 1")
 
-        async def generate() -> None:
+        async def generate() -> list[GenerateSampleResult]:
             semaphore = asyncio.Semaphore(args.concurrency)
 
-            async def generate_one(sample) -> None:
+            async def generate_one(sample: DuplexSample) -> GenerateSampleResult:
                 async with semaphore:
-                    await generate_sample(
+                    return await generate_sample(
                         sample,
                         url=args.url,
                         model=args.model,
@@ -89,16 +144,16 @@ def run(args: argparse.Namespace) -> int:
                         overwrite=args.overwrite,
                     )
 
-            await asyncio.gather(*(generate_one(sample) for sample in samples))
+            return list(await asyncio.gather(*(generate_one(sample) for sample in samples)))
 
-        asyncio.run(generate())
+        _write_duplex_metrics(args.response_root, asyncio.run(generate()))
         return 0
 
     if args.eval_workers < 1:
         raise ValueError("--eval-workers must be at least 1")
     judge = DuplexJudge(args.judge_base_url, args.judge_model, api_key=args.judge_api_key)
 
-    def evaluate_one(sample) -> None:
+    def evaluate_one(sample: DuplexSample) -> None:
         response_path = Path(args.response_root) / sample.split / f"{sample.id}.json"
         score_path = Path(args.score_root) / sample.split / f"{sample.id}.json"
         if score_path.exists() and not args.overwrite:
diff --git a/vllm_omni/entrypoints/cli/serve.py b/vllm_omni/entrypoints/cli/serve.py
index 5c0204a33..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
@@ -71,6 +83,16 @@ def _nonneg_finite_float(value: str) -> float:
     return parsed
 
 
+def _json_object(value: str) -> dict[str, object]:
+    try:
+        parsed = json.loads(value)
+    except json.JSONDecodeError as exc:
+        raise argparse.ArgumentTypeError(f"must be valid JSON: {exc}") from exc
+    if not isinstance(parsed, dict):
+        raise argparse.ArgumentTypeError("must be a JSON object")
+    return parsed
+
+
 def _ensure_vllm_platform():
     """Ensure vLLM's current_platform is valid before arg parsing.
 
@@ -131,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))
 
@@ -138,12 +162,89 @@ class OmniServeCommand(CLISubcommand):
         if args.stage_id is not None and (args.omni_master_address is None or args.omni_master_port is None):
             raise ValueError("--stage-id requires both --omni-master-address and --omni-master-port to be set")
 
+        # Require an explicit model under --omni. ``args.model`` always carries
+        # vLLM's ModelConfig default (``Qwen/Qwen3-0.6B``), so an omit is silent:
+        # the default text LLM is routed into the diffusion stage and startup
+        # crashes deep in the diffusion worker with a confusing registry error.
+        # Fail fast instead.
+        #
+        # The model must come from the CLI -- positionally
+        # (``vllm serve <model> --omni``) or via ``--model``. A deploy YAML
+        # (``--deploy-config``) is NOT a model source: it carries per-stage
+        # engine args only, and the checkpoint is always threaded in from
+        # ``args.model`` (see
+        # ``load_and_resolve_stage_configs``, which takes ``model`` as its first
+        # argument). Treating its mere presence as "model provided" let
+        # ``vllm serve --omni --deploy-config <cfg>`` slip through with the
+        # default model and reproduce the very crash this guard prevents. See
+        # https://github.com/vllm-project/vllm-omni/issues/4158.
+        if getattr(args, "omni", False):
+            explicit_keys = getattr(args, "explicit_keys", None) or frozenset()
+            # Resolve the model the user actually supplied on the CLI. A
+            # positional ``model_tag`` takes precedence (``cmd`` later copies it
+            # onto ``args.model``); otherwise ``--model`` counts only when it was
+            # explicitly passed. An empty/whitespace value (e.g. ``--model
+            # "$MODEL"`` with ``MODEL`` unset) is treated as "not provided" so it
+            # fails here with a clear message instead of the same confusing
+            # downstream crash.
+            model_tag = getattr(args, "model_tag", None)
+            if model_tag is not None:
+                explicit_model = model_tag
+            elif "model" in explicit_keys:
+                explicit_model = getattr(args, "model", None)
+            else:
+                explicit_model = None
+            model_provided = explicit_model is not None and str(explicit_model).strip() != ""
+            if not model_provided:
+                raise ValueError(
+                    "`vllm serve --omni` requires an explicit model. Pass it "
+                    "positionally (`vllm serve <model> --omni`) or via `--model`. "
+                    "`--deploy-config` carries per-stage engine args only and "
+                    "does not supply a model; without an "
+                    "explicit model, vLLM's default (Qwen/Qwen3-0.6B) is selected "
+                    "and routed into the diffusion stage, which fails with a "
+                    "confusing diffusion-registry error."
+                )
+
         # --omni-replica-address is only consulted in run_headless(); reject it
         # on the head so a misconfigured launch fails loudly instead of being
         # silently ignored.
         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)
@@ -167,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)
@@ -206,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)
@@ -535,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",
@@ -658,7 +771,10 @@ class OmniServeCommand(CLISubcommand):
             "--cache-backend",
             type=str,
             default="none",
-            help="Cache backend for diffusion models, options: 'tea_cache', 'cache_dit', 'mag_cache', 'step_cache'",
+            help=(
+                "Cache backend for diffusion models, options: 'tea_cache', "
+                "'cache_dit', 'mag_cache', 'sea_cache', 'step_cache'"
+            ),
         )
         omni_config_group.add_argument(
             "--cache-config",
@@ -669,6 +785,14 @@ class OmniServeCommand(CLISubcommand):
             'MagCache: \'{"mag_threshold": 0.24, "mag_max_skip_steps": 5, "mag_retention_ratio": 0.1}\'. '
             "Calibration mode: add '\"mag_calibrate\": true'",
         )
+        omni_config_group.add_argument(
+            "--video-output-transport",
+            type=_json_object,
+            default=None,
+            help=(
+                "JSON object configuring video output preparation, for example '{\"enable_device_postprocess\": true}'."
+            ),
+        )
         omni_config_group.add_argument(
             "--enable-cache-dit-summary",
             action="store_true",
@@ -708,6 +832,13 @@ class OmniServeCommand(CLISubcommand):
             default=True,
             help="Disable multi-threaded safetensors loading (default: enabled with 4 threads).",
         )
+        omni_config_group.add_argument(
+            "--enable-broadcast-weight-load",
+            action="store_true",
+            dest="enable_broadcast_weight_load",
+            default=False,
+            help="Enable Rank-0 shared weight broadcast across workers for HSDP (default: disabled).",
+        )
         omni_config_group.add_argument(
             "--num-weight-load-threads",
             type=int,
@@ -822,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",
@@ -912,6 +1044,15 @@ class OmniServeCommand(CLISubcommand):
             action="store_true",
             help="Disable Cosmos3 text/video safety guardrails for this server.",
         )
+        omni_config_group.add_argument(
+            "--robot-openpi-idle-timeout",
+            type=_nonneg_finite_float,
+            default=30.0,
+            help=(
+                "Seconds the /v1/realtime/robot/openpi endpoint waits for the next request "
+                "before closing an idle WebSocket (default: 30). Set to 0 to disable the timeout."
+            ),
+        )
 
         # Enable diffusion pipeline profiling
         omni_config_group.add_argument(
@@ -946,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.
 
@@ -967,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,
@@ -993,13 +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 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
@@ -1015,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)
@@ -1058,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 0aa0c7c5a..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.
@@ -39,3 +44,9 @@ class ClientRequestState:
         # without re-querying stage_pools.
         self.audio_emit_stage_id: int | None = None
         self.audio_emit_replica_id: int | None = None
+        # De-dup set for metric messages: OmniBase populates this in
+        # ``_handle_output_message`` / ``_process_single_result`` so the same
+        # ``id(msg)`` isn't counted twice into per-request metrics. Kept on
+        # the request state (not a class-level dict) so it is released with
+        # the state — see #6462 / #6561.
+        self.consumed_metric_message_ids: set[int] = set()
diff --git a/vllm_omni/entrypoints/duplex/__init__.py b/vllm_omni/entrypoints/duplex/__init__.py
index 736e98a6a..327eab07f 100644
--- a/vllm_omni/entrypoints/duplex/__init__.py
+++ b/vllm_omni/entrypoints/duplex/__init__.py
@@ -1,6 +1,13 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
-from .websocket import DuplexWebSocketActor
+"""Thin websocket serving for engine-resident duplex sessions.
 
-__all__ = ["DuplexWebSocketActor"]
+The session logic lives in ``vllm_omni.engine.duplex`` and is reached through
+``vllm_omni.entrypoints.duplex_omni.DuplexOmni``; this package only speaks the
+OpenAI Realtime wire protocol over ``/v1/realtime?duplex=1``.
+"""
+
+from .serving import OmniDuplexSessionHandler
+
+__all__ = ["OmniDuplexSessionHandler"]
diff --git a/vllm_omni/entrypoints/duplex/audio_encoding.py b/vllm_omni/entrypoints/duplex/audio_encoding.py
new file mode 100644
index 000000000..f790b029b
--- /dev/null
+++ b/vllm_omni/entrypoints/duplex/audio_encoding.py
@@ -0,0 +1,55 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Audio encoding for duplex model output (entrypoint layer, injected into ``DuplexOmniEngine``)."""
+
+from __future__ import annotations
+
+import numpy as np
+from vllm.logger import init_logger
+
+logger = init_logger(__name__)
+
+
+def encode_audio(
+    audio_data: object,
+    sample_rate_hz: int,
+    response_format: str,
+    speed: float | None,
+) -> str | None:
+    """Encode a model audio tensor/array into base64 in ``response_format``.
+
+    Moved from the serving runtime bridge; uses the shared ``AudioMixin``
+    encoder directly instead of going through the chat service.
+    """
+    if audio_data is None:
+        return None
+    try:
+        import torch
+
+        from vllm_omni.entrypoints.openai.audio_utils_mixin import AudioMixin
+        from vllm_omni.entrypoints.openai.protocol.audio import CreateAudio
+
+        if isinstance(audio_data, torch.Tensor):
+            audio_tensor = audio_data.detach().cpu().float().numpy()
+        else:
+            audio_tensor = np.asarray(audio_data, dtype=np.float32)
+        if audio_tensor.ndim > 1:
+            audio_tensor = audio_tensor.reshape(-1)
+        audio_response = AudioMixin().create_audio(
+            CreateAudio(
+                audio_tensor=audio_tensor,
+                sample_rate=sample_rate_hz,
+                response_format=response_format,
+                speed=float(speed) if isinstance(speed, int | float) and speed > 0 else 1.0,
+                stream_format="audio",
+                base64_encode=True,
+            )
+        )
+        return str(audio_response.audio_data)
+    except Exception:
+        logger.exception("Failed to encode duplex data-plane audio output")
+        return None
+
+
+__all__ = ["encode_audio"]
diff --git a/vllm_omni/entrypoints/duplex/capability.py b/vllm_omni/entrypoints/duplex/capability.py
deleted file mode 100644
index 50126886b..000000000
--- a/vllm_omni/entrypoints/duplex/capability.py
+++ /dev/null
@@ -1,34 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-from vllm.logger import init_logger
-
-logger = init_logger(__name__)
-
-
-def should_enable_duplex_endpoint(
-    stage_configs: list | None,
-    *,
-    config_path: str | None = None,
-) -> bool:
-    """Enable the realtime session handler for explicitly configured deployments."""
-    if stage_configs:
-        for stage in stage_configs:
-            session_mode = (
-                stage.get("session_mode") if isinstance(stage, dict) else getattr(stage, "session_mode", None)
-            )
-            if session_mode == "duplex":
-                return True
-    if config_path:
-        try:
-            from vllm_omni.config.stage_config import resolve_deploy_yaml
-
-            raw_config = resolve_deploy_yaml(config_path)
-            if raw_config.get("session_mode") == "duplex" or isinstance(raw_config.get("duplex_session"), dict):
-                return True
-        except Exception as exc:
-            logger.warning("Failed to inspect realtime session configuration from %s: %s", config_path, exc)
-    return False
-
-
-__all__ = ["should_enable_duplex_endpoint"]
diff --git a/vllm_omni/entrypoints/duplex/chat_fallback.py b/vllm_omni/entrypoints/duplex/chat_fallback.py
deleted file mode 100644
index f41d7205b..000000000
--- a/vllm_omni/entrypoints/duplex/chat_fallback.py
+++ /dev/null
@@ -1,271 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-from __future__ import annotations
-
-import asyncio
-import json
-from collections.abc import AsyncGenerator
-from typing import Any
-
-from vllm.entrypoints.openai.chat_completion.protocol import ChatCompletionRequest
-from vllm.entrypoints.serve.engine.protocol import ErrorResponse
-from vllm.logger import init_logger
-
-from vllm_omni.entrypoints.duplex.protocol import DuplexSession
-
-logger = init_logger(__name__)
-
-
-class ChatFallbackProjectorMixin:
-    """Project generic chat completion output into duplex response events."""
-
-    async def _run_response(self, session: DuplexSession, send_json) -> None:
-        response_id = session.begin_response()
-        epoch = session.epoch
-        request_id = f"duplex-{session.session_id}-{epoch}-{session.input_commit_seq}"
-        session.bind_request(f"chatcmpl-{request_id}")
-        await send_json(
-            self._response_created_payload(
-                session,
-                response_id,
-                epoch=epoch,
-                request_id=session.active_request_id,
-            )
-        )
-
-        try:
-            request = self._build_chat_request(session, request_id)
-            result = await self._chat_service.create_chat_completion(request, raw_request=None)
-            if isinstance(result, ErrorResponse):
-                error = result.error
-                await send_json(
-                    {
-                        "type": "error",
-                        "error": error.message if error else "Chat request failed",
-                        "code": error.type if error else "chat_error",
-                    }
-                )
-                session.end_response(commit_text=False)
-                return
-            if hasattr(result, "__aiter__"):
-                await self._drain_streaming_response(session, result, epoch, response_id, send_json)
-            else:
-                await self._emit_full_response(session, result, epoch, response_id, send_json)
-            if session.epoch == epoch:
-                final_stage_metrics = session.accumulate_response_stage_metrics(None)
-                should_commit = self._should_commit_response_to_history(session, response_id)
-                committed_message = session.end_response(commit_text=should_commit)
-                if should_commit:
-                    session.register_history_item(f"item_{response_id}", committed_message)
-                done_payload: dict[str, object] = {
-                    "type": "response.done",
-                    "session_id": session.session_id,
-                    "response_id": response_id,
-                    "epoch": epoch,
-                    "committed": committed_message is not None,
-                    "playback": session.playback.as_dict(),
-                }
-                if final_stage_metrics:
-                    done_payload["vllm_omni"] = {"stage_metrics": final_stage_metrics}
-                await send_json(done_payload)
-        except asyncio.CancelledError:
-            raise
-        except Exception as exc:
-            logger.exception("Duplex response failed: %s", exc)
-            session.end_response(commit_text=False)
-            await send_json(
-                {
-                    "type": "error",
-                    "session_id": session.session_id,
-                    "response_id": response_id,
-                    "error": str(exc),
-                    "code": "response_error",
-                }
-            )
-
-    def _build_chat_request(self, session: DuplexSession, request_id: str) -> ChatCompletionRequest:
-        response_config = session.response_config
-        messages: list[dict[str, object]] = []
-        if response_config.instructions:
-            messages.append({"role": "system", "content": response_config.instructions})
-        messages.extend(session.history)
-
-        kwargs: dict[str, Any] = {
-            "model": response_config.model or self._chat_service.model_config.model,
-            "messages": messages,
-            "stream": True,
-        }
-        if response_config.temperature is not None:
-            kwargs["temperature"] = response_config.temperature
-        if response_config.max_tokens is not None:
-            kwargs["max_tokens"] = response_config.max_tokens
-        model_extra = dict(response_config.extra_body)
-        model_extra.pop("native_duplex", None)
-        model_extra.pop("minicpmo45_native_duplex", None)
-        tools = model_extra.pop("realtime_response_tools", model_extra.pop("realtime_tools", None))
-        tool_choice = model_extra.pop(
-            "realtime_response_tool_choice",
-            model_extra.pop("realtime_tool_choice", None),
-        )
-        for protocol_key in (
-            "realtime_response_conversation",
-            "realtime_response_metadata",
-            "realtime_response_prompt",
-        ):
-            model_extra.pop(protocol_key, None)
-        kwargs.update(model_extra)
-        if isinstance(tools, list):
-            kwargs["tools"] = tools
-        if isinstance(tool_choice, str | dict):
-            kwargs["tool_choice"] = tool_choice
-
-        request = ChatCompletionRequest(**kwargs)
-        object.__setattr__(request, "modalities", response_config.modalities)
-        object.__setattr__(request, "request_id", request_id)
-        object.__setattr__(
-            request,
-            "chat_template_kwargs",
-            {"use_tts_template": response_config.use_tts_template},
-        )
-        return request
-
-    async def _drain_streaming_response(
-        self,
-        session: DuplexSession,
-        result: AsyncGenerator[str, None],
-        epoch: int,
-        response_id: str,
-        send_json,
-    ) -> None:
-        async for raw_chunk in result:
-            if session.epoch != epoch:
-                return
-            for payload in self._parse_sse_payloads(raw_chunk):
-                if payload == "[DONE]":
-                    continue
-                if isinstance(payload, dict):
-                    await self._emit_chat_payload(session, payload, epoch, response_id, send_json)
-
-    async def _emit_full_response(
-        self,
-        session: DuplexSession,
-        result: Any,
-        epoch: int,
-        response_id: str,
-        send_json,
-    ) -> None:
-        if hasattr(result, "model_dump"):
-            payload = result.model_dump(mode="json", exclude_unset=True)
-        else:
-            payload = {"response": str(result)}
-        await self._emit_chat_payload(session, payload, epoch, response_id, send_json)
-
-    def _parse_sse_payloads(self, raw_chunk: str) -> list[dict[str, object] | str]:
-        payloads: list[dict[str, object] | str] = []
-        for line in raw_chunk.splitlines():
-            line = line.strip()
-            if not line.startswith("data:"):
-                continue
-            data = line[5:].strip()
-            if not data:
-                continue
-            if data == "[DONE]":
-                payloads.append(data)
-                continue
-            try:
-                parsed = json.loads(data)
-            except json.JSONDecodeError:
-                logger.debug("Skipping non-JSON duplex stream payload: %s", data)
-                continue
-            if isinstance(parsed, dict):
-                payloads.append(parsed)
-        return payloads
-
-    async def _emit_chat_payload(
-        self,
-        session: DuplexSession,
-        payload: dict[str, object],
-        epoch: int,
-        response_id: str,
-        send_json,
-    ) -> None:
-        metrics = payload.get("metrics")
-        stage_metrics = metrics.get("stage_metrics") if isinstance(metrics, dict) else None
-        if isinstance(stage_metrics, dict):
-            session.replace_response_stage_metric_snapshots(stage_metrics)
-
-        modality = payload.get("modality")
-        if modality not in {None, "text", "audio"}:
-            await send_json(
-                {
-                    "type": "error",
-                    "session_id": session.session_id,
-                    "response_id": response_id,
-                    "epoch": epoch,
-                    "code": "unsupported_response_modality",
-                    "error": f"Unsupported chat response modality: {modality}",
-                }
-            )
-            return
-        choices = payload.get("choices")
-        if not isinstance(choices, list):
-            await send_json(
-                {
-                    "type": "response.message",
-                    "session_id": session.session_id,
-                    "response_id": response_id,
-                    "epoch": epoch,
-                    "payload": payload,
-                }
-            )
-            return
-
-        for choice in choices:
-            if not isinstance(choice, dict):
-                continue
-            delta = choice.get("delta")
-            message = choice.get("message")
-            content = None
-            if isinstance(delta, dict):
-                content = delta.get("content")
-            elif isinstance(message, dict):
-                content = message.get("content")
-
-            if isinstance(content, str) and content:
-                if modality == "audio":
-                    session.mark_audio_sent()
-                    await send_json(
-                        {
-                            "type": "response.output_audio.delta",
-                            "session_id": session.session_id,
-                            "response_id": response_id,
-                            "epoch": epoch,
-                            "audio": content,
-                            "format": session.response_config.response_format,
-                        }
-                    )
-                else:
-                    session.append_assistant_text(content)
-                    await send_json(
-                        {
-                            "type": "response.text.delta",
-                            "session_id": session.session_id,
-                            "response_id": response_id,
-                            "epoch": epoch,
-                            "delta": content,
-                        }
-                    )
-
-            finish_reason = choice.get("finish_reason")
-            if finish_reason is not None and modality != "audio":
-                await send_json(
-                    {
-                        "type": "response.output_item.done",
-                        "session_id": session.session_id,
-                        "response_id": response_id,
-                        "epoch": epoch,
-                        "finish_reason": finish_reason,
-                        "modality": modality,
-                    }
-                )
diff --git a/vllm_omni/entrypoints/duplex/realtime_input.py b/vllm_omni/entrypoints/duplex/realtime_input.py
index 7fdadbcb2..79a081696 100644
--- a/vllm_omni/entrypoints/duplex/realtime_input.py
+++ b/vllm_omni/entrypoints/duplex/realtime_input.py
@@ -1,1584 +1,179 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
+"""Thin OpenAI Realtime wire envelope for one websocket connection.
+
+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), 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
+:class:`~vllm_omni.engine.duplex.events.ErrorEvent`.
+"""
+
 from __future__ import annotations
 
-import asyncio
-import base64
-import binascii
-from collections.abc import Callable
-from uuid import uuid4
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
 
-import numpy as np
+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 translate_realtime_command
+from vllm_omni.protocol.duplex import RealtimeInputDefaults
 
-from vllm_omni.entrypoints.duplex.audio import (
-    convert_input_audio_with_rate,
-    encode_float32_mono_wav_base64,
-    validate_input_sample_rate_hz,
-)
-from vllm_omni.entrypoints.duplex.protocol import normalize_native_duplex_key
-from vllm_omni.entrypoints.duplex.realtime_state import (
-    REALTIME_INPUT_AUDIO_FORMATS,
-    REALTIME_OUTPUT_AUDIO_FORMATS,
-    RealtimeStateOwner,
-    realtime_default_sample_rate_hz,
-)
-from vllm_omni.entrypoints.duplex.server_vad import ServerVADConfig, parse_session_turn_detection
+if TYPE_CHECKING:
+    from starlette.websockets import WebSocket
+
+__all__ = ["RealtimeEnvelope", "RealtimeHandshake", "ResumeRequest", "parse_resume_request"]
+
+_TRUE_VALUES = {"1", "true", "yes", "on"}
+_FALSE_VALUES = {"0", "false", "no", "off"}
+
+#: Client events the envelope handles itself (never translated into commands).
+#: ``conversation.item.retrieve`` is deliberately absent: the conversation items
+#: it reads live engine-side, so it travels as a command like any other event.
+ENVELOPE_EVENT_TYPES = frozenset({"session.resume", "session.event_ack"})
 
 
-class RealtimeInputTranslator(RealtimeStateOwner):
-    """Translate and validate client Realtime events for the duplex core."""
+@dataclass(frozen=True, slots=True)
+class RealtimeHandshake:
+    """What the first client message asks for."""
 
-    _opened: bool
-    _initial_session_update: bool
-    _input_speech_started: bool
-    _input_audio_buffer_has_audio: bool
-    _input_audio_buffer_had_non_speech: bool
-    _input_audio_buffer_transcript_parts: list[str]
-    _active_input_item_id: str | None
-    _last_conversation_item_id: str | None
-    _active_response_id: str | None
-    _last_response_id: str | None
-    _input_audio_format: str
-    _output_audio_format: str
-    _input_sample_rate_hz: int
-    _conversation_items: dict[str, dict[str, object]]
-    _item_truncation_cursors: dict[str, tuple[int, int]]
-    _pending_outbound: asyncio.Queue[dict[str, object]]
+    #: ``"open"`` (session object in ``session_payload``) or ``"resume"`` (resume payload).
+    kind: str
+    session_payload: dict[str, object] = field(default_factory=dict)
+    resume_payload: dict[str, object] = field(default_factory=dict)
+    #: A client event that arrived before the session existed and must run right after opening.
+    pending_command_payload: dict[str, object] | None = None
 
-    async def _send_realtime_payload(self, payload: dict[str, object]) -> None:
-        raise NotImplementedError
 
-    def _realtime_error_payload(
-        self,
+@dataclass(frozen=True, slots=True)
+class ResumeRequest:
+    """A validated ``session.resume`` client event."""
+
+    session_id: str
+    resume_token: str
+    last_received_server_event_seq: int
+
+
+def parse_resume_request(event: Mapping[str, object]) -> ResumeRequest | None:
+    """Validate the shape of ``session.resume``; ``None`` when any field is missing or malformed."""
+    session_id = event.get("session_id")
+    resume_token = event.get("resume_token")
+    last_received = event.get("last_received_server_event_seq", 0)
+    if (
+        not isinstance(session_id, str)
+        or not session_id
+        or not isinstance(resume_token, str)
+        or not resume_token
+        or not isinstance(last_received, int)
+        or last_received < 0
+    ):
+        return None
+    return ResumeRequest(
+        session_id=session_id,
+        resume_token=resume_token,
+        last_received_server_event_seq=last_received,
+    )
+
+
+@dataclass
+class RealtimeEnvelope:
+    """Per-connection Realtime wire policy (no session state)."""
+
+    default_model: str | None = None
+    #: ``?resume=1`` / ``?autostart=0``: the first message must be ``session.resume``/``session.update``.
+    resume_only: bool = False
+    opened: bool = False
+    autostarted_default_session: bool = False
+    defaults: RealtimeInputDefaults = field(default_factory=RealtimeInputDefaults)
+
+    @classmethod
+    def from_query_params(cls, query_params: Mapping[str, str] | WebSocket) -> RealtimeEnvelope:
+        if hasattr(query_params, "query_params"):
+            query_params = query_params.query_params
+        getter = query_params.get if hasattr(query_params, "get") else None
+        resume_only = getter("resume") if getter is not None else None
+        autostart = getter("autostart") if getter is not None else None
+        model = getter("model") if getter is not None else None
+        return cls(
+            default_model=model if isinstance(model, str) and model else None,
+            resume_only=(
+                str(resume_only).strip().lower() in _TRUE_VALUES or str(autostart).strip().lower() in _FALSE_VALUES
+            ),
+        )
+
+    # ---- handshake ----
+
+    def default_session_payload(self) -> dict[str, object]:
+        return {"model": self.default_model}
+
+    def initial_open_payload(self) -> dict[str, object] | None:
+        """Session object to open with *before* any client message (``?model=`` autostart), else None."""
+        if self.opened or self.resume_only or self.autostarted_default_session or not self.default_model:
+            return None
+        self.opened = True
+        self.autostarted_default_session = True
+        return self.default_session_payload()
+
+    def first_message(self, payload: Mapping[str, object]) -> RealtimeHandshake:
+        """Classify the first client message (call only while ``not opened``).
+
+        ``session.update`` opens with its session object; ``session.resume``
+        resumes; any other event autostarts the default session and is then
+        treated as a command (``pending_command_payload``).
+        """
+        event_type = payload.get("type")
+        self.opened = True
+        if event_type == "session.resume":
+            return RealtimeHandshake(kind="resume", resume_payload=dict(payload))
+        if event_type == "session.update":
+            session = payload.get("session")
+            session_payload = dict(session) if isinstance(session, dict) else dict(payload)
+            session_payload.pop("type", None)
+            self.note_session_payload(session_payload)
+            return RealtimeHandshake(kind="open", session_payload=session_payload)
+        self.autostarted_default_session = True
+        return RealtimeHandshake(
+            kind="open",
+            session_payload=self.default_session_payload(),
+            pending_command_payload=dict(payload),
+        )
+
+    def note_session_payload(self, session_payload: Mapping[str, object]) -> None:
+        """Track wire defaults declared by a session object (open or session.update)."""
+        self.defaults = self.defaults.with_session_payload(session_payload)
+
+    # ---- commands ----
+
+    def is_envelope_event(self, payload: Mapping[str, object]) -> bool:
+        return payload.get("type") in ENVELOPE_EVENT_TYPES
+
+    def translate(self, payload: Mapping[str, object]) -> DuplexCommand:
+        """Wire event -> command (raises :class:`DuplexCommandError`)."""
+        if payload.get("type") == "session.update":
+            session = payload.get("session")
+            if isinstance(session, dict):
+                self.note_session_payload(session)
+        return translate_realtime_command(payload, defaults=self.defaults)
+
+    # ---- outbound helpers ----
+
+    @staticmethod
+    def error_payload(
         code: str,
         message: str,
         *,
         event_id: object | None = None,
         param: object | None = None,
     ) -> dict[str, object]:
-        raise NotImplementedError
-
-    _response_is_done: Callable[[object], bool]
-
-    @property
-    def _turn_based_server_vad(self) -> bool:
-        return self._turn_detection is not None and not self._native_input_append
-
-    def _reset_realtime_input_buffer_state(self) -> None:
-        self._input_speech_started = False
-        self._active_input_item_id = None
-        self._input_audio_buffer_has_audio = False
-        self._input_audio_buffer_had_non_speech = False
-        self._input_audio_buffer_transcript_parts.clear()
-
-    async def discard_pending_input_audio(
-        self,
-        *,
-        audio_end_ms: int | None = None,
-    ) -> None:
-        """Drop Realtime input-buffer state that was consumed as overlap.
-
-        The serving overlap policy may classify a short acknowledgement such
-        as "continue" as a side-channel signal instead of user turn input. The
-        Realtime protocol has already observed the append and may have emitted
-        ``speech_started``; reset that transient buffer so a later commit does
-        not accidentally attach the acknowledgement transcript/audio to the
-        next real user turn.
-        """
-        if self._input_speech_started and self._active_input_item_id is not None:
-            await self._send_realtime_payload(
-                {
-                    "type": "input_audio_buffer.speech_stopped",
-                    "audio_end_ms": max(0, int(audio_end_ms or 0)),
-                    "item_id": self._active_input_item_id,
-                }
-            )
-        self._reset_realtime_input_buffer_state()
-
-    async def _send_realtime_input_ack(self, event: dict[str, object]) -> None:
-        if event.get("type") != "conversation.item.create":
-            return
-        item = event.get("item")
-        if not isinstance(item, dict):
-            return
-        previous_item_id = event.get("previous_item_id")
-        if isinstance(previous_item_id, str):
-            item["_previous_item_id"] = previous_item_id
-        if item.get("role") != "user":
-            return
-        self._conversation_items[str(item["id"])] = item
-        for payload in self._conversation_item_added_events(item):
-            await self._send_realtime_payload(payload)
-
-    async def _to_duplex_event(self, event: dict[str, object]) -> dict[str, object] | None:
-        event_type = event.get("type")
-        if event_type == "session.update":
-            session = event.get("session")
-            session_payload: dict[str, object] = session if isinstance(session, dict) else event
-            try:
-                turn_detection_configured, server_vad = parse_session_turn_detection(session_payload)
-            except ValueError as exc:
-                await self._send_realtime_payload(
-                    self._realtime_error_payload(
-                        "unsupported_turn_detection",
-                        str(exc),
-                        event_id=event.get("event_id"),
-                        param="turn_detection",
-                    )
-                )
-                return None
-            normalized_turn_detection = server_vad.as_dict() if server_vad is not None else None
-            previous_protocol_config = self._realtime_protocol_config()
-            try:
-                self._apply_realtime_session_defaults(session_payload)
-            except ValueError as exc:
-                self._set_realtime_protocol_config(previous_protocol_config)
-                await self._send_realtime_payload(
-                    self._realtime_error_payload(
-                        "unsupported_audio_format",
-                        str(exc),
-                        event_id=event.get("event_id"),
-                        param="audio.input.format",
-                    )
-                )
-                return None
-            turn_detection_error = self._validate_realtime_turn_detection(
-                session_payload,
-                configured=turn_detection_configured,
-                normalized=normalized_turn_detection,
-            )
-            if turn_detection_error is not None:
-                self._set_realtime_protocol_config(previous_protocol_config)
-                await self._send_realtime_payload(
-                    self._realtime_error_payload(
-                        "unsupported_turn_detection",
-                        turn_detection_error,
-                        event_id=event.get("event_id"),
-                        param="turn_detection",
-                    )
-                )
-                return None
-            turn_detection_candidate = self._prepare_realtime_turn_detection_update(
-                session_payload,
-                configured=turn_detection_configured,
-                normalized=normalized_turn_detection,
-            )
-            try:
-                session_payload.update(self._realtime_overlap_fields(session_payload))
-                if not self._opened:
-                    self._opened = True
-                    self._initial_session_update = True
-                    translated = self._session_create_from_realtime(session_payload)
-                    event_id = event.get("event_id")
-                    if isinstance(event_id, str) and event_id:
-                        translated["_realtime_event_id"] = event_id
-                else:
-                    translated = {
-                        "type": "turn.signal",
-                        "event": "session.update",
-                        "payload": session_payload,
-                        "realtime_event_id": event.get("event_id"),
-                    }
-                candidate_protocol_config = self._realtime_protocol_config()
-            finally:
-                self._set_realtime_protocol_config(previous_protocol_config)
-            if turn_detection_candidate[0] or candidate_protocol_config != previous_protocol_config:
-                self._pending_turn_detection_update = (
-                    *turn_detection_candidate,
-                    asyncio.Event(),
-                    candidate_protocol_config,
-                )
-            return translated
-        if event_type == "conversation.item.create":
-            return await self._conversation_item_to_duplex(event)
-        if event_type == "conversation.item.delete":
-            item_id = event.get("item_id")
-            if not isinstance(item_id, str) or not item_id:
-                await self._send_realtime_payload(
-                    self._realtime_error_payload(
-                        "missing_item_id",
-                        "conversation.item.delete requires item_id",
-                        event_id=event.get("event_id"),
-                    )
-                )
-                return None
-            if item_id not in self._conversation_items:
-                await self._send_realtime_payload(
-                    self._realtime_error_payload(
-                        "item_not_found",
-                        f"Conversation item not found: {item_id}",
-                        event_id=event.get("event_id"),
-                    )
-                )
-                return None
-            self._remove_conversation_item(item_id)
-            await self._pending_outbound.put(
-                {
-                    "type": "turn.signal",
-                    "event": "conversation.item.delete",
-                    "payload": {"item_id": item_id},
-                }
-            )
-            return None
-        if event_type == "conversation.item.retrieve":
-            item_id = event.get("item_id")
-            if not isinstance(item_id, str) or not item_id:
-                await self._send_realtime_payload(
-                    self._realtime_error_payload(
-                        "missing_item_id",
-                        "conversation.item.retrieve requires item_id",
-                        event_id=event.get("event_id"),
-                    )
-                )
-                return None
-            item = self._conversation_items.get(item_id)
-            if item is None:
-                await self._send_realtime_payload(
-                    self._realtime_error_payload(
-                        "item_not_found",
-                        f"Conversation item not found: {item_id}",
-                        event_id=event.get("event_id"),
-                    )
-                )
-                return None
-            await self._send_realtime_payload({"type": "conversation.item.retrieved", "item": item})
-            return None
-        if event_type == "conversation.item.truncate":
-            item_id = event.get("item_id")
-            audio_end_ms = event.get("audio_end_ms")
-            content_index = event.get("content_index", 0)
-            if not isinstance(item_id, str) or not item_id:
-                await self._send_realtime_payload(
-                    self._realtime_error_payload(
-                        "missing_item_id",
-                        "conversation.item.truncate requires item_id",
-                        event_id=event.get("event_id"),
-                    )
-                )
-                return None
-            if not isinstance(audio_end_ms, int | float):
-                await self._send_realtime_payload(
-                    self._realtime_error_payload(
-                        "bad_event",
-                        "conversation.item.truncate requires numeric audio_end_ms",
-                        event_id=event.get("event_id"),
-                        param="audio_end_ms",
-                    )
-                )
-                return None
-            item = self._conversation_items.get(item_id)
-            if not isinstance(item, dict):
-                await self._send_realtime_payload(
-                    self._realtime_error_payload(
-                        "item_not_found",
-                        f"Conversation item not found: {item_id}",
-                        event_id=event.get("event_id"),
-                    )
-                )
-                return None
-            truncate_error = self._validate_realtime_item_truncate(
-                item,
-                content_index=int(content_index) if isinstance(content_index, int | float) else 0,
-                audio_end_ms=int(audio_end_ms),
-            )
-            if truncate_error is not None:
-                await self._send_realtime_payload(
-                    self._realtime_error_payload(
-                        "bad_event",
-                        truncate_error,
-                        event_id=event.get("event_id"),
-                    )
-                )
-                return None
-            self._item_truncation_cursors[item_id] = (
-                int(content_index) if isinstance(content_index, int | float) else 0,
-                int(audio_end_ms),
-            )
-            self._truncate_realtime_item_content(
-                item,
-                content_index=int(content_index) if isinstance(content_index, int | float) else 0,
-                audio_end_ms=int(audio_end_ms),
-            )
-            await self._pending_outbound.put(
-                {
-                    "type": "turn.signal",
-                    "event": "conversation.item.truncate",
-                    "payload": {
-                        "item_id": item_id,
-                        "content_index": content_index,
-                        "audio_end_ms": audio_end_ms,
-                    },
-                }
-            )
-            await self._pending_outbound.put(
-                {
-                    "type": "playback.ack",
-                    "item_id": item_id,
-                    "committed_ms": int(audio_end_ms),
-                    "played_ms": int(audio_end_ms),
-                    "truncate": True,
-                }
-            )
-            return None
-        if event_type == "input_audio_buffer.append":
-            audio = event.get("audio") or event.get("delta")
-            event_format = event.get("format") or event.get("input_audio_format")
-            native_server_vad = self._turn_detection is not None and self._native_input_append
-            turn_based_server_vad = self._turn_based_server_vad
-            try:
-                fmt, format_rate = self._parse_realtime_audio_format(event_format or self._input_audio_format)
-                sample_rate_hz = event.get("sample_rate_hz") or event.get("sample_rate") or format_rate
-                if sample_rate_hz is None:
-                    sample_rate_hz = (
-                        realtime_default_sample_rate_hz(fmt)
-                        if event_format is not None and fmt != self._input_audio_format
-                        else self._input_sample_rate_hz
-                    )
-                if turn_based_server_vad:
-                    sample_rate_hz = validate_input_sample_rate_hz(sample_rate_hz)
-            except ValueError as exc:
-                await self._send_realtime_payload(
-                    self._realtime_error_payload(
-                        "bad_event",
-                        str(exc),
-                        event_id=event.get("event_id"),
-                        param="sample_rate_hz",
-                    )
-                )
-                return None
-            channels = event.get("channels", 1)
-            if not self._is_supported_realtime_input_format(fmt):
-                await self._send_realtime_payload(
-                    self._realtime_error_payload(
-                        "unsupported_audio_format",
-                        f"Unsupported input_audio_format: {fmt}",
-                        event_id=event.get("event_id"),
-                    )
-                )
-                return None
-            if turn_based_server_vad and (fmt != "pcm16" or channels != 1 or sample_rate_hz not in {16_000, 24_000}):
-                await self._send_realtime_payload(
-                    self._realtime_error_payload(
-                        "unsupported_audio_format",
-                        "server_vad requires mono PCM16 input at 16 kHz or 24 kHz",
-                        event_id=event.get("event_id"),
-                        param="audio.input.format",
-                    )
-                )
-                return None
-            looks_like_speech: bool | None = None
-            if not turn_based_server_vad:
-                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:
-                    await self._send_realtime_payload(
-                        self._realtime_error_payload(
-                            "bad_event",
-                            str(exc),
-                            event_id=event.get("event_id"),
-                            param="sample_rate_hz",
-                        )
-                    )
-                    return None
-            if not turn_based_server_vad and not native_server_vad:
-                looks_like_speech = self._input_looks_like_speech(event, audio=audio, fmt=fmt)
-                has_audio_payload = isinstance(audio, str) and bool(audio)
-                self._input_audio_buffer_has_audio = self._input_audio_buffer_has_audio or (
-                    looks_like_speech and has_audio_payload
-                )
-                self._input_audio_buffer_had_non_speech = self._input_audio_buffer_had_non_speech or (
-                    not looks_like_speech and has_audio_payload
-                )
-                if looks_like_speech:
-                    await self._emit_input_speech_started(event)
-                    self._remember_input_transcript_hint(event)
-            payload = {
-                "type": "input_audio_buffer.append",
-                "audio": audio,
-                "format": fmt,
-                "sample_rate_hz": sample_rate_hz,
-            }
-            event_id = event.get("event_id")
-            if self._turn_detection is not None and isinstance(event_id, str) and event_id:
-                payload["_realtime_event_id"] = event_id
-            video_frames = event.get("video_frames")
-            if video_frames is not None:
-                frames_error = self._validate_realtime_video_frames(video_frames, event.get("max_slice_nums"))
-                if frames_error is not None:
-                    await self._send_realtime_payload(
-                        self._realtime_error_payload(
-                            "invalid_video_frames",
-                            frames_error,
-                            event_id=event.get("event_id"),
-                            param="video_frames",
-                        )
-                    )
-                    return None
-                if isinstance(video_frames, list):
-                    payload["video_frames"] = [frame for frame in video_frames if isinstance(frame, str) and frame]
-            self._copy_realtime_input_hints(event, payload)
-            if looks_like_speech is not None:
-                payload["is_speech"] = looks_like_speech
-            return payload
-        if event_type == "input_audio_buffer.commit":
-            if self._turn_based_server_vad:
-                await self._send_realtime_payload(
-                    self._realtime_error_payload(
-                        "server_vad_manual_commit_unsupported",
-                        (
-                            "input_audio_buffer.commit is not supported while server_vad is enabled; "
-                            "wait for server endpointing, or start a session with turn_detection=null "
-                            "to use manual commit"
-                        ),
-                        event_id=event.get("event_id"),
-                    )
-                )
-                return None
-            if not self._input_audio_buffer_has_audio:
-                if self._input_audio_buffer_had_non_speech:
-                    self._input_audio_buffer_had_non_speech = False
-                    self._active_input_item_id = None
-                    return {
-                        "type": "input_audio_buffer.commit",
-                        "final": event.get("final", True),
-                        "response_create": False,
-                        "is_speech": False,
-                    }
-                await self._send_realtime_payload(
-                    self._realtime_error_payload(
-                        "input_audio_buffer_empty",
-                        "input_audio_buffer.commit requires a non-empty input audio buffer",
-                        event_id=event.get("event_id"),
-                    )
-                )
-                return None
-            item_id = self._active_input_item_id or f"item_{uuid4().hex}"
-            await self._emit_input_speech_stopped(event, item_id=item_id)
-            transcript = self._consume_input_transcript_hint()
-            self._active_input_item_id = None
-            self._input_audio_buffer_has_audio = False
-            self._input_audio_buffer_had_non_speech = False
-            payload = {
-                "type": "input_audio_buffer.commit",
-                "final": event.get("final", True),
-                "item_id": item_id,
-                "response_create": bool(event.get("response_create", False)),
-            }
-            if transcript:
-                payload["transcript"] = transcript
-            return payload
-        if event_type == "input_audio_buffer.clear":
-            self._reset_realtime_input_buffer_state()
-            return {"type": "input_audio_buffer.clear", "reason": event_type}
-        if event_type == "output_audio_buffer.clear":
-            payload = {"type": "output_audio_buffer.clear", "reason": event_type}
-            response_id = event.get("response_id")
-            if not isinstance(response_id, str) or not response_id:
-                response_id = self._active_response_id or self._last_response_id
-            if self._response_is_done(response_id):
-                await self._send_realtime_payload(
-                    {
-                        "type": "output_audio_buffer.cleared",
-                        "response_id": response_id,
-                    }
-                )
-                return None
-            if isinstance(response_id, str) and response_id:
-                payload["response_id"] = response_id
-            return payload
-        if event_type == "response.cancel":
-            payload = {"type": "response.cancel", "reason": event_type}
-            response_id = event.get("response_id")
-            if not isinstance(response_id, str) or not response_id:
-                response_id = self._active_response_id or self._last_response_id
-            if self._response_is_done(response_id):
-                await self._send_realtime_payload(
-                    self._realtime_error_payload(
-                        "response_not_active",
-                        f"Response is already complete: {response_id}",
-                        event_id=event.get("event_id"),
-                    )
-                )
-                return None
-            if isinstance(response_id, str) and response_id:
-                payload["response_id"] = response_id
-            return payload
-        if event_type == "response.create":
-            response_payload = event.get("response")
-            if isinstance(response_payload, dict):
-                format_error = self._validate_realtime_response_audio_formats(response_payload)
-                if format_error is not None:
-                    await self._send_realtime_payload(
-                        self._realtime_error_payload(
-                            "unsupported_audio_format",
-                            format_error,
-                            event_id=event.get("event_id"),
-                        )
-                    )
-                    return None
-            return {
-                "type": "response.create",
-                "response": response_payload if isinstance(response_payload, dict) else {},
-            }
-        if event_type in {"session.close", "close"}:
-            return {"type": "session.close"}
-        return event
+        """Wire JSON of a transport-level error (derived from the typed ``ErrorEvent``)."""
+        return error_event(code, message, event_id=event_id, param=param).to_realtime()
 
     @staticmethod
-    def _normalize_conversation_item(item: dict[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
-
-    @staticmethod
-    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 = RealtimeInputTranslator._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"] = ""
-
-    @staticmethod
-    def _validate_realtime_item_truncate(
-        item: dict[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
-
-    @staticmethod
-    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 _conversation_item_added_events(self, item: dict[str, object]) -> list[dict[str, object]]:
-        item_id = item.get("id")
-        explicit_previous_item_id = item.pop("_previous_item_id", None)
-        previous_item_id = (
-            explicit_previous_item_id if isinstance(explicit_previous_item_id, str) else self._last_conversation_item_id
-        )
-        if isinstance(item_id, str) and item_id:
-            self._last_conversation_item_id = item_id
-        return [
-            {
-                "type": "conversation.item.added",
-                "previous_item_id": previous_item_id,
-                "item": item,
-            },
-        ]
-
-    def _conversation_item_done_event(self, item: dict[str, object]) -> dict[str, object]:
-        item_id = item.get("id")
-        previous_item_id = self._previous_item_id(item_id) if isinstance(item_id, str) else None
-        if isinstance(item_id, str) and item_id:
-            already_known = item_id in self._conversation_items
-            self._conversation_items[item_id] = item
-            # Completing an item that was already added must not move it to the
-            # end of the conversation. A later user item may have been added
-            # while this response was still in progress.
-            if not already_known:
-                self._last_conversation_item_id = item_id
-        return {
-            "type": "conversation.item.done",
-            "previous_item_id": previous_item_id,
-            "item": item,
-        }
-
-    def _remove_conversation_item(self, item_id: str) -> bool:
-        removed = self._conversation_items.pop(item_id, None) is not None
-        if self._last_conversation_item_id == item_id:
-            remaining_ids = list(self._conversation_items)
-            self._last_conversation_item_id = remaining_ids[-1] if remaining_ids else None
-        self._item_truncation_cursors.pop(item_id, None)
-        return removed
-
-    def _response_output_item_added_events(
-        self,
-        *,
-        response_id: object,
-        item: dict[str, object],
-    ) -> list[dict[str, object]]:
-        return [
-            {
-                "type": "response.output_item.added",
-                "response_id": response_id,
-                "output_index": 0,
-                "item": item,
-            },
-        ]
-
-    @staticmethod
-    def _response_content_part(*, transcript: str = "") -> dict[str, object]:
-        return {
-            "type": "audio",
-            "transcript": transcript,
-        }
-
-    @staticmethod
-    def _response_text_content_part(*, text: str = "") -> dict[str, object]:
-        return {
-            "type": "text",
-            "text": text,
-        }
-
-    @staticmethod
-    def _response_item_content_part(
-        *,
-        transcript: str = "",
-        audio_duration_ms: int | None = None,
-        audio_text_marks: list[dict[str, int]] | None = None,
-    ) -> dict[str, object]:
-        part: dict[str, object] = {
-            "type": "output_audio",
-            "transcript": transcript,
-        }
-        if audio_duration_ms is not None:
-            part["audio_duration_ms"] = int(audio_duration_ms)
-        if audio_text_marks:
-            part["audio_text_marks"] = [dict(mark) for mark in audio_text_marks]
-        return part
-
-    @staticmethod
-    def _response_item_text_content_part(*, text: str = "") -> dict[str, object]:
-        return {
-            "type": "output_text",
-            "text": text,
-        }
-
-    def _previous_item_id(self, item_id: str) -> str | None:
-        previous: str | None = None
-        for known_id in self._conversation_items:
-            if known_id == item_id:
-                return previous
-            previous = known_id
-        if self._last_conversation_item_id == item_id:
-            return previous
-        return self._last_conversation_item_id
-
-    def _input_audio_buffer_committed_event(
-        self,
-        *,
-        item_id: str,
-    ) -> dict[str, object]:
-        return {
-            "type": "input_audio_buffer.committed",
-            "previous_item_id": self._previous_item_id(item_id),
-            "item_id": item_id,
-        }
-
-    def _session_create_from_realtime(self, session_payload: dict[str, object]) -> dict[str, object]:
-        model = session_payload.get("model")
-        audio_config = session_payload.get("audio")
-        audio_input = audio_config.get("input") if isinstance(audio_config, dict) else None
-        audio_output = audio_config.get("output") if isinstance(audio_config, dict) else None
-        extra_body_payload = session_payload.get("extra_body")
-        extra_body = (
-            normalize_native_duplex_key(dict(extra_body_payload)) if isinstance(extra_body_payload, dict) else {}
-        )
-        extra_body["realtime_session_payload"] = self._json_safe_realtime_payload(session_payload)
-        if isinstance(session_payload.get("tools"), list):
-            extra_body["realtime_tools"] = session_payload["tools"]
-        if isinstance(session_payload.get("tool_choice"), str | dict):
-            extra_body["realtime_tool_choice"] = session_payload["tool_choice"]
-        metadata = session_payload.get("metadata")
-        if isinstance(metadata, dict):
-            extra_body["realtime_metadata"] = dict(metadata)
-        include = session_payload.get("include")
-        if isinstance(include, list):
-            extra_body["realtime_include"] = list(include)
-        prompt = session_payload.get("prompt")
-        if isinstance(prompt, dict):
-            extra_body["realtime_prompt"] = dict(prompt)
-        input_audio_transcription = self._input_audio_transcription_config(session_payload)
-        if isinstance(input_audio_transcription, dict):
-            extra_body["realtime_input_audio_transcription"] = dict(input_audio_transcription)
-        noise_reduction = session_payload.get("input_audio_noise_reduction")
-        if isinstance(noise_reduction, dict):
-            extra_body["realtime_input_audio_noise_reduction"] = dict(noise_reduction)
-        audio_noise_reduction = audio_input.get("noise_reduction") if isinstance(audio_input, dict) else None
-        if isinstance(audio_noise_reduction, dict):
-            extra_body["realtime_input_audio_noise_reduction"] = dict(audio_noise_reduction)
-        audio = session_payload.get("audio")
-        if isinstance(audio, dict):
-            extra_body["realtime_audio"] = dict(audio)
-        if isinstance(session_payload.get("tracing"), str | dict):
-            extra_body["realtime_tracing"] = session_payload["tracing"]
-        response_format = self._duplex_response_format(self._output_audio_format)
-        extra_body.setdefault("realtime_output_audio_format", self._output_audio_format)
-        overlap_fields = self._realtime_overlap_fields(session_payload)
-        voice = session_payload.get("voice")
-        if not isinstance(voice, str) and isinstance(audio_output, dict):
-            voice = audio_output.get("voice")
-        speed = session_payload.get("speed")
-        if not isinstance(speed, int | float) and isinstance(audio_output, dict):
-            speed = audio_output.get("speed")
-        return {
-            "type": "session.create",
-            "session_id": session_payload.get("session_id") or session_payload.get("id"),
-            "session": {
-                "model": model,
-                "modalities": (
-                    session_payload.get("modalities") or session_payload.get("output_modalities") or ["text", "audio"]
-                ),
-                "instructions": session_payload.get("instructions"),
-                "voice": voice,
-                "ref_audio": session_payload.get("ref_audio"),
-                "response_format": response_format,
-                "temperature": session_payload.get("temperature"),
-                "max_tokens": self.realtime_max_output_tokens(
-                    session_payload.get("max_response_output_tokens")
-                    or session_payload.get("max_output_tokens")
-                    or session_payload.get("max_tokens")
-                ),
-                "speed": speed,
-                "idle_timeout_s": session_payload.get("idle_timeout_s") or 300.0,
-                **overlap_fields,
-                "extra_body": extra_body,
-            },
-        }
-
-    def _apply_realtime_session_defaults(self, session_payload: dict[str, object]) -> None:
-        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_configured = input_format is not None
-        input_format, input_rate = self._parse_realtime_audio_format(input_format)
-        if input_format is not None and not (
-            isinstance(input_format, str) and input_format.lower() in REALTIME_INPUT_AUDIO_FORMATS
-        ):
-            raise ValueError(f"Unsupported input_audio_format: {input_format}")
-        if isinstance(input_format, str):
-            self._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 = self._parse_realtime_audio_format(output_format)
-        if output_rate is None and output_rate_raw is not None:
-            output_rate = validate_input_sample_rate_hz(output_rate_raw)
-        if output_format is not None and not (
-            isinstance(output_format, str) and output_format.lower() in REALTIME_OUTPUT_AUDIO_FORMATS
-        ):
-            raise ValueError(f"Unsupported output_audio_format: {output_format}")
-        if isinstance(output_format, str):
-            self._output_audio_format = self._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 sample_rate is not None:
-            self._input_sample_rate_hz = validate_input_sample_rate_hz(sample_rate)
-        elif input_format_configured:
-            default_input_rate = realtime_default_sample_rate_hz(input_format)
-            if default_input_rate is not None:
-                self._input_sample_rate_hz = default_input_rate
-        if output_rate is not None:
-            self._output_sample_rate_hz = output_rate
-        overlap_fields = self._realtime_overlap_fields(session_payload)
-        overlap_silence_rms = overlap_fields.get("overlap_silence_rms")
-        if isinstance(overlap_silence_rms, int | float):
-            self._overlap_silence_rms = max(0.0, float(overlap_silence_rms))
-
-    @classmethod
-    def _validate_realtime_response_audio_formats(cls, response_payload: dict[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")
-        try:
-            parsed_output, _ = cls._parse_realtime_audio_format(output_format)
-        except ValueError as exc:
-            return str(exc)
-        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
-
-    @staticmethod
-    def _json_safe_realtime_payload(payload: dict[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] = RealtimeInputTranslator._json_safe_realtime_payload(value)
-            elif isinstance(value, list):
-                clean[key] = [
-                    (RealtimeInputTranslator._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
-
-    @staticmethod
-    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 = validate_input_sample_rate_hz(rate) if rate is not None 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
-
-    @staticmethod
-    def _duplex_response_format(realtime_format: str) -> str:
-        normalized = realtime_format.lower()
-        if normalized in {"pcm16", "pcm_s16le", "s16le"}:
-            return "pcm"
-        if normalized in {"g711_ulaw", "g711_alaw"}:
-            return "pcm"
-        if normalized in {"wav", "pcm"}:
-            return normalized
-        return "wav"
-
-    @staticmethod
-    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")
-
-    @staticmethod
-    def _is_supported_realtime_input_format(fmt: object) -> bool:
-        return isinstance(fmt, str) and fmt.lower() in REALTIME_INPUT_AUDIO_FORMATS
-
-    @staticmethod
-    def _input_explicitly_non_speech(event: dict[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(self, event: dict[str, object], *, audio: object, fmt: object) -> bool:
-        if RealtimeInputTranslator._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" or not isinstance(audio, str):
-            return True
-        try:
-            raw = base64.b64decode(audio, validate=True)
-        except (binascii.Error, ValueError):
-            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 self._overlap_silence_rms
-        return rms >= max(0.0, silence_rms)
-
-    @staticmethod
-    def _copy_realtime_input_hints(source: dict[str, object], target: dict[str, object]) -> None:
-        for key in (
-            "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",
-        ):
-            if key in source:
-                target[key] = source[key]
-
-    @classmethod
-    def _realtime_overlap_fields(cls, session_payload: dict[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
-
-    @staticmethod
-    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). HD slicing (max_slice_nums > 1) is not implemented
-        by the duplex adapter yet and is rejected explicitly rather than
-        silently ignored; note official suggests it for composites
-        (``max_slice_nums=[2, 1]``), so stacked detail is capped at
-        scale_resolution until that lands.
-        """
-        if max_slice_nums not in (None, 1):
-            return "max_slice_nums > 1 (HD slicing) is not implemented by the duplex Realtime adapter"
-        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 _validate_realtime_turn_detection(
-        self,
-        session_payload: dict[str, object],
-        *,
-        configured: bool,
-        normalized: dict[str, object] | None,
-    ) -> str | None:
-        effective_turn_detection = normalized if configured else self._turn_detection
-        if effective_turn_detection is None:
-            if session_payload.get("overlap_policy") == "barge_in_on_speech":
-                return "overlap_policy='barge_in_on_speech' requires turn_detection.type='server_vad'"
-            return None
-
-        interrupt_response = effective_turn_detection.get("interrupt_response")
-        if interrupt_response is None:
-            # Serving resolves the default and validates overlap policy once
-            # the session's runtime capabilities are known.
-            return None
-        desired_policy = "barge_in_on_speech" if interrupt_response else "listen_only"
-        overlap_policy = session_payload.get("overlap_policy")
-        if isinstance(overlap_policy, str) and overlap_policy != desired_policy:
-            return f"overlap_policy={overlap_policy!r} conflicts with turn_detection; expected {desired_policy!r}"
-        return None
-
-    def validate_server_vad_input_audio(self, session_payload: dict[str, object]) -> str | None:
-        """Validate turn-based VAD audio after serving resolves runtime capabilities."""
-        candidate = self._pending_turn_detection_update
-        input_format, input_rate, *_ = candidate[3] if candidate is not None else self._realtime_protocol_config()
-        audio_config = session_payload.get("audio")
-        audio_input = audio_config.get("input") if isinstance(audio_config, dict) else None
-        channels = audio_input.get("channels") if isinstance(audio_input, dict) else None
-        raw_format = session_payload.get("input_audio_format")
-        if raw_format is None and isinstance(audio_input, dict):
-            raw_format = audio_input.get("format")
-        if channels is None and isinstance(raw_format, dict):
-            channels = raw_format.get("channels")
-        if channels is None:
-            channels = 1
-        if input_format != "pcm16" or channels != 1 or input_rate not in {16_000, 24_000}:
-            return "server_vad requires mono PCM16 input at 16 kHz or 24 kHz"
-        return None
-
-    def _prepare_realtime_turn_detection_update(
-        self,
-        session_payload: dict[str, object],
-        *,
-        configured: bool,
-        normalized: dict[str, object] | None,
-    ) -> tuple[bool, dict[str, object] | None]:
-        if self._pending_turn_detection_update is not None:
-            raise RuntimeError("A Realtime session update is already pending")
-
-        turn_detection = dict(normalized) if configured and normalized is not None else None
-        if configured:
-            if turn_detection is None:
-                session_payload.setdefault("overlap_policy", "listen_only")
-            elif "interrupt_response" in turn_detection:
-                session_payload.setdefault(
-                    "overlap_policy", "barge_in_on_speech" if turn_detection["interrupt_response"] else "listen_only"
-                )
-            session_payload["turn_detection"] = turn_detection
-        return configured, turn_detection
-
-    def _realtime_protocol_config(self) -> tuple[str, int, str, int | None, float]:
-        return (
-            self._input_audio_format,
-            self._input_sample_rate_hz,
-            self._output_audio_format,
-            self._output_sample_rate_hz,
-            self._overlap_silence_rms,
-        )
-
-    def _set_realtime_protocol_config(
-        self,
-        config: tuple[str, int, str, int | None, float],
-    ) -> None:
-        (
-            self._input_audio_format,
-            self._input_sample_rate_hz,
-            self._output_audio_format,
-            self._output_sample_rate_hz,
-            self._overlap_silence_rms,
-        ) = config
-
-    def pending_realtime_input_audio_config_changed(self) -> bool:
-        candidate = self._pending_turn_detection_update
-        if candidate is None:
-            return False
-        candidate_protocol_config = candidate[3]
-        return candidate_protocol_config[:2] != self._realtime_protocol_config()[:2]
-
-    async def wait_for_realtime_turn_detection_update(self) -> None:
-        candidate = self._pending_turn_detection_update
-        if candidate is not None:
-            await candidate[2].wait()
-
-    def commit_realtime_turn_detection_update(self, server_vad: ServerVADConfig | None = None) -> None:
-        self._resolve_realtime_turn_detection_update(commit=True, server_vad=server_vad)
-
-    def reject_realtime_turn_detection_update(self) -> None:
-        self._resolve_realtime_turn_detection_update(commit=False)
-
-    def _resolve_realtime_turn_detection_update(
-        self, *, commit: bool, server_vad: ServerVADConfig | None = None
-    ) -> None:
-        candidate = self._pending_turn_detection_update
-        if candidate is None:
-            return
-        configured, turn_detection, resolved, protocol_config = candidate
-        if commit:
-            self._set_realtime_protocol_config(protocol_config)
-            if configured:
-                self._turn_detection = server_vad.as_dict() if server_vad is not None else turn_detection
-                self._turn_detection_configured = True
-        self._pending_turn_detection_update = None
-        resolved.set()
-
-    @staticmethod
-    def _input_audio_transcription_config(session_payload: dict[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
-
-    @staticmethod
-    def realtime_max_output_tokens(value: object) -> int | None:
-        """Normalize Realtime max output tokens.
-
-        OpenAI Realtime clients commonly send ``"inf"`` for unbounded output.
-        The duplex core represents that as ``None`` because model-specific
-        defaults remain in force.
-        """
-        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
-
-    async def _conversation_item_to_duplex(self, event: dict[str, object]) -> dict[str, object] | None:
-        raw_item = event.get("item")
-        if not isinstance(raw_item, dict):
-            return None
-        public_item = self._normalize_conversation_item(raw_item)
-        previous_item_id = event.get("previous_item_id")
-        if isinstance(previous_item_id, str):
-            public_item["_previous_item_id"] = previous_item_id
-        item_id = str(public_item["id"])
-        item_type = public_item.get("type")
-        role = public_item.get("role")
-        if item_type == "function_call_output":
-            call_id = public_item.get("call_id")
-            output = public_item.get("output")
-            matching_call = any(
-                known.get("type") == "function_call" and known.get("call_id") == call_id
-                for known in self._conversation_items.values()
-            )
-            duplicate_output = any(
-                known.get("type") == "function_call_output" and known.get("call_id") == call_id
-                for known in self._conversation_items.values()
-            )
-            if not isinstance(call_id, str) or not call_id or not matching_call:
-                await self._send_realtime_payload(
-                    self._realtime_error_payload(
-                        "invalid_function_call_output",
-                        "function_call_output requires the call_id of a completed function call",
-                        event_id=event.get("event_id"),
-                        param="item.call_id",
-                    )
-                )
-                return None
-            if not isinstance(output, str) or duplicate_output:
-                await self._send_realtime_payload(
-                    self._realtime_error_payload(
-                        "invalid_function_call_output",
-                        (
-                            "function_call_output requires a string output"
-                            if not isinstance(output, str)
-                            else f"function_call_output already exists for call_id {call_id}"
-                        ),
-                        event_id=event.get("event_id"),
-                        param="item.output",
-                    )
-                )
-                return None
-            # Do not retain the result until SessionRunner has delivered its
-            # runtime update. On success, the resulting
-            # ``conversation.item.created`` event records it in the shared
-            # input/output protocol state; on failure the client may retry the
-            # same call_id instead of being rejected by provisional history.
-        content = public_item.get("content")
-        if not isinstance(content, list):
-            return None
-        parsed_audio_formats: dict[int, tuple[object, int | None]] = {}
-        for index, part in enumerate(content):
-            if not isinstance(part, dict) or part.get("type") not in {"input_audio", "audio"}:
-                continue
-            raw_format = part.get("format")
-            try:
-                parsed_format = self._parse_realtime_audio_format(raw_format or self._input_audio_format)
-            except ValueError as exc:
-                await self._send_realtime_payload(
-                    self._realtime_error_payload(
-                        "unsupported_audio_format",
-                        str(exc),
-                        event_id=event.get("event_id"),
-                        param="item.content.audio",
-                    )
-                )
-                return None
-            if not self._is_supported_realtime_input_format(parsed_format[0]):
-                await self._send_realtime_payload(
-                    self._realtime_error_payload(
-                        "unsupported_audio_format",
-                        f"Unsupported input_audio format in conversation.item.create: {raw_format}",
-                        event_id=event.get("event_id"),
-                        param="item.content.audio",
-                    )
-                )
-                return None
-            parsed_audio_formats[index] = parsed_format
-        if item_type != "message" or role in {"assistant", "system"}:
-            event["item"] = public_item
-            return {
-                "type": "turn.signal",
-                "event": "conversation.item.create",
-                "payload": {"item": public_item},
-            }
-        server_vad_full_audio_item = self._turn_based_server_vad
-        text_chunks: list[str] = []
-        audio_events: list[dict[str, object]] = []
-        normalized_content: list[object] = []
-        normalized_full_audio = False
-        for index, part in enumerate(content):
-            if not isinstance(part, dict):
-                normalized_content.append(part)
-                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") in {"input_audio", "audio"}:
-                audio = part.get("audio") or part.get("data")
-                if not isinstance(audio, str) or not audio:
-                    await self._send_realtime_payload(
-                        self._realtime_error_payload(
-                            "bad_audio",
-                            "conversation.item.create input_audio must not be empty",
-                            event_id=event.get("event_id"),
-                            param="item.content.audio",
-                        )
-                    )
-                    return None
-                raw_part_format = part.get("format")
-                fmt, format_rate = parsed_audio_formats[index]
-                explicit_sample_rate_hz = part.get("sample_rate_hz")
-                if explicit_sample_rate_hz is None:
-                    explicit_sample_rate_hz = part.get("sample_rate")
-                if explicit_sample_rate_hz is None and isinstance(raw_part_format, dict):
-                    explicit_sample_rate_hz = (
-                        raw_part_format.get("rate")
-                        if "rate" in raw_part_format
-                        else raw_part_format.get("sample_rate_hz", raw_part_format.get("sample_rate"))
-                    )
-                sample_rate_hz = explicit_sample_rate_hz or format_rate or self._input_sample_rate_hz
-                if server_vad_full_audio_item and (
-                    fmt != self._input_audio_format
-                    or (explicit_sample_rate_hz is not None and explicit_sample_rate_hz != self._input_sample_rate_hz)
-                ):
-                    await self._send_realtime_payload(
-                        self._realtime_error_payload(
-                            "bad_audio",
-                            "conversation.item.create input_audio must use the Session input format and sample rate",
-                            event_id=event.get("event_id"),
-                            param="item.content.audio",
-                        )
-                    )
-                    return None
-                if server_vad_full_audio_item:
-                    try:
-                        normalized_audio = self._normalize_complete_audio_item_part(audio, self._input_sample_rate_hz)
-                    except ValueError as exc:
-                        await self._send_realtime_payload(
-                            self._realtime_error_payload(
-                                "bad_audio",
-                                str(exc),
-                                event_id=event.get("event_id"),
-                                param="item.content.audio",
-                            )
-                        )
-                        return None
-                    normalized_part = dict(part)
-                    normalized_part.pop("data", None)
-                    normalized_part.update(audio=normalized_audio, format="wav", sample_rate_hz=16_000)
-                    normalized_content.append(normalized_part)
-                    normalized_full_audio = True
-                    continue
-                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:
-                    await self._send_realtime_payload(
-                        self._realtime_error_payload(
-                            "bad_audio",
-                            str(exc),
-                            event_id=event.get("event_id"),
-                            param="item.content.audio",
-                        )
-                    )
-                    return None
-                speech_hints = dict(event)
-                speech_hints.update(part)
-                if not self._input_looks_like_speech(speech_hints, audio=audio, fmt=fmt):
-                    continue
-                self._input_speech_started = True
-                payload = {
-                    "type": "input_audio_buffer.append",
-                    "audio": audio,
-                    "format": fmt,
-                    "sample_rate_hz": sample_rate_hz,
-                }
-                self._copy_realtime_input_hints(part, payload)
-                self._copy_realtime_input_hints(event, payload)
-                audio_events.append(payload)
-                continue
-            normalized_content.append(part)
-        if server_vad_full_audio_item and normalized_full_audio:
-            history_item = dict(public_item)
-            history_item["content"] = normalized_content
-            history_item["status"] = "completed"
-            event["item"] = public_item
-            return {
-                "type": "turn.signal",
-                "event": "conversation.item.create",
-                "payload": {
-                    "item": public_item,
-                    "history_item": history_item,
-                },
-            }
-        if audio_events:
-            transcript = self._input_transcript_from_item(public_item)
-            for extra_event in audio_events[1:]:
-                self._pending_outbound.put_nowait(extra_event)
-            commit_payload: dict[str, object] = {
-                "type": "input_audio_buffer.commit",
-                "final": True,
-                "item_id": item_id,
-                "response_create": False,
-            }
-            if transcript:
-                commit_payload["transcript"] = transcript
-            self._pending_outbound.put_nowait(commit_payload)
-            # This complete item is already committed locally; a later ack
-            # must not be needed to start accepting the next input turn.
-            self._reset_realtime_input_buffer_state()
-            event["item"] = public_item
-            return audio_events[0]
-        if not text_chunks:
-            return None
-        text_item = dict(public_item)
-        text_item["status"] = "completed"
-        event["item"] = text_item
-        return {
-            "type": "turn.signal",
-            "event": "conversation.item.create",
-            "payload": {"item": text_item},
-        }
-
-    @staticmethod
-    def _normalize_complete_audio_item_part(
-        audio: str,
-        sample_rate_hz: int,
-    ) -> str:
-        """Package a complete Realtime audio item for the chat fallback path."""
-        try:
-            raw = base64.b64decode(audio.strip(), validate=True)
-        except (binascii.Error, ValueError) as exc:
-            raise ValueError("conversation.item.create input_audio is not valid Base64") from exc
-        if not raw or len(raw) % np.dtype("<i2").itemsize:
-            raise ValueError("conversation.item.create input_audio must contain complete PCM16 samples")
-        samples = np.frombuffer(raw, dtype="<i2").astype(np.float32) / 32768.0
-        if sample_rate_hz != 16_000:
-            from vllm_omni.entrypoints.openai.audio_utils_mixin import StreamingAudioResampler
-
-            samples = StreamingAudioResampler(sample_rate_hz, 16_000).process(samples, final=True)
-        return encode_float32_mono_wav_base64(samples, sample_rate_hz=16_000)
-
-    def _remember_input_transcript_hint(self, event: dict[str, object]) -> None:
-        transcript = event.get("transcript")
-        if not isinstance(transcript, str):
-            transcript = event.get("text") if isinstance(event.get("text"), str) else None
-        if not isinstance(transcript, str):
-            hints = event.get("hints")
-            if isinstance(hints, dict):
-                transcript = hints.get("transcript")
-                if not isinstance(transcript, str):
-                    transcript = hints.get("text") if isinstance(hints.get("text"), str) else None
-        if isinstance(transcript, str) and transcript:
-            if (
-                self._input_audio_buffer_transcript_parts
-                and self._input_audio_buffer_transcript_parts[-1] == transcript
-            ):
-                return
-            self._input_audio_buffer_transcript_parts.append(transcript)
-
-    def _consume_input_transcript_hint(self) -> str:
-        transcript = "".join(self._input_audio_buffer_transcript_parts).strip()
-        self._input_audio_buffer_transcript_parts.clear()
-        return transcript
-
-    @staticmethod
-    def _input_transcript_from_item(item: dict[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()
-
-    @staticmethod
-    def _input_audio_transcription_completed_event(
-        item_id: str,
-        item: dict[str, object],
-    ) -> dict[str, object] | None:
-        content = item.get("content")
-        if not isinstance(content, list):
-            return None
-        transcript_parts: list[str] = []
-        for index, part in enumerate(content):
-            if not isinstance(part, dict):
-                continue
-            if part.get("type") != "input_audio":
-                continue
-            transcript = part.get("transcript")
-            if isinstance(transcript, str) and transcript:
-                transcript_parts.append(transcript)
-                return {
-                    "type": "conversation.item.input_audio_transcription.completed",
-                    "item_id": item_id,
-                    "content_index": index,
-                    "transcript": "".join(transcript_parts),
-                }
-        return None
-
-    async def _emit_input_speech_started(self, event: dict[str, object]) -> None:
-        if self._input_speech_started:
-            return
-        self._input_speech_started = True
-        if self._active_input_item_id is None:
-            self._active_input_item_id = f"item_{uuid4().hex}"
-        audio_start_ms = event.get("audio_start_ms", 0)
-        await self._send_realtime_payload(
-            {
-                "type": "input_audio_buffer.speech_started",
-                "audio_start_ms": int(audio_start_ms) if isinstance(audio_start_ms, int | float) else 0,
-                "item_id": self._active_input_item_id,
-            }
-        )
-
-    async def _emit_input_speech_stopped(self, event: dict[str, object], *, item_id: str) -> None:
-        if not self._input_speech_started:
-            return
-        self._input_speech_started = False
-        audio_end_ms = event.get("audio_end_ms", event.get("audio_ms", 0))
-        await self._send_realtime_payload(
-            {
-                "type": "input_audio_buffer.speech_stopped",
-                "audio_end_ms": int(audio_end_ms) if isinstance(audio_end_ms, int | float) else 0,
-                "item_id": item_id,
-            }
-        )
+    def command_error_payload(exc: DuplexCommandError) -> dict[str, object]:
+        return error_event(exc.code, str(exc), event_id=exc.event_id).to_realtime()
diff --git a/vllm_omni/entrypoints/duplex/realtime_output.py b/vllm_omni/entrypoints/duplex/realtime_output.py
deleted file mode 100644
index 82ce9761e..000000000
--- a/vllm_omni/entrypoints/duplex/realtime_output.py
+++ /dev/null
@@ -1,1007 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-from __future__ import annotations
-
-from typing import Any
-from uuid import uuid4
-
-from vllm_omni.entrypoints.duplex.audio import convert_output_audio
-from vllm_omni.entrypoints.duplex.realtime_state import (
-    _RealtimeResponseState,
-)
-
-
-class RealtimeOutputProjector:
-    """Project internal duplex events onto the OpenAI Realtime schema."""
-
-    def _from_duplex_event(self, event: dict[str, Any]) -> list[dict[str, object]]:
-        event_type = event.get("type")
-        if event_type == "session.created":
-            session = self._realtime_session_payload(event.get("session"))
-            created: dict[str, object] = {"type": "session.created", "session": session}
-            for key in (
-                "incarnation",
-                "attachment_generation",
-                "resume_token",
-            ):
-                if key in event:
-                    created[key] = event[key]
-            payloads: list[dict[str, object]] = [created]
-            if self._initial_session_update:
-                payloads.append({"type": "session.updated", "session": session})
-                self._initial_session_update = False
-            self._hold_realtime_output_until_session_created = False
-            if self._held_realtime_payloads:
-                payloads.extend(self._held_realtime_payloads)
-                self._held_realtime_payloads = []
-            return payloads
-        if event_type == "session.updated":
-            session = self._realtime_session_payload(event.get("session"))
-            return [{"type": "session.updated", "session": session}]
-        if event_type == "input_audio_buffer.speech_started":
-            item_id = event.get("item_id")
-            if isinstance(item_id, str):
-                self._active_input_item_id = item_id
-            self._input_speech_started = True
-            self._input_audio_buffer_has_audio = True
-            return [
-                {
-                    "type": "input_audio_buffer.speech_started",
-                    "audio_start_ms": max(0, int(event.get("audio_start_ms", 0) or 0)),
-                    "item_id": item_id,
-                }
-            ]
-        if event_type == "input_audio_buffer.speech_stopped":
-            self._input_speech_started = False
-            return [
-                {
-                    "type": "input_audio_buffer.speech_stopped",
-                    "audio_end_ms": max(0, int(event.get("audio_end_ms", 0) or 0)),
-                    "item_id": event.get("item_id") or self._active_input_item_id,
-                }
-            ]
-        if event_type in {
-            "session.resumed",
-            "session.heartbeat_ack",
-            "session.replaced",
-            "session.expired",
-            "session.resync_required",
-        }:
-            if event_type == "session.resumed":
-                self._hold_realtime_output_until_session_created = False
-            return [dict(event)]
-        if event_type == "response.created":
-            response_id = event.get("response_id")
-            if isinstance(response_id, str) and response_id:
-                self._active_response_id = response_id
-                self._last_response_id = response_id
-            item_id = self._response_item_id(response_id)
-            modalities = event.get("modalities")
-            has_audio_modality = not isinstance(modalities, list) or "audio" in modalities
-            item = {
-                "id": item_id,
-                "object": "realtime.item",
-                "type": "message",
-                "role": "assistant",
-                "status": "in_progress",
-                "content": [],
-            }
-            self._conversation_items[item_id] = item
-            payloads = [
-                self._response_created_event(event),
-                *self._conversation_item_added_events(item),
-                *self._response_output_item_added_events(response_id=response_id, item=item),
-            ]
-            if has_audio_modality:
-                payloads.extend(self._ensure_response_audio_part_added(response_id))
-            return payloads
-        if event_type == "response.listen":
-            listen_response: dict[str, object] = {
-                "object": "realtime.response",
-                "status": "listening",
-                "metadata": event,
-            }
-            listen_payload: dict[str, object] = {
-                "type": "response.listen",
-                "session_id": event.get("session_id"),
-                "epoch": event.get("epoch"),
-                "response": listen_response,
-            }
-            listen_response_id = event.get("response_id")
-            if isinstance(listen_response_id, str) and listen_response_id:
-                # Keep the response identity visible on the Realtime dialect:
-                # a listen that terminates a precreated response is matched to
-                # it by this id (clients demultiplex on response_id).
-                listen_response["id"] = listen_response_id
-                listen_payload["response_id"] = listen_response_id
-            return [listen_payload]
-        if event_type == "response.speak":
-            response_id = event.get("response_id")
-            state = self._response_state(response_id)
-            if state is not None:
-                if state.speak_emitted:
-                    return []
-                state.speak_emitted = True
-            return [
-                {
-                    "type": "response.speak",
-                    "response_id": response_id,
-                    "item_id": self._response_item_id(response_id),
-                    "output_index": 0,
-                    "content_index": 0,
-                    "metadata": self._response_speak_metadata(event),
-                }
-            ]
-        if event_type == "overlap.decision":
-            return [
-                {
-                    "type": "overlap.decision",
-                    "session_id": event.get("session_id"),
-                    "epoch": event.get("epoch"),
-                    "policy": event.get("policy"),
-                    "action": event.get("action"),
-                    "reason": event.get("reason"),
-                    "metadata": event,
-                }
-            ]
-        if event_type == "response.output_audio.delta":
-            response_id = event.get("response_id")
-            audio = event.get("audio", "")
-            payloads: list[dict[str, object]] = []
-            if isinstance(audio, str) and audio:
-                payloads.extend(self._ensure_response_audio_part_added(response_id))
-                payloads.extend(self._realtime_audio_delta_events(event, response_id, audio))
-                self._refresh_in_progress_response_item(response_id)
-            text = event.get("text")
-            has_text = isinstance(text, str) and bool(text)
-            if has_text:
-                self._append_response_transcript(response_id, text)
-                self._refresh_in_progress_response_item(response_id)
-            # Keep the audio.delta + transcript.delta pair invariant even for
-            # text-less units (deduplicated continuations, turn-end flush):
-            # clients that treat the pair as unit-complete would otherwise
-            # wait on a transcript that never comes.
-            emit_transcript = has_text or (isinstance(audio, str) and bool(audio))
-            if emit_transcript:
-                if not has_text:
-                    text = ""
-                payloads.append(
-                    {
-                        "type": "response.audio_transcript.delta",
-                        "response_id": response_id,
-                        "item_id": self._response_item_id(response_id),
-                        "output_index": 0,
-                        "content_index": 0,
-                        "delta": text,
-                    }
-                )
-            if event.get("end_of_turn") is True:
-                payloads.extend(self._realtime_audio_done_events(event, response_id))
-                payloads.extend(
-                    self._realtime_response_terminal_events(
-                        event,
-                        response_id,
-                        status="completed",
-                        status_details={
-                            "type": "completed",
-                            "reason": event.get("finish_reason") or "stop",
-                        },
-                    )
-                )
-            return payloads
-        if event_type == "response.text.delta":
-            response_id = event.get("response_id")
-            text = event.get("delta", "")
-            state = self._response_state(response_id)
-            if state is not None and isinstance(text, str) and text:
-                state.text_parts.append(text)
-                self._refresh_in_progress_response_item(response_id)
-            payloads = self._ensure_response_text_part_added(response_id)
-            payloads.append(
-                {
-                    "type": "response.output_text.delta",
-                    "response_id": response_id,
-                    "item_id": self._response_item_id(response_id),
-                    "output_index": 0,
-                    "content_index": 1 if state is not None and state.audio_part_added else 0,
-                    "delta": text,
-                }
-            )
-            return payloads
-        if event_type == "response.done":
-            response_id = event.get("response_id")
-            status = event.get("status") if isinstance(event.get("status"), str) else "completed"
-            status_details = event.get("status_details") if isinstance(event.get("status_details"), dict) else None
-            return [
-                *self._realtime_audio_done_events(event, response_id),
-                *self._realtime_response_terminal_events(
-                    event,
-                    response_id,
-                    status=status,
-                    status_details=status_details,
-                ),
-            ]
-        if event_type == "input.committed":
-            event_item_id = event.get("item_id")
-            # Acknowledgements carry their own identity; untracked silence
-            # commits must not consume another turn's item ID.
-            item_id = event_item_id if isinstance(event_item_id, str) and event_item_id else f"item_{uuid4().hex}"
-            # The reader may already have accepted audio for the next turn.
-            if self._active_input_item_id == item_id:
-                self._reset_realtime_input_buffer_state()
-            item = self._conversation_items.get(item_id)
-            payloads = [self._input_audio_buffer_committed_event(item_id=item_id)]
-            if item is None:
-                message = event.get("message")
-                no_response = event.get("no_response") is True
-                is_speech = event.get("is_speech")
-                item = {
-                    "id": item_id,
-                    "object": "realtime.item",
-                    "type": "message",
-                    "role": "user",
-                    "status": "completed",
-                    "content": (
-                        [{"type": "input_audio", "transcript": "", "is_speech": False}]
-                        if no_response and is_speech is False
-                        else self._user_item_content_from_duplex_message(message)
-                    ),
-                }
-                self._conversation_items[item_id] = item
-                payloads.extend(self._conversation_item_added_events(item))
-            item["status"] = "completed"
-            transcription_event = self._input_audio_transcription_completed_event(item_id, item)
-            if transcription_event is not None:
-                payloads.append(transcription_event)
-            payloads.append(self._conversation_item_done_event(item))
-            return payloads
-        if event_type == "input.cancelled":
-            self._reset_realtime_input_buffer_state()
-            return [{"type": "input_audio_buffer.cleared"}]
-        if event_type == "input_audio_buffer.cleared":
-            self._reset_realtime_input_buffer_state()
-            return [{"type": "input_audio_buffer.cleared"}]
-        if event_type == "audio.cancelled":
-            response_id = event.get("response_id")
-            payloads: list[dict[str, object]] = []
-            if event.get("reason") == "output_audio_buffer_clear":
-                if not isinstance(response_id, str) or not response_id:
-                    response_id = self._active_response_id or self._last_response_id
-                payloads.append(
-                    {
-                        "type": "output_audio_buffer.cleared",
-                        "response_id": response_id,
-                    }
-                )
-                if not isinstance(response_id, str) or not response_id:
-                    return payloads
-            elif not isinstance(response_id, str) or not response_id:
-                response_id = self._active_response_id
-            if not isinstance(response_id, str) or not response_id:
-                return payloads
-            if self._response_is_done(response_id):
-                return payloads
-            committed_ms = event.get("committed_ms")
-            if isinstance(committed_ms, int | float):
-                item_id = self._response_item_id(response_id)
-                committed_audio_ms = max(0, int(committed_ms))
-                self._item_truncation_cursors[item_id] = (0, committed_audio_ms)
-                item = self._conversation_items.get(item_id)
-                if item is not None:
-                    self._truncate_realtime_item_content(
-                        item,
-                        content_index=0,
-                        audio_end_ms=committed_audio_ms,
-                    )
-                # Align server history with acknowledged playback; only explicit
-                # client truncation emits ``conversation.item.truncated``.
-            payloads.extend(self._realtime_audio_done_events(event, response_id))
-            payloads.extend(
-                self._realtime_response_terminal_events(
-                    event,
-                    response_id,
-                    status="cancelled",
-                    status_details={
-                        "type": "cancelled",
-                        "reason": event.get("reason") or "client_cancelled",
-                    },
-                )
-            )
-            if isinstance(response_id, str) and response_id == self._active_response_id:
-                self._active_response_id = None
-            return payloads
-        if event_type == "playback.acknowledged":
-            return [{"type": "playback.acknowledged", "event": event}]
-        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 self._conversation_items
-                self._conversation_items[item_id] = item
-                if already_known:
-                    if item.get("status") == "completed":
-                        return [self._conversation_item_done_event(item)]
-                    return []
-                payloads = self._conversation_item_added_events(item)
-                if item.get("status") == "completed":
-                    payloads.append(self._conversation_item_done_event(item))
-                return payloads
-            return [{"type": "conversation.item.created", "item": item, "event": event}]
-        if event_type == "conversation.item.deleted":
-            item_id = event.get("item_id")
-            if isinstance(item_id, str):
-                self._remove_conversation_item(item_id)
-            return [
-                {
-                    "type": "conversation.item.deleted",
-                    "item_id": item_id,
-                    "event": event,
-                }
-            ]
-        if event_type == "conversation.item.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 = self._conversation_items.get(item_id)
-                if item is not None:
-                    self._truncate_realtime_item_content(
-                        item,
-                        content_index=int(content_index) if isinstance(content_index, int | float) else 0,
-                        audio_end_ms=int(audio_end_ms) if isinstance(audio_end_ms, int | float) else 0,
-                    )
-            return [
-                {
-                    "type": "conversation.item.truncated",
-                    "item_id": item_id,
-                    "content_index": content_index,
-                    "audio_end_ms": audio_end_ms,
-                    "event": event,
-                }
-            ]
-        if event_type == "response.output_item.done":
-            response_id = event.get("response_id")
-            return self._realtime_response_terminal_events(
-                event,
-                response_id,
-                status="completed",
-                status_details={
-                    "type": "completed",
-                    "reason": event.get("finish_reason") or "stop",
-                },
-            )
-        if event_type == "function_call.done":
-            call_id = event.get("call_id")
-            name = event.get("name")
-            arguments = event.get("arguments", "")
-            if not isinstance(call_id, str) or not call_id or not isinstance(name, str) or not name:
-                return [{"type": "duplex.function_call.done", "event": event}]
-            if not isinstance(arguments, str):
-                arguments = str(arguments)
-            response_id = f"resp_{uuid4().hex}"
-            item = {
-                "id": f"item_{uuid4().hex}",
-                "object": "realtime.item",
-                "type": "function_call",
-                "status": "completed",
-                "name": name,
-                "call_id": call_id,
-                "arguments": arguments,
-            }
-            self._conversation_items[str(item["id"])] = item
-            response = {
-                "id": response_id,
-                "object": "realtime.response",
-                "status": "completed",
-                "status_details": {"type": "completed", "reason": "completed"},
-                "output": [dict(item)],
-                "metadata": {},
-            }
-            return [
-                {"type": "response.created", "response": {**response, "status": "in_progress", "output": []}},
-                *self._conversation_item_added_events(item),
-                {
-                    "type": "response.output_item.added",
-                    "response_id": response_id,
-                    "output_index": 0,
-                    "item": dict(item),
-                },
-                {
-                    "type": "response.function_call_arguments.delta",
-                    "response_id": response_id,
-                    "item_id": item["id"],
-                    "output_index": 0,
-                    "call_id": call_id,
-                    "delta": arguments,
-                },
-                {
-                    "type": "response.function_call_arguments.done",
-                    "response_id": response_id,
-                    "item_id": item["id"],
-                    "output_index": 0,
-                    "call_id": call_id,
-                    "arguments": arguments,
-                },
-                {
-                    "type": "response.output_item.done",
-                    "response_id": response_id,
-                    "output_index": 0,
-                    "item": dict(item),
-                },
-                self._conversation_item_done_event(item),
-                {"type": "response.done", "response": response},
-            ]
-        if event_type == "error":
-            raw_error = event.get("error")
-            if isinstance(raw_error, dict):
-                return [event]
-            message = str(raw_error or event.get("message") or "Duplex runtime error")
-            code = str(event.get("code") or "duplex_error")
-            return [
-                self._realtime_error_payload(
-                    code,
-                    message,
-                    event_id=event.get("realtime_event_id") or event.get("event_id"),
-                    param=event.get("param"),
-                )
-            ]
-        if event_type == "session.closed":
-            return [{"type": "session.closed", "event": event}]
-        return [{"type": f"duplex.{event_type}", "event": event}]
-
-    @staticmethod
-    def _user_item_content_from_duplex_message(message: object) -> list[dict[str, object]]:
-        if not isinstance(message, dict):
-            return [{"type": "input_audio", "transcript": ""}]
-        message_transcript = message.get("transcript")
-        content = message.get("content")
-        if isinstance(content, str):
-            return [{"type": "input_text", "text": content}]
-        if not isinstance(content, list):
-            return [
-                {
-                    "type": "input_audio",
-                    "transcript": message_transcript if isinstance(message_transcript, str) else "",
-                }
-            ]
-        parts: list[dict[str, object]] = []
-        for part in content:
-            if not isinstance(part, dict):
-                continue
-            part_type = part.get("type")
-            if part_type in {"text", "input_text"} and isinstance(part.get("text"), str):
-                parts.append({"type": "input_text", "text": part["text"]})
-                continue
-            if part_type == "audio_url":
-                transcript = (
-                    part.get("transcript")
-                    if isinstance(part.get("transcript"), str)
-                    else message_transcript
-                    if isinstance(message_transcript, str)
-                    else ""
-                )
-                parts.append({"type": "input_audio", "transcript": transcript})
-                continue
-            if part_type in {"audio", "input_audio"}:
-                transcript = part.get("transcript") if isinstance(part.get("transcript"), str) else ""
-                parts.append({"type": "input_audio", "transcript": transcript})
-        return parts or [{"type": "input_audio", "transcript": ""}]
-
-    def _realtime_session_payload(self, session: object) -> object:
-        if not isinstance(session, dict):
-            return session
-        payload = dict(session)
-        payload.setdefault("object", "realtime.session")
-        payload.setdefault("type", "realtime")
-        payload.setdefault("id", payload.get("id") or self._default_session_id)
-        payload.setdefault("model", payload.get("model") or self._default_model)
-        payload.setdefault("input_audio_format", self._input_audio_format)
-        payload.setdefault("output_audio_format", self._output_audio_format)
-        payload.setdefault("modalities", payload.get("modalities") or ["text", "audio"])
-        payload.setdefault("output_modalities", payload.get("output_modalities") or payload.get("modalities"))
-        payload.setdefault("object", "realtime.session")
-        payload.setdefault(
-            "audio",
-            {
-                "input": {
-                    "format": self._realtime_audio_format_object(
-                        self._input_audio_format,
-                        sample_rate_hz=self._input_sample_rate_hz,
-                    ),
-                    "sample_rate_hz": self._input_sample_rate_hz,
-                },
-                "output": {
-                    "format": self._realtime_audio_format_object(
-                        self._output_audio_format,
-                        sample_rate_hz=self._output_sample_rate_hz,
-                    ),
-                },
-            },
-        )
-        if self._turn_detection_configured or "turn_detection" in payload:
-            turn_detection = payload.get("turn_detection", self._turn_detection)
-            audio = dict(payload["audio"]) if isinstance(payload.get("audio"), dict) else {}
-            audio_input = dict(audio["input"]) if isinstance(audio.get("input"), dict) else {}
-            audio_input["turn_detection"] = turn_detection
-            audio["input"] = audio_input
-            payload["audio"] = audio
-            payload["turn_detection"] = turn_detection
-        payload.setdefault("input_audio_transcription", payload.get("input_audio_transcription"))
-        payload.setdefault("tracing", payload.get("tracing"))
-        return payload
-
-    @staticmethod
-    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 _response_state(
-        self,
-        response_id: object,
-        *,
-        event: dict[str, Any] | None = None,
-        create: bool = True,
-    ) -> _RealtimeResponseState | None:
-        if isinstance(response_id, str) and response_id:
-            key: str | int = response_id
-            item_id = f"item_{response_id}"
-        elif event is not None:
-            key = id(event)
-            item_id = f"item_{uuid4().hex}"
-        else:
-            return None
-        state = self._response_states.get(key)
-        if state is None and create:
-            state = _RealtimeResponseState(item_id=item_id)
-            self._response_states[key] = state
-        return state
-
-    def _response_is_done(self, response_id: object) -> bool:
-        state = self._response_state(response_id, create=False)
-        return state is not None and state.done_emitted
-
-    def _response_item_id(self, response_id: object) -> str:
-        state = self._response_state(response_id)
-        if state is not None:
-            return state.item_id
-        return f"item_{uuid4().hex}"
-
-    def _response_done_output_item(
-        self,
-        response_id: object,
-        *,
-        status: str,
-    ) -> dict[str, object]:
-        item_id = self._response_item_id(response_id)
-        state = self._response_state(response_id)
-        transcript = state.transcript if state is not None else ""
-        text = state.text if state is not None else ""
-        audio_duration_ms = state.audio_duration_ms if state is not None else None
-        audio_text_marks = state.audio_text_marks if state is not None else None
-        content: list[dict[str, object]] = []
-        if (state is not None and state.audio_part_added) or transcript or audio_duration_ms is not None:
-            content.append(
-                self._response_item_content_part(
-                    transcript=transcript,
-                    audio_duration_ms=audio_duration_ms,
-                    audio_text_marks=audio_text_marks,
-                )
-            )
-        if text:
-            content.append(self._response_item_text_content_part(text=text))
-        item = {
-            "id": item_id,
-            "object": "realtime.item",
-            "type": "message",
-            "role": "assistant",
-            "status": status,
-            "content": content,
-        }
-        self._apply_pending_item_truncation(item)
-        return item
-
-    def _apply_pending_item_truncation(self, item: dict[str, object]) -> None:
-        item_id = item.get("id")
-        if not isinstance(item_id, str) or not item_id:
-            return
-        cursor = self._item_truncation_cursors.get(item_id)
-        if cursor is None:
-            return
-        content_index, audio_end_ms = cursor
-        self._truncate_realtime_item_content(
-            item,
-            content_index=content_index,
-            audio_end_ms=audio_end_ms,
-        )
-
-    def _refresh_in_progress_response_item(self, response_id: object) -> None:
-        if not isinstance(response_id, str) or not response_id:
-            return
-        item_id = self._response_item_id(response_id)
-        item = self._conversation_items.get(item_id)
-        if not isinstance(item, dict):
-            return
-        content = item.get("content")
-        if not isinstance(content, list):
-            content = []
-            item["content"] = content
-
-        state = self._response_state(response_id)
-        if state is None:
-            return
-        transcript = state.transcript
-        audio_duration_ms = state.audio_duration_ms
-        audio_text_marks = state.audio_text_marks
-        has_audio = state.audio_part_added or bool(transcript) or audio_duration_ms is not None
-        if has_audio:
-            audio_part = self._response_item_content_part(
-                transcript=transcript,
-                audio_duration_ms=audio_duration_ms,
-                audio_text_marks=audio_text_marks,
-            )
-            if content and isinstance(content[0], dict) and content[0].get("type") in {"audio", "output_audio"}:
-                content[0] = audio_part
-            else:
-                content.insert(0, audio_part)
-
-        text = state.text
-        if text:
-            text_index = (
-                1
-                if content
-                and isinstance(content[0], dict)
-                and content[0].get("type")
-                in {
-                    "audio",
-                    "output_audio",
-                }
-                else 0
-            )
-            text_part = self._response_item_text_content_part(text=text)
-            if (
-                len(content) > text_index
-                and isinstance(content[text_index], dict)
-                and content[text_index].get("type") in {"text", "output_text"}
-            ):
-                content[text_index] = text_part
-            else:
-                content.insert(text_index, text_part)
-
-        self._apply_pending_item_truncation(item)
-
-    def _append_response_transcript(self, response_id: object, text: str) -> None:
-        state = self._response_state(response_id)
-        if state is None or not text:
-            return
-        state.transcript_parts.append(text)
-
-    def _ensure_response_text_part_added(self, response_id: object) -> list[dict[str, object]]:
-        state = self._response_state(response_id)
-        if state is None:
-            return []
-        if state.text_part_added:
-            return []
-        state.text_part_added = True
-        content_index = 1 if state.audio_part_added else 0
-        return [
-            {
-                "type": "response.content_part.added",
-                "response_id": response_id,
-                "item_id": self._response_item_id(response_id),
-                "output_index": 0,
-                "content_index": content_index,
-                "part": self._response_text_content_part(),
-            }
-        ]
-
-    def _ensure_response_audio_part_added(self, response_id: object) -> list[dict[str, object]]:
-        state = self._response_state(response_id)
-        if state is None:
-            return []
-        if state.audio_part_added:
-            return []
-        state.audio_part_added = True
-        return [
-            {
-                "type": "response.content_part.added",
-                "response_id": response_id,
-                "item_id": self._response_item_id(response_id),
-                "output_index": 0,
-                "content_index": 0,
-                "part": self._response_content_part(),
-            }
-        ]
-
-    def _remember_response_audio_metadata(self, response_id: object, event: dict[str, Any]) -> None:
-        state = self._response_state(response_id)
-        if state is None:
-            return
-        duration = event.get("audio_duration_ms")
-        playback = event.get("playback")
-        if not isinstance(duration, int | float) and isinstance(playback, dict):
-            duration = playback.get("sent_ms") or playback.get("generated_ms")
-        if isinstance(duration, int | float):
-            state.audio_duration_ms = max(state.audio_duration_ms or 0, int(duration))
-        marks = event.get("audio_text_marks")
-        if not isinstance(marks, list):
-            return
-        clean_marks: list[dict[str, int]] = []
-        for mark in marks:
-            if not isinstance(mark, dict):
-                continue
-            text_chars = mark.get("text_chars")
-            audio_end_ms = mark.get("audio_end_ms", mark.get("audio_ms"))
-            if not isinstance(text_chars, int | float) or not isinstance(audio_end_ms, int | float):
-                continue
-            clean_marks.append(
-                {
-                    "text_chars": max(0, int(text_chars)),
-                    "audio_end_ms": max(0, int(audio_end_ms)),
-                }
-            )
-        if clean_marks:
-            merged = list(state.audio_text_marks)
-            merged.extend(clean_marks)
-            deduped: dict[tuple[int, int], dict[str, int]] = {}
-            for mark in merged:
-                deduped[(int(mark["audio_end_ms"]), int(mark["text_chars"]))] = mark
-            state.audio_text_marks = sorted(
-                deduped.values(),
-                key=lambda mark: (mark["audio_end_ms"], mark["text_chars"]),
-            )
-
-    def _response_created_event(self, event: dict[str, Any]) -> dict[str, object]:
-        response_id = event.get("response_id")
-        metadata = event.get("metadata")
-        if not isinstance(metadata, dict):
-            metadata = {}
-        metadata = {**metadata, "duplex_event": event}
-        return {
-            "type": "response.created",
-            "response_id": response_id,
-            "response": {
-                "id": response_id,
-                "object": "realtime.response",
-                "status": "in_progress",
-                "status_details": None,
-                "output": [],
-                "modalities": event.get("modalities") or ["audio", "text"],
-                "metadata": metadata,
-            },
-        }
-
-    def _realtime_audio_delta_events(
-        self,
-        event: dict[str, Any],
-        response_id: object,
-        audio: str,
-    ) -> list[dict[str, object]]:
-        item_id = self._response_item_id(response_id)
-        fmt, format_rate = self._parse_realtime_audio_format(event.get("format", "wav"))
-        source_fmt = self._realtime_output_format(fmt)
-        source_sample_rate_hz = event.get("sample_rate_hz") or format_rate
-        target_sample_rate_hz = (
-            self._output_sample_rate_hz if self._output_audio_format in {"g711_ulaw", "g711_alaw"} else None
-        )
-        audio, fmt, converted_sample_rate_hz = convert_output_audio(
-            audio,
-            source_fmt=source_fmt,
-            target_fmt=self._output_audio_format,
-            source_sample_rate_hz=(
-                int(source_sample_rate_hz) if isinstance(source_sample_rate_hz, int | float) else None
-            ),
-            target_sample_rate_hz=target_sample_rate_hz,
-        )
-        sample_rate_hz = (
-            converted_sample_rate_hz
-            if fmt in {"g711_ulaw", "g711_alaw"}
-            else event.get("sample_rate_hz") or format_rate or self._output_sample_rate_hz
-        )
-        metadata: dict[str, object] = {}
-        for key in ("session_id", "epoch", "model_speak", "end_of_turn", "playback", "vllm_omni"):
-            if key in event:
-                metadata[key] = event[key]
-        duration_ms = event.get("audio_duration_ms")
-        if isinstance(duration_ms, int | float):
-            metadata["audio_duration_ms"] = int(duration_ms)
-        marks = event.get("audio_text_marks")
-        if isinstance(marks, list):
-            metadata["audio_text_marks"] = marks
-        state = self._response_state(response_id)
-        if state is not None:
-            state.audio_delta_emitted = True
-            self._remember_response_audio_metadata(response_id, event)
-        payloads: list[dict[str, object]] = []
-        if state is not None and not state.speak_emitted and metadata.get("model_speak") is True:
-            state.speak_emitted = True
-            payloads.insert(
-                0,
-                {
-                    "type": "response.speak",
-                    "response_id": response_id,
-                    "item_id": item_id,
-                    "output_index": 0,
-                    "content_index": 0,
-                    "metadata": self._response_speak_metadata(event),
-                },
-            )
-        payloads.append(
-            {
-                "type": "response.audio.delta",
-                "response_id": response_id,
-                "item_id": item_id,
-                "output_index": 0,
-                "content_index": 0,
-                "delta": audio,
-                "format": fmt,
-                **({"sample_rate_hz": int(sample_rate_hz)} if isinstance(sample_rate_hz, int | float) else {}),
-                **({"metadata": metadata} if metadata else {}),
-            }
-        )
-        return payloads
-
-    @staticmethod
-    def _response_speak_metadata(event: dict[str, Any]) -> dict[str, object]:
-        return {key: event[key] for key in ("session_id", "epoch", "model_speak") if key in event}
-
-    def _realtime_audio_done_events(
-        self,
-        event: dict[str, Any],
-        response_id: object,
-    ) -> list[dict[str, object]]:
-        item_id = self._response_item_id(response_id)
-        state = self._response_state(response_id, event=event)
-        transcript = state.transcript if state is not None else ""
-        payloads: list[dict[str, object]] = []
-        if isinstance(response_id, str) and state is not None and not state.audio_delta_emitted and not transcript:
-            return payloads
-        if state is None or not state.audio_done_emitted:
-            if state is not None:
-                state.audio_done_emitted = True
-            payloads.append(
-                {
-                    "type": "response.audio.done",
-                    "response_id": response_id,
-                    "item_id": item_id,
-                    "output_index": 0,
-                    "content_index": 0,
-                }
-            )
-            if transcript:
-                payloads.append(
-                    {
-                        "type": "response.audio_transcript.done",
-                        "response_id": response_id,
-                        "item_id": item_id,
-                        "output_index": 0,
-                        "content_index": 0,
-                        "transcript": transcript,
-                    }
-                )
-        return payloads
-
-    def _realtime_response_terminal_events(
-        self,
-        event: dict[str, Any],
-        response_id: object,
-        *,
-        status: str = "completed",
-        status_details: dict[str, object] | None = None,
-    ) -> list[dict[str, object]]:
-        item_id = self._response_item_id(response_id)
-        state = self._response_state(response_id, event=event)
-        transcript = state.transcript if state is not None else ""
-        payloads: list[dict[str, object]] = []
-        if state is not None and state.audio_part_added and not state.audio_part_done:
-            state.audio_part_done = True
-            payloads.append(
-                {
-                    "type": "response.content_part.done",
-                    "response_id": response_id,
-                    "item_id": item_id,
-                    "output_index": 0,
-                    "content_index": 0,
-                    "part": self._response_content_part(transcript=transcript),
-                }
-            )
-        if state is not None and state.text_parts and not state.output_text_done:
-            state.output_text_done = True
-            content_index = 1 if state.audio_part_added else 0
-            payloads.append(
-                {
-                    "type": "response.output_text.done",
-                    "response_id": response_id,
-                    "item_id": item_id,
-                    "output_index": 0,
-                    "content_index": content_index,
-                    "text": state.text,
-                }
-            )
-        if state is not None and state.text_parts and not state.text_part_done:
-            state.text_part_done = True
-            content_index = 1 if state.audio_part_added else 0
-            payloads.append(
-                {
-                    "type": "response.content_part.done",
-                    "response_id": response_id,
-                    "item_id": item_id,
-                    "output_index": 0,
-                    "content_index": content_index,
-                    "part": self._response_text_content_part(text=state.text),
-                }
-            )
-        if state is None or not state.output_item_done:
-            if state is not None:
-                state.output_item_done = True
-            item = self._response_done_output_item(response_id, status=status)
-            payloads.append(
-                {
-                    "type": "response.output_item.done",
-                    "response_id": response_id,
-                    "output_index": 0,
-                    "item": item,
-                }
-            )
-            if state is None or not state.conversation_item_done:
-                if state is not None:
-                    state.conversation_item_done = True
-                payloads.append(self._conversation_item_done_event(item))
-        done_event = self._realtime_response_done_event(
-            {**event, "response_id": response_id},
-            state=state,
-            status=status,
-            status_details=status_details,
-        )
-        if done_event is not None:
-            payloads.append(done_event)
-            payloads.append(self._rate_limits_updated_event())
-            if isinstance(response_id, str) and response_id == self._active_response_id:
-                self._active_response_id = None
-        return payloads
-
-    def _realtime_response_done_event(
-        self,
-        event: dict[str, Any],
-        *,
-        state: _RealtimeResponseState | None = None,
-        status: str = "completed",
-        status_details: dict[str, object] | None = None,
-    ) -> dict[str, object] | None:
-        response_id = event.get("response_id")
-        if state is None:
-            state = self._response_state(response_id, event=event)
-        if state is not None:
-            if state.done_emitted:
-                return None
-            state.done_emitted = True
-        return {
-            "type": "response.done",
-            "response_id": response_id,
-            "response": {
-                "id": response_id,
-                "object": "realtime.response",
-                "status": status,
-                "status_details": status_details,
-                "output": [self._response_done_output_item(response_id, status=status)],
-                "metadata": event,
-            },
-        }
-
-    @staticmethod
-    def _rate_limits_updated_event() -> dict[str, object]:
-        # vLLM-Omni does not yet expose a Realtime-specific quota budget. Emit
-        # the terminal event with an empty list so clients that sequence on
-        # rate_limits.updated do not need a private vLLM branch.
-        return {"type": "rate_limits.updated", "rate_limits": []}
diff --git a/vllm_omni/entrypoints/duplex/realtime_session.py b/vllm_omni/entrypoints/duplex/realtime_session.py
deleted file mode 100644
index 122a7ab52..000000000
--- a/vllm_omni/entrypoints/duplex/realtime_session.py
+++ /dev/null
@@ -1,147 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-from __future__ import annotations
-
-import json
-from typing import Any
-from uuid import uuid4
-
-from fastapi import WebSocket
-
-from vllm_omni.entrypoints.duplex import realtime_state as _state
-from vllm_omni.entrypoints.duplex.realtime_input import (
-    RealtimeInputTranslator,
-)
-from vllm_omni.entrypoints.duplex.realtime_output import (
-    RealtimeOutputProjector,
-)
-
-REALTIME_ERROR_TYPES_BY_CODE = _state.REALTIME_ERROR_TYPES_BY_CODE
-REALTIME_INPUT_AUDIO_FORMATS = _state.REALTIME_INPUT_AUDIO_FORMATS
-REALTIME_OUTPUT_AUDIO_FORMATS = _state.REALTIME_OUTPUT_AUDIO_FORMATS
-RealtimeSessionState = _state.RealtimeSessionState
-_RealtimeResponseState = _state._RealtimeResponseState
-
-
-class NativeRealtimeSessionProtocol(
-    RealtimeInputTranslator,
-    RealtimeOutputProjector,
-    _state.RealtimeStateOwner,
-):
-    """Compatibility facade for one native Realtime protocol session.
-
-    Input translation, output projection, and mutable state have separate
-    owners. The facade retains the established import path and private helper
-    surface used by serving and protocol contract tests.
-    """
-
-    def __init__(self, query_params: Any) -> None:
-        self._state = RealtimeSessionState.from_query_params(query_params)
-
-    def bind_sender(self, send_realtime_json) -> None:
-        self._send_realtime_json = send_realtime_json
-
-    def bind_native_input_append(self, enabled: bool) -> None:
-        """Use the serving-selected input path, independent of interruption policy."""
-        self._native_input_append = enabled
-
-    def _default_session_payload(self) -> dict[str, object]:
-        payload: dict[str, object] = {
-            "model": self._default_model,
-            "session_id": self._default_session_id,
-        }
-        if self._default_extra_body:
-            payload["extra_body"] = dict(self._default_extra_body)
-        return payload
-
-    async def receive_internal_event_text(self, websocket: WebSocket) -> str:
-        if not self._pending_outbound.empty():
-            return json.dumps(await self._pending_outbound.get())
-        if not self._opened and not self._resume_only and not self._autostarted_default_session and self._default_model:
-            self._opened = True
-            self._autostarted_default_session = True
-            return json.dumps(self._session_create_from_realtime(self._default_session_payload()))
-        while True:
-            if not self._pending_outbound.empty():
-                return json.dumps(await self._pending_outbound.get())
-            await self.wait_for_realtime_turn_detection_update()
-            raw = await websocket.receive_text()
-            try:
-                event = json.loads(raw)
-            except json.JSONDecodeError:
-                return raw
-            if not isinstance(event, dict):
-                return raw
-            if not self._opened and event.get("type") == "session.resume":
-                self._opened = True
-                translated = await self._to_duplex_event(event)
-                if translated is None:
-                    if not self._pending_outbound.empty():
-                        return json.dumps(await self._pending_outbound.get())
-                    continue
-                return json.dumps(translated)
-            if not self._opened and self._resume_only:
-                translated = await self._to_duplex_event(event)
-                if translated is None:
-                    if not self._pending_outbound.empty():
-                        return json.dumps(await self._pending_outbound.get())
-                    continue
-                return json.dumps(translated)
-            if not self._opened and event.get("type") != "session.update":
-                self._opened = True
-                await self._pending_outbound.put(self._session_create_from_realtime(self._default_session_payload()))
-                translated = await self._to_duplex_event(event)
-                if translated is not None:
-                    await self._send_realtime_input_ack(event)
-                    await self._pending_outbound.put(translated)
-                return json.dumps(await self._pending_outbound.get())
-            translated = await self._to_duplex_event(event)
-            if translated is None:
-                if not self._pending_outbound.empty():
-                    return json.dumps(await self._pending_outbound.get())
-                continue
-            await self._send_realtime_input_ack(event)
-            return json.dumps(translated)
-
-    def encode_outbound_event(self, data: dict[str, Any]) -> list[dict[str, object]]:
-        payloads = self._from_duplex_event(data)
-        for payload in payloads:
-            self._attach_event_id(payload)
-        return payloads
-
-    @staticmethod
-    def _attach_event_id(payload: dict[str, object]) -> None:
-        payload.setdefault("event_id", f"event_{uuid4().hex}")
-
-    async def _send_realtime_payload(self, payload: dict[str, object]) -> None:
-        self._attach_event_id(payload)
-        if (
-            self._hold_realtime_output_until_session_created
-            and payload.get("type") != "error"
-            and payload.get("type") != "session.created"
-        ):
-            self._held_realtime_payloads.append(payload)
-            return
-        if self._send_realtime_json is None:
-            raise RuntimeError("Native Realtime sender is not bound")
-        await self._send_realtime_json(payload)
-
-    @staticmethod
-    def _realtime_error_payload(
-        code: str,
-        message: str,
-        *,
-        event_id: object | None = None,
-        param: object | None = None,
-    ) -> dict[str, object]:
-        error: dict[str, object] = {
-            "type": REALTIME_ERROR_TYPES_BY_CODE.get(code, "invalid_request_error"),
-            "code": code,
-            "message": message,
-        }
-        if isinstance(event_id, str) and event_id:
-            error["event_id"] = event_id
-        if isinstance(param, str) and param:
-            error["param"] = param
-        return {"type": "error", "error": error}
diff --git a/vllm_omni/entrypoints/duplex/realtime_state.py b/vllm_omni/entrypoints/duplex/realtime_state.py
deleted file mode 100644
index babb470a5..000000000
--- a/vllm_omni/entrypoints/duplex/realtime_state.py
+++ /dev/null
@@ -1,245 +0,0 @@
-# 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 typing import Any, Generic, TypeVar
-
-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",
-}
-REALTIME_PCM_DEFAULT_SAMPLE_RATE_HZ = 24_000
-REALTIME_PCM_F32_DEFAULT_SAMPLE_RATE_HZ = 16_000
-REALTIME_G711_DEFAULT_SAMPLE_RATE_HZ = 8_000
-
-_RealtimeProtocolConfig = tuple[str, int, str, int | None, float]
-_PendingTurnDetectionUpdate = tuple[
-    bool,
-    dict[str, object] | None,
-    asyncio.Event,
-    _RealtimeProtocolConfig,
-]
-
-
-def realtime_default_sample_rate_hz(fmt: object) -> int | None:
-    if not isinstance(fmt, str):
-        return None
-    normalized = fmt.lower()
-    if normalized in {"pcm16", "pcm_s16le", "s16le", "pcm", "audio/pcm"}:
-        return REALTIME_PCM_DEFAULT_SAMPLE_RATE_HZ
-    if normalized in {"pcm_f32le", "audio/pcm_f32le"}:
-        return REALTIME_PCM_F32_DEFAULT_SAMPLE_RATE_HZ
-    if normalized in {"g711_ulaw", "g711_alaw", "audio/g711_ulaw", "audio/g711_alaw"}:
-        return REALTIME_G711_DEFAULT_SAMPLE_RATE_HZ
-    return None
-
-
-REALTIME_ERROR_TYPES_BY_CODE = {
-    "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_open_failed": "server_error",
-    "runtime_open_unsupported": "server_error",
-    "runtime_append_failed": "server_error",
-    "runtime_append_task_failed": "server_error",
-    "runtime_signal_failed": "server_error",
-    "runtime_close_failed": "server_error",
-    "runtime_abort_failed": "server_error",
-    "runtime_data_plane_stream_failed": "server_error",
-    "runtime_data_plane_text_without_audio": "server_error",
-    "response_error": "server_error",
-    "chat_error": "server_error",
-    "server_vad_initialization_failed": "server_error",
-    "server_vad_inference_failed": "server_error",
-    "duplex_session_busy": "rate_limit_error",
-    "resource_exhausted": "rate_limit_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",
-    "input_audio_buffer_empty": "invalid_request_error",
-    "server_vad_manual_commit_unsupported": "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_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",
-    "runtime_native_stage_role_required": "server_error",
-    "runtime_native_runner_kv_required": "server_error",
-}
-
-
-@dataclass(slots=True)
-class _RealtimeResponseState:
-    item_id: str
-    transcript_parts: list[str] = field(default_factory=list)
-    text_parts: list[str] = field(default_factory=list)
-    audio_duration_ms: int | None = None
-    audio_text_marks: list[dict[str, int]] = field(default_factory=list)
-    audio_delta_emitted: bool = False
-    audio_done_emitted: bool = False
-    audio_part_added: bool = False
-    audio_part_done: bool = False
-    text_part_added: bool = False
-    text_part_done: bool = False
-    output_text_done: bool = False
-    output_item_done: bool = False
-    conversation_item_done: bool = False
-    speak_emitted: bool = False
-    done_emitted: bool = False
-
-    @property
-    def transcript(self) -> str:
-        return "".join(self.transcript_parts)
-
-    @property
-    def text(self) -> str:
-        return "".join(self.text_parts)
-
-
-@dataclass(slots=True)
-class RealtimeSessionState:
-    """Single mutable authority for one Realtime protocol session."""
-
-    _opened: bool = False
-    _autostarted_default_session: bool = False
-    _resume_only: bool = False
-    _pending_outbound: asyncio.Queue[dict[str, object]] = field(default_factory=asyncio.Queue)
-    _held_realtime_payloads: list[dict[str, object]] = field(default_factory=list)
-    _hold_realtime_output_until_session_created: bool = True
-    _default_model: object | None = None
-    _default_session_id: object | None = None
-    _default_extra_body: dict[str, object] = field(default_factory=dict)
-    _input_audio_format: str = "pcm16"
-    _input_sample_rate_hz: int = REALTIME_PCM_DEFAULT_SAMPLE_RATE_HZ
-    _output_audio_format: str = "pcm16"
-    _overlap_silence_rms: float = 0.003
-    _turn_detection: dict[str, object] | None = None
-    _native_input_append: bool = False
-    _pending_turn_detection_update: _PendingTurnDetectionUpdate | None = None
-    _send_realtime_json: Any = None
-    _initial_session_update: bool = False
-    _input_speech_started: bool = False
-    _response_states: dict[str | int, _RealtimeResponseState] = field(default_factory=dict)
-    _item_truncation_cursors: dict[str, tuple[int, int]] = field(default_factory=dict)
-    _active_response_id: str | None = None
-    _last_response_id: str | None = None
-    _conversation_items: dict[str, dict[str, object]] = field(default_factory=dict)
-    _last_conversation_item_id: str | None = None
-    _output_sample_rate_hz: int | None = None
-    _active_input_item_id: str | None = None
-    _input_audio_buffer_has_audio: bool = False
-    _input_audio_buffer_had_non_speech: bool = False
-    _input_audio_buffer_transcript_parts: list[str] = field(default_factory=list)
-    _turn_detection_configured: bool = False
-
-    @classmethod
-    def from_query_params(cls, query_params: Any) -> RealtimeSessionState:
-        if hasattr(query_params, "query_params"):
-            query_params = query_params.query_params
-        getter = query_params.get if hasattr(query_params, "get") else None
-        # Canonical query param plus the deprecated model-prefixed alias;
-        # both seed the canonical extra_body key.
-        native_duplex = None
-        if getter is not None:
-            native_duplex = getter("native_duplex")
-            if native_duplex is None:
-                native_duplex = getter("minicpmo45_native_duplex")
-        resume_only = getter("resume") if getter is not None else None
-        autostart = getter("autostart") if getter is not None else None
-        default_extra_body = {}
-        if str(native_duplex).strip().lower() in {"1", "true", "yes", "on"}:
-            default_extra_body["native_duplex"] = True
-        return cls(
-            _resume_only=(
-                str(resume_only).strip().lower() in {"1", "true", "yes", "on"}
-                or str(autostart).strip().lower() in {"0", "false", "no", "off"}
-            ),
-            _default_model=getter("model") if getter is not None else None,
-            _default_session_id=(getter("session_id") if getter is not None else None),
-            _default_extra_body=default_extra_body,
-        )
-
-
-_StateValue = TypeVar("_StateValue")
-
-
-class _RealtimeStateField(Generic[_StateValue]):
-    """Explicit descriptor binding one protocol attribute to session state."""
-
-    def __set_name__(self, owner: type, name: str) -> None:
-        del owner
-        self._name = name
-
-    def __get__(self, instance: Any, owner: type | None = None) -> _StateValue | _RealtimeStateField[_StateValue]:
-        del owner
-        if instance is None:
-            return self
-        return getattr(instance._state, self._name)
-
-    def __set__(self, instance: Any, value: _StateValue) -> None:
-        setattr(instance._state, self._name, value)
-
-
-class RealtimeStateOwner:
-    """Declare the mutable state surface shared by input/output projectors."""
-
-    _state: RealtimeSessionState
-    _opened: bool = _RealtimeStateField()
-    _autostarted_default_session: bool = _RealtimeStateField()
-    _resume_only: bool = _RealtimeStateField()
-    _pending_outbound: asyncio.Queue[dict[str, object]] = _RealtimeStateField()
-    _held_realtime_payloads: list[dict[str, object]] = _RealtimeStateField()
-    _hold_realtime_output_until_session_created: bool = _RealtimeStateField()
-    _default_model: object | None = _RealtimeStateField()
-    _default_session_id: object | None = _RealtimeStateField()
-    _default_extra_body: dict[str, object] = _RealtimeStateField()
-    _input_audio_format: str = _RealtimeStateField()
-    _input_sample_rate_hz: int = _RealtimeStateField()
-    _output_audio_format: str = _RealtimeStateField()
-    _overlap_silence_rms: float = _RealtimeStateField()
-    _turn_detection: dict[str, object] | None = _RealtimeStateField()
-    _native_input_append: bool = _RealtimeStateField()
-    _pending_turn_detection_update: _PendingTurnDetectionUpdate | None = _RealtimeStateField()
-    _send_realtime_json: Any = _RealtimeStateField()
-    _initial_session_update: bool = _RealtimeStateField()
-    _input_speech_started: bool = _RealtimeStateField()
-    _response_states: dict[str | int, _RealtimeResponseState] = _RealtimeStateField()
-    _item_truncation_cursors: dict[str, tuple[int, int]] = _RealtimeStateField()
-    _active_response_id: str | None = _RealtimeStateField()
-    _last_response_id: str | None = _RealtimeStateField()
-    _conversation_items: dict[str, dict[str, object]] = _RealtimeStateField()
-    _last_conversation_item_id: str | None = _RealtimeStateField()
-    _output_sample_rate_hz: int | None = _RealtimeStateField()
-    _active_input_item_id: str | None = _RealtimeStateField()
-    _input_audio_buffer_has_audio: bool = _RealtimeStateField()
-    _input_audio_buffer_had_non_speech: bool = _RealtimeStateField()
-    _input_audio_buffer_transcript_parts: list[str] = _RealtimeStateField()
-    _turn_detection_configured: bool = _RealtimeStateField()
diff --git a/vllm_omni/entrypoints/duplex/runtime_adapter.py b/vllm_omni/entrypoints/duplex/runtime_adapter.py
deleted file mode 100644
index a873f33a8..000000000
--- a/vllm_omni/entrypoints/duplex/runtime_adapter.py
+++ /dev/null
@@ -1,331 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-from __future__ import annotations
-
-import asyncio
-from collections.abc import Awaitable, Callable, Iterable, Mapping, MutableMapping
-from dataclasses import dataclass, field
-from importlib import import_module
-from typing import Any, Protocol
-
-
-class ServingRuntimeConfigError(ValueError):
-    """A model serving plugin rejected client-visible runtime configuration."""
-
-    def __init__(self, message: str, *, code: str = "invalid_duplex_runtime_config") -> None:
-        super().__init__(message)
-        self.code = code
-
-
-def reject_changed_runtime_value(
-    new_value: object,
-    current_value: object,
-    *,
-    message: str,
-    code: str,
-    error_cls: type[ServingRuntimeConfigError] = ServingRuntimeConfigError,
-) -> None:
-    if new_value != current_value:
-        raise error_cls(message, code=code)
-
-
-class PcmAppendReservation(Protocol):
-    operation_id: str
-    payload: dict[str, object] | None
-
-    @property
-    def active(self) -> bool: ...
-
-    @property
-    def byte_count(self) -> int: ...
-
-    def commit(self) -> None: ...
-
-    def rollback(self) -> None: ...
-
-
-class PcmAppendBuffer(Protocol):
-    @property
-    def pending_byte_count(self) -> int: ...
-
-    def clear(self) -> None: ...
-
-    def clear_force_listen(self) -> None: ...
-
-    def has_pending(self) -> bool: ...
-
-    def has_reserved(self) -> bool: ...
-
-    def prepare_append(
-        self,
-        payload: dict[str, object],
-        *,
-        operation_id: str,
-        chunk_period_ms: int,
-        allow_emit: bool,
-    ) -> PcmAppendReservation | None: ...
-
-    def prepare_commit(
-        self,
-        *,
-        operation_id: str,
-        chunk_period_ms: int,
-    ) -> PcmAppendReservation: ...
-
-    def flush(self, *, chunk_period_ms: int) -> dict[str, object] | None: ...
-
-
-class ServingRuntimeSessionState(Protocol):
-    audio_buffer: PcmAppendBuffer
-    input_since_commit: bool
-    speech_since_commit: bool
-    native_context_locked: bool
-    committed_audio_payload: dict[str, object] | None
-    committed_audio_operation_id: str | None
-    committed_audio_reserved_bytes: int
-    deferred_response_create: bool
-    deferred_precreate_response: bool
-    data_plane_task: asyncio.Task[None] | None
-    data_plane_restart_requested: bool
-    continuation_owner_id: str | None
-    continuation_units: int
-    pending_silence_task: asyncio.Task[bool] | None
-    pending_silence_owner_id: str | None
-    silence_continuation_scheduler: Callable[..., Awaitable[bool]] | None
-
-    def retain_committed_audio(
-        self,
-        payload: dict[str, object],
-        *,
-        operation_id: str | None,
-        reserved_bytes: int = 0,
-    ) -> None: ...
-
-    def clear_committed_audio(self) -> int: ...
-
-    def clear_continuation(self) -> None: ...
-
-
-class _TurnBasedPcmAppendBuffer:
-    """Empty native-audio buffer for chat-fallback sessions.
-
-    Turn-based sessions keep input audio in ``DuplexSession`` and never use
-    the model-native append path.  The runner still shares lifecycle and
-    cancellation code with native sessions, so it needs an inert buffer for
-    those common operations.
-    """
-
-    @property
-    def pending_byte_count(self) -> int:
-        return 0
-
-    def clear(self) -> None:
-        return None
-
-    def clear_force_listen(self) -> None:
-        return None
-
-    def has_pending(self) -> bool:
-        return False
-
-    def has_reserved(self) -> bool:
-        return False
-
-    def prepare_append(
-        self,
-        payload: dict[str, object],
-        *,
-        operation_id: str,
-        chunk_period_ms: int,
-        allow_emit: bool,
-    ) -> PcmAppendReservation | None:
-        del payload, operation_id, chunk_period_ms, allow_emit
-        raise RuntimeError("Model-native audio append is not enabled for this session")
-
-    def prepare_commit(
-        self,
-        *,
-        operation_id: str,
-        chunk_period_ms: int,
-    ) -> PcmAppendReservation:
-        del operation_id, chunk_period_ms
-        raise RuntimeError("Model-native audio append is not enabled for this session")
-
-    def flush(self, *, chunk_period_ms: int) -> dict[str, object] | None:
-        del chunk_period_ms
-        return None
-
-
-@dataclass(slots=True)
-class TurnBasedServingSessionState:
-    """Runner-local state for sessions served through chat fallback."""
-
-    audio_buffer: PcmAppendBuffer = field(default_factory=_TurnBasedPcmAppendBuffer)
-    input_since_commit: bool = False
-    speech_since_commit: bool = False
-    native_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
-    data_plane_task: asyncio.Task[None] | None = None
-    data_plane_restart_requested: 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
-    silence_continuation_scheduler: Callable[..., Awaitable[bool]] | 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
-
-
-class RuntimeDataPlane(Protocol):
-    def begin_request(self, request_id: str) -> None: ...
-
-    def is_terminal(self, request_id: str | None) -> bool: ...
-
-    def mark_terminal(self, request_id: str) -> None: ...
-
-    def close_stream(self, request_id: str) -> None: ...
-
-    def close_session(self, session_id: str, *, active_request_id: str | None = None) -> None: ...
-
-    def project(self, result: object, *, context: object | None = None) -> Iterable[dict[str, object]]: ...
-
-
-class ServingRuntimeAdapter(Protocol):
-    adapter_id: str
-    session_states: MutableMapping[str, ServingRuntimeSessionState]
-    data_plane: RuntimeDataPlane
-    clean_response_done_prefix: str
-    interrupted_tts_prefix: str
-    private_runtime_config_keys: frozenset[str]
-    collect_outputs_on_append: bool
-
-    def create_session_state(self) -> ServingRuntimeSessionState: ...
-
-    def session_state(self, session_id: str) -> ServingRuntimeSessionState: ...
-
-    def remove_session_state(self, session_id: str) -> None: ...
-
-    def is_enabled(self, config: object) -> bool: ...
-
-    def capabilities(self, *, max_sessions: int) -> object: ...
-
-    def validate_client_extra_body(self, extra_body: object) -> None: ...
-
-    async def prepare_runtime_config(self, config: object, *, model_config: Any) -> dict[str, object]: ...
-
-    def runtime_config_for_update(
-        self,
-        config: object,
-        current: Mapping[str, object],
-    ) -> dict[str, object]: ...
-
-    def data_plane_context(
-        self,
-        *,
-        epoch: int,
-        turn_id: int,
-        active_response_turn_id: int | None,
-        active_response_id: str | None,
-        auto_responds: bool,
-        response_format: str,
-        speed: float | None,
-        modalities: tuple[str, ...],
-    ) -> object: ...
-
-
-def load_serving_runtime_adapter(
-    path: str,
-    encode_audio,
-) -> ServingRuntimeAdapter:
-    module_name, separator, attribute_name = path.rpartition(".")
-    if not separator:
-        raise ValueError(f"Invalid duplex serving runtime adapter path: {path!r}")
-    adapter_type = getattr(import_module(module_name), attribute_name)
-    return validate_serving_runtime_adapter(adapter_type(encode_audio))
-
-
-def validate_serving_runtime_adapter(adapter: object) -> ServingRuntimeAdapter:
-    required_methods = (
-        "create_session_state",
-        "session_state",
-        "remove_session_state",
-        "is_enabled",
-        "capabilities",
-        "validate_client_extra_body",
-        "prepare_runtime_config",
-        "runtime_config_for_update",
-        "data_plane_context",
-    )
-    missing = [name for name in required_methods if not callable(getattr(adapter, name, None))]
-    if missing:
-        raise TypeError(f"Duplex serving runtime adapter is missing callable method(s): {', '.join(missing)}")
-    if not isinstance(getattr(adapter, "adapter_id", None), str) or not adapter.adapter_id:
-        raise TypeError("Duplex serving runtime adapter must declare adapter_id")
-    if not isinstance(getattr(adapter, "session_states", None), MutableMapping):
-        raise TypeError("Duplex serving runtime adapter must declare mutable session_states")
-    for prefix_name in ("clean_response_done_prefix", "interrupted_tts_prefix"):
-        if not isinstance(getattr(adapter, prefix_name, None), str):
-            raise TypeError(f"Duplex serving runtime adapter must declare {prefix_name}")
-    private_keys = getattr(adapter, "private_runtime_config_keys", None)
-    if not isinstance(private_keys, frozenset) or any(not isinstance(key, str) for key in private_keys):
-        raise TypeError("Duplex serving runtime adapter must declare private_runtime_config_keys as frozenset[str]")
-    data_plane = getattr(adapter, "data_plane", None)
-    if data_plane is None:
-        raise TypeError("Duplex serving runtime adapter must declare data_plane")
-    data_plane_methods = (
-        "begin_request",
-        "is_terminal",
-        "mark_terminal",
-        "close_stream",
-        "close_session",
-        "project",
-    )
-    missing_data_plane_methods = [name for name in data_plane_methods if not callable(getattr(data_plane, name, None))]
-    if missing_data_plane_methods:
-        raise TypeError(
-            "Duplex serving runtime adapter data_plane is missing callable method(s): "
-            + ", ".join(missing_data_plane_methods)
-        )
-    return adapter  # type: ignore[return-value]
-
-
-def payload_turn_id(payload: object) -> int | None:
-    if not isinstance(payload, Mapping):
-        return None
-    return coerce_int(payload.get("duplex_turn_id", payload.get("model_turn_id")))
-
-
-def coerce_int(value: object) -> int | None:
-    try:
-        return int(value) if value is not None else None
-    except (TypeError, ValueError):
-        return None
diff --git a/vllm_omni/entrypoints/duplex/runtime_bridge.py b/vllm_omni/entrypoints/duplex/runtime_bridge.py
deleted file mode 100644
index bf839523c..000000000
--- a/vllm_omni/entrypoints/duplex/runtime_bridge.py
+++ /dev/null
@@ -1,1441 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-from __future__ import annotations
-
-import asyncio
-import base64
-import inspect
-from collections.abc import Mapping
-from dataclasses import asdict, is_dataclass
-from enum import Enum
-
-import numpy as np
-from vllm.logger import init_logger
-
-from vllm_omni.engine.duplex.control_client import DuplexControlRequestError
-from vllm_omni.engine.duplex.messages import DuplexFence
-from vllm_omni.engine.duplex.runtime import duplex_data_plane_request_info
-from vllm_omni.entrypoints.duplex.protocol import (
-    DuplexSession,
-    DuplexSessionState,
-)
-from vllm_omni.entrypoints.duplex.runtime_adapter import (
-    coerce_int,
-    payload_turn_id,
-)
-
-logger = init_logger(__name__)
-
-
-class NativeRuntimeBridgeMixin:
-    """Bridge serving sessions to native runtime control and data-plane APIs."""
-
-    _NATIVE_RUNTIME_FENCE_CONTRACT = {
-        "open_duplex_session_async": ("fence",),
-        "append_duplex_input_async": ("fence",),
-        "signal_duplex_turn_async": ("fence", "next_fence"),
-        "close_duplex_session_async": ("fence",),
-    }
-
-    async def _open_runtime_session(self, session: DuplexSession, send_json) -> dict[str, object] | bool:
-        # Turn-based sessions use the chat-fallback path and do not own a
-        # model-native duplex runtime.  Do not send control messages merely
-        # because the shared engine client exposes the duplex RPC methods.
-        if not self._uses_serving_runtime_adapter(session.config):
-            return True
-        contract_error = self._native_runtime_contract_error(session)
-        if contract_error is not None:
-            await send_json(
-                {
-                    "type": "error",
-                    "code": "runtime_contract_invalid",
-                    "error": contract_error,
-                }
-            )
-            return False
-        open_session = getattr(self._chat_service.engine_client, "open_duplex_session_async", None)
-        if not callable(open_session):
-            return True
-        try:
-            open_kwargs = {
-                "session_mode": "duplex",
-                "capabilities": session.capabilities.as_dict(),
-                "session_config": session.config.as_dict(),
-                "timeout": self._runtime_control_timeout_s(session),
-            }
-            if self._callable_accepts_keyword(open_session, "runtime_config"):
-                open_kwargs["runtime_config"] = dict(session.runtime_config)
-            if self._callable_accepts_keyword(open_session, "fence"):
-                open_kwargs["fence"] = DuplexFence(
-                    session.session_id,
-                    epoch=session.epoch,
-                    turn_id=session.turn_id,
-                    incarnation=session.incarnation,
-                )
-            result = await open_session(session.session_id, **open_kwargs)
-        except Exception as exc:
-            if isinstance(exc, DuplexControlRequestError) and exc.code == "resource_exhausted":
-                logger.info("Duplex runtime session admission rejected: %s", exc)
-            else:
-                logger.exception("Failed to open duplex runtime session: %s", exc)
-            await self._send_runtime_error(send_json, "runtime_open_failed", exc, session=session)
-            return False
-        if (
-            isinstance(result, dict)
-            and session.capabilities.implementation_level == "model_native_duplex"
-            and self._runtime_control_failed(result)
-        ):
-            await send_json(
-                {
-                    "type": "error",
-                    "error": "Native duplex runtime is not available for this session",
-                    "code": ("runtime_open_unsupported" if result.get("unsupported_count") else "runtime_open_failed"),
-                    "runtime_control": self._redact_runtime_control_result(result),
-                }
-            )
-            return False
-        return result if isinstance(result, dict) else True
-
-    async def _append_runtime_input(
-        self,
-        session: DuplexSession,
-        payload: object,
-        *,
-        operation_id: str | None = None,
-        final: bool,
-        send_json,
-        mode: str = "append_tokens",
-        expected_epoch: int | None = None,
-    ) -> tuple[bool, bool]:
-        if not session.capabilities.supports_input_append:
-            return True, False
-        append_input = getattr(self._chat_service.engine_client, "append_duplex_input_async", None)
-        if not callable(append_input):
-            return True, False
-        if expected_epoch is not None and session.epoch != expected_epoch:
-            return True, False
-        try:
-            append_kwargs = {
-                "mode": mode,
-                "payload": payload,
-                "final": final,
-                "timeout": self._runtime_control_timeout_s(session),
-            }
-            if operation_id is not None and self._callable_accepts_keyword(append_input, "operation_id"):
-                append_kwargs["operation_id"] = operation_id
-            if expected_epoch is not None and self._callable_accepts_keyword(append_input, "expected_epoch"):
-                append_kwargs["expected_epoch"] = expected_epoch
-            if self._callable_accepts_keyword(append_input, "fence"):
-                payload_turn = payload_turn_id(payload)
-                append_kwargs["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
-                        )
-                    ),
-                    incarnation=session.incarnation,
-                )
-            if self._callable_accepts_keyword(append_input, "collect_outputs"):
-                append_kwargs["collect_outputs"] = bool(
-                    getattr(self._serving_runtime_adapter, "collect_outputs_on_append", False)
-                )
-            result = await append_input(session.session_id, **append_kwargs)
-        except Exception as exc:
-            logger.exception("Failed to append duplex runtime input: %s", exc)
-            await self._send_runtime_error(send_json, "runtime_append_failed", exc, session=session)
-            return False, False
-        if isinstance(result, dict) and self._runtime_control_failed(result):
-            await self._send_runtime_control_error(
-                send_json,
-                "runtime_append_failed",
-                "Duplex runtime append failed",
-                result,
-                session=session,
-            )
-            return False, False
-        if expected_epoch is not None and session.epoch != expected_epoch:
-            return True, False
-        await self._send_runtime_control_if_needed(send_json, result, session=session)
-        request_id, _ = self._data_plane_request_info(result) if isinstance(result, dict) else (None, None)
-        if request_id is not None:
-            self._serving_runtime_adapter.data_plane.begin_request(request_id)
-        close_reason, emitted_response = await self._send_native_duplex_events(
-            send_json,
-            result,
-            session=session,
-            expected_epoch=expected_epoch,
-        )
-        # A resumable data-plane append remains active even when its persistent
-        # drain task already exists. Treating only a newly-created drain as
-        # activity clears active_request_id after later appends and prevents a
-        # terminal TTS segment from scheduling the next model decision.
-        emitted_response = emitted_response or request_id is not None
-        if close_reason is None and await self._start_native_data_plane_stream_task(
-            send_json,
-            result,
-            session=session,
-            expected_epoch=expected_epoch,
-        ):
-            emitted_response = True
-        if close_reason is not None:
-            if not await self._close_runtime_session(session, reason=close_reason, send_json=send_json):
-                return False, emitted_response
-            session.close()
-            await send_json(
-                {
-                    "type": "session.closed",
-                    "session_id": session.session_id,
-                    "reason": close_reason,
-                }
-            )
-            return False, emitted_response
-        return True, emitted_response
-
-    @staticmethod
-    def _callable_accepts_keyword(fn, name: str) -> bool:
-        try:
-            params = inspect.signature(fn).parameters.values()
-        except (TypeError, ValueError):
-            return True
-        return any(param.kind == inspect.Parameter.VAR_KEYWORD or param.name == name for param in params)
-
-    def _native_runtime_contract_error(self, session: DuplexSession) -> str | None:
-        if session.capabilities.implementation_level != "model_native_duplex":
-            return None
-        engine_client = self._chat_service.engine_client
-        invalid: list[str] = []
-        for method_name, required_keywords in self._NATIVE_RUNTIME_FENCE_CONTRACT.items():
-            method = getattr(engine_client, method_name, None)
-            if not callable(method):
-                invalid.append(f"{method_name} is missing")
-                continue
-            try:
-                parameters = tuple(inspect.signature(method).parameters.values())
-            except (TypeError, ValueError):
-                invalid.append(f"{method_name} signature is not inspectable")
-                continue
-            accepts_kwargs = any(parameter.kind == inspect.Parameter.VAR_KEYWORD for parameter in parameters)
-            declared = {parameter.name for parameter in parameters}
-            missing = [name for name in required_keywords if not accepts_kwargs and name not in declared]
-            if missing:
-                invalid.append(f"{method_name} is missing keyword(s): {', '.join(missing)}")
-        if not invalid:
-            return None
-        return "Native duplex runtime requires the fenced control contract: " + "; ".join(invalid)
-
-    async def _start_native_data_plane_stream_task(
-        self,
-        send_json,
-        result: object,
-        *,
-        session: DuplexSession,
-        expected_epoch: int | None = None,
-    ) -> bool:
-        request_id, _ = self._data_plane_request_info(result)
-        if request_id is None or self._data_plane_outputs_finished(result):
-            return False
-        session.bind_request(request_id)
-
-        native = self._runtime_session_state(session)
-        old_task = native.data_plane_task
-        if old_task is not None and not old_task.done():
-            if self._session_auto_responds(session):
-                # One persistent drain per session, like the official worker's
-                # single synchronous loop: the resumable data-plane request id
-                # is stable, and cancel/restart on every append orphans any
-                # decision that lands in the swap window.
-                native.data_plane_restart_requested = True
-                return False
-            old_task.cancel()
-            try:
-                await asyncio.wait_for(asyncio.gather(old_task, return_exceptions=True), timeout=0.25)
-            except asyncio.TimeoutError:
-                pass
-
-        async def _run() -> None:
-            close_reason: str | None = None
-            try:
-                close_reason = await self._drain_native_data_plane_stream(
-                    send_json,
-                    result,
-                    session=session,
-                    expected_epoch=expected_epoch,
-                )
-                if close_reason is not None:
-                    if await self._close_runtime_session(session, reason=close_reason, send_json=send_json):
-                        session.close()
-                        await send_json(
-                            {
-                                "type": "session.closed",
-                                "session_id": session.session_id,
-                                "reason": close_reason,
-                            }
-                        )
-            except asyncio.CancelledError:
-                raise
-            except Exception as exc:
-                logger.exception("Failed to drain duplex data-plane stream: %s", exc)
-                await self._send_runtime_error(send_json, "runtime_data_plane_stream_failed", exc, session=session)
-                if session.state != DuplexSessionState.CLOSED:
-                    close_reason = "runtime_data_plane_stream_failed"
-                    if await self._close_runtime_session(session, reason=close_reason, send_json=send_json):
-                        session.close()
-                        await send_json(
-                            {
-                                "type": "session.closed",
-                                "session_id": session.session_id,
-                                "reason": close_reason,
-                            }
-                        )
-            finally:
-                if native.data_plane_task is task:
-                    native.data_plane_task = None
-                restart_requested = (
-                    native.data_plane_restart_requested
-                    and close_reason is None
-                    and session.state != DuplexSessionState.CLOSED
-                    and session.active_request_id == request_id
-                    and (expected_epoch is None or session.epoch == expected_epoch)
-                )
-                native.data_plane_restart_requested = False
-                if close_reason is None and not self._session_auto_responds(session):
-                    # Auto-respond sessions keep one resumable stage-1 stream
-                    # whose audio accumulates across speak units; the offset
-                    # must survive drain-task turnover or every unit re-sends
-                    # the reply audio from the start.
-                    self._serving_runtime_adapter.data_plane.close_stream(request_id)
-            if restart_requested:
-                await self._start_native_data_plane_stream_task(
-                    send_json,
-                    result,
-                    session=session,
-                    expected_epoch=expected_epoch,
-                )
-            elif close_reason is None:
-                await self._maybe_continue_native_response(send_json, session=session, expected_epoch=expected_epoch)
-
-        task = asyncio.create_task(_run())
-        native.data_plane_task = task
-        return True
-
-    # One MiniCPM model unit (1 s at 16 kHz) is the compatibility default.
-    # Other native-duplex adapters may use a different frame-locked unit.
-    _NATIVE_SILENCE_UNIT_PAYLOAD_AUDIO = base64.b64encode(bytes(16000 * 4)).decode("ascii")
-    _NATIVE_RESPONSE_MAX_CONTINUATION_UNITS = 8
-    # Each unit is one second of silence. Auto-response needs substantially
-    # more room than the eight decision beats above, but must still terminate
-    # well before the 300-second benchmark playback horizon. The final unit
-    # asks the model to LISTEN; a protocol fallback closes the response if that
-    # logit hint is ignored.
-    _NATIVE_AUTO_RESPONSE_MAX_CONTINUATION_UNITS = 64
-
-    def _native_silence_unit_payload(self) -> dict[str, object]:
-        samples = int(getattr(self._serving_runtime_adapter, "silence_continuation_samples", 16000))
-        audio = (
-            self._NATIVE_SILENCE_UNIT_PAYLOAD_AUDIO
-            if samples == 16000
-            else base64.b64encode(bytes(samples * 4)).decode("ascii")
-        )
-        return {
-            "type": "audio",
-            "audio": audio,
-            "format": "pcm_f32le",
-            "sample_rate_hz": 16000,
-        }
-
-    def _native_response_continuations_remaining(self, session: DuplexSession, response_id: str) -> bool:
-        native = self._runtime_session_state(session)
-        owner_id = f"response:{response_id}"
-        count = native.continuation_units if native.continuation_owner_id == owner_id else 0
-        limit = (
-            self._NATIVE_AUTO_RESPONSE_MAX_CONTINUATION_UNITS
-            if self._session_auto_responds(session)
-            else self._NATIVE_RESPONSE_MAX_CONTINUATION_UNITS
-        )
-        return count < limit
-
-    async def _finish_bounded_native_auto_response(
-        self,
-        send_json,
-        *,
-        session: DuplexSession,
-        expected_epoch: int | None,
-        model_turn_id: int | None = None,
-    ) -> None:
-        """Close an auto-response whose final silence unit did not end it."""
-        native = self._runtime_session_state(session)
-        response_id = session.active_response_id
-        response_epoch = session.epoch
-        response_turn_id = model_turn_id if model_turn_id is not None else session.active_response_turn_id
-        if expected_epoch is not None and response_epoch != expected_epoch:
-            return
-        native.clear_continuation()
-        payload = {
-            "type": "response.listen",
-            "session_id": session.session_id,
-            "epoch": response_epoch,
-            "reason": "continuation_limit",
-            "model_listen": False,
-        }
-        if response_id is not None:
-            # Clients demultiplex a listen against a precreated response by
-            # its id; every listen that terminates a response must carry it.
-            payload["response_id"] = response_id
-        await send_json(payload)
-        if response_id is None:
-            if session.epoch == response_epoch and response_turn_id is not None:
-                session.complete_model_turn(response_turn_id)
-            return
-        if session.epoch != response_epoch or session.active_response_id != response_id:
-            return
-        if response_turn_id is not None:
-            session.complete_model_turn(response_turn_id)
-        session.end_response(commit_text=False, preserve_request=True)
-        await send_json(
-            {
-                "type": "response.done",
-                "session_id": session.session_id,
-                "response_id": response_id,
-                "epoch": response_epoch,
-                "committed": False,
-                "playback": session.playback.as_dict(),
-            }
-        )
-
-    def _native_silence_continuation_is_stale(
-        self,
-        session: DuplexSession,
-        *,
-        request_id: str,
-        response_id: str | None,
-        response_owned: bool,
-        expected_epoch: int | None,
-        expected_incarnation: int,
-        expected_model_turn_id: int | None,
-    ) -> bool:
-        stale_common_owner = (
-            session.state == DuplexSessionState.CLOSED
-            or session.incarnation != expected_incarnation
-            or session.active_request_id != request_id
-            or (expected_epoch is not None and session.epoch != expected_epoch)
-        )
-        stale_response_owner = response_owned and session.active_response_id != response_id
-        stale_model_turn_owner = not response_owned and (
-            session.active_response_id is not None or session.turn_id != expected_model_turn_id
-        )
-        return stale_common_owner or stale_response_owner or stale_model_turn_owner
-
-    async def _maybe_continue_native_response(
-        self,
-        send_json,
-        *,
-        session: DuplexSession,
-        expected_epoch: int | None,
-        expected_model_turn_id: int | None = None,
-    ) -> None:
-        """Give an active model turn another silence unit.
-
-        A model turn can need another unit before it has emitted visible
-        text/audio and therefore before a Realtime response exists. Bind that
-        continuation to the model-turn identity; once a response exists, its
-        response/turn ownership remains the continuation fence.
-        """
-        response_id = session.active_response_id
-        native = self._runtime_session_state(session)
-        if session.state == DuplexSessionState.CLOSED:
-            native.clear_continuation()
-            return
-        request_id = session.active_request_id
-        if request_id is None:
-            native.clear_continuation()
-            return
-        if expected_epoch is not None and session.epoch != expected_epoch:
-            return
-        auto_response = self._session_auto_responds(session)
-        response_owned = response_id is not None
-        if response_owned:
-            owner_id = f"response:{response_id}"
-            payload_turn_id = (
-                session.active_response_turn_id if session.active_response_turn_id is not None else session.turn_id
-            )
-        else:
-            if not auto_response or expected_model_turn_id is None or session.turn_id != expected_model_turn_id:
-                native.clear_continuation()
-                return
-            owner_id = f"model-turn:{expected_model_turn_id}"
-            payload_turn_id = expected_model_turn_id
-        count = native.continuation_units if native.continuation_owner_id == owner_id else 0
-        continuation_limit = (
-            self._NATIVE_AUTO_RESPONSE_MAX_CONTINUATION_UNITS
-            if auto_response
-            else self._NATIVE_RESPONSE_MAX_CONTINUATION_UNITS
-        )
-        if count >= continuation_limit:
-            if auto_response:
-                await self._finish_bounded_native_auto_response(
-                    send_json,
-                    session=session,
-                    expected_epoch=expected_epoch,
-                    model_turn_id=payload_turn_id,
-                )
-            return
-        payload = self._native_silence_unit_payload()
-        if auto_response and count + 1 == continuation_limit:
-            payload["force_listen"] = True
-        payload["duplex_turn_id"] = payload_turn_id
-
-        scheduler = native.silence_continuation_scheduler
-        if scheduler is None:
-            return
-        try:
-            scheduled = await scheduler(
-                payload,
-                request_id=request_id,
-                owner_id=owner_id,
-                response_id=response_id,
-                response_owned=response_owned,
-                expected_epoch=expected_epoch,
-                expected_incarnation=session.incarnation,
-                expected_model_turn_id=expected_model_turn_id,
-                send_json=send_json,
-            )
-        except Exception as exc:
-            logger.exception("Failed to schedule duplex native response continuation: %s", exc)
-            scheduled = False
-        if scheduled:
-            native.continuation_owner_id = owner_id
-            native.continuation_units = count + 1
-
-    async def _cancel_native_data_plane_stream(self, session: DuplexSession) -> bool:
-        native = self._runtime_session_state(session)
-        task = native.data_plane_task
-        native.data_plane_task = None
-        native.data_plane_restart_requested = False
-        if task is None or task.done():
-            return False
-        task.cancel()
-        try:
-            await asyncio.wait_for(asyncio.gather(task, return_exceptions=True), timeout=0.25)
-        except asyncio.TimeoutError:
-            # Keep barge-in/cancel responsive. The task still carries the old
-            # expected_epoch and late model output is filtered by the writer.
-            pass
-        return True
-
-    async def _signal_runtime_session(
-        self,
-        session: DuplexSession,
-        event: str,
-        send_json=None,
-        *,
-        fence: DuplexFence | None = None,
-        next_fence: DuplexFence | None = None,
-        session_config: dict[str, object] | None = None,
-        runtime_config: dict[str, object] | None = None,
-    ) -> bool:
-        if not self._uses_serving_runtime_adapter(session.config):
-            return True
-        signal_turn = getattr(self._chat_service.engine_client, "signal_duplex_turn_async", None)
-        if not callable(signal_turn):
-            return True
-        try:
-            signal_kwargs = {
-                "event": event,
-                "timeout": self._runtime_control_timeout_s(session),
-            }
-            if self._callable_accepts_keyword(signal_turn, "fence"):
-                signal_kwargs["fence"] = fence or DuplexFence(
-                    session.session_id,
-                    epoch=session.epoch,
-                    turn_id=session.turn_id,
-                    incarnation=session.incarnation,
-                )
-            if next_fence is not None and self._callable_accepts_keyword(signal_turn, "next_fence"):
-                signal_kwargs["next_fence"] = next_fence
-            if session_config is not None and self._callable_accepts_keyword(signal_turn, "session_config"):
-                signal_kwargs["session_config"] = session_config
-            if runtime_config is not None and self._callable_accepts_keyword(signal_turn, "runtime_config"):
-                signal_kwargs["runtime_config"] = runtime_config
-            result = await signal_turn(session.session_id, **signal_kwargs)
-        except Exception as exc:
-            logger.exception("Failed to signal duplex runtime session: %s", exc)
-            if send_json is not None:
-                await self._send_runtime_error(send_json, "runtime_signal_failed", exc, session=session)
-            return False
-        if isinstance(result, dict) and self._runtime_signal_failed(result):
-            logger.warning(
-                "Duplex runtime signal failed: session=%s event=%s result=%s",
-                session.session_id,
-                event,
-                self._redact_runtime_control_result(result),
-            )
-            if send_json is not None:
-                await self._send_runtime_control_error(
-                    send_json,
-                    "runtime_signal_failed",
-                    "Duplex runtime signal failed",
-                    result,
-                    session=session,
-                )
-            return False
-        await self._send_runtime_control_if_needed(send_json, result, session=session)
-        return True
-
-    async def _close_runtime_session(self, session: DuplexSession, *, reason: str, send_json=None) -> bool:
-        if not self._uses_serving_runtime_adapter(session.config):
-            return True
-        close_session = getattr(self._chat_service.engine_client, "close_duplex_session_async", None)
-        if not callable(close_session):
-            return True
-        try:
-            close_kwargs = {
-                "reason": reason,
-                "timeout": self._runtime_control_timeout_s(session),
-            }
-            if self._callable_accepts_keyword(close_session, "fence"):
-                close_kwargs["fence"] = DuplexFence(
-                    session.session_id,
-                    epoch=session.epoch,
-                    turn_id=session.turn_id,
-                    incarnation=session.incarnation,
-                )
-            result = await close_session(session.session_id, **close_kwargs)
-        except Exception as exc:
-            logger.exception("Failed to close duplex runtime session: %s", exc)
-            if send_json is not None:
-                await self._send_runtime_error(send_json, "runtime_close_failed", exc, session=session)
-            return False
-        if isinstance(result, dict) and self._runtime_control_failed(result):
-            if send_json is not None:
-                await self._send_runtime_control_error(
-                    send_json,
-                    "runtime_close_failed",
-                    "Duplex runtime close failed",
-                    result,
-                    session=session,
-                )
-            return False
-        await self._send_runtime_control_if_needed(send_json, result, session=session)
-        return True
-
-    @staticmethod
-    def _runtime_control_timeout_s(session: DuplexSession) -> float:
-        raw = session.config.extra_body.get("duplex_control_timeout_s") or session.config.extra_body.get(
-            "runtime_control_timeout_s"
-        )
-        if isinstance(raw, int | float) and raw > 0:
-            return float(raw)
-        if session.capabilities.implementation_level == "model_native_duplex":
-            return 60.0
-        return 10.0
-
-    async def _send_runtime_control_if_needed(
-        self,
-        send_json,
-        result: object,
-        *,
-        session: DuplexSession,
-    ) -> None:
-        if send_json is None:
-            return
-        if not isinstance(result, dict):
-            return
-        if not result.get("unsupported_count") and not result.get("error_count"):
-            return
-        await send_json(
-            {
-                "type": "runtime.control",
-                "session_id": session.session_id,
-                "epoch": session.epoch,
-                "result": self._redact_runtime_control_result(result),
-            }
-        )
-
-    @staticmethod
-    def _runtime_control_failed(result: dict[str, object]) -> bool:
-        if result.get("ok") is False:
-            return True
-        for key in ("unsupported_count", "error_count"):
-            value = result.get(key)
-            if isinstance(value, int | float) and value > 0:
-                return True
-        return False
-
-    @classmethod
-    def _runtime_signal_failed(cls, result: dict[str, object]) -> bool:
-        error_count = result.get("error_count")
-        if isinstance(error_count, int | float) and error_count > 0:
-            return True
-        if result.get("ok") is not False:
-            return False
-        return not cls._runtime_signal_has_data_plane_ack(result)
-
-    @classmethod
-    def _runtime_signal_has_data_plane_ack(cls, value: object) -> bool:
-        if isinstance(value, dict):
-            if value.get("data_plane_signal") is True and value.get("supported") is True:
-                return True
-            return any(cls._runtime_signal_has_data_plane_ack(child) for child in value.values())
-        if isinstance(value, list | tuple):
-            return any(cls._runtime_signal_has_data_plane_ack(item) for item in value)
-        return False
-
-    @classmethod
-    def _redact_runtime_control_result(cls, value: object) -> object:
-        if isinstance(value, dict):
-            redacted = {
-                key: cls._redact_runtime_control_result(child)
-                for key, child in value.items()
-                if key
-                not in {
-                    "stage_handoff",
-                    "tts_handoff",
-                    "omni_payload",
-                    "tts_hidden_states",
-                    "tts_token_ids",
-                    "traceback",
-                }
-            }
-            native_result = redacted.get("native_result")
-            if isinstance(native_result, dict):
-                if native_result.get("requires_stage_handoff") is True:
-                    native_result.pop("requires_stage_handoff", None)
-                if native_result.get("requires_tts_stage") is True:
-                    native_result.pop("requires_tts_stage", None)
-            return redacted
-        if isinstance(value, list | tuple):
-            return [cls._redact_runtime_control_result(item) for item in value]
-        if is_dataclass(value) and not isinstance(value, type):
-            # Control results carry typed values straight from the engine:
-            # `fence` and `accepted_fence` are `DuplexFence` instances added by
-            # `DuplexControlClient.execute`. This redacted value is emitted on
-            # the wire (for example `session.created.runtime_control` in
-            # `session_runner`), where `WebSocket.send_json` would raise
-            # `TypeError: Object of type DuplexFence is not JSON serializable`
-            # and kill the session during the handshake.
-            return {key: cls._redact_runtime_control_result(child) for key, child in asdict(value).items()}
-        if isinstance(value, Enum):
-            return value.value
-        return value
-
-    async def _send_native_duplex_events(
-        self,
-        send_json,
-        result: object,
-        *,
-        session: DuplexSession,
-        expected_epoch: int | None = None,
-    ) -> tuple[str | None, bool]:
-        if send_json is None:
-            return None, False
-        if expected_epoch is not None and session.epoch != expected_epoch:
-            return None, False
-        close_reason: str | None = None
-        emitted_response = False
-        request_id, _ = self._data_plane_request_info(result)
-        if self._serving_runtime_adapter.data_plane.is_terminal(request_id):
-            return None, False
-        if request_id is not None and session.active_request_id is None:
-            session.bind_request(request_id)
-        context = self._runtime_data_plane_context(session)
-        for native_result in self._serving_runtime_adapter.data_plane.project(result, context=context):
-            close_reason_for_result, did_emit = await self._send_one_native_duplex_event(
-                send_json,
-                native_result,
-                session=session,
-                expected_epoch=expected_epoch,
-            )
-            emitted_response = emitted_response or did_emit
-            close_reason = close_reason or close_reason_for_result
-            if expected_epoch is not None and session.epoch != expected_epoch:
-                return None, emitted_response
-        return close_reason, emitted_response
-
-    async def _drain_native_data_plane_stream(
-        self,
-        send_json,
-        result: object,
-        *,
-        session: DuplexSession,
-        expected_epoch: int | None = None,
-    ) -> str | None:
-        request_id, response_stage_id = self._data_plane_request_info(result)
-        if request_id is None:
-            return None
-        if self._data_plane_outputs_finished(result):
-            return None
-        collect_outputs = getattr(
-            self._chat_service.engine_client,
-            "collect_duplex_data_plane_outputs_async",
-            None,
-        )
-        if not callable(collect_outputs):
-            return None
-
-        close_reason: str | None = None
-        empty_polls = 0
-        while close_reason is None:
-            if self._serving_runtime_adapter.data_plane.is_terminal(request_id):
-                return None
-            if self._session_auto_responds(session):
-                active_request_id = session.active_request_id
-                if active_request_id is not None and active_request_id != request_id:
-                    return None
-            if expected_epoch is not None and session.epoch != expected_epoch:
-                return None
-            if session.state == DuplexSessionState.CLOSED:
-                return None
-            outputs = await collect_outputs(
-                request_id,
-                response_stage_id=response_stage_id,
-                timeout=self._runtime_control_timeout_s(session),
-            )
-            if expected_epoch is not None and session.epoch != expected_epoch:
-                return None
-            if not outputs:
-                # An empty poll means no output arrived within one control
-                # window, not that the stream is over. Exiting here orphans a
-                # decision that lands moments later: it would sit queued until
-                # the NEXT append starts a fresh drain task, adding one full
-                # chunk of latency to every model decision.
-                empty_polls += 1
-                if empty_polls >= 3:
-                    return None
-                continue
-            empty_polls = 0
-            drain_result = {
-                "data_plane_outputs": outputs,
-            }
-            close_reason, emitted_response = await self._send_native_duplex_events(
-                send_json,
-                drain_result,
-                session=session,
-                expected_epoch=expected_epoch,
-            )
-            if (
-                self._data_plane_outputs_finished(drain_result)
-                and emitted_response
-                and not self._session_auto_responds(session)
-            ):
-                # Auto-respond sessions are resumable: every segment ends
-                # with finished=True but the stream continues with the next
-                # audio chunk. Exiting here would make each decision wait for
-                # the next append to start a fresh drain task (one full chunk
-                # of added latency); keep draining until epoch change,
-                # session close, or cancellation by a newer drain task.
-                return close_reason
-            # A batch without a client-visible event (e.g. the generic
-            # stage-0 final-output message that precedes the listen/speak
-            # decision in the same segment) must not terminate the drain;
-            # the real decision is still in flight.
-        return close_reason
-
-    @staticmethod
-    def _data_plane_outputs_finished(result: object) -> bool:
-        if not isinstance(result, dict):
-            return False
-        outputs = result.get("data_plane_outputs")
-        if not isinstance(outputs, list) or not outputs:
-            return False
-        return bool(getattr(outputs[-1], "finished", False))
-
-    @staticmethod
-    def _data_plane_request_info(result: object) -> tuple[str | None, int | None]:
-        if not isinstance(result, dict):
-            return None, None
-        return duplex_data_plane_request_info(result)
-
-    def _runtime_data_plane_context(self, session: DuplexSession) -> object:
-        response_config = session.response_config
-        return self._serving_runtime_adapter.data_plane_context(
-            epoch=session.epoch,
-            turn_id=session.turn_id,
-            active_response_turn_id=session.active_response_turn_id,
-            active_response_id=session.active_response_id,
-            auto_responds=self._session_auto_responds(session),
-            response_format=response_config.response_format,
-            speed=response_config.speed,
-            modalities=tuple(response_config.modalities),
-        )
-
-    async def _send_one_native_duplex_event(
-        self,
-        send_json,
-        native_result: dict[str, object],
-        *,
-        session: DuplexSession,
-        expected_epoch: int | None = None,
-    ) -> tuple[str | None, bool]:
-        close_reason: str | None = None
-        emitted_response = False
-        if expected_epoch is not None and session.epoch != expected_epoch:
-            return close_reason, emitted_response
-        data_plane_request_id = native_result.get("data_plane_request_id")
-        if isinstance(data_plane_request_id, str) and self._serving_runtime_adapter.data_plane.is_terminal(
-            data_plane_request_id
-        ):
-            return close_reason, emitted_response
-        active_request_matches = session.active_request_id == data_plane_request_id or (
-            self._session_auto_responds(session) and session.active_request_id is None
-        )
-        if isinstance(data_plane_request_id, str) and not active_request_matches:
-            return close_reason, emitted_response
-        if isinstance(native_result.get("error_code"), str):
-            response_id = session.active_response_id
-            await send_json(
-                {
-                    "type": "error",
-                    "code": native_result.get("error_code"),
-                    "session_id": session.session_id,
-                    "epoch": session.epoch,
-                    "error": str(native_result.get("error") or "Duplex native data-plane error"),
-                }
-            )
-            if response_id is not None:
-                session.end_response(commit_text=False)
-                await send_json(
-                    {
-                        "type": "response.done",
-                        "session_id": session.session_id,
-                        "response_id": response_id,
-                        "epoch": session.epoch,
-                        "committed": False,
-                        "status": "failed",
-                        "status_details": {
-                            "type": "failed",
-                            "reason": native_result.get("error_code"),
-                        },
-                        "playback": session.playback.as_dict(),
-                    }
-                )
-            return close_reason, True
-        if native_result.get("function_call") is True:
-            await send_json(
-                {
-                    "type": "function_call.done",
-                    "session_id": session.session_id,
-                    "epoch": session.epoch,
-                    "call_id": native_result.get("call_id"),
-                    "name": native_result.get("name"),
-                    "arguments": native_result.get("arguments", ""),
-                }
-            )
-            return close_reason, True
-        if native_result.get("requires_stage_handoff") is True or native_result.get("requires_tts_stage") is True:
-            # Stage0 announces a talker handoff before Stage1 has produced
-            # client-visible audio. A single client input stream may contain
-            # several model turns, including terminal-only turns. Reserve the
-            # protocol response only when Stage1 emits text/audio so empty
-            # model turns cannot create empty responses or steal later audio.
-            return close_reason, False
-        is_listen = native_result.get("is_listen")
-        model_turn_id = coerce_int(native_result.get("model_turn_id"))
-        if native_result.get("is_buffering") is True or native_result.get("prefill_success") is False:
-            if native_result.get("data_plane_request_id") == session.active_request_id:
-                session.clear_request()
-            # No response_id here: a buffering listen is informational, not a
-            # response terminal — clients must not close a handle over it.
-            payload = {
-                "type": "response.listen",
-                "session_id": session.session_id,
-                "epoch": session.epoch,
-                "reason": native_result.get("reason") or "buffering",
-                "model_listen": False,
-                "buffering": True,
-            }
-            self._attach_native_runtime_metadata(payload, native_result)
-            await send_json(payload)
-            return close_reason, emitted_response
-        if is_listen is True:
-            await self._end_active_response_before_future_model_turn(
-                send_json,
-                session=session,
-                model_turn_id=model_turn_id,
-            )
-            if (
-                session.active_response_id is not None
-                and model_turn_id is not None
-                and not session.active_response_accepts_model_turn(model_turn_id)
-            ):
-                return close_reason, emitted_response
-            auto_response = self._session_auto_responds(session)
-            active_response_id = session.active_response_id
-            auto_continuations_remaining = active_response_id is None or self._native_response_continuations_remaining(
-                session, active_response_id
-            )
-            non_terminal_auto_listen = (
-                auto_response
-                and active_response_id is not None
-                and session.active_request_id is not None
-                and native_result.get("end_of_turn") is not True
-                and auto_continuations_remaining
-            )
-            if non_terminal_auto_listen:
-                await self._maybe_continue_native_response(
-                    send_json,
-                    session=session,
-                    expected_epoch=expected_epoch,
-                )
-                return close_reason, emitted_response
-            if not auto_response and data_plane_request_id == session.active_request_id:
-                session.clear_request()
-            model_listen = native_result.get("model_listen")
-            if not isinstance(model_listen, bool):
-                model_listen = native_result.get("reason") in {None, "", "model_listen"}
-            response_id = session.active_response_id
-            if isinstance(data_plane_request_id, str) and not auto_response:
-                self._serving_runtime_adapter.data_plane.mark_terminal(data_plane_request_id)
-            emitted_response = True
-            payload = {
-                "type": "response.listen",
-                "session_id": session.session_id,
-                "epoch": session.epoch,
-                "reason": native_result.get("reason") or "model_listen",
-                "model_listen": model_listen,
-            }
-            if response_id is not None:
-                # The listen is this response's terminal decision (a
-                # response.done follows below with the same id); carry the id
-                # so clients can bind the decision to the precreated response.
-                payload["response_id"] = response_id
-            self._attach_native_runtime_metadata(payload, native_result)
-            await send_json(payload)
-            if native_result.get("abort_data_plane_request") is True and isinstance(data_plane_request_id, str):
-                await self._abort_request_background(
-                    session,
-                    data_plane_request_id,
-                    send_json,
-                    notify=False,
-                )
-            if response_id is not None:
-                if not self._session_auto_responds(session) and self._native_response_continuations_remaining(
-                    session, response_id
-                ):
-                    # The official model often listens for a silence beat or
-                    # two before answering; keep the response open and give it
-                    # the next silence unit as a decision point.
-                    await self._maybe_continue_native_response(
-                        send_json,
-                        session=session,
-                        expected_epoch=expected_epoch,
-                    )
-                    return close_reason, emitted_response
-                if auto_response:
-                    self._runtime_session_state(session).clear_continuation()
-                    if not auto_continuations_remaining:
-                        completed_turn_id = model_turn_id
-                        if completed_turn_id is None:
-                            completed_turn_id = session.active_response_turn_id
-                        if completed_turn_id is not None:
-                            session.complete_model_turn(completed_turn_id)
-                session.end_response(commit_text=False, preserve_request=auto_response)
-                await send_json(
-                    {
-                        "type": "response.done",
-                        "session_id": session.session_id,
-                        "response_id": response_id,
-                        "epoch": session.epoch,
-                        "committed": False,
-                        "playback": session.playback.as_dict(),
-                    }
-                )
-            return close_reason, emitted_response
-
-        text = native_result.get("text")
-        audio = native_result.get("audio_data", native_result.get("audio"))
-        end_of_turn = bool(native_result.get("end_of_turn", False))
-        has_text = isinstance(text, str) and bool(text)
-        has_audio = isinstance(audio, str) and bool(audio)
-        if not has_text and not has_audio and not end_of_turn:
-            tts_segment_ended = (
-                native_result.get("stage_role") == "tts" and native_result.get("abort_data_plane_request") is True
-            )
-            if (
-                tts_segment_ended
-                and self._session_auto_responds(session)
-                and (model_turn_id is not None or session.active_response_id is not None)
-            ):
-                await self._maybe_continue_native_response(
-                    send_json,
-                    session=session,
-                    expected_epoch=expected_epoch,
-                    expected_model_turn_id=model_turn_id,
-                )
-            return close_reason, emitted_response
-        if end_of_turn and not has_text and not has_audio and session.active_response_id is None:
-            if isinstance(data_plane_request_id, str):
-                if not self._session_auto_responds(session) and data_plane_request_id == session.active_request_id:
-                    session.clear_request()
-                if not self._session_auto_responds(session):
-                    self._serving_runtime_adapter.data_plane.mark_terminal(data_plane_request_id)
-            if model_turn_id is not None:
-                session.complete_model_turn(model_turn_id)
-            if self._session_auto_responds(session):
-                self._runtime_session_state(session).clear_continuation()
-                emitted_response = True
-                payload = {
-                    "type": "response.listen",
-                    "session_id": session.session_id,
-                    "epoch": session.epoch,
-                    "reason": "model_turn_completed_without_output",
-                    "model_listen": True,
-                }
-                self._attach_native_runtime_metadata(payload, native_result)
-                await send_json(payload)
-            return close_reason, emitted_response
-        if session.active_response_id is None and model_turn_id is not None and model_turn_id < session.turn_id:
-            # A continuation append can already be in flight when the prior
-            # response reaches turn EOS.  Its late audio still carries the
-            # completed model turn, so it must not reserve a second Realtime
-            # response for that turn.
-            return close_reason, emitted_response
-        await self._end_active_response_before_future_model_turn(
-            send_json,
-            session=session,
-            model_turn_id=model_turn_id,
-        )
-        if (
-            session.active_response_id is not None
-            and model_turn_id is not None
-            and not session.active_response_accepts_model_turn(model_turn_id)
-        ):
-            return close_reason, emitted_response
-        emitted_response = True
-        response_created = False
-        response_id = session.active_response_id
-        if response_id is None:
-            response_id = session.begin_response(turn_id=model_turn_id)
-            response_created = True
-            await send_json(
-                self._response_created_payload(
-                    session,
-                    response_id,
-                    epoch=session.epoch,
-                )
-            )
-        response_stage_metrics = session.accumulate_response_stage_metrics(
-            native_result.get("stage_metrics") if isinstance(native_result.get("stage_metrics"), Mapping) else None
-        )
-        if response_created:
-            speak_payload = {
-                "type": "response.speak",
-                "session_id": session.session_id,
-                "response_id": response_id,
-                "epoch": session.epoch,
-                "text": text if isinstance(text, str) else "",
-                "end_of_turn": end_of_turn,
-                "model_speak": True,
-            }
-            self._attach_native_runtime_metadata(
-                speak_payload,
-                native_result,
-                stage_metrics=response_stage_metrics,
-            )
-            await send_json(speak_payload)
-        previous_sent_ms = session.playback.sent_ms
-        text_chars_before_append = len("".join(session.assistant_text_buffer))
-        if isinstance(text, str):
-            session.append_assistant_text(text)
-        duration_ms = native_result.get("audio_duration_ms")
-        text_chars = len("".join(session.assistant_text_buffer))
-        mark_duration_ms = None
-        mark_text_chars: int | None = text_chars
-        if native_result.get("audio_text_mark") is False:
-            mark_text_chars = None
-        if isinstance(duration_ms, int | float):
-            mark_duration_ms = int(duration_ms)
-            if native_result.get("audio_duration_is_cumulative") is not True:
-                mark_duration_ms += session.playback.sent_ms
-        audio_text_marks = native_result.get("audio_text_marks")
-        audio_text_marks = self._normalize_native_audio_text_marks(
-            audio_text_marks if isinstance(audio_text_marks, list) else None,
-            audio_offset_ms=(
-                0
-                if native_result.get("audio_text_marks_are_cumulative") is True
-                or native_result.get("audio_duration_is_cumulative") is True
-                else previous_sent_ms
-            ),
-            text_offset_chars=(
-                0 if native_result.get("audio_text_marks_are_cumulative") is True else text_chars_before_append
-            ),
-        )
-        session.mark_audio_sent(
-            mark_duration_ms,
-            text_chars=mark_text_chars if mark_duration_ms is not None else None,
-            audio_text_marks=audio_text_marks,
-        )
-        payload = {
-            "type": "response.output_audio.delta",
-            "session_id": session.session_id,
-            "response_id": response_id,
-            "epoch": session.epoch,
-            "text": text if isinstance(text, str) else "",
-            "audio": audio if isinstance(audio, str) else "",
-            "format": (
-                native_result.get("audio_format")
-                if isinstance(native_result.get("audio_format"), str)
-                else session.response_config.response_format
-            ),
-            "end_of_turn": end_of_turn,
-            "model_speak": True,
-        }
-        if mark_duration_ms is not None:
-            payload["audio_duration_ms"] = mark_duration_ms
-        if audio_text_marks:
-            payload["audio_text_marks"] = audio_text_marks
-        elif mark_duration_ms is not None and mark_text_chars is not None:
-            payload["audio_text_marks"] = [
-                {
-                    "text_chars": max(0, int(mark_text_chars)),
-                    "audio_end_ms": max(0, int(mark_duration_ms)),
-                }
-            ]
-        payload["playback"] = session.playback.as_dict()
-        sample_rate_hz = native_result.get("sample_rate_hz") or native_result.get("audio_sample_rate_hz")
-        if isinstance(sample_rate_hz, int | float) and int(sample_rate_hz) > 0:
-            payload["sample_rate_hz"] = int(sample_rate_hz)
-        self._attach_native_runtime_metadata(
-            payload,
-            native_result,
-            stage_metrics=response_stage_metrics,
-        )
-        await send_json(payload)
-        if (
-            not end_of_turn
-            and native_result.get("stage_role") == "tts"
-            and native_result.get("abort_data_plane_request") is True
-            and self._session_auto_responds(session)
-        ):
-            await self._maybe_continue_native_response(
-                send_json,
-                session=session,
-                expected_epoch=expected_epoch,
-            )
-        if end_of_turn:
-            data_plane_request_id = native_result.get("data_plane_request_id")
-            if isinstance(data_plane_request_id, str) and not self._session_auto_responds(session):
-                self._serving_runtime_adapter.data_plane.close_stream(data_plane_request_id)
-            if isinstance(data_plane_request_id, str):
-                if not self._session_auto_responds(session) and data_plane_request_id == session.active_request_id:
-                    session.clear_request()
-                if not self._session_auto_responds(session):
-                    self._serving_runtime_adapter.data_plane.mark_terminal(data_plane_request_id)
-            should_commit = self._should_commit_response_to_history(session, response_id)
-            committed_message = session.end_response(
-                commit_text=should_commit,
-                preserve_request=self._session_auto_responds(session),
-            )
-            model_turn_id = coerce_int(native_result.get("model_turn_id"))
-            if model_turn_id is not None:
-                session.complete_model_turn(model_turn_id)
-            if should_commit:
-                session.register_history_item(f"item_{response_id}", committed_message)
-            await send_json(
-                {
-                    "type": "response.done",
-                    "session_id": session.session_id,
-                    "response_id": response_id,
-                    "epoch": session.epoch,
-                    "committed": committed_message is not None,
-                    "playback": session.playback.as_dict(),
-                }
-            )
-        return close_reason, emitted_response
-
-    async def _end_active_response_before_future_model_turn(
-        self,
-        send_json,
-        *,
-        session: DuplexSession,
-        model_turn_id: int | None,
-    ) -> None:
-        if not self._session_auto_responds(session):
-            return
-        response_id = session.active_response_id
-        active_turn_id = session.active_response_turn_id
-        if response_id is None or model_turn_id is None or active_turn_id is None:
-            return
-        if int(model_turn_id) <= int(active_turn_id):
-            return
-        session.complete_model_turn(int(model_turn_id) - 1)
-        should_commit = self._should_commit_response_to_history(session, response_id)
-        committed_message = session.end_response(
-            commit_text=should_commit,
-            preserve_request=True,
-        )
-        if should_commit:
-            session.register_history_item(f"item_{response_id}", committed_message)
-        await send_json(
-            {
-                "type": "response.done",
-                "session_id": session.session_id,
-                "response_id": response_id,
-                "epoch": session.epoch,
-                "committed": committed_message is not None,
-                "playback": session.playback.as_dict(),
-            }
-        )
-
-    @staticmethod
-    def _normalize_native_audio_text_marks(
-        audio_text_marks: list[object] | None,
-        *,
-        audio_offset_ms: int,
-        text_offset_chars: int,
-    ) -> list[dict[str, int]] | None:
-        if not audio_text_marks:
-            return None
-        normalized: list[dict[str, int]] = []
-        for raw_mark in audio_text_marks:
-            if not isinstance(raw_mark, dict):
-                continue
-            raw_text_chars = raw_mark.get("text_chars")
-            raw_audio_end_ms = raw_mark.get("audio_end_ms", raw_mark.get("audio_ms"))
-            if not isinstance(raw_text_chars, int | float) or not isinstance(raw_audio_end_ms, int | float):
-                continue
-            normalized.append(
-                {
-                    "text_chars": max(0, int(raw_text_chars) + int(text_offset_chars)),
-                    "audio_end_ms": max(0, int(raw_audio_end_ms) + int(audio_offset_ms)),
-                }
-            )
-        return normalized or None
-
-    def _cleanup_duplex_session_state(self, session: DuplexSession) -> None:
-        session_id = session.session_id
-        pipeline = self._server_vad_pipelines.pop(session_id, None)
-        if pipeline is not None:
-            pipeline.reset()
-            self._realtime_vad_metrics.session_finished()
-        adapter = self._serving_runtime_adapter
-        if adapter is None:
-            self._serving_session_states.pop(session_id, None)
-        else:
-            adapter.remove_session_state(session_id)
-            adapter.data_plane.close_session(
-                session_id,
-                active_request_id=session.active_request_id,
-            )
-
-    def _encode_native_data_plane_audio(
-        self,
-        audio_data: object,
-        sample_rate_hz: int,
-        response_format: str,
-        speed: float | None,
-    ) -> str | None:
-        if audio_data is None:
-            return None
-        try:
-            import torch
-
-            from vllm_omni.entrypoints.openai.protocol.audio import CreateAudio
-
-            if isinstance(audio_data, torch.Tensor):
-                audio_tensor = audio_data.detach().cpu().float().numpy()
-            else:
-                audio_tensor = np.asarray(audio_data, dtype=np.float32)
-            if audio_tensor.ndim > 1:
-                audio_tensor = audio_tensor.reshape(-1)
-            audio_response = self._chat_service.create_audio(
-                CreateAudio(
-                    audio_tensor=audio_tensor,
-                    sample_rate=sample_rate_hz,
-                    response_format=response_format,
-                    speed=float(speed) if isinstance(speed, int | float) and speed > 0 else 1.0,
-                    stream_format="audio",
-                    base64_encode=True,
-                )
-            )
-            return str(audio_response.audio_data)
-        except Exception:
-            logger.exception("Failed to encode duplex data-plane audio output")
-            return None
-
-    @staticmethod
-    def _attach_native_runtime_metadata(
-        payload: dict[str, object],
-        native_result: dict[str, object],
-        *,
-        stage_metrics: Mapping[str, object] | None = None,
-    ) -> None:
-        metadata: dict[str, object] = {}
-        runtime_impl = native_result.get("runtime_impl")
-        if isinstance(runtime_impl, str) and runtime_impl:
-            metadata["runtime_impl"] = runtime_impl
-        owned_runtime = native_result.get("owned_runtime")
-        if isinstance(owned_runtime, bool):
-            metadata["owned_runtime"] = owned_runtime
-        model_turn_id = coerce_int(native_result.get("model_turn_id"))
-        if model_turn_id is not None:
-            metadata["model_turn_id"] = model_turn_id
-        for name in (
-            "uses_model_runner_scheduler",
-            "runner_kv_backed",
-        ):
-            value = native_result.get(name)
-            if isinstance(value, bool):
-                metadata[name] = value
-        effective_stage_metrics = stage_metrics if stage_metrics is not None else native_result.get("stage_metrics")
-        if isinstance(effective_stage_metrics, Mapping):
-            metadata["stage_metrics"] = {
-                str(stage_id): dict(values)
-                for stage_id, values in effective_stage_metrics.items()
-                if isinstance(values, Mapping)
-            }
-        if metadata:
-            payload["vllm_omni"] = metadata
-
-    async def _send_runtime_error(
-        self,
-        send_json,
-        code: str,
-        exc: Exception,
-        *,
-        session: DuplexSession | None = None,
-    ) -> None:
-        retryable = False
-        message = str(exc)
-        if isinstance(exc, DuplexControlRequestError):
-            code = exc.code
-            retryable = exc.retryable
-            error_data = exc.result.get("error")
-            if isinstance(error_data, dict) and isinstance(error_data.get("message"), str):
-                message = error_data["message"]
-        payload: dict[str, object] = {
-            "type": "error",
-            "code": code,
-            "error": message,
-            "retryable": retryable,
-        }
-        if session is not None:
-            payload["session_id"] = session.session_id
-            payload["epoch"] = session.epoch
-        await send_json(payload)
-
-    async def _send_runtime_control_error(
-        self,
-        send_json,
-        code: str,
-        message: str,
-        result: dict[str, object],
-        *,
-        session: DuplexSession,
-    ) -> None:
-        await send_json(
-            {
-                "type": "error",
-                "code": code,
-                "error": message,
-                "session_id": session.session_id,
-                "epoch": session.epoch,
-                "runtime_control": self._redact_runtime_control_result(result),
-            }
-        )
diff --git a/vllm_omni/entrypoints/duplex/server_vad.py b/vllm_omni/entrypoints/duplex/server_vad.py
deleted file mode 100644
index 610e51c8c..000000000
--- a/vllm_omni/entrypoints/duplex/server_vad.py
+++ /dev/null
@@ -1,528 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-from __future__ import annotations
-
-import asyncio
-import hashlib
-import threading
-import time
-from collections.abc import Mapping
-from dataclasses import dataclass, replace
-from pathlib import Path
-from typing import TYPE_CHECKING, Literal, Protocol
-
-import numpy as np
-from vllm.transformers_utils.repo_utils import try_get_local_file
-
-if TYPE_CHECKING:
-    from vllm_omni.entrypoints.openai.audio_utils_mixin import StreamingAudioResampler
-
-SILERO_VAD_REPO_ID = "istupakov/silero-vad-onnx"
-SILERO_VAD_REVISION = "8b14476858ef240c50b3884bb38cc67290c1cc70"
-SILERO_VAD_FILENAME = "silero_vad.onnx"
-SILERO_VAD_SHA256 = "1a153a22f4509e292a94e67d6f9b85e8deb25b4988682b7e174c65279d8788e3"
-SILERO_VAD_MIN_THRESHOLD = 0.15
-SILERO_VAD_DEFAULT_MIN_SPEECH_DURATION_MS = 96
-
-_SERVER_VAD_FIELDS = {
-    "type",
-    "threshold",
-    "prefix_padding_ms",
-    "silence_duration_ms",
-    "create_response",
-    "interrupt_response",
-    "min_speech_duration_ms",
-}
-
-
-@dataclass(frozen=True, slots=True)
-class ServerVADConfig:
-    """Validated OpenAI-compatible ``server_vad`` session configuration."""
-
-    type: Literal["server_vad"] = "server_vad"
-    threshold: float = 0.5
-    prefix_padding_ms: int = 300
-    silence_duration_ms: int = 500
-    create_response: bool = True
-    # Omission is resolved from runtime capabilities before the session is opened.
-    interrupt_response: bool | None = None
-    min_speech_duration_ms: int | None = None
-
-    @classmethod
-    def from_value(cls, value: object) -> ServerVADConfig:
-        if not isinstance(value, dict):
-            raise ValueError("turn_detection must be null or an object")
-        unknown = sorted(set(value) - _SERVER_VAD_FIELDS)
-        if unknown:
-            raise ValueError(f"Unknown server_vad field(s): {', '.join(unknown)}")
-        vad_type = value.get("type")
-        if vad_type != "server_vad":
-            raise ValueError("turn_detection.type must be 'server_vad'")
-
-        threshold = value.get("threshold", 0.5)
-        if isinstance(threshold, bool) or not isinstance(threshold, int | float) or not 0 <= threshold <= 1:
-            raise ValueError("server_vad.threshold must be a number between 0 and 1")
-
-        prefix_padding_ms = value.get("prefix_padding_ms", 300)
-        if isinstance(prefix_padding_ms, bool) or not isinstance(prefix_padding_ms, int) or prefix_padding_ms < 0:
-            raise ValueError("server_vad.prefix_padding_ms must be a non-negative integer")
-
-        silence_duration_ms = value.get("silence_duration_ms", 500)
-        if (
-            isinstance(silence_duration_ms, bool)
-            or not isinstance(silence_duration_ms, int)
-            or silence_duration_ms <= 0
-        ):
-            raise ValueError("server_vad.silence_duration_ms must be a positive integer")
-
-        create_response = value.get("create_response", True)
-        if not isinstance(create_response, bool):
-            raise ValueError("server_vad.create_response must be a boolean")
-
-        interrupt_response = value.get("interrupt_response")
-        if "interrupt_response" in value and not isinstance(interrupt_response, bool):
-            raise ValueError("server_vad.interrupt_response must be a boolean")
-
-        min_speech_duration_ms = value.get("min_speech_duration_ms")
-        if min_speech_duration_ms is not None and (
-            isinstance(min_speech_duration_ms, bool)
-            or not isinstance(min_speech_duration_ms, int | float)
-            or not np.isfinite(float(min_speech_duration_ms))
-            or min_speech_duration_ms < 0
-        ):
-            raise ValueError("server_vad.min_speech_duration_ms must be a non-negative number")
-
-        return cls(
-            type=vad_type,
-            threshold=float(threshold),
-            prefix_padding_ms=prefix_padding_ms,
-            silence_duration_ms=silence_duration_ms,
-            create_response=create_response,
-            interrupt_response=interrupt_response,
-            min_speech_duration_ms=(int(min_speech_duration_ms) if min_speech_duration_ms is not None else None),
-        )
-
-    def as_dict(self) -> dict[str, object]:
-        result: dict[str, object] = {
-            "type": self.type,
-            "threshold": self.threshold,
-            "prefix_padding_ms": self.prefix_padding_ms,
-            "silence_duration_ms": self.silence_duration_ms,
-            "create_response": self.create_response,
-        }
-        if self.interrupt_response is not None:
-            result["interrupt_response"] = self.interrupt_response
-        if self.min_speech_duration_ms is not None:
-            result["min_speech_duration_ms"] = self.min_speech_duration_ms
-        return result
-
-
-def parse_session_turn_detection(
-    payload: Mapping[str, object],
-) -> tuple[bool, ServerVADConfig | None]:
-    """Extract and validate OpenAI-compatible turn detection aliases."""
-    configured_values: list[tuple[str, object]] = []
-    if "turn_detection" in payload:
-        configured_values.append(("turn_detection", payload["turn_detection"]))
-    audio = payload.get("audio")
-    if isinstance(audio, Mapping):
-        audio_input = audio.get("input")
-        if isinstance(audio_input, Mapping) and "turn_detection" in audio_input:
-            configured_values.append(("audio.input.turn_detection", audio_input["turn_detection"]))
-    if not configured_values:
-        return False, None
-
-    first_path, first_value = configured_values[0]
-    first_config = None if first_value is None else ServerVADConfig.from_value(first_value)
-    for field_path, value in configured_values[1:]:
-        config = None if value is None else ServerVADConfig.from_value(value)
-        if first_config is not None and config is not None:
-            # An omitted option must not conflict with an explicit alias value.
-            if first_config.interrupt_response is None:
-                first_config = replace(first_config, interrupt_response=config.interrupt_response)
-            if config.interrupt_response is None:
-                config = replace(config, interrupt_response=first_config.interrupt_response)
-        if config != first_config:
-            raise ValueError(f"{first_path} and {field_path} must not specify conflicting values")
-    return True, first_config
-
-
-class SpeechDetectorBackend(Protocol):
-    """Detector contract; per-stream state is owned by the pipeline."""
-
-    frame_samples: int
-
-    def new_state(self) -> object: ...
-
-    def infer(self, frame: np.ndarray, state: object) -> tuple[float, object]: ...
-
-
-class SpeechDetectorBackendProvider(Protocol):
-    def get(self) -> SpeechDetectorBackend: ...
-
-
-@dataclass(frozen=True, slots=True)
-class SpeechEndpointDecision:
-    speech_started: bool = False
-    speech_stopped: bool = False
-    audio_start_ms: int | None = None
-    audio_end_ms: int | None = None
-    endpoint_delay_ms: int | None = None
-
-
-class SpeechEndpointPolicy(Protocol):
-    @property
-    def speech_active(self) -> bool: ...
-
-    def update(
-        self,
-        probability: float,
-        *,
-        frame_start_sample: int,
-        frame_samples: int,
-    ) -> SpeechEndpointDecision: ...
-
-    def reset(self) -> None: ...
-
-
-class ThresholdEndpointPolicy:
-    """Apply threshold and trailing-silence endpoint rules."""
-
-    def __init__(self, config: ServerVADConfig, *, sample_rate_hz: int) -> None:
-        self.config = config
-        self.sample_rate_hz = sample_rate_hz
-        self._speech_active = False
-        self._candidate_samples = 0
-        self._candidate_start_sample: int | None = None
-        self._silence_samples = 0
-
-    @property
-    def speech_active(self) -> bool:
-        return self._speech_active
-
-    def update(
-        self,
-        probability: float,
-        *,
-        frame_start_sample: int,
-        frame_samples: int,
-    ) -> SpeechEndpointDecision:
-        if probability >= self.config.threshold:
-            self._silence_samples = 0
-            if not self._speech_active:
-                if self._candidate_samples == 0:
-                    self._candidate_start_sample = frame_start_sample
-                self._candidate_samples += frame_samples
-                min_speech_duration_ms = self.config.min_speech_duration_ms or 0
-                min_speech_samples = max(1, round(min_speech_duration_ms * self.sample_rate_hz / 1000))
-                if self._candidate_samples < min_speech_samples:
-                    return SpeechEndpointDecision()
-                self._speech_active = True
-                detected_start_sample = (
-                    self._candidate_start_sample if self._candidate_start_sample is not None else frame_start_sample
-                )
-                detected_start_ms = round(detected_start_sample * 1000 / self.sample_rate_hz)
-                self._candidate_samples = 0
-                self._candidate_start_sample = None
-                return SpeechEndpointDecision(
-                    speech_started=True,
-                    audio_start_ms=max(0, detected_start_ms - self.config.prefix_padding_ms),
-                )
-            return SpeechEndpointDecision()
-
-        if not self._speech_active:
-            self._candidate_samples = 0
-            self._candidate_start_sample = None
-            return SpeechEndpointDecision()
-
-        # Match Silero v6.2's streaming VAD hysteresis: activation uses the
-        # configured threshold, while potential speech end starts only below
-        # ``max(threshold - 0.15, 0.01)``. Once a silence candidate exists,
-        # intermediate frames keep elapsed time moving but cannot themselves
-        # close the turn.
-        negative_threshold = max(self.config.threshold - SILERO_VAD_MIN_THRESHOLD, 0.01)
-        below_negative_threshold = probability < negative_threshold
-        if not below_negative_threshold and self._silence_samples == 0:
-            return SpeechEndpointDecision()
-
-        self._silence_samples += frame_samples
-        if not below_negative_threshold:
-            return SpeechEndpointDecision()
-        silence_limit = max(1, round(self.config.silence_duration_ms * self.sample_rate_hz / 1000))
-        if self._silence_samples < silence_limit:
-            return SpeechEndpointDecision()
-
-        # OpenAI defines ``audio_end_ms`` as the end of the audio sent to the
-        # model, including the trailing silence used for endpoint detection.
-        audio_end_sample = frame_start_sample + frame_samples
-        endpoint_delay_ms = round(self._silence_samples * 1000 / self.sample_rate_hz)
-        self.reset()
-        return SpeechEndpointDecision(
-            speech_stopped=True,
-            audio_end_ms=max(0, round(audio_end_sample * 1000 / self.sample_rate_hz)),
-            endpoint_delay_ms=endpoint_delay_ms,
-        )
-
-    def reset(self) -> None:
-        self._speech_active = False
-        self._candidate_samples = 0
-        self._candidate_start_sample = None
-        self._silence_samples = 0
-
-
-@dataclass(frozen=True, slots=True)
-class ServerVADFrame:
-    samples: np.ndarray
-    decision: SpeechEndpointDecision
-
-
-@dataclass(frozen=True, slots=True)
-class ServerVADBatch:
-    frames: tuple[ServerVADFrame, ...]
-    inference_ms: float
-
-
-class ServerVADPipeline:
-    """Frame continuous 16 kHz audio and apply acoustic endpointing.
-
-    The pipeline retains only input-resampling residuals, a partial frame,
-    detector state, and timing counters. Commit-eligible prefix and utterance
-    audio remain session-owned.
-    """
-
-    sample_rate_hz = 16_000
-
-    def __init__(
-        self,
-        backend: SpeechDetectorBackend,
-        config: ServerVADConfig,
-        *,
-        endpoint_policy: SpeechEndpointPolicy | None = None,
-    ) -> None:
-        self.backend = backend
-        self.config = config
-        self.endpoint_policy = endpoint_policy or ThresholdEndpointPolicy(
-            config,
-            sample_rate_hz=self.sample_rate_hz,
-        )
-        self._input_resampler: StreamingAudioResampler | None = None
-        self._source_sample_rate_hz: int | None = None
-        self._scratch = np.empty(0, dtype=np.float32)
-        self._detector_state = backend.new_state()
-        self._processed_samples = 0
-        self._stream_start_ms = 0
-
-    @property
-    def speech_active(self) -> bool:
-        return self.endpoint_policy.speech_active
-
-    @property
-    def source_sample_rate_hz(self) -> int | None:
-        return self._source_sample_rate_hz
-
-    @property
-    def scratch_bytes(self) -> int:
-        resampler_bytes = self._input_resampler.scratch_bytes if self._input_resampler is not None else 0
-        return int(self._scratch.nbytes) + resampler_bytes
-
-    async def push_pcm16(
-        self,
-        samples: bytes,
-        *,
-        source_sample_rate_hz: int,
-    ) -> ServerVADBatch:
-        """Normalize chunked mono PCM16 input and run endpoint detection."""
-        if isinstance(source_sample_rate_hz, bool) or source_sample_rate_hz not in {16_000, 24_000}:
-            raise ValueError("server_vad PCM16 input sample rate must be 16000 or 24000 Hz")
-
-        if len(samples) % np.dtype("<i2").itemsize:
-            raise ValueError("server_vad PCM16 input contains an incomplete sample")
-        pcm16 = np.frombuffer(samples, dtype="<i2")
-
-        if self._source_sample_rate_hz is not None and source_sample_rate_hz != self._source_sample_rate_hz:
-            raise ValueError("server_vad input sample rate cannot change within a continuous audio stream")
-        if pcm16.size and self._source_sample_rate_hz is None:
-            from vllm_omni.entrypoints.openai.audio_utils_mixin import StreamingAudioResampler
-
-            self._input_resampler = (
-                None
-                if source_sample_rate_hz == self.sample_rate_hz
-                else StreamingAudioResampler(source_sample_rate_hz, self.sample_rate_hz)
-            )
-            self._source_sample_rate_hz = source_sample_rate_hz
-
-        normalized = np.ascontiguousarray(pcm16, dtype=np.float32) * np.float32(1.0 / 32768.0)
-        if self._input_resampler is not None:
-            normalized = self._input_resampler.process(normalized)
-        return await self.push(normalized)
-
-    async def push(self, samples: np.ndarray) -> ServerVADBatch:
-        normalized = np.ascontiguousarray(samples, dtype=np.float32).reshape(-1)
-        return await asyncio.to_thread(self._push_sync, normalized)
-
-    def _push_sync(self, samples: np.ndarray) -> ServerVADBatch:
-        started_at = time.perf_counter()
-        if self._scratch.size:
-            samples = np.concatenate((self._scratch, samples))
-        frame_samples = int(self.backend.frame_samples)
-        complete_samples = samples.size - samples.size % frame_samples
-        # Retained state must not keep the whole input chunk alive through a view.
-        self._scratch = samples[complete_samples:].copy()
-
-        results: list[ServerVADFrame] = []
-        for offset in range(0, complete_samples, frame_samples):
-            frame = np.ascontiguousarray(samples[offset : offset + frame_samples], dtype=np.float32)
-            frame_start = self._processed_samples
-            probability, self._detector_state = self.backend.infer(frame, self._detector_state)
-            probability = min(1.0, max(0.0, float(probability)))
-            decision = self.endpoint_policy.update(
-                probability,
-                frame_start_sample=frame_start,
-                frame_samples=frame_samples,
-            )
-            if decision.speech_started and decision.audio_start_ms is not None:
-                # Prefix audio before the most recent reset is no longer available.
-                decision = replace(decision, audio_start_ms=max(self._stream_start_ms, decision.audio_start_ms))
-
-            self._processed_samples += frame_samples
-            results.append(
-                ServerVADFrame(
-                    samples=frame,
-                    decision=decision,
-                )
-            )
-        return ServerVADBatch(
-            frames=tuple(results),
-            inference_ms=(time.perf_counter() - started_at) * 1000,
-        )
-
-    def reset(self) -> None:
-        """Discard stream state while preserving the session-relative audio clock."""
-        self._stream_start_ms = round(self._processed_samples * 1000 / self.sample_rate_hz)
-        self._input_resampler = None
-        self._source_sample_rate_hz = None
-        self._scratch = np.empty(0, dtype=np.float32)
-        self._detector_state = self.backend.new_state()
-        self.endpoint_policy.reset()
-
-
-@dataclass(frozen=True, slots=True)
-class _SileroVADState:
-    model_state: np.ndarray
-    context: np.ndarray
-
-
-class SileroVADBackend:
-    """Shared ONNX Runtime Silero v6.2 detector running on CPU."""
-
-    sample_rate_hz = 16_000
-    frame_samples = 512
-    context_samples = 64
-    model_state_shape = (2, 1, 128)
-
-    def __init__(self, model_path: str | Path) -> None:
-        try:
-            import onnxruntime as ort
-        except ImportError as exc:  # pragma: no cover - platform packaging supplies ORT.
-            raise RuntimeError("server_vad requires ONNX Runtime") from exc
-
-        session_options = ort.SessionOptions()
-        session_options.inter_op_num_threads = 1
-        session_options.intra_op_num_threads = 1
-
-        self.model_path = Path(model_path)
-        self._session = ort.InferenceSession(
-            str(self.model_path),
-            providers=["CPUExecutionProvider"],
-            sess_options=session_options,
-        )
-        input_names = {item.name for item in self._session.get_inputs()}
-        if "input" not in input_names or "sr" not in input_names or "state" not in input_names:
-            raise RuntimeError(f"Unsupported Silero ONNX input contract: {sorted(input_names)}")
-        self._warm_up()
-
-    def _warm_up(self) -> None:
-        self.infer(np.zeros(self.frame_samples, dtype=np.float32), self.new_state())
-
-    def new_state(self) -> _SileroVADState:
-        return _SileroVADState(
-            model_state=np.zeros(self.model_state_shape, dtype=np.float32),
-            context=np.zeros((1, self.context_samples), dtype=np.float32),
-        )
-
-    def infer(self, frame: np.ndarray, state: object) -> tuple[float, object]:
-        if not isinstance(state, _SileroVADState):
-            raise TypeError("Silero detector state must be created by SileroVADBackend.new_state()")
-        model_state = np.ascontiguousarray(state.model_state, dtype=np.float32)
-        context = np.ascontiguousarray(state.context, dtype=np.float32)
-        if model_state.shape != self.model_state_shape:
-            raise ValueError(f"Silero model state must have shape {self.model_state_shape}, got {model_state.shape}")
-        expected_context_shape = (1, self.context_samples)
-        if context.shape != expected_context_shape:
-            raise ValueError(f"Silero context must have shape {expected_context_shape}, got {context.shape}")
-
-        audio = np.ascontiguousarray(frame, dtype=np.float32).reshape(1, -1)
-        if audio.shape[1] != self.frame_samples:
-            raise ValueError(
-                f"Silero detector frame must contain exactly {self.frame_samples} samples, got {audio.shape[1]}"
-            )
-        model_input = np.concatenate((context, audio), axis=1)
-        inputs = {
-            "input": model_input,
-            "state": model_state,
-            "sr": np.asarray(self.sample_rate_hz, dtype=np.int64),
-        }
-        # ONNX Runtime permits concurrent Run calls on one CPU session. Stream
-        # state is explicit, so independent pipelines can safely share the session.
-        output = self._session.run(None, inputs)
-        if len(output) < 2:
-            raise RuntimeError("Silero ONNX model did not return probability and model state")
-        probability = float(np.asarray(output[0]).reshape(-1)[0])
-        next_state = _SileroVADState(
-            model_state=np.ascontiguousarray(output[1], dtype=np.float32),
-            context=np.ascontiguousarray(model_input[:, -self.context_samples :], dtype=np.float32),
-        )
-        return probability, next_state
-
-
-class SileroVADBackendProvider:
-    """Resolve, verify, and load one Silero model instance per process."""
-
-    def __init__(self, *, model_path: str | None = None) -> None:
-        self.model_path = model_path
-        self._backend: SileroVADBackend | None = None
-        self._lock = threading.Lock()
-
-    def get(self) -> SileroVADBackend:
-        if self._backend is not None:
-            return self._backend
-        with self._lock:
-            if self._backend is None:
-                path = self._resolve_local_artifact()
-                self._verify_checksum(path)
-                self._backend = SileroVADBackend(path)
-        return self._backend
-
-    def _resolve_local_artifact(self) -> Path:
-        if self.model_path:
-            path = Path(self.model_path).expanduser()
-            if path.is_file():
-                return path
-            raise RuntimeError(f"Configured Silero VAD model does not exist: {path}")
-        cached = try_get_local_file(
-            model=SILERO_VAD_REPO_ID,
-            file_name=SILERO_VAD_FILENAME,
-            revision=SILERO_VAD_REVISION,
-        )
-        if isinstance(cached, Path) and cached.is_file():
-            return cached
-        raise RuntimeError(
-            "Silero VAD artifact is not available locally. Pre-download the pinned artifact "
-            "or configure duplex_session.server_vad_model_path."
-        )
-
-    def _verify_checksum(self, path: Path) -> None:
-        digest = hashlib.sha256(path.read_bytes()).hexdigest()
-        if digest != SILERO_VAD_SHA256:
-            raise RuntimeError(f"Silero VAD checksum mismatch for {path}: expected {SILERO_VAD_SHA256}, got {digest}")
diff --git a/vllm_omni/entrypoints/duplex/serving.py b/vllm_omni/entrypoints/duplex/serving.py
index 7bd690841..ff1abbe25 100644
--- a/vllm_omni/entrypoints/duplex/serving.py
+++ b/vllm_omni/entrypoints/duplex/serving.py
@@ -1,2130 +1,543 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
+"""Thin websocket serving for ``/v1/realtime?duplex=1``.
+
+Everything about a duplex *session* lives inside the engine (see
+``vllm_omni.entrypoints.duplex_omni``). This handler only does transport:
+
+* accept the socket and run the Realtime handshake (``session.update`` opens a
+  session through ``DuplexOmni.open_session``; ``session.resume`` re-attaches
+  to an existing one);
+* translate each client JSON event into a ``DuplexCommand`` and submit it in
+  arrival order;
+* pump the session's typed events to the wire, journaling them for resume;
+* manage attachments: resume tokens, replay, takeover, detach on disconnect.
+"""
+
 from __future__ import annotations
 
 import asyncio
-import base64
-import binascii
-import inspect
 import json
-from collections.abc import Mapping, MutableMapping
+from collections.abc import Mapping
 from contextlib import suppress
 from dataclasses import dataclass, replace
-from typing import TYPE_CHECKING
 
-import numpy as np
-from fastapi import WebSocket
+from fastapi import WebSocket, WebSocketDisconnect
 from vllm.logger import init_logger
 
-from vllm_omni.config.stage_config import DuplexSessionRuntimeConfig
-from vllm_omni.engine.duplex.messages import DuplexFence, DuplexSessionLifecycleMessage
-from vllm_omni.engine.duplex.runtime import duplex_resource_request_id
-from vllm_omni.entrypoints.duplex.capability import (
-    should_enable_duplex_endpoint,
-)
-from vllm_omni.entrypoints.duplex.chat_fallback import (
-    ChatFallbackProjectorMixin,
-)
-from vllm_omni.entrypoints.duplex.protocol import (
-    NATIVE_DUPLEX_KEY,
-    DuplexCapabilities,
-    DuplexCommittedInput,
-    DuplexOverlapPolicy,
-    DuplexPlaybackCommitPolicy,
-    DuplexSession,
-    DuplexSessionConfig,
-    DuplexSessionRegistry,
-    DuplexSessionState,
-    DuplexTurnController,
-    ResponseCreateOptions,
-    native_duplex_opt_in,
-    normalize_native_duplex_key,
-)
-from vllm_omni.entrypoints.duplex.realtime_session import (
-    REALTIME_OUTPUT_AUDIO_FORMATS,
-    NativeRealtimeSessionProtocol,
-)
-from vllm_omni.entrypoints.duplex.runtime_adapter import (
-    ServingRuntimeAdapter,
-    ServingRuntimeConfigError,
-    ServingRuntimeSessionState,
-    TurnBasedServingSessionState,
-    load_serving_runtime_adapter,
-    validate_serving_runtime_adapter,
-)
-from vllm_omni.entrypoints.duplex.runtime_bridge import (
-    NativeRuntimeBridgeMixin,
-)
-from vllm_omni.entrypoints.duplex.server_vad import (
-    SILERO_VAD_DEFAULT_MIN_SPEECH_DURATION_MS,
-    SILERO_VAD_MIN_THRESHOLD,
-    ServerVADPipeline,
-    SileroVADBackendProvider,
-    SpeechDetectorBackendProvider,
-    parse_session_turn_detection,
+from vllm_omni.engine.duplex.commands import DuplexCommand, DuplexCommandError
+from vllm_omni.engine.duplex.events import (
+    DuplexEvent,
+    SessionClosed,
+    SessionCreated,
+    SessionReplaced,
+    SessionResumed,
+    SessionResyncRequired,
 )
+from vllm_omni.engine.duplex.messages import DuplexSessionError
+from vllm_omni.entrypoints.duplex.realtime_input import RealtimeEnvelope, parse_resume_request
 from vllm_omni.entrypoints.duplex.session_attachment import (
     DuplexJournalGapError,
+    DuplexJournalOverflowError,
     DuplexSessionAttachmentRegistry,
     InvalidResumeTokenError,
-)
-from vllm_omni.entrypoints.duplex.session_runner import (
-    DuplexSessionRunnerMixin,
+    ResumeToken,
 )
 from vllm_omni.entrypoints.duplex.websocket import (
-    DOMAIN_TERMINAL_EVENTS,
-    DuplexSessionTasks,
-    DuplexWebSocketActor,
+    MAX_EVENT_BYTES,
+    SendJson,
+    attachment_callbacks,
+    receive_text_with_timeout,
 )
-from vllm_omni.metrics.realtime import RealtimeVADMetrics
-
-if TYPE_CHECKING:
-    from vllm_omni.entrypoints.openai.serving_chat import OmniOpenAIServingChat
+from vllm_omni.entrypoints.duplex_omni import DuplexOmni, DuplexSessionHandle
+from vllm_omni.protocol.duplex import RealtimeInputDefaults
 
 logger = init_logger(__name__)
 
-__all__ = ["OmniDuplexSessionHandler", "should_enable_duplex_endpoint"]
+__all__ = ["OmniDuplexSessionHandler"]
 
 _DEFAULT_CONFIG_TIMEOUT_S = 10.0
 _DEFAULT_IDLE_TIMEOUT_S = 300.0
+#: How long the endpoint waits for the session pump to deliver its terminal
+#: event once the session is closed. Bounded so a wedged pump cannot pin the
+#: connection open; the pump itself closes the socket on its way out.
+_PUMP_DRAIN_TIMEOUT_S = 5.0
+#: session.created is journaled by the registry when it hands out the resume credential.
+_UNJOURNALED_EVENTS = (SessionCreated,)
+
+
+@dataclass
+class _Attachment:
+    """What one websocket connection knows about the session it is attached to."""
+
+    handle: DuplexSessionHandle
+    generation: int
 
 
 @dataclass(frozen=True)
-class _DuplexSessionHandshake:
-    session: DuplexSession
-    resumed: bool = False
-    attachment_generation: int | None = None
-    event_id: str | None = None
+class _ResumeCredentials:
+    """Transport credentials stamped onto ``session.created`` for a resumable session."""
+
+    attachment_generation: int
+    resume_token: str
 
 
-class OmniDuplexSessionHandler(
-    DuplexSessionRunnerMixin,
-    NativeRuntimeBridgeMixin,
-    ChatFallbackProjectorMixin,
-):
-    """WebSocket handler for RFC-style full-duplex session control.
-
-    This owns the serving-side session actor, ordered inbound mailbox,
-    barge-in epoch, turn controller, and playback commit state. Generic sessions
-    can still fall back to chat requests, while MiniCPM-o 4.5 native sessions
-    route audio appends through scheduler data-plane stage requests. It
-    deliberately does not claim core persistent KV lease support.
-    """
+class OmniDuplexSessionHandler:
+    """WebSocket transport for engine-resident duplex sessions."""
 
     def __init__(
         self,
         *,
-        chat_service: OmniOpenAIServingChat,
-        served_model_name: str | None = None,
+        duplex_omni: DuplexOmni,
         config_timeout_s: float = _DEFAULT_CONFIG_TIMEOUT_S,
         idle_timeout_s: float = _DEFAULT_IDLE_TIMEOUT_S,
-        log_stats: bool = True,
-        duplex_session_config: DuplexSessionRuntimeConfig | None = None,
-        serving_runtime_adapter: ServingRuntimeAdapter | None = None,
-        serving_runtime_adapter_path: str | None = None,
-        server_vad_backend_provider: SpeechDetectorBackendProvider | None = None,
     ) -> None:
-        self._chat_service = chat_service
+        self._omni = duplex_omni
         self._config_timeout_s = config_timeout_s
         self._idle_timeout_s = idle_timeout_s
-        self._duplex_session_config = duplex_session_config or DuplexSessionRuntimeConfig()
-        self._server_vad_backend_provider = server_vad_backend_provider or SileroVADBackendProvider(
-            model_path=self._duplex_session_config.server_vad_model_path,
-        )
-        self._server_vad_pipelines: dict[str, ServerVADPipeline] = {}
-        self._realtime_vad_metrics = RealtimeVADMetrics(
-            served_model_name or chat_service.model_config.model,
-            log_stats=log_stats,
-        )
-        self._registry = DuplexSessionRegistry(
-            DuplexCapabilities(
-                supports_model_native_turn_policy=False,
-                supports_input_append=False,
-                supports_replace_latest_chunk=True,
-                supports_reencode_context=True,
-                supports_turn_commit_only=True,
-                supports_kv_lease=False,
-            )
-        )
-        self._turn_controller = DuplexTurnController()
-        adapter_path = serving_runtime_adapter_path or getattr(
-            chat_service,
-            "duplex_serving_adapter_path",
-            None,
-        )
-        self._serving_runtime_adapter: ServingRuntimeAdapter | None
-        if serving_runtime_adapter is not None:
-            self._serving_runtime_adapter = validate_serving_runtime_adapter(serving_runtime_adapter)
-        elif isinstance(adapter_path, str) and adapter_path:
-            self._serving_runtime_adapter = load_serving_runtime_adapter(
-                adapter_path,
-                self._encode_native_data_plane_audio,
-            )
-        else:
-            self._serving_runtime_adapter = None
-        self._serving_session_states: MutableMapping[str, ServingRuntimeSessionState] = (
-            self._serving_runtime_adapter.session_states if self._serving_runtime_adapter is not None else {}
-        )
-        self._session_tasks: dict[str, DuplexSessionTasks] = {}
-        self._realtime_protocols: dict[str, NativeRealtimeSessionProtocol] = {}
-        self._lease_generations: dict[str, int] = {}
-        self._resync_required_sessions: set[str] = set()
-        self._lifecycle_queue = getattr(self._chat_service.engine_client, "duplex_lifecycle_events", None)
-        self._lifecycle_task: asyncio.Task[None] | None = None
+        runtime_config = duplex_omni.duplex_session_config
         self._attachment_registry = DuplexSessionAttachmentRegistry(
-            replay_ttl_s=self._duplex_session_config.resume_replay_ttl_s,
-            replay_max_bytes_per_session=self._duplex_session_config.resume_replay_max_bytes_per_session,
-            disconnect_grace_s=self._duplex_session_config.disconnect_grace_s,
+            replay_ttl_s=runtime_config.resume_replay_ttl_s,
+            replay_max_bytes_per_session=runtime_config.resume_replay_max_bytes_per_session,
         )
+        self._resync_required_sessions: set[str] = set()
+        #: Wire defaults (input/output audio format and rate) per session. They
+        #: are negotiated on the session but live on the per-connection
+        #: envelope, so a reconnect has to be handed them back.
+        self._input_defaults: dict[str, RealtimeInputDefaults] = {}
+        self._pumps: dict[str, asyncio.Task[None]] = {}
+
+    # ------------------------------------------------------------------ #
+    # Entry point                                                         #
+    # ------------------------------------------------------------------ #
 
     async def handle_realtime_session(self, websocket: WebSocket) -> None:
-        await self.handle_session(
-            websocket,
-            realtime_protocol=NativeRealtimeSessionProtocol(websocket.query_params),
-        )
+        await websocket.accept()
+        envelope = RealtimeEnvelope.from_query_params(websocket.query_params)
 
-    def _ensure_lifecycle_listener(self) -> None:
-        if not isinstance(self._lifecycle_queue, asyncio.Queue):
-            return
-        if self._lifecycle_task is None or self._lifecycle_task.done():
-            self._lifecycle_task = asyncio.create_task(
-                self._run_lifecycle_listener(),
-                name="duplex-serving-lifecycle",
-            )
+        async def send_json(payload: Mapping[str, object]) -> None:
+            await websocket.send_json(dict(payload))
 
-    async def _run_lifecycle_listener(self) -> None:
-        queue = self._lifecycle_queue
-        if not isinstance(queue, asyncio.Queue):
-            return
+        attachment: _Attachment | None = None
+        pending_command: dict[str, object] | None = None
         try:
-            while True:
-                message = await queue.get()
-                try:
-                    if isinstance(message, DuplexSessionLifecycleMessage):
-                        await self._apply_runtime_lifecycle(message)
-                finally:
-                    queue.task_done()
-                if self._registry.active_count() == 0:
+            open_payload = envelope.initial_open_payload()
+            if open_payload is None:
+                first = await self._receive_first_message(websocket, envelope, send_json)
+                if first is None:
                     return
-        finally:
-            if self._lifecycle_task is asyncio.current_task():
-                self._lifecycle_task = None
-
-    async def _apply_runtime_lifecycle(self, message: DuplexSessionLifecycleMessage) -> None:
-        session = self._registry.get(message.session_id)
-        if session is None:
-            return
-        fence = message.fence
-        if (
-            fence.session_id != session.session_id
-            or fence.incarnation != session.incarnation
-            or fence.epoch < session.epoch
-        ):
-            return
-        current_generation = self._lease_generations.get(session.session_id, 0)
-        if message.lease_generation < current_generation:
-            return
-        protocol = self._realtime_protocols.get(session.session_id)
-        expired_payload: dict[str, object] = {
-            "type": "session.expired",
-            "session_id": session.session_id,
-            "incarnation": session.incarnation,
-            "reason": message.reason,
-        }
-        if protocol is not None:
-            expired_payload = protocol.encode_outbound_event(expired_payload)[0]
-        with suppress(Exception):
-            await self._attachment_registry.send_event(
-                session.session_id,
-                expired_payload,
-                journal=False,
-            )
-
-        tasks = self._session_tasks.pop(session.session_id, None)
-        if tasks is not None:
-            await tasks.cancel_append_tasks()
-            active_response_task = tasks.active_response_task
-            if active_response_task is not None and not active_response_task.done():
-                active_response_task.cancel()
-                with suppress(asyncio.CancelledError):
-                    await active_response_task
-        native = self._serving_session_states.get(session.session_id)
-        if native is not None and native.data_plane_task is not None:
-            data_plane_task = native.data_plane_task
-            native.data_plane_task = None
-            data_plane_task.cancel()
-            with suppress(asyncio.CancelledError):
-                await data_plane_task
-        if session.active_response_id is not None:
-            session.end_response(commit_text=False)
-        self._cleanup_duplex_session_state(session)
-        self._registry.close(session.session_id)
-        self._realtime_protocols.pop(session.session_id, None)
-        self._lease_generations.pop(session.session_id, None)
-        self._resync_required_sessions.discard(session.session_id)
-        attachment = await self._attachment_registry.close(session.session_id)
-        if attachment is not None:
+                handshake = envelope.first_message(first)
+                if handshake.kind == "resume":
+                    attachment = await self._resume(websocket, envelope, handshake.resume_payload, send_json)
+                    if attachment is None:
+                        return
+                else:
+                    open_payload = handshake.session_payload
+                    pending_command = handshake.pending_command_payload
+            if attachment is None:
+                assert open_payload is not None
+                attachment = await self._open(websocket, envelope, open_payload, send_json)
+                if attachment is None:
+                    return
+            if pending_command is not None:
+                await self._submit_wire_event(attachment, envelope, pending_command, send_json)
+            self._input_defaults[attachment.handle.session_id] = envelope.defaults
+            await self._read_loop(websocket, envelope, attachment, send_json)
+            await self._drain_terminal_pump(attachment)
+        except WebSocketDisconnect:
+            if attachment is not None:
+                await self._on_disconnect(attachment)
+        except Exception as exc:
+            logger.exception("Duplex websocket session failed: %s", exc)
+            if attachment is not None and await self._attachment_registry.is_current_attachment(
+                attachment.handle.session_id, attachment.generation
+            ):
+                with suppress(Exception):
+                    await self._attachment_registry.close(attachment.handle.session_id)
+                with suppress(Exception):
+                    await attachment.handle.close(reason="transport_error")
             with suppress(Exception):
-                await attachment.close("session_expired")
+                await send_json(envelope.error_payload("realtime_input_failed", str(exc)))
 
-    def _stop_lifecycle_listener_if_idle(self) -> None:
-        task = self._lifecycle_task
-        if self._registry.active_count() != 0 or task is None or task.done():
-            return
-        if task is not asyncio.current_task():
-            task.cancel()
-            self._lifecycle_task = None
-
-    @staticmethod
-    def _native_audio_payload_size_bytes(payload: Mapping[str, object]) -> int:
-        audio = payload.get("audio") or payload.get("data")
-        if not isinstance(audio, str):
-            return 0
+    async def _receive_first_message(
+        self, websocket: WebSocket, envelope: RealtimeEnvelope, send_json: SendJson
+    ) -> dict[str, object] | None:
+        raw = await receive_text_with_timeout(websocket, self._config_timeout_s)
+        if raw is None:
+            await send_json(envelope.error_payload("config_timeout", "Timeout waiting for session.update"))
+            return None
         try:
-            return len(base64.b64decode(audio, validate=True))
-        except (ValueError, binascii.Error):
-            return 0
+            first = json.loads(raw)
+        except json.JSONDecodeError:
+            await send_json(envelope.error_payload("invalid_json", "Invalid JSON in session.update"))
+            return None
+        if not isinstance(first, dict):
+            await send_json(envelope.error_payload("bad_event", "Realtime event must be a JSON object"))
+            return None
+        return first
 
-    async def _apply_outbound_session_event(
-        self,
-        payload: dict[str, object],
-        *,
-        session: DuplexSession | None,
-        actor: DuplexWebSocketActor,
-        native: ServingRuntimeSessionState,
-        realtime_protocol: NativeRealtimeSessionProtocol | None,
-    ) -> tuple[bool, dict[str, object] | None]:
-        """Apply domain transitions before an event is queued for transport."""
-        payload_type = payload.get("type")
-        is_terminal = payload_type in DOMAIN_TERMINAL_EVENTS
-        if is_terminal and session is not None:
-            payload_epoch = payload.get("epoch")
-            if isinstance(payload_epoch, int) and payload_epoch != session.epoch:
-                return False, None
-            if payload_type in {"response.done", "response.listen"} and (
-                actor.closing or session.state == DuplexSessionState.CLOSED
-            ):
-                return False, None
-        elif actor._is_stale_model_output(payload):
-            return False, None
+    # ------------------------------------------------------------------ #
+    # Handshake                                                           #
+    # ------------------------------------------------------------------ #
 
-        if payload_type == "session.closed":
-            actor.close_reason = actor.close_reason or str(payload.get("reason") or "closed")
-            if session is not None:
-                session.mark_closing()
-
-        if not is_terminal or session is None:
-            return True, None
-
-        terminal_status = payload.get("status")
-        terminal_status_details = payload.get("status_details")
-        if terminal_status is None and isinstance(terminal_status_details, dict):
-            terminal_status = terminal_status_details.get("type")
-        response_terminal = payload_type == "response.done" or (
-            payload_type == "response.listen" and session.active_response_id is not None
-        )
-        can_promote_overlap = response_terminal and terminal_status not in {"cancelled", "failed"}
-        deferred_overlap_payload: dict[str, object] | None = None
-        continuous_input_crosses_terminal = (
-            can_promote_overlap
-            and realtime_protocol is not None
-            and self._session_auto_responds(session)
-            and native.input_since_commit
-            and not native.deferred_response_create
-        )
-        if continuous_input_crosses_terminal:
-            # Auto-response is a model-owned continuous stream. A response
-            # terminal advances the model turn without requiring the browser
-            # to close its Realtime input item. Keep any partial model unit so
-            # later PCM can complete it. Serving does not create or promote a
-            # new model generation here; Stage0 advances generation identity
-            # only after the model's terminal token.
-            session.reset_overlap_speech()
-            return True, None
-        realtime_input_still_open = (
-            can_promote_overlap
-            and realtime_protocol is not None
-            and native.input_since_commit
-            and not native.deferred_response_create
-        )
-        if realtime_input_still_open:
-            # response.done only closes the assistant response. It does not
-            # close the current Realtime input item, and it does not reserve
-            # or advance a model generation.
-            session.reset_overlap_speech()
-            return True, None
-        if can_promote_overlap and session.overlap_speech_ms > 0:
-            has_deferred_overlap = native.audio_buffer.has_pending() or native.committed_audio_payload is not None
-            should_promote_overlap = (
-                session.state == DuplexSessionState.OPEN
-                and self._uses_native_input_append(session)
-                and has_deferred_overlap
-                and session.overlap_speech_ms > session.config.overlap_short_ack_ms
-            )
-            if should_promote_overlap:
-                flushed_reserved_bytes = native.audio_buffer.pending_byte_count
-                deferred_overlap_payload = native.audio_buffer.flush(
-                    chunk_period_ms=session.capabilities.chunk_period_ms or 1000
-                )
-                if native.committed_audio_payload is not None:
-                    if deferred_overlap_payload is not None:
-                        deferred_overlap_payload = self._merge_native_audio_payloads(
-                            native.committed_audio_payload,
-                            deferred_overlap_payload,
-                        )
-                    else:
-                        deferred_overlap_payload = native.committed_audio_payload
-                if self._session_auto_responds(session) and deferred_overlap_payload is not None:
-                    deferred_overlap_payload = dict(deferred_overlap_payload)
-                    deferred_overlap_payload["force_listen"] = False
-                if deferred_overlap_payload is not None:
-                    native.retain_committed_audio(
-                        deferred_overlap_payload,
-                        operation_id=native.committed_audio_operation_id,
-                        reserved_bytes=flushed_reserved_bytes,
-                    )
-                native.input_since_commit = deferred_overlap_payload is not None
-                if realtime_protocol is not None:
-                    native.deferred_response_create = True
-                    native.deferred_precreate_response = False
-                    deferred_overlap_payload = None
-            else:
-                had_pending_overlap_audio = native.audio_buffer.has_pending()
-                native.audio_buffer.clear()
-                native.input_since_commit = False
-                native.speech_since_commit = False
-                if had_pending_overlap_audio and realtime_protocol is not None:
-                    await realtime_protocol.discard_pending_input_audio(audio_end_ms=session.overlap_speech_ms)
-                if payload_type in {"audio.cancelled", "input.cancelled", "session.closed"}:
-                    session.release_input_bytes(native.clear_committed_audio())
-
-        session.reset_overlap_speech()
-        if can_promote_overlap and native.deferred_response_create and native.committed_audio_payload is not None:
-            deferred_overlap_payload = native.committed_audio_payload
-            native.deferred_response_create = False
-            native.input_since_commit = False
-            native.speech_since_commit = False
-        return True, deferred_overlap_payload
-
-    @staticmethod
-    def _advance_barge_in_epoch(session: DuplexSession) -> tuple[int, dict[str, int]]:
-        old_playback = session.playback.as_dict()
-        new_epoch = session.barge_in()
-        session.clear_playback_cursor()
-        return new_epoch, old_playback
-
-    @staticmethod
-    def _commit_played_response_history(
-        session: DuplexSession,
-        response_id: str | None,
-        committed_ms: int,
-    ) -> None:
-        if not response_id or committed_ms < 0:
-            return
-        session.truncate_history_item(
-            f"item_{response_id}",
-            audio_end_ms=committed_ms,
-            playback=session.playback_for_response(response_id),
-        )
-
-    @staticmethod
-    def _should_commit_response_to_history(session: DuplexSession, response_id: str | None) -> bool:
-        if response_id is not None and response_id != session.active_response_id:
-            return True
-        mode = session.response_config.extra_body.get("realtime_response_conversation")
-        return not isinstance(mode, str) or mode.strip().lower() != "none"
-
-    def _response_created_payload(
-        self,
-        session: DuplexSession,
-        response_id: str,
-        *,
-        epoch: int,
-        request_id: str | None = None,
-    ) -> dict[str, object]:
-        response_config = session.response_config
-        payload: dict[str, object] = {
-            "type": "response.created",
-            "session_id": session.session_id,
-            "response_id": response_id,
-            "epoch": epoch,
-            "modalities": list(response_config.modalities),
-        }
-        if request_id is not None:
-            payload["request_id"] = request_id
-        metadata = response_config.extra_body.get("realtime_response_metadata")
-        if not isinstance(metadata, dict):
-            metadata = response_config.extra_body.get("realtime_metadata")
-        if isinstance(metadata, dict):
-            payload["metadata"] = dict(metadata)
-        conversation = response_config.extra_body.get("realtime_response_conversation")
-        if isinstance(conversation, str):
-            payload["conversation"] = conversation
-        prompt = response_config.extra_body.get("realtime_response_prompt")
-        if isinstance(prompt, dict):
-            payload["prompt"] = dict(prompt)
-        return payload
-
-    def _overlap_decision(
-        self,
-        session: DuplexSession,
-        event: dict[str, object],
-        payload: dict[str, object],
-    ) -> dict[str, object]:
-        """Classify input that arrives while assistant audio is active.
-
-        This is a serving-side policy. The model still owns listen/speak
-        decisions for normal chunks; overlap policy only decides whether the
-        current assistant response should be interrupted before the new audio is
-        appended.
-        """
-        duration_ms = self._input_audio_duration_ms(event, payload)
-        is_speech = self._input_looks_like_speech(event, payload, session=session)
-        if not session.capabilities.supports_barge_in and self._event_requests_barge_in(event):
-            return self._defer_unsupported_barge_in(session, duration_ms=duration_ms, is_speech=is_speech)
-        explicit = event.get("overlap_action") or event.get("overlap")
-        if isinstance(explicit, str):
-            normalized = explicit.strip().lower()
-            if normalized in {"barge_in", "interrupt", "cancel"}:
-                return {
-                    "action": "barge_in",
-                    "reason": "client_overlap_action",
-                    "duration_ms": duration_ms,
-                    "buffer_audio": True,
-                }
-            if normalized in {"listen", "continue", "continue_output", "ack"}:
-                session.reset_overlap_speech()
-                return {
-                    "action": "listen",
-                    "reason": "client_overlap_action",
-                    "duration_ms": duration_ms,
-                    "buffer_audio": (
-                        normalized == "listen" and is_speech and duration_ms > session.config.overlap_short_ack_ms
-                    ),
-                    "defer_runtime_append": True,
-                }
-            if normalized in {"drop", "ignore", "silence"}:
-                session.reset_overlap_speech()
-                return {
-                    "action": "drop",
-                    "reason": "client_overlap_action",
-                    "duration_ms": duration_ms,
-                    "buffer_audio": False,
-                }
-
-        if bool(event.get("force_barge_in", False)):
-            return {
-                "action": "barge_in",
-                "reason": "client_force_barge_in",
-                "duration_ms": duration_ms,
-                "buffer_audio": True,
-            }
-        if self._session_auto_responds(session):
-            # Full-duplex input remains model-owned while output is active. Feed
-            # complete model units into the existing Stage0 stream immediately;
-            # playback only controls history ACKs, not model admission.
-            if is_speech:
-                session.accumulate_overlap_speech(duration_ms)
-            vad_speech_started = self._vad_speech_started(event, payload)
-            if (
-                self._uses_native_input_append(session)
-                and session.capabilities.supports_barge_in
-                and is_speech
-                and session.config.overlap_policy == DuplexOverlapPolicy.BARGE_IN_ON_SPEECH.value
-                and vad_speech_started is not False
-            ):
-                return {
-                    "action": "barge_in",
-                    "reason": ("server_vad_speech_started" if vad_speech_started is True else "barge_in_on_speech"),
-                    "cancel_reason": "turn_detected" if vad_speech_started is True else "barge_in",
-                    "duration_ms": duration_ms,
-                    "overlap_speech_ms": session.overlap_speech_ms,
-                    "buffer_audio": True,
-                }
-            return {
-                "action": "listen",
-                "reason": "auto_response_continuous",
-                "duration_ms": duration_ms,
-                "overlap_speech_ms": session.overlap_speech_ms,
-                "buffer_audio": True,
-                "defer_runtime_append": False,
-                "force_listen": event.get("force_listen") is True or payload.get("force_listen") is True,
-                "preserve_realtime_input": True,
-            }
-        if bool(event.get("force_listen", False)):
-            session.reset_overlap_speech()
-            return {
-                "action": "listen",
-                "reason": "client_force_listen",
-                "duration_ms": duration_ms,
-                "buffer_audio": is_speech,
-                "defer_runtime_append": True,
-            }
-
-        policy = session.config.overlap_policy
-        if not is_speech:
-            if session.overlap_speech_ms <= 0:
-                session.reset_overlap_speech()
-            return {
-                "action": "drop",
-                "reason": "silence_or_noise",
-                "duration_ms": duration_ms,
-                "overlap_speech_ms": session.overlap_speech_ms,
-                "buffer_audio": False,
-            }
-
-        if self._is_short_ack_transcript_hint(event, payload):
-            session.reset_overlap_speech()
-            return {
-                "action": "listen",
-                "reason": "short_ack_transcript",
-                "duration_ms": duration_ms,
-                "overlap_speech_ms": session.overlap_speech_ms,
-                "buffer_audio": False,
-                "defer_runtime_append": True,
-            }
-
-        if policy == DuplexOverlapPolicy.LISTEN_ONLY.value:
-            session.accumulate_overlap_speech(duration_ms)
-            return {
-                "action": "listen",
-                "reason": "policy_listen_only",
-                "duration_ms": duration_ms,
-                "overlap_speech_ms": session.overlap_speech_ms,
-                "buffer_audio": True,
-                "defer_runtime_append": True,
-            }
-
-        if policy == DuplexOverlapPolicy.BARGE_IN_ON_SPEECH.value and not session.capabilities.supports_barge_in:
-            return self._defer_unsupported_barge_in(session, duration_ms=duration_ms, is_speech=True)
-
-        session.accumulate_overlap_speech(duration_ms)
-        if policy == DuplexOverlapPolicy.BARGE_IN_ON_SPEECH.value:
-            vad_speech_started = self._vad_speech_started(event, payload)
-            if vad_speech_started is False:
-                return {
-                    "action": "listen",
-                    "reason": "server_vad_utterance_active",
-                    "duration_ms": duration_ms,
-                    "overlap_speech_ms": session.overlap_speech_ms,
-                    "buffer_audio": True,
-                    "defer_runtime_append": False,
-                    "force_listen": True,
-                    "preserve_realtime_input": True,
-                }
-            return {
-                "action": "barge_in",
-                "reason": ("server_vad_speech_started" if vad_speech_started is True else "policy_barge_in_on_speech"),
-                "cancel_reason": "turn_detected" if vad_speech_started is True else "barge_in",
-                "duration_ms": duration_ms,
-                "overlap_speech_ms": session.overlap_speech_ms,
-                "buffer_audio": True,
-            }
-
-        if (
-            duration_ms <= session.config.overlap_short_ack_ms
-            and session.overlap_speech_ms <= session.config.overlap_short_ack_ms
-        ):
-            return {
-                "action": "listen",
-                "reason": "short_ack",
-                "duration_ms": duration_ms,
-                "overlap_speech_ms": session.overlap_speech_ms,
-                "buffer_audio": True,
-                "defer_runtime_append": True,
-            }
-        if session.overlap_speech_ms >= session.config.overlap_barge_in_ms:
-            if not session.capabilities.supports_barge_in:
-                return {
-                    "action": "listen",
-                    "reason": "barge_in_unsupported",
-                    "duration_ms": duration_ms,
-                    "overlap_speech_ms": session.overlap_speech_ms,
-                    "buffer_audio": True,
-                    "defer_runtime_append": True,
-                }
-            return {
-                "action": "barge_in",
-                "reason": "long_overlap_speech",
-                "duration_ms": duration_ms,
-                "overlap_speech_ms": session.overlap_speech_ms,
-                "buffer_audio": True,
-            }
-        return {
-            "action": "listen",
-            "reason": "accumulating_overlap_speech",
-            "duration_ms": duration_ms,
-            "overlap_speech_ms": session.overlap_speech_ms,
-            "buffer_audio": True,
-            "defer_runtime_append": True,
-        }
-
-    @staticmethod
-    def _vad_speech_started(
-        event: Mapping[str, object],
-        payload: Mapping[str, object],
-    ) -> bool | None:
-        for source in (event, payload):
-            vad = source.get("vad")
-            if isinstance(vad, Mapping) and isinstance(vad.get("speech_started"), bool):
-                return bool(vad["speech_started"])
-        return None
-
-    @staticmethod
-    def _event_requests_barge_in(event: Mapping[str, object]) -> bool:
-        if event.get("force_barge_in") is True:
-            return True
-        explicit = event.get("overlap_action") or event.get("overlap")
-        return isinstance(explicit, str) and explicit.strip().lower() in {
-            "barge_in",
-            "interrupt",
-            "cancel",
-        }
-
-    @staticmethod
-    def _defer_unsupported_barge_in(
-        session: DuplexSession,
-        *,
-        duration_ms: int,
-        is_speech: bool,
-    ) -> dict[str, object]:
-        if is_speech:
-            session.accumulate_overlap_speech(duration_ms)
-        return {
-            "action": "listen",
-            "reason": "barge_in_unsupported",
-            "duration_ms": duration_ms,
-            "overlap_speech_ms": session.overlap_speech_ms,
-            "buffer_audio": is_speech,
-            "defer_runtime_append": True,
-        }
-
-    @staticmethod
-    def _barge_in_unsupported_error(session: DuplexSession) -> dict[str, object]:
-        return {
-            "type": "error",
-            "session_id": session.session_id,
-            "code": "barge_in_unsupported",
-            "error": "Barge-in is not supported by this duplex model",
-        }
-
-    @staticmethod
-    def _is_short_ack_transcript_hint(event: dict[str, object], payload: dict[str, object]) -> bool:
-        raw_text = event.get("transcript") or event.get("text") or payload.get("transcript") or payload.get("text")
-        if not isinstance(raw_text, str):
-            return False
-        normalized = raw_text.strip().lower()
-        if not normalized:
-            return False
-        compact = "".join(ch for ch in normalized if ch.isalnum() or "\u4e00" <= ch <= "\u9fff")
-        if compact in {
-            "嗯",
-            "嗯嗯",
-            "对",
-            "对的",
-            "好",
-            "好的",
-            "继续",
-            "继续说",
-            "可以",
-            "是的",
-            "yes",
-            "yeah",
-            "yep",
-            "ok",
-            "okay",
-            "continue",
-            "goon",
-            "right",
-        }:
-            return True
-        return normalized in {"go on", "keep going", "please continue"}
-
-    @staticmethod
-    def _input_audio_duration_ms(event: dict[str, object], payload: dict[str, object]) -> int:
-        for key in ("duration_ms", "audio_duration_ms"):
-            value = event.get(key)
-            if isinstance(value, int | float):
-                return max(0, int(value))
-        fmt = payload.get("format")
-        sample_rate_hz = payload.get("sample_rate_hz")
-        audio = payload.get("audio")
-        if fmt == "pcm_f32le" and isinstance(sample_rate_hz, int) and sample_rate_hz > 0 and isinstance(audio, str):
-            try:
-                raw = base64.b64decode(audio, validate=True)
-            except (binascii.Error, ValueError):
-                return 0
-            return int((len(raw) // 4) * 1000 / sample_rate_hz)
-        return 0
-
-    @staticmethod
-    def _merge_native_audio_payloads(
-        first: dict[str, object],
-        second: dict[str, object],
-    ) -> dict[str, object]:
-        if first.get("format") != "pcm_f32le" or second.get("format") != "pcm_f32le":
-            return second
-        first_rate = first.get("sample_rate_hz")
-        second_rate = second.get("sample_rate_hz")
-        if not isinstance(first_rate, int) or not isinstance(second_rate, int) or first_rate != second_rate:
-            return second
-        first_audio = first.get("audio")
-        second_audio = second.get("audio")
-        if not isinstance(first_audio, str) or not isinstance(second_audio, str):
-            return second
-        try:
-            first_raw = base64.b64decode(first_audio, validate=True)
-            second_raw = base64.b64decode(second_audio, validate=True)
-        except (binascii.Error, ValueError):
-            return second
-        merged = dict(second)
-        merged["audio"] = base64.b64encode(first_raw + second_raw).decode("ascii")
-        merged["sample_rate_hz"] = first_rate
-        merged_frames = [
-            frame
-            for source in (first.get("video_frames"), second.get("video_frames"))
-            if isinstance(source, list)
-            for frame in source
-            if isinstance(frame, str) and frame
-        ]
-        if merged_frames:
-            merged["video_frames"] = merged_frames
-        else:
-            merged.pop("video_frames", None)
-        merged["force_listen"] = bool(first.get("force_listen", False)) or bool(second.get("force_listen", False))
-        merged.pop("force_speak", None)
-        merged["is_speech"] = bool(first.get("is_speech", False)) or bool(second.get("is_speech", False))
-        return merged
-
-    @classmethod
-    def _should_force_listen_for_short_commit(
-        cls,
-        session: DuplexSession,
-        event: dict[str, object],
-        payload: dict[str, object],
-    ) -> bool:
-        """Keep very short committed Realtime chunks in listen mode.
-
-        Realtime VAD can emit a commit for a short pause even when the user has
-        not actually yielded the turn. For MiniCPM-o native duplex, make that
-        policy explicit by steering the scheduler path to the model listen
-        token instead of letting a sub-second chunk start a response.
-        """
-        if event.get("force_listen") is True or payload.get("force_listen") is True:
-            return True
-        if event.get("force_barge_in") is True:
-            return False
-        if event.get("response_create") is not True:
-            return False
-        duration_ms = cls._input_audio_duration_ms(event, payload)
-        return 0 < duration_ms <= session.config.overlap_short_ack_ms
-
-    def _create_runtime_session_state(self) -> ServingRuntimeSessionState:
-        adapter = self._serving_runtime_adapter
-        if adapter is not None:
-            return adapter.create_session_state()
-        return TurnBasedServingSessionState()
-
-    def _runtime_session_state(self, session: DuplexSession) -> ServingRuntimeSessionState:
-        adapter = self._serving_runtime_adapter
-        if adapter is not None:
-            return adapter.session_state(session.session_id)
-        state = self._serving_session_states.get(session.session_id)
-        if state is None:
-            state = TurnBasedServingSessionState()
-            self._serving_session_states[session.session_id] = state
-        return state
-
-    def _require_serving_runtime_adapter(self) -> ServingRuntimeAdapter:
-        adapter = self._serving_runtime_adapter
-        if adapter is None:
-            raise RuntimeError("Model-native duplex runtime is not configured for this session")
-        return adapter
-
-    def _should_force_listen_for_auto_response_overlap(
-        self,
-        session: DuplexSession,
-        event: dict[str, object],
-        payload: dict[str, object],
-    ) -> bool:
-        if not self._session_auto_responds(session):
-            return False
-        if event.get("force_barge_in") is True:
-            return False
-        return event.get("force_listen") is True or payload.get("force_listen") is True
-
-    @staticmethod
-    def _assistant_playback_active(session: DuplexSession) -> bool:
-        return (
-            session.config.playback_commit_policy == DuplexPlaybackCommitPolicy.ACK_ONLY.value
-            and session.playback.sent_ms > session.playback.committed_ms
-        )
-
-    @staticmethod
-    def _input_looks_like_speech(
-        event: dict[str, object],
-        payload: dict[str, object],
-        *,
-        session: DuplexSession,
-    ) -> bool:
-        # Prefer serving-derived fields in ``payload`` over optional client
-        # hints retained in ``event``. In server-VAD mode the pipeline, rather
-        # than the client or the RMS fallback below, owns speech classification.
-        for source in (payload, event):
-            for key in ("is_speech", "speech"):
-                value = source.get(key)
-                if isinstance(value, bool):
-                    return value
-            vad = source.get("vad")
-            if isinstance(vad, dict):
-                value = vad.get("is_speech")
-                if isinstance(value, bool):
-                    return value
-                probability = vad.get("speech_probability", vad.get("probability"))
-                if isinstance(probability, int | float):
-                    return float(probability) >= 0.5
-            probability = source.get("speech_probability")
-            if isinstance(probability, int | float):
-                return float(probability) >= 0.5
-
-        fmt = payload.get("format")
-        audio = payload.get("audio")
-        if fmt in {"pcm_f32le", "pcm16"} and isinstance(audio, str):
-            try:
-                raw = base64.b64decode(audio, validate=True)
-            except (binascii.Error, ValueError):
-                return True
-            if fmt == "pcm_f32le":
-                if len(raw) < 4 or len(raw) % 4 != 0:
-                    return True
-                samples = np.frombuffer(raw, dtype=np.float32)
-            else:
-                if len(raw) < 2 or len(raw) % 2 != 0:
-                    return True
-                samples = np.frombuffer(raw, dtype=np.int16).astype(np.float32) / 32768.0
-            if samples.size == 0:
-                return False
-            rms = float(np.sqrt(np.mean(np.square(samples.astype(np.float32)))))
-            return rms >= session.config.overlap_silence_rms
-        return True
-
-    async def _emit_overlap_decision(
-        self,
-        send_json,
-        session: DuplexSession,
-        decision: dict[str, object],
-    ) -> None:
-        await send_json(
-            {
-                "type": "overlap.decision",
-                "session_id": session.session_id,
-                "epoch": session.epoch,
-                "policy": session.config.overlap_policy,
-                **decision,
-            }
-        )
-
-    async def _open_session(
+    async def _open(
         self,
         websocket: WebSocket,
-        send_json,
-        *,
-        realtime_protocol: NativeRealtimeSessionProtocol | None = None,
-        attachment_send=None,
-        attachment_close=None,
-    ) -> _DuplexSessionHandshake | None:
-        raw = await self._receive_text(
-            websocket,
-            self._config_timeout_s,
-            realtime_protocol=realtime_protocol,
-        )
-        if raw is None:
-            await send_json({"type": "error", "error": "Timeout waiting for session.create", "code": "config_timeout"})
-            return None
+        envelope: RealtimeEnvelope,
+        session_payload: Mapping[str, object],
+        send_json: SendJson,
+    ) -> _Attachment | None:
+        # Any ``session_id`` / ``id`` in the payload is ignored: the server
+        # allocates the id and announces it in ``session.created``.
         try:
-            event = json.loads(raw)
-        except json.JSONDecodeError:
-            await send_json({"type": "error", "error": "Invalid JSON in session.create", "code": "invalid_json"})
+            handle = await self._omni.open_session(session_payload)
+        except DuplexSessionError as exc:
+            await send_json(envelope.error_payload(exc.code, str(exc)))
             return None
-        if isinstance(event, dict) and event.get("type") == "session.resume":
-            if realtime_protocol is None:
-                await send_json(
-                    {
-                        "type": "error",
-                        "error": "session.resume requires the Realtime protocol",
-                        "code": "unsupported_session_resume",
-                    }
-                )
-                return None
-            return await self._resume_session_handshake(
-                event,
-                send_json=send_json,
-                realtime_protocol=realtime_protocol,
-                attachment_send=attachment_send,
-                attachment_close=attachment_close,
-            )
-        if not isinstance(event, dict) or event.get("type") not in {"session.create", "open_session", "session.config"}:
-            await send_json(
-                {
-                    "type": "error",
-                    "error": f"Expected session.create, got: {event.get('type') if isinstance(event, dict) else None}",
-                    "code": "bad_event",
-                }
-            )
+        except (TypeError, ValueError) as exc:
+            await send_json(envelope.error_payload("invalid_session_config", str(exc)))
             return None
-
-        try:
-            config = DuplexSessionConfig.from_event(event)
-        except ValueError as exc:
-            error: dict[str, object] = {
-                "type": "error",
-                "error": str(exc),
-                "code": "invalid_request_error",
-            }
-            event_id = event.get("_realtime_event_id")
-            if isinstance(event_id, str) and event_id:
-                error["event_id"] = event_id
-            await send_json(error)
-            return None
-        if config.idle_timeout_s == _DEFAULT_IDLE_TIMEOUT_S:
-            config.idle_timeout_s = self._idle_timeout_s
-        runtime_adapter = self._serving_runtime_adapter if self._uses_serving_runtime_adapter(config) else None
-        runtime_config: dict[str, object] = {}
-        if runtime_adapter is not None:
-            try:
-                runtime_config = await runtime_adapter.prepare_runtime_config(
-                    config,
-                    model_config=getattr(self._chat_service, "model_config", None),
-                )
-            except ServingRuntimeConfigError as exc:
-                await send_json({"type": "error", "error": str(exc), "code": exc.code})
-                return None
-            except ValueError as exc:
-                await send_json({"type": "error", "error": str(exc), "code": "unsupported_ref_audio_path"})
-                return None
-        session_id = event.get("session_id") if isinstance(event.get("session_id"), str) else None
-        session = self._registry.create(config=config, session_id=session_id)
-        if runtime_adapter is not None:
-            session.replace_capabilities(
-                runtime_adapter.capabilities(max_sessions=self._duplex_session_config.max_sessions)
-            )
-            session.replace_runtime_config(runtime_config)
-        session_payload = event.get("session")
-        self._resolve_server_vad_defaults(
-            session, config, session_payload if isinstance(session_payload, dict) else event
-        )
-        event_id = event.get("_realtime_event_id")
-        return _DuplexSessionHandshake(
-            session=session,
-            event_id=event_id if isinstance(event_id, str) and event_id else None,
+        attachment_send, attachment_close = attachment_callbacks(websocket)
+        created = await self._attachment_registry.create(
+            handle.session_id,
+            send=attachment_send,
+            close=attachment_close,
         )
+        resume_supported = bool(handle.capabilities.supports_session_resume)
+        attachment = _Attachment(handle=handle, generation=created.attachment_generation)
+        credentials: _ResumeCredentials | None = None
+        if resume_supported:
+            credentials = _ResumeCredentials(
+                attachment_generation=created.attachment_generation,
+                resume_token=created.resume_token.plaintext,
+            )
+        self._start_pump(handle, credentials)
+        return attachment
 
-    async def _resume_session_handshake(
+    async def _resume(
         self,
-        event: dict[str, object],
-        *,
-        send_json,
-        realtime_protocol: NativeRealtimeSessionProtocol,
-        attachment_send,
-        attachment_close,
-    ) -> _DuplexSessionHandshake | None:
-        session_id = event.get("session_id")
-        incarnation = event.get("incarnation")
-        resume_token = event.get("resume_token")
-        last_received = event.get("last_received_server_event_seq", 0)
-        if (
-            not isinstance(session_id, str)
-            or not session_id
-            or not isinstance(incarnation, int)
-            or incarnation < 0
-            or not isinstance(resume_token, str)
-            or not resume_token
-            or not isinstance(last_received, int)
-            or last_received < 0
-        ):
+        websocket: WebSocket,
+        envelope: RealtimeEnvelope,
+        event: Mapping[str, object],
+        send_json: SendJson,
+    ) -> _Attachment | None:
+        request = parse_resume_request(event)
+        if request is None:
             await send_json(
-                {
-                    "type": "error",
-                    "error": (
-                        "session.resume requires session_id, incarnation, resume_token, "
-                        "and a non-negative event sequence"
-                    ),
-                    "code": "invalid_session_resume",
-                }
+                envelope.error_payload(
+                    "invalid_session_resume",
+                    "session.resume requires session_id, resume_token, and a non-negative event sequence",
+                )
             )
             return None
-        session = self._registry.get(session_id)
-        if session is None or session.state != DuplexSessionState.OPEN:
+        session_id = request.session_id
+        handle = self._omni.get_session(session_id)
+        if handle is None or handle.closed:
             await send_json(
-                {
-                    "type": "error",
-                    "error": f"Unknown or expired duplex session: {session_id}",
-                    "code": "session_resume_expired",
-                }
+                envelope.error_payload("session_resume_expired", f"Unknown or expired duplex session: {session_id}")
             )
             return None
-        if not session.capabilities.supports_session_resume:
+        if not handle.capabilities.supports_session_resume:
             await send_json(
-                {
-                    "type": "error",
-                    "error": f"Session does not support resume: {session_id}",
-                    "code": "unsupported_session_resume",
-                }
+                envelope.error_payload("unsupported_session_resume", f"Session does not support resume: {session_id}")
             )
             return None
         try:
             await self._attachment_registry.authenticate_resume(
                 session_id,
-                incarnation=incarnation,
-                resume_token=resume_token,
-                last_received_server_event_seq=last_received,
+                resume_token=request.resume_token,
+                last_received_server_event_seq=request.last_received_server_event_seq,
             )
         except InvalidResumeTokenError:
-            await send_json(
-                {
-                    "type": "error",
-                    "error": "Invalid duplex session resume token",
-                    "code": "invalid_resume_token",
-                }
-            )
+            await send_json(envelope.error_payload("invalid_resume_token", "Invalid duplex session resume token"))
             return None
         except DuplexJournalGapError:
-            await send_json(
-                {
-                    "type": "session.resync_required",
-                    "session_id": session_id,
-                    "reason": "journal_gap",
-                }
-            )
+            await send_json(SessionResyncRequired(session_id=session_id, reason="journal_gap").to_realtime())
             return None
         except (KeyError, ValueError) as exc:
-            await send_json(
-                {
-                    "type": "error",
-                    "error": str(exc),
-                    "code": "session_resume_conflict",
-                }
-            )
+            await send_json(envelope.error_payload("session_resume_conflict", str(exc)))
             return None
-
-        resume_runtime = getattr(self._chat_service.engine_client, "resume_duplex_session_async", None)
-        if not callable(resume_runtime):
-            await send_json(
-                {
-                    "type": "error",
-                    "error": "Duplex runtime does not expose session resume control",
-                    "code": "runtime_resume_unsupported",
-                }
-            )
-            return None
-        expected_generation = self._lease_generations.get(session_id, 0)
         try:
-            runtime_result = await resume_runtime(
+            await self._omni.resume_session(
                 session_id,
-                fence=DuplexFence(
-                    session.session_id,
-                    epoch=session.epoch,
-                    turn_id=session.turn_id,
-                    incarnation=session.incarnation,
-                ),
-                expected_lease_generation=expected_generation,
-            )
-            lease_generation = self._runtime_lease_generation(runtime_result)
-            if lease_generation is None:
-                raise RuntimeError("runtime resume result omitted lease_generation")
-        except Exception as exc:
-            await send_json(
-                {
-                    "type": "error",
-                    "error": str(exc),
-                    "code": "runtime_resume_failed",
-                }
+                expected_lease_generation=handle.lease_generation,
             )
+        except DuplexSessionError as exc:
+            await send_json(envelope.error_payload("runtime_resume_failed", str(exc)))
             return None
 
-        if not callable(attachment_send) or not callable(attachment_close):
-            raise RuntimeError("session.resume requires transport attachment callbacks")
+        attachment_send, attachment_close = attachment_callbacks(websocket)
 
-        def activation_payload_factory(token, generation: int) -> dict[str, object]:
-            internal = {
-                "type": "session.resumed",
-                "session_id": session_id,
-                "incarnation": incarnation,
-                "attachment_generation": generation,
-                "resume_token": token.plaintext,
-            }
-            return realtime_protocol.encode_outbound_event(internal)[0]
+        def activation_payload_factory(token: ResumeToken, generation: int) -> dict[str, object]:
+            return SessionResumed(
+                session_id=session_id,
+                session=dict(handle.public_session),
+                attachment_generation=generation,
+                resume_token=token.plaintext,
+            ).to_realtime()
 
         try:
             resumed = await self._attachment_registry.resume(
                 session_id,
-                incarnation=incarnation,
-                resume_token=resume_token,
-                last_received_server_event_seq=last_received,
+                resume_token=request.resume_token,
+                last_received_server_event_seq=request.last_received_server_event_seq,
                 send=attachment_send,
                 close=attachment_close,
                 activation_payload_factory=activation_payload_factory,
             )
         except Exception as exc:
-            # The engine-side CAS already advanced even if the transport
-            # vanished before it received the rotated token. Keep that
-            # generation so the registry's one-shot recovery token can retry.
-            self._lease_generations[session_id] = lease_generation
-            await send_json(
-                {
-                    "type": "error",
-                    "error": str(exc),
-                    "code": "session_resume_conflict",
-                }
-            )
+            # The engine lease was already resumed above, so a failed activation
+            # would leave the session attached to nothing -- unless another
+            # connection won the race and is attached right now. Detaching then
+            # would start the disconnect grace for the *winner*, which ordinary
+            # heartbeats do not clear. Roll back only what this attempt owns.
+            if not await self._attachment_registry.has_attachment(session_id):
+                with suppress(DuplexSessionError):
+                    await self._omni.detach_session(session_id)
+            await send_json(envelope.error_payload("session_resume_conflict", str(exc)))
             return None
-        self._lease_generations[session_id] = lease_generation
         replaced = resumed.replaced_attachment
         if replaced is not None:
-            replaced_payload = realtime_protocol.encode_outbound_event(
-                {
-                    "type": "session.replaced",
-                    "session_id": session_id,
-                    "attachment_generation": replaced.generation,
-                }
-            )[0]
             with suppress(Exception):
-                await replaced.send(replaced_payload)
+                await replaced.send(
+                    SessionReplaced(session_id=session_id, attachment_generation=replaced.generation).to_realtime()
+                )
             with suppress(Exception):
                 await replaced.close("session_replaced")
-        return _DuplexSessionHandshake(
-            session=session,
-            resumed=True,
-            attachment_generation=resumed.attachment_generation,
-        )
+        # A reconnect brings a fresh envelope carrying pcm16/16 kHz wire
+        # defaults. The negotiated input format is a wire default, not part of
+        # the public session object, so it has to be carried over explicitly:
+        # otherwise the first append that omits format/rate is decoded as pcm16.
+        remembered = self._input_defaults.get(session_id)
+        if remembered is not None:
+            envelope.defaults = remembered
+        self._start_pump(handle, None)
+        return _Attachment(handle=handle, generation=resumed.attachment_generation)
 
-    @classmethod
-    def _runtime_lease_generation(cls, result: object) -> int | None:
-        if isinstance(result, dict):
-            generation = result.get("lease_generation")
-            if isinstance(generation, int):
-                return generation
-            for key in ("stage_results", "result"):
-                generation = cls._runtime_lease_generation(result.get(key))
-                if generation is not None:
-                    return generation
-            return None
-        if isinstance(result, list | tuple):
-            for item in result:
-                generation = cls._runtime_lease_generation(item)
-                if generation is not None:
-                    return generation
-        return None
+    # ------------------------------------------------------------------ #
+    # Outbound pump (session-scoped, survives reconnects)                #
+    # ------------------------------------------------------------------ #
 
-    def _uses_serving_runtime_adapter(self, config: DuplexSessionConfig) -> bool:
-        adapter = self._serving_runtime_adapter
-        return adapter is not None and adapter.is_enabled(config)
-
-    def _runtime_session_update_error(
-        self,
-        session: DuplexSession,
-        payload: dict[str, object],
-    ) -> dict[str, object] | None:
-        if not self._uses_native_input_append(session):
-            return None
-        try:
-            self._require_serving_runtime_adapter().validate_client_extra_body(payload.get("extra_body"))
-        except ServingRuntimeConfigError as exc:
-            return {
-                "type": "error",
-                "session_id": session.session_id,
-                "code": exc.code,
-                "error": str(exc),
-            }
-        return None
-
-    def _runtime_config_for_session_update(
-        self,
-        session: DuplexSession,
-        candidate_config: DuplexSessionConfig,
-    ) -> dict[str, object]:
-        if not self._uses_native_input_append(session):
-            return dict(session.runtime_config)
-        return self._require_serving_runtime_adapter().runtime_config_for_update(
-            candidate_config,
-            dict(session.runtime_config),
-        )
-
-    def _resolve_server_vad_defaults(
-        self,
-        session: DuplexSession,
-        config: DuplexSessionConfig,
-        payload: dict[str, object],
-    ) -> None:
-        """Resolve omitted options without overriding explicit client policies."""
-        if config.server_vad is None:
+    def _start_pump(self, handle: DuplexSessionHandle, credentials: _ResumeCredentials | None) -> None:
+        existing = self._pumps.get(handle.session_id)
+        if existing is not None and not existing.done():
             return
-        if config.server_vad.interrupt_response is None:
-            config.server_vad = replace(config.server_vad, interrupt_response=self._uses_native_input_append(session))
-        extra = payload.get("extra_body")
-        overlap_policy = extra.get("overlap_policy") if isinstance(extra, dict) else None
-        if not isinstance(overlap_policy, str):
-            overlap_policy = payload.get("overlap_policy")
-        config.overlap_policy = (
-            overlap_policy
-            if isinstance(overlap_policy, str)
-            else "barge_in_on_speech"
-            if config.server_vad.interrupt_response
-            else "listen_only"
+        self._pumps[handle.session_id] = asyncio.create_task(
+            self._pump_events(handle, credentials),
+            name=f"duplex-session-pump-{handle.session_id}",
         )
 
-    def _runtime_session_candidate_update_error(
-        self,
-        session: DuplexSession,
-        candidate_config: DuplexSessionConfig,
-        *,
-        realtime_protocol: NativeRealtimeSessionProtocol | None = None,
-    ) -> dict[str, object] | None:
-        if candidate_config.server_vad is not None:
-            desired_policy = "barge_in_on_speech" if candidate_config.server_vad.interrupt_response else "listen_only"
-            if candidate_config.overlap_policy != desired_policy:
-                return {
-                    "type": "error",
-                    "code": "unsupported_turn_detection",
-                    "error": f"overlap_policy conflicts with turn_detection; expected {desired_policy!r}",
-                    "param": "overlap_policy",
-                }
-        if not self._uses_native_input_append(session):
-            if (
-                candidate_config.server_vad is not None
-                and candidate_config.server_vad.min_speech_duration_ms is not None
-            ):
-                return {
-                    "type": "error",
-                    "code": "unsupported_turn_detection",
-                    "error": "server_vad.min_speech_duration_ms is only supported by model-native duplex runtimes",
-                }
-            requests_interruption = (
-                candidate_config.server_vad is not None and candidate_config.server_vad.interrupt_response
-            ) or candidate_config.overlap_policy == DuplexOverlapPolicy.BARGE_IN_ON_SPEECH.value
-            if requests_interruption:
-                return {
-                    "type": "error",
-                    "code": "server_vad_requires_native_duplex",
-                    "error": (
-                        "Realtime server_vad interruption requires a model-native duplex runtime; "
-                        "set interrupt_response=false for turn-based models"
-                    ),
-                }
-            if candidate_config.server_vad is not None and realtime_protocol is not None:
-                session_payload = candidate_config.extra_body.get("realtime_session_payload")
-                audio_error = realtime_protocol.validate_server_vad_input_audio(
-                    session_payload if isinstance(session_payload, dict) else {}
-                )
-                if audio_error is not None:
-                    return {
-                        "type": "error",
-                        "code": "unsupported_turn_detection",
-                        "error": audio_error,
-                        "param": "audio.input.format",
-                    }
-            return None
-        if candidate_config.server_vad is not None:
-            if not candidate_config.server_vad.interrupt_response:
-                return {
-                    "type": "error",
-                    "session_id": session.session_id,
-                    "code": "unsupported_turn_detection",
-                    "error": "Model-native duplex server_vad requires interrupt_response=true",
-                }
-            if candidate_config.server_vad.threshold <= SILERO_VAD_MIN_THRESHOLD:
-                return {
-                    "type": "error",
-                    "session_id": session.session_id,
-                    "code": "unsupported_turn_detection",
-                    "error": (
-                        f"Model-native duplex server_vad.threshold must be greater than {SILERO_VAD_MIN_THRESHOLD}"
-                    ),
-                }
-            if not candidate_config.server_vad.create_response:
-                return {
-                    "type": "error",
-                    "session_id": session.session_id,
-                    "code": "unsupported_turn_detection",
-                    "error": "Model-native duplex server_vad requires create_response=true",
-                }
-        if (
-            candidate_config.instructions != session.config.instructions
-            and self._runtime_session_state(session).native_context_locked
-        ):
-            return {
-                "type": "error",
-                "session_id": session.session_id,
-                "code": "instructions_update_unsupported",
-                "error": "session.update cannot change instructions after the native duplex context is initialized",
-            }
-        if native_duplex_opt_in(session.config.extra_body) is not True:
-            return None
-        if not self._config_requests_audio_output(candidate_config):
-            return None
-        if "ref_audio_data" in session.runtime_config:
-            return None
-        return {
-            "type": "error",
-            "session_id": session.session_id,
-            "code": "ref_audio_required",
-            "error": "MiniCPM-o native duplex audio output requires ref_audio",
-        }
+    async def _pump_events(self, handle: DuplexSessionHandle, credentials: _ResumeCredentials | None) -> None:
+        session_id = handle.session_id
+        close_reason = "session_closed"
+        try:
+            async for event in handle.events():
+                if isinstance(event, SessionCreated) and credentials is not None:
+                    event = replace(
+                        event,
+                        attachment_generation=credentials.attachment_generation,
+                        resume_token=credentials.resume_token,
+                    )
+                await self._send_event(session_id, event)
+                if isinstance(event, SessionClosed):
+                    close_reason = event.reason or event.type
+                    break
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:
+            logger.exception("Duplex event pump failed for %s: %s", session_id, exc)
+        finally:
+            self._pumps.pop(session_id, None)
+            self._resync_required_sessions.discard(session_id)
+            self._input_defaults.pop(session_id, None)
+            attachment = None
+            with suppress(Exception):
+                attachment = await self._attachment_registry.close(session_id)
+            if attachment is not None:
+                with suppress(Exception):
+                    await attachment.close(close_reason)
 
-    @staticmethod
-    def _uses_native_input_append(session: DuplexSession) -> bool:
-        return (
-            session.capabilities.implementation_level == "model_native_duplex"
-            and session.capabilities.supports_input_append
-            and native_duplex_opt_in(session.config.extra_body) is not False
-        )
+    async def _drain_terminal_pump(self, attachment: _Attachment) -> None:
+        """Let the pump deliver ``session.closed`` before the endpoint returns.
 
-    @staticmethod
-    def _config_requests_audio_output(config: DuplexSessionConfig) -> bool:
-        return any(str(modality).lower() == "audio" for modality in config.modalities)
+        ``DuplexSessionHandle._deliver`` queues ``SessionClosed`` on the outbox
+        and marks the handle closed in the same synchronous step, so
+        ``handle.closed`` is already true while that event is still sitting in
+        the queue. ``_read_loop`` stops on exactly that flag: if the engine
+        closes the session between two reads, the loop returns, this endpoint
+        returns, and the ASGI server tears the socket down with the terminal
+        event unsent -- the client sees an abrupt close instead of
+        ``session.closed``. Waiting for the pump keeps the two in order; it is
+        the pump that sends the event and then closes with code 1000.
 
-    @staticmethod
-    def _native_stage0_request_id(session: DuplexSession, epoch: int) -> str:
-        return duplex_resource_request_id(
-            DuplexFence(
-                session.session_id,
-                epoch=epoch,
-                incarnation=session.incarnation,
-            ),
-            "stage0",
-        )
-
-    @staticmethod
-    def _session_auto_responds(session: DuplexSession) -> bool:
-        """Full-duplex / model-driven mode.
-
-        When set, the server runs per-chunk speak-generation continuously (like
-        the official MiniCPM-o ``duplex_generate`` loop) instead of waiting for an
-        explicit ``response.create``: each ~chunk_period of appended audio is
-        emitted and fed to the stage0 stream so the model itself decides to speak
-        or listen. Signaled by the client via ``extra_body.auto_response`` (or
-        ``extra_body.full_duplex``).
+        Only for a closed session. A takeover or a resumable disconnect leaves
+        the pump running for the next attachment, and must not be waited on.
         """
-        extra = getattr(session.config, "extra_body", None)
-        if not isinstance(extra, dict):
-            return False
-        return extra.get("auto_response") is True or extra.get("full_duplex") is True
+        if not attachment.handle.closed:
+            return
+        pump = self._pumps.get(attachment.handle.session_id)
+        if pump is None or pump.done():
+            return
+        # shield: a drain timeout must not cancel a pump that is still the
+        # session's only writer.
+        with suppress(Exception):
+            await asyncio.wait_for(asyncio.shield(pump), _PUMP_DRAIN_TIMEOUT_S)
 
-    async def _receive_text(
+    async def _send_event(self, session_id: str, event: DuplexEvent) -> None:
+        payload = event.to_realtime()
+        journal = not isinstance(event, _UNJOURNALED_EVENTS) and session_id not in self._resync_required_sessions
+        try:
+            try:
+                await self._attachment_registry.send_event(session_id, payload, journal=journal)
+            except DuplexJournalOverflowError:
+                first_overflow = session_id not in self._resync_required_sessions
+                self._resync_required_sessions.add(session_id)
+                if first_overflow:
+                    resync = SessionResyncRequired(session_id=session_id, reason="journal_overflow")
+                    await self._attachment_registry.send_event(session_id, resync.to_realtime(), journal=False)
+                await self._attachment_registry.send_event(session_id, payload, journal=False)
+        except KeyError:
+            # Attachment already closed (takeover or teardown); the journal is gone.
+            pass
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:
+            # The socket died mid-send. The session is alive in the engine:
+            # treat it as a disconnect of the current attachment (the pump
+            # keeps journaling for a resume) instead of tearing the session down.
+            logger.info("Duplex transport send failed for %s: %s", session_id, exc)
+            await self._detach_current_attachment(session_id)
+
+    async def _detach_current_attachment(self, session_id: str) -> None:
+        """Disconnect semantics for the socket currently attached to ``session_id``.
+
+        The pump is session-scoped and outlives any one connection, so it can
+        only name the session: the registry detaches whichever socket is
+        attached, which is the one whose send just failed.
+        """
+        handle = self._omni.get_session(session_id)
+        if handle is None or handle.closed:
+            return
+        if handle.capabilities.supports_session_resume:
+            if await self._attachment_registry.detach(session_id, attachment_generation=None):
+                with suppress(DuplexSessionError):
+                    await self._omni.detach_session(session_id)
+            return
+        with suppress(DuplexSessionError):
+            await handle.close(reason="disconnect")
+
+    # ------------------------------------------------------------------ #
+    # Inbound                                                             #
+    # ------------------------------------------------------------------ #
+
+    async def _read_loop(
         self,
         websocket: WebSocket,
-        timeout_s: float,
-        *,
-        realtime_protocol: NativeRealtimeSessionProtocol | None = None,
-    ) -> str | None:
-        try:
-            if realtime_protocol is not None:
-                return await asyncio.wait_for(
-                    realtime_protocol.receive_internal_event_text(websocket),
-                    timeout=max(0.1, timeout_s),
-                )
-            return await asyncio.wait_for(websocket.receive_text(), timeout=max(0.1, timeout_s))
-        except asyncio.TimeoutError:
-            return None
-
-    @staticmethod
-    def _input_committed_payload(
-        session: DuplexSession,
-        committed: DuplexCommittedInput,
-        *,
-        item_id: object | None = None,
-    ) -> dict[str, object]:
-        payload: dict[str, object] = {
-            "type": "input.committed",
-            "session_id": session.session_id,
-            "turn_id": committed.turn_id,
-            "epoch": committed.epoch,
-            "history_len": len(session.history),
-            "message": committed.message,
-        }
-        if isinstance(item_id, str) and item_id:
-            payload["item_id"] = item_id
-        return payload
-
-    @staticmethod
-    def _commit_native_audio_input(
-        session: DuplexSession,
-        *,
-        item_id: object | None = None,
-        transcript: object | None = None,
-        turn_id: int | None = None,
-    ) -> DuplexCommittedInput:
-        clean_transcript = transcript.strip() if isinstance(transcript, str) else None
-        committed = session.commit_native_audio_input(
-            transcript=clean_transcript or None,
-            turn_id=turn_id,
-        )
-        if isinstance(item_id, str) and item_id:
-            session.register_history_item(item_id, committed.message)
-        return committed
-
-    @staticmethod
-    def _native_audio_committed_payload(
-        session: DuplexSession,
-        *,
-        committed: DuplexCommittedInput | None = None,
-        item_id: object | None = None,
-        transcript: object | None = None,
-    ) -> dict[str, object]:
-        message = committed.message if committed is not None else None
-        if not isinstance(message, dict):
-            input_audio_part: dict[str, object] = {
-                "type": "audio_url",
-                "audio_url": {"url": "native-duplex:input-audio"},
-            }
-            if isinstance(transcript, str) and transcript:
-                input_audio_part["transcript"] = transcript
-            message = {
-                "role": "user",
-                "content": [input_audio_part],
-            }
-        payload: dict[str, object] = {
-            "type": "input.committed",
-            "session_id": session.session_id,
-            "turn_id": committed.turn_id if committed is not None else session.turn_id,
-            "epoch": committed.epoch if committed is not None else session.epoch,
-            "history_len": len(session.history),
-            "native_audio": True,
-            "message": message,
-        }
-        if isinstance(transcript, str) and transcript:
-            payload["transcript"] = transcript
-        if isinstance(item_id, str) and item_id:
-            payload["item_id"] = item_id
-        return payload
-
-    def _apply_session_update(
-        self,
-        session: DuplexSession,
-        payload: dict[str, object],
-    ) -> dict[str, object] | None:
-        model = payload.get("model")
-        audio_config = payload.get("audio")
-        audio_input = audio_config.get("input") if isinstance(audio_config, dict) else None
-        audio_output = audio_config.get("output") if isinstance(audio_config, dict) else None
-        voice = payload.get("voice")
-        if not isinstance(voice, str) and isinstance(audio_output, dict):
-            voice = audio_output.get("voice")
-        if isinstance(model, str) and session.config.model is not None and model != session.config.model:
-            return {
-                "type": "error",
-                "session_id": session.session_id,
-                "code": "model_update_unsupported",
-                "error": "session.update cannot change model for an open realtime duplex session",
-            }
-        if isinstance(model, str) and session.config.model is None:
-            session.config.model = model
-        if isinstance(voice, str) and (session.playback.generated_ms > 0 or session.playback.sent_ms > 0):
-            return {
-                "type": "error",
-                "session_id": session.session_id,
-                "code": "voice_update_after_audio_unsupported",
-                "error": "session.update cannot change voice after audio output has started",
-            }
-        if isinstance(payload.get("ref_audio"), str):
-            return {
-                "type": "error",
-                "session_id": session.session_id,
-                "code": "ref_audio_update_unsupported",
-                "error": "session.update cannot change ref_audio after the native duplex runtime is open",
-            }
-        extra_body_payload = payload.get("extra_body")
-        if isinstance(extra_body_payload, dict):
-            # Fold the deprecated model-prefixed alias into the canonical
-            # native_duplex key before comparing or merging.
-            extra_body_payload = normalize_native_duplex_key(dict(extra_body_payload))
-            payload = {**payload, "extra_body": extra_body_payload}
-        if isinstance(extra_body_payload, dict) and NATIVE_DUPLEX_KEY in extra_body_payload:
-            requested_native_duplex = extra_body_payload[NATIVE_DUPLEX_KEY]
-            if not isinstance(requested_native_duplex, bool):
-                return {
-                    "type": "error",
-                    "session_id": session.session_id,
-                    "code": "invalid_request_error",
-                    "error": "extra_body.native_duplex must be a boolean",
-                }
-            current_native_duplex = native_duplex_opt_in(session.config.extra_body)
-            if current_native_duplex is not None and extra_body_payload[NATIVE_DUPLEX_KEY] != current_native_duplex:
-                return {
-                    "type": "error",
-                    "session_id": session.session_id,
-                    "code": "native_duplex_mode_update_unsupported",
-                    "error": "session.update cannot change native_duplex after the session is created",
-                }
-        if isinstance(payload.get("instructions"), str):
-            session.config.instructions = str(payload["instructions"])
-        elif "instructions" in payload and payload.get("instructions") is None:
-            session.config.instructions = None
-        if isinstance(voice, str):
-            session.config.voice = str(voice)
-        elif "voice" in payload and payload.get("voice") is None:
-            session.config.voice = None
-        response_format = payload.get("output_audio_format") or payload.get("response_format")
-        if response_format is None and isinstance(audio_config, dict):
-            if isinstance(audio_output, dict):
-                response_format = audio_output.get("format")
-        response_format, _ = NativeRealtimeSessionProtocol._parse_realtime_audio_format(response_format)
-        if isinstance(response_format, str) and response_format.lower() in REALTIME_OUTPUT_AUDIO_FORMATS:
-            session.config.response_format = NativeRealtimeSessionProtocol._duplex_response_format(response_format)
-        if isinstance(payload.get("temperature"), int | float):
-            session.config.temperature = float(payload["temperature"])
-        speed = payload.get("speed")
-        if not isinstance(speed, int | float) and isinstance(audio_output, dict):
-            speed = audio_output.get("speed")
-        if isinstance(speed, int | float):
-            session.config.speed = float(speed)
-        max_tokens = (
-            payload.get("max_response_output_tokens")
-            if "max_response_output_tokens" in payload
-            else payload.get("max_output_tokens")
-            if "max_output_tokens" in payload
-            else payload.get("max_tokens")
-        )
-        if "max_response_output_tokens" in payload or "max_output_tokens" in payload or "max_tokens" in payload:
-            session.config.max_tokens = NativeRealtimeSessionProtocol.realtime_max_output_tokens(max_tokens)
-        if isinstance(payload.get("overlap_policy"), str):
-            session.config.overlap_policy = DuplexSessionConfig._normalize_overlap_policy(
-                str(payload["overlap_policy"])
-            )
-        if isinstance(payload.get("overlap_short_ack_ms"), int | float):
-            session.config.overlap_short_ack_ms = max(0, int(payload["overlap_short_ack_ms"]))
-        if isinstance(payload.get("overlap_barge_in_ms"), int | float):
-            session.config.overlap_barge_in_ms = max(0, int(payload["overlap_barge_in_ms"]))
-        if isinstance(payload.get("overlap_silence_rms"), int | float):
-            session.config.overlap_silence_rms = max(0.0, float(payload["overlap_silence_rms"]))
-        if isinstance(payload.get("playback_commit_policy"), str):
-            session.config.playback_commit_policy = DuplexSessionConfig._normalize_playback_commit_policy(
-                str(payload["playback_commit_policy"])
-            )
-        modalities = payload.get("modalities") or payload.get("output_modalities")
-        if isinstance(modalities, list) and all(isinstance(item, str) for item in modalities):
-            session.config.modalities = list(modalities)
-        if isinstance(payload.get("extra_body"), dict):
-            session.config.extra_body.update(payload["extra_body"])
-            extra = payload["extra_body"]
-            if isinstance(extra.get("overlap_policy"), str):
-                session.config.overlap_policy = DuplexSessionConfig._normalize_overlap_policy(
-                    str(extra["overlap_policy"])
-                )
-            if isinstance(extra.get("playback_commit_policy"), str):
-                session.config.playback_commit_policy = DuplexSessionConfig._normalize_playback_commit_policy(
-                    str(extra["playback_commit_policy"])
-                )
-        if isinstance(payload.get("tools"), list):
-            session.config.extra_body["realtime_tools"] = payload["tools"]
-        elif "tools" in payload and payload.get("tools") is None:
-            session.config.extra_body.pop("realtime_tools", None)
-        if isinstance(payload.get("tool_choice"), str | dict):
-            session.config.extra_body["realtime_tool_choice"] = payload["tool_choice"]
-        elif "tool_choice" in payload and payload.get("tool_choice") is None:
-            session.config.extra_body.pop("realtime_tool_choice", None)
-        if isinstance(payload.get("metadata"), dict):
-            session.config.extra_body["realtime_metadata"] = dict(payload["metadata"])
-        elif "metadata" in payload and payload.get("metadata") is None:
-            session.config.extra_body.pop("realtime_metadata", None)
-        if isinstance(payload.get("include"), list):
-            session.config.extra_body["realtime_include"] = list(payload["include"])
-        elif "include" in payload and payload.get("include") is None:
-            session.config.extra_body.pop("realtime_include", None)
-        if isinstance(payload.get("prompt"), dict):
-            session.config.extra_body["realtime_prompt"] = dict(payload["prompt"])
-        elif "prompt" in payload and payload.get("prompt") is None:
-            session.config.extra_body.pop("realtime_prompt", None)
-        input_audio_transcription = NativeRealtimeSessionProtocol._input_audio_transcription_config(payload)
-        if isinstance(input_audio_transcription, dict):
-            session.config.extra_body["realtime_input_audio_transcription"] = dict(input_audio_transcription)
-        elif "input_audio_transcription" in payload and payload.get("input_audio_transcription") is None:
-            session.config.extra_body.pop("realtime_input_audio_transcription", None)
-        if isinstance(payload.get("input_audio_noise_reduction"), dict):
-            session.config.extra_body["realtime_input_audio_noise_reduction"] = dict(
-                payload["input_audio_noise_reduction"]
-            )
-        elif "input_audio_noise_reduction" in payload and payload.get("input_audio_noise_reduction") is None:
-            session.config.extra_body.pop("realtime_input_audio_noise_reduction", None)
-        if isinstance(audio_input, dict) and isinstance(audio_input.get("noise_reduction"), dict):
-            session.config.extra_body["realtime_input_audio_noise_reduction"] = dict(audio_input["noise_reduction"])
-        elif isinstance(audio_input, dict) and audio_input.get("noise_reduction") is None:
-            session.config.extra_body.pop("realtime_input_audio_noise_reduction", None)
-        if isinstance(payload.get("audio"), dict):
-            session.config.extra_body["realtime_audio"] = dict(payload["audio"])
-        elif "audio" in payload and payload.get("audio") is None:
-            session.config.extra_body.pop("realtime_audio", None)
-        if isinstance(payload.get("tracing"), str | dict):
-            session.config.extra_body["realtime_tracing"] = payload["tracing"]
-        elif "tracing" in payload and payload.get("tracing") is None:
-            session.config.extra_body.pop("realtime_tracing", None)
-        session.config.extra_body["realtime_session_payload"] = (
-            NativeRealtimeSessionProtocol._json_safe_realtime_payload(payload)
-        )
-        try:
-            turn_detection_configured, server_vad = parse_session_turn_detection(payload)
-            if turn_detection_configured:
-                vad_config = replace(session.config, server_vad=server_vad)
-                self._resolve_server_vad_defaults(session, vad_config, payload)
-                server_vad = vad_config.server_vad
-                if (
-                    not self._uses_native_input_append(session)
-                    and session.turn_detection_config_locked
-                    and (not session.config.turn_detection_configured or server_vad != session.config.server_vad)
-                ):
-                    return {
-                        "type": "error",
-                        "session_id": session.session_id,
-                        "code": "unsupported_turn_detection",
-                        "error": "turn_detection cannot be changed after the first audio append",
-                    }
-                session.config.turn_detection_configured = True
-                session.config.server_vad = server_vad
-                session.config.overlap_policy = vad_config.overlap_policy
-        except ValueError as exc:
-            return {
-                "type": "error",
-                "session_id": session.session_id,
-                "code": "invalid_request_error",
-                "error": str(exc),
-            }
-        return None
-
-    async def _configure_server_vad(self, session: DuplexSession) -> None:
-        pipeline = await self._prepare_server_vad_pipeline(session, session.config)
-        self._install_server_vad_pipeline(session, pipeline)
-
-    def _install_server_vad_pipeline(
-        self,
-        session: DuplexSession,
-        pipeline: ServerVADPipeline | None,
+        envelope: RealtimeEnvelope,
+        attachment: _Attachment,
+        send_json: SendJson,
     ) -> None:
-        existing = self._server_vad_pipelines.pop(session.session_id, None)
-        if existing is not None:
-            existing.reset()
-            self._realtime_vad_metrics.session_finished()
-        if pipeline is None:
-            return
-        self._server_vad_pipelines[session.session_id] = pipeline
-        self._realtime_vad_metrics.session_started()
-
-    async def _prepare_server_vad_pipeline(
-        self,
-        session: DuplexSession,
-        config: DuplexSessionConfig,
-    ) -> ServerVADPipeline | None:
-        if config.server_vad is None:
-            return None
-        backend = await asyncio.to_thread(self._server_vad_backend_provider.get)
-        pipeline_config = config.server_vad
-        if self._uses_native_input_append(session) and pipeline_config.min_speech_duration_ms is None:
-            pipeline_config = replace(
-                pipeline_config,
-                min_speech_duration_ms=SILERO_VAD_DEFAULT_MIN_SPEECH_DURATION_MS,
-            )
-        return ServerVADPipeline(backend, pipeline_config)
-
-    def _apply_response_create_options(
-        self,
-        session: DuplexSession,
-        payload: dict[str, object],
-    ) -> str | None:
-        """Reserve options that apply only to the next response lifecycle."""
-        audio_config = payload.get("audio")
-        audio_output = audio_config.get("output") if isinstance(audio_config, dict) else None
-        if session.capabilities.implementation_level == "model_native_duplex":
-            nested_voice = audio_output.get("voice") if isinstance(audio_output, dict) else None
-            unsupported = (
-                payload.get("instructions") is not None
-                or payload.get("voice") is not None
-                or nested_voice is not None
-                or payload.get("temperature") is not None
-                or any(
-                    payload.get(field_name) is not None
-                    for field_name in ("max_response_output_tokens", "max_output_tokens", "max_tokens")
-                )
-                or payload.get("tools") is not None
-                or payload.get("tool_choice") is not None
-            )
-            if unsupported:
-                return "unsupported_native_response_options"
-
-        instructions = str(payload["instructions"]) if isinstance(payload.get("instructions"), str) else None
-        voice = payload.get("voice")
-        if not isinstance(voice, str) and isinstance(audio_output, dict):
-            voice = audio_output.get("voice")
-        voice = str(voice) if isinstance(voice, str) else None
-        response_format = payload.get("output_audio_format") or payload.get("response_format")
-        if response_format is None and isinstance(audio_config, dict):
-            if isinstance(audio_output, dict):
-                response_format = audio_output.get("format")
-        response_format, _ = NativeRealtimeSessionProtocol._parse_realtime_audio_format(response_format)
-        if isinstance(response_format, str) and response_format.lower() in REALTIME_OUTPUT_AUDIO_FORMATS:
-            response_format = NativeRealtimeSessionProtocol._duplex_response_format(response_format)
-        else:
-            response_format = None
-        temperature = float(payload["temperature"]) if isinstance(payload.get("temperature"), int | float) else None
-        speed = payload.get("speed")
-        if not isinstance(speed, int | float) and isinstance(audio_output, dict):
-            speed = audio_output.get("speed")
-        speed = float(speed) if isinstance(speed, int | float) else None
-        max_tokens = (
-            payload.get("max_response_output_tokens")
-            if "max_response_output_tokens" in payload
-            else payload.get("max_output_tokens")
-            if "max_output_tokens" in payload
-            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 = NativeRealtimeSessionProtocol.realtime_max_output_tokens(max_tokens)
-        else:
-            max_tokens = 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)
-        else:
-            modalities = None
-        response_extra: dict[str, object] = {}
-        conversation = payload.get("conversation")
-        if isinstance(conversation, str):
-            response_extra["realtime_response_conversation"] = conversation
-        metadata = payload.get("metadata")
-        if isinstance(metadata, dict):
-            response_extra["realtime_response_metadata"] = dict(metadata)
-        prompt = payload.get("prompt")
-        if isinstance(prompt, dict):
-            response_extra["realtime_response_prompt"] = dict(prompt)
-        if isinstance(payload.get("tools"), list):
-            response_extra["realtime_response_tools"] = payload["tools"]
-        if isinstance(payload.get("tool_choice"), str | dict):
-            response_extra["realtime_response_tool_choice"] = payload["tool_choice"]
-        extra_body = payload.get("extra_body")
-        if isinstance(extra_body, dict):
-            if session.capabilities.implementation_level == "model_native_duplex":
-                response_extra.update(
-                    (key, value)
-                    for key, value in extra_body.items()
-                    if key not in self._require_serving_runtime_adapter().private_runtime_config_keys
-                )
-            else:
-                response_extra.update(extra_body)
-        try:
-            session.reserve_response_options(
-                ResponseCreateOptions(
-                    instructions=instructions,
-                    voice=voice,
-                    response_format=response_format,
-                    temperature=temperature,
-                    max_tokens=max_tokens,
-                    speed=speed,
-                    modalities=modalities,
-                    extra_body=response_extra,
-                )
-            )
-        except RuntimeError:
-            return "response_already_active"
-        return None
-
-    @staticmethod
-    def _realtime_item_to_history_message(item: object) -> dict[str, object] | None:
-        if not isinstance(item, dict):
-            return None
-        role = item.get("role")
-        if role not in {"system", "user", "assistant"}:
-            return None
-        content = item.get("content")
-        if isinstance(content, str):
-            text = content.strip()
-            return {"role": role, "content": text} if text else None
-        if not isinstance(content, list):
-            return None
-        text_chunks: list[str] = []
-        audio_chunks: list[dict[str, object]] = []
-        for part in content:
-            if not isinstance(part, dict):
+        handle = attachment.handle
+        idle_timeout_s = self._idle_timeout_s
+        config_timeout = handle.public_session.get("idle_timeout_s") if handle.public_session else None
+        if isinstance(config_timeout, int | float) and config_timeout > 0:
+            idle_timeout_s = float(config_timeout)
+        while not handle.closed:
+            raw = await receive_text_with_timeout(websocket, idle_timeout_s)
+            if not await self._attachment_registry.is_current_attachment(handle.session_id, attachment.generation):
+                # A newer connection took the session over; this socket is done.
+                return
+            if raw is None:
+                # Nothing from this socket for the idle window: same as a
+                # disconnect (engine grace for resumable sessions); the engine
+                # lease decides whether the session itself expires.
+                await self._on_disconnect(attachment)
+                return
+            if len(raw.encode("utf-8")) > MAX_EVENT_BYTES:
+                await send_json(envelope.error_payload("event_too_large", "Duplex event too large"))
                 continue
-            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 in {"input_audio", "audio"}:
-                audio = part.get("audio") or part.get("data")
-                fmt = part.get("format") if isinstance(part.get("format"), str) else "wav"
-                if isinstance(audio, str) and audio:
-                    audio_chunks.append(
-                        {
-                            "type": "audio_url",
-                            "audio_url": {
-                                "url": f"data:audio/{fmt};base64,{audio}",
-                            },
-                        }
-                    )
-            elif part_type in {"audio_transcript", "transcript"} and isinstance(part.get("text"), str):
-                text_chunks.append(str(part["text"]))
-        text = "".join(text_chunks).strip()
-        if audio_chunks:
-            content_items: list[dict[str, object]] = []
-            if text:
-                content_items.append({"type": "text", "text": text})
-            content_items.extend(audio_chunks)
-            return {"role": role, "content": content_items}
-        if text:
-            return {"role": role, "content": text}
-        return None
-
-    async def _handle_playback_ack(self, session: DuplexSession, event: dict[str, object], send_json) -> None:
-        played_ms = event.get("played_ms", event.get("audio_ms", 0))
-        committed_ms = event.get("committed_ms")
-        if not isinstance(played_ms, int | float):
-            await send_json({"type": "error", "error": "playback.ack requires played_ms", "code": "bad_event"})
-            return
-        committed_cursor = int(committed_ms) if isinstance(committed_ms, int | float) else int(played_ms)
-        item_id = event.get("item_id")
-        response_id = event.get("response_id")
-        response_id = response_id if isinstance(response_id, str) and response_id else None
-        if not isinstance(item_id, str) or not item_id:
-            item_id = f"item_{response_id}" if response_id is not None else None
-        elif response_id is None and item_id.startswith("item_"):
-            response_id = item_id.removeprefix("item_")
-        if response_id is None and item_id is None and len(session.pending_history_item_ids) == 1:
-            item_id = next(iter(session.pending_history_item_ids))
-            if item_id.startswith("item_"):
-                response_id = item_id.removeprefix("item_")
-        if response_id is None and item_id is None and session.active_response_id is not None:
-            response_id = session.active_response_id
-            item_id = f"item_{response_id}"
-        if response_id is not None:
-            expected_item_id = f"item_{response_id}"
-            if item_id is None:
-                item_id = expected_item_id
-            elif item_id != expected_item_id:
-                await send_json(
-                    {
-                        "type": "error",
-                        "session_id": session.session_id,
-                        "epoch": session.epoch,
-                        "code": "playback_item_mismatch",
-                        "error": "playback.ack item_id must match item_<response_id>.",
-                    }
-                )
-                return
-            if not session.has_assistant_response_item(response_id, item_id):
-                await send_json(
-                    {
-                        "type": "error",
-                        "session_id": session.session_id,
-                        "epoch": session.epoch,
-                        "code": "playback_item_not_found",
-                        "error": f"No assistant response item is registered for {response_id}.",
-                    }
-                )
-                return
-            if session.playback_ack_is_too_late(response_id, item_id):
-                await send_json(
-                    {
-                        "type": "error",
-                        "session_id": session.session_id,
-                        "epoch": session.epoch,
-                        "code": "playback_ack_too_late",
-                        "error": "playback.ack arrived after a later user input was committed.",
-                    }
-                )
-                return
-            # Reserve the response's current history position before any later
-            # input commit can append a user item.  A 0 ms ACK is intentional:
-            # the response may be active but have no audio delta yet.
-            session.reserve_history_item(item_id)
-        elif item_id is not None:
-            await send_json(
-                {
-                    "type": "error",
-                    "session_id": session.session_id,
-                    "epoch": session.epoch,
-                    "code": "playback_item_not_found",
-                    "error": "playback.ack requires a response-owned assistant item.",
-                }
-            )
-            return
-        hard_truncate = event.get("truncate") is True
-        if hard_truncate:
-            playback = session.acknowledge_playback(
-                int(played_ms),
-                committed_cursor,
-                response_id=response_id,
-            )
-            playback = session.truncate_playback_commit(
-                committed_cursor,
-                response_id=response_id,
-            )
-        else:
-            playback = session.acknowledge_playback(
-                int(played_ms),
-                committed_cursor,
-                response_id=response_id,
-            )
-        committed_history = False
-        if isinstance(item_id, str) and item_id:
-            expected_item_id = f"item_{response_id}" if response_id is not None else None
-            if (
-                expected_item_id == item_id
-                and item_id not in session.history_item_ids
-                and item_id not in session.pending_history_item_ids
-            ):
-                # ACK_ONLY responses are normally registered as pending when
-                # the response ends. Recover the response-local item if that
-                # registration was lost across the response/ack boundary.
-                session.register_history_item(item_id, None)
-            committed_history = session.truncate_history_item(
-                item_id,
-                audio_end_ms=committed_cursor,
-                playback=playback,
-                hard=hard_truncate,
-            )
-        elif session.pending_history_item_ids:
-            # A plain playback ack has no OpenAI item id. Commit the only
-            # uncommitted assistant candidate if the session has an unambiguous
-            # pending response; otherwise wait for conversation.item.truncate.
-            pending_ids = list(session.pending_history_item_ids)
-            if len(pending_ids) == 1:
-                item_id = pending_ids[0]
-                committed_history = session.truncate_history_item(
-                    item_id,
-                    audio_end_ms=committed_cursor,
-                    playback=playback,
-                    hard=hard_truncate,
-                )
-        elif session.active_response_id is not None:
-            item_id = f"item_{session.active_response_id}"
-            committed_history = session.truncate_history_item(
-                item_id,
-                audio_end_ms=committed_cursor,
-                playback=playback,
-                hard=hard_truncate,
-            )
-        elif session.last_assistant_full_message is not None:
-            if item_id is None and session.history_item_ids:
-                assistant_item_ids = [
-                    known_item_id
-                    for known_item_id, message in session.history_item_ids.items()
-                    if message.get("role") == "assistant"
-                ]
-                if len(assistant_item_ids) == 1:
-                    item_id = assistant_item_ids[0]
-            if isinstance(item_id, str) and item_id:
-                committed_history = session.truncate_history_item(
-                    item_id,
-                    audio_end_ms=committed_cursor,
-                    playback=playback,
-                    hard=hard_truncate,
-                )
-        await send_json(
-            {
-                "type": "playback.acknowledged",
-                "session_id": session.session_id,
-                "epoch": session.epoch,
-                "item_id": item_id,
-                "played_ms": int(played_ms),
-                "committed_ms": committed_cursor,
-                "truncate": event.get("truncate") is True,
-                "playback": playback.as_dict(),
-                "history_committed": committed_history,
-            }
-        )
-        if committed_history and committed_cursor >= max(playback.sent_ms, playback.generated_ms):
-            session.release_response_playback(response_id)
-            session.release_response_history_snapshot(response_id)
-
-    async def _cancel_active_response(
-        self,
-        session: DuplexSession,
-        active_task: asyncio.Task[None] | None,
-        send_json,
-        *,
-        reason: str,
-        notify: bool = True,
-    ) -> bool:
-        has_running_task = active_task is not None and not active_task.done()
-        if not has_running_task and session.active_request_id is None and session.active_response_id is None:
-            return False
-
-        old_epoch = session.epoch
-        old_request_id = session.active_request_id
-        old_response_id = session.active_response_id
-        committed_ms = session.playback.committed_ms
-        committed_message = session.end_response(
-            commit_text=self._should_commit_response_to_history(session, old_response_id),
-            playback_commit_policy=DuplexPlaybackCommitPolicy.ACK_ONLY.value,
-        )
-        if old_response_id is not None:
-            item_id = f"item_{old_response_id}"
-            if committed_message is not None:
-                session.register_history_item(item_id, committed_message)
-            elif committed_ms > 0 and not session.playback_ack_is_too_late(old_response_id, item_id):
-                session.truncate_history_item(item_id, audio_end_ms=committed_ms)
-        new_epoch, old_playback = self._advance_barge_in_epoch(session)
-        if old_request_id is not None:
-            # Epoch-scoped request ids prevent state reuse, but explicitly
-            # release projector/parser cursors so cancelled epochs do not
-            # accumulate until the whole session closes.
-            if self._serving_runtime_adapter is not None:
-                self._serving_runtime_adapter.data_plane.close_stream(old_request_id)
-            await self._abort_request_background(
-                session,
-                old_request_id,
-                send_json,
-                notify=notify,
-            )
-        if has_running_task and active_task is not None:
-            active_task.cancel()
             try:
-                await asyncio.wait_for(asyncio.gather(active_task, return_exceptions=True), timeout=0.25)
-            except asyncio.TimeoutError:
-                pass
-        if notify:
-            await send_json(
-                {
-                    "type": "audio.cancelled",
-                    "session_id": session.session_id,
-                    "response_id": old_response_id,
-                    "reason": reason,
-                    "cancelled_epoch": old_epoch,
-                    "epoch": new_epoch,
-                    "committed_ms": committed_ms,
-                    "playback": old_playback,
-                }
-            )
-        return True
+                payload = json.loads(raw)
+            except json.JSONDecodeError:
+                await send_json(envelope.error_payload("invalid_json", "Invalid JSON event"))
+                continue
+            if not isinstance(payload, dict) or not isinstance(payload.get("type"), str):
+                await send_json(envelope.error_payload("bad_event", "Duplex event must be a JSON object with a type"))
+                continue
+            if envelope.is_envelope_event(payload):
+                await self._handle_envelope_event(attachment, envelope, payload, send_json)
+                continue
+            await self._submit_wire_event(attachment, envelope, payload, send_json)
 
-    async def _abort_request_background(
+    async def _handle_envelope_event(
         self,
-        session: DuplexSession,
-        request_id: str,
-        send_json,
-        *,
-        notify: bool,
+        attachment: _Attachment,
+        envelope: RealtimeEnvelope,
+        payload: dict[str, object],
+        send_json: SendJson,
+    ) -> None:
+        handle = attachment.handle
+        event_type = payload.get("type")
+        event_id = payload.get("event_id")
+        if event_type == "session.event_ack":
+            acknowledged = payload.get("server_event_seq")
+            if not isinstance(acknowledged, int) or acknowledged < 0:
+                message = "session.event_ack requires a non-negative server_event_seq"
+                await send_json(envelope.error_payload("invalid_event_ack", message, event_id=event_id))
+                return
+            try:
+                await self._attachment_registry.acknowledge(handle.session_id, acknowledged)
+            except ValueError as exc:
+                await send_json(envelope.error_payload("invalid_event_ack", str(exc), event_id=event_id))
+            return
+        message = "session.resume must be the first message of a new connection"
+        await send_json(envelope.error_payload("unsupported_session_resume", message, event_id=event_id))
+
+    async def _submit_wire_event(
+        self,
+        attachment: _Attachment,
+        envelope: RealtimeEnvelope,
+        payload: dict[str, object],
+        send_json: SendJson,
     ) -> None:
         try:
-            abort_internal = getattr(self._chat_service.engine_client, "_abort_internal_requests", None)
-            if callable(abort_internal):
-                result = abort_internal([request_id])
-            else:
-                result = self._chat_service.engine_client.abort([request_id])
-            if inspect.isawaitable(result):
-                await result
-        except Exception as exc:
-            logger.exception("Failed to abort duplex request %s: %s", request_id, exc)
-            if notify and session.state != DuplexSessionState.CLOSED:
-                await self._send_runtime_error(send_json, "runtime_abort_failed", exc, session=session)
+            command = envelope.translate(payload)
+        except DuplexCommandError as exc:
+            await send_json(envelope.command_error_payload(exc))
+            return
+        # ``translate`` folds a session.update's audio settings into the
+        # envelope; remember them so a later reconnect starts where this left off.
+        self._input_defaults[attachment.handle.session_id] = envelope.defaults
+        await self._submit_command(attachment, envelope, command, send_json)
 
-    async def _cancel_pending_input(self, session: DuplexSession, send_json, *, reason: str) -> None:
-        cancelled = session.cancel_pending_input()
-        self._advance_barge_in_epoch(session)
-        await send_json(
-            {
-                "type": "input.cancelled",
-                "session_id": session.session_id,
-                "reason": reason,
-                "epoch": session.epoch,
-                "cancelled": cancelled,
-            }
-        )
+    async def _submit_command(
+        self,
+        attachment: _Attachment,
+        envelope: RealtimeEnvelope,
+        command: DuplexCommand,
+        send_json: SendJson,
+    ) -> None:
+        try:
+            await attachment.handle.submit(command)
+        except DuplexSessionError as exc:
+            await send_json(envelope.error_payload(exc.code, str(exc), event_id=command.event_id))
+
+    # ------------------------------------------------------------------ #
+    # Disconnect                                                          #
+    # ------------------------------------------------------------------ #
+
+    async def _on_disconnect(self, attachment: _Attachment) -> None:
+        handle = attachment.handle
+        if handle.closed:
+            return
+        if handle.capabilities.supports_session_resume:
+            if await self._attachment_registry.detach(handle.session_id, attachment_generation=attachment.generation):
+                # Engine-owned disconnect grace: expiry arrives as session.expired.
+                with suppress(DuplexSessionError):
+                    await self._omni.detach_session(handle.session_id)
+            # Otherwise a newer connection already took the session over; the
+            # replaced socket's disconnect must not touch it.
+            return
+        with suppress(DuplexSessionError):
+            await handle.close(reason="disconnect")
diff --git a/vllm_omni/entrypoints/duplex/session_attachment.py b/vllm_omni/entrypoints/duplex/session_attachment.py
index d68fb268b..f2dc09f1c 100644
--- a/vllm_omni/entrypoints/duplex/session_attachment.py
+++ b/vllm_omni/entrypoints/duplex/session_attachment.py
@@ -180,7 +180,6 @@ class DuplexEventJournal:
 @dataclass(frozen=True)
 class DuplexSessionAttachmentCreated:
     session_id: str
-    incarnation: int
     attachment_generation: int
     resume_token: ResumeToken = field(repr=False)
 
@@ -188,7 +187,6 @@ class DuplexSessionAttachmentCreated:
 @dataclass(frozen=True)
 class DuplexSessionResumeResult:
     session_id: str
-    incarnation: int
     attachment_generation: int
     resume_token: ResumeToken = field(repr=False)
     replay_entries: tuple[JournalEntry, ...] = ()
@@ -198,14 +196,12 @@ class DuplexSessionResumeResult:
 @dataclass
 class _DuplexSessionAttachmentState:
     session_id: str
-    incarnation: int
     credential: DuplexResumeCredential
     journal: DuplexEventJournal
     attachment: DuplexTransportAttachment | None
     attachment_generation: int
     outbound_lock: asyncio.Lock = field(default_factory=asyncio.Lock, repr=False)
     recovery_token_digest: bytes | None = field(default=None, repr=False)
-    grace_task: asyncio.Task[None] | None = field(default=None, repr=False)
 
 
 class DuplexSessionAttachmentRegistry:
@@ -214,18 +210,14 @@ class DuplexSessionAttachmentRegistry:
         *,
         replay_ttl_s: float,
         replay_max_bytes_per_session: int,
-        disconnect_grace_s: float = 30.0,
         clock: Callable[[], float] | None = None,
     ) -> None:
         if replay_ttl_s <= 0:
             raise ValueError("replay_ttl_s must be positive")
         if replay_max_bytes_per_session <= 0:
             raise ValueError("replay_max_bytes_per_session must be positive")
-        if disconnect_grace_s <= 0:
-            raise ValueError("disconnect_grace_s must be positive")
         self._replay_ttl_s = replay_ttl_s
         self._replay_max_bytes_per_session = replay_max_bytes_per_session
-        self._disconnect_grace_s = disconnect_grace_s
         self._clock = clock or time.monotonic
         self._sessions: dict[str, _DuplexSessionAttachmentState] = {}
         self._lock = asyncio.Lock()
@@ -237,7 +229,6 @@ class DuplexSessionAttachmentRegistry:
         self,
         session_id: str,
         *,
-        incarnation: int,
         send: Callable[[dict[str, object]], Awaitable[None]],
         close: Callable[[str], Awaitable[None]],
     ) -> DuplexSessionAttachmentCreated:
@@ -248,7 +239,6 @@ class DuplexSessionAttachmentRegistry:
             generation = 1
             self._sessions[session_id] = _DuplexSessionAttachmentState(
                 session_id=session_id,
-                incarnation=incarnation,
                 credential=DuplexResumeCredential.from_token(token),
                 journal=DuplexEventJournal(
                     max_bytes=self._replay_max_bytes_per_session,
@@ -264,7 +254,6 @@ class DuplexSessionAttachmentRegistry:
             )
             return DuplexSessionAttachmentCreated(
                 session_id=session_id,
-                incarnation=incarnation,
                 attachment_generation=generation,
                 resume_token=token,
             )
@@ -275,12 +264,18 @@ class DuplexSessionAttachmentRegistry:
         payload: Mapping[str, object],
         *,
         journal: bool = True,
+        on_accepted: Callable[[], None] | None = None,
     ) -> JournalEntry | None:
         """Sequence and dispatch one event to the current attachment.
 
         The per-session lock keeps wire order equal to journal order without
         serializing unrelated sessions. A detached session still records
         replayable events, but has no transport side effect.
+
+        ``on_accepted`` runs synchronously once the event is journaled, or
+        after a successful transport send when journaling is disabled. A later
+        send failure cannot undo acceptance into the journal. Detached,
+        non-journaled events do not invoke it. The callback must not raise.
         """
         async with self._lock:
             state = self._require(session_id)
@@ -291,41 +286,51 @@ class DuplexSessionAttachmentRegistry:
                 entry = state.journal.record(payload) if journal else None
                 attachment = state.attachment
                 wire_payload = dict(entry.payload) if entry is not None else dict(payload)
+            if entry is not None and on_accepted is not None:
+                on_accepted()
             if attachment is not None:
                 await attachment.send(wire_payload)
+                if entry is None and on_accepted is not None:
+                    on_accepted()
             return entry
 
     async def acknowledge(self, session_id: str, sequence: int) -> int:
         async with self._lock:
             return self._require(session_id).journal.acknowledge(sequence)
 
-    async def detach(
-        self,
-        session_id: str,
-        *,
-        attachment_generation: int,
-        on_grace_expired: Callable[[], Awaitable[None]] | None = None,
-    ) -> bool:
+    async def detach(self, session_id: str, *, attachment_generation: int | None = None) -> bool:
+        """Drop the current transport; the engine lease owns the disconnect grace.
+
+        ``attachment_generation`` names the connection asking to detach, so a
+        socket that already lost a takeover cannot detach the winner. ``None``
+        means "whichever connection is attached right now" and is for callers
+        that only know the session (the outbound pump, whose send just failed).
+
+        Returns whether this call is the one that detached: an already-detached
+        session answers ``False`` so a second disconnect signal for the same
+        socket cannot restart the engine's disconnect grace window.
+        """
         async with self._lock:
             state = self._sessions.get(session_id)
-            if state is None or state.attachment_generation != attachment_generation:
+            if state is None or state.attachment is None:
+                return False
+            if attachment_generation is not None and state.attachment_generation != attachment_generation:
                 return False
             state.attachment = None
-            if state.grace_task is not None:
-                state.grace_task.cancel()
-            state.grace_task = (
-                asyncio.create_task(
-                    self._run_disconnect_grace(
-                        state,
-                        attachment_generation=attachment_generation,
-                        callback=on_grace_expired,
-                    )
-                )
-                if on_grace_expired is not None
-                else None
-            )
             return True
 
+    async def has_attachment(self, session_id: str) -> bool:
+        """Whether some connection is attached right now, whoever it is.
+
+        A resume that failed to activate has no generation of its own, so it
+        cannot ask ``is_current_attachment``. What it needs to know before
+        rolling the engine lease back into its disconnect grace is only whether
+        it would be rolling back somebody else's live attachment.
+        """
+        async with self._lock:
+            state = self._sessions.get(session_id)
+            return state is not None and state.attachment is not None
+
     async def is_current_attachment(self, session_id: str, attachment_generation: int) -> bool:
         async with self._lock:
             state = self._sessions.get(session_id)
@@ -339,25 +344,19 @@ class DuplexSessionAttachmentRegistry:
         self,
         session_id: str,
         *,
-        incarnation: int,
         resume_token: str,
         last_received_server_event_seq: int,
     ) -> None:
         """Validate transport credentials before any engine resume control."""
         async with self._lock:
             state = self._require(session_id)
-            self._validate_resume_identity(
-                state,
-                incarnation=incarnation,
-                resume_token=resume_token,
-            )
+            self._validate_resume_identity(state, resume_token=resume_token)
             state.journal.replay_after(last_received_server_event_seq)
 
     async def resume(
         self,
         session_id: str,
         *,
-        incarnation: int,
         resume_token: str,
         last_received_server_event_seq: int,
         send: Callable[[dict[str, object]], Awaitable[None]],
@@ -370,18 +369,11 @@ class DuplexSessionAttachmentRegistry:
             async with self._lock:
                 if self._sessions.get(session_id) is not state:
                     raise KeyError(f"unknown duplex attachment session: {session_id}")
-                used_recovery = self._validate_resume_identity(
-                    state,
-                    incarnation=incarnation,
-                    resume_token=resume_token,
-                )
+                used_recovery = self._validate_resume_identity(state, resume_token=resume_token)
                 replay_entries = state.journal.replay_after(last_received_server_event_seq)
                 accepted_token_digest = (
                     state.recovery_token_digest if used_recovery else bytes(state.credential.token_digest)
                 )
-                if state.grace_task is not None:
-                    state.grace_task.cancel()
-                    state.grace_task = None
                 state.recovery_token_digest = None
                 rotated_token = state.credential.rotate()
                 replaced = state.attachment
@@ -397,53 +389,53 @@ class DuplexSessionAttachmentRegistry:
                     await send(dict(activation_payload_factory(rotated_token, attachment_generation)))
                     for entry in replay_entries:
                         await send(dict(entry.payload))
-                except Exception:
-                    async with self._lock:
-                        if (
-                            self._sessions.get(session_id) is state
-                            and state.attachment_generation == attachment_generation
-                        ):
-                            state.attachment = None
-                            state.recovery_token_digest = accepted_token_digest
+                except (Exception, asyncio.CancelledError):
+                    # CancelledError derives from BaseException, so an
+                    # ``except Exception`` here would let a cancellation during
+                    # activation or replay skip the rollback: the dead
+                    # attachment would stay current while the token it rotated
+                    # past is gone, leaving the session attached to an unusable
+                    # transport with no way back. Both failures take the same
+                    # path deliberately, so they cannot drift apart.
+                    await self._rollback_resume(
+                        session_id,
+                        state=state,
+                        attachment_generation=attachment_generation,
+                        accepted_token_digest=accepted_token_digest,
+                    )
                     raise
             return DuplexSessionResumeResult(
                 session_id=session_id,
-                incarnation=incarnation,
                 attachment_generation=attachment_generation,
                 resume_token=rotated_token,
                 replay_entries=replay_entries,
                 replaced_attachment=replaced,
             )
 
+    async def _rollback_resume(
+        self,
+        session_id: str,
+        *,
+        state: _DuplexSessionAttachmentState,
+        attachment_generation: int,
+        accepted_token_digest: bytes,
+    ) -> None:
+        """Undo a resume whose activation never reached the client.
+
+        Generation-checked: a later resume that already took over must keep its
+        attachment. Restoring ``recovery_token_digest`` is what lets the caller
+        retry with the token it presented, which ``resume`` had rotated past.
+        """
+        async with self._lock:
+            if self._sessions.get(session_id) is state and state.attachment_generation == attachment_generation:
+                state.attachment = None
+                state.recovery_token_digest = accepted_token_digest
+
     async def close(self, session_id: str) -> DuplexTransportAttachment | None:
         async with self._lock:
             state = self._sessions.pop(session_id, None)
-            if state is not None and state.grace_task is not None:
-                state.grace_task.cancel()
             return state.attachment if state is not None else None
 
-    async def _run_disconnect_grace(
-        self,
-        state: _DuplexSessionAttachmentState,
-        *,
-        attachment_generation: int,
-        callback: Callable[[], Awaitable[None]] | None,
-    ) -> None:
-        try:
-            await asyncio.sleep(self._disconnect_grace_s)
-        except asyncio.CancelledError:
-            return
-        async with self._lock:
-            if (
-                self._sessions.get(state.session_id) is not state
-                or state.attachment is not None
-                or state.attachment_generation != attachment_generation
-            ):
-                return
-            state.grace_task = None
-        if callback is not None:
-            await callback()
-
     def _require(self, session_id: str) -> _DuplexSessionAttachmentState:
         state = self._sessions.get(session_id)
         if state is None:
@@ -451,14 +443,7 @@ class DuplexSessionAttachmentRegistry:
         return state
 
     @staticmethod
-    def _validate_resume_identity(
-        state: _DuplexSessionAttachmentState,
-        *,
-        incarnation: int,
-        resume_token: str,
-    ) -> bool:
-        if incarnation != state.incarnation:
-            raise ValueError(f"duplex attachment incarnation mismatch: expected {state.incarnation}, got {incarnation}")
+    def _validate_resume_identity(state: _DuplexSessionAttachmentState, *, resume_token: str) -> bool:
         if state.credential.verify(resume_token):
             return False
         recovery_digest = state.recovery_token_digest
diff --git a/vllm_omni/entrypoints/duplex/session_runner.py b/vllm_omni/entrypoints/duplex/session_runner.py
deleted file mode 100644
index ed18d8591..000000000
--- a/vllm_omni/entrypoints/duplex/session_runner.py
+++ /dev/null
@@ -1,2507 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-from __future__ import annotations
-
-import asyncio
-import binascii
-import json
-import uuid
-from contextlib import suppress
-from copy import deepcopy
-
-import numpy as np
-import pybase64 as base64
-from fastapi import WebSocket, WebSocketDisconnect
-from vllm.logger import init_logger
-
-from vllm_omni.engine.duplex.lease import DuplexLeaseActivity
-from vllm_omni.engine.duplex.messages import DuplexFence
-from vllm_omni.entrypoints.duplex.audio import (
-    convert_input_audio_with_rate,
-    validate_input_sample_rate_hz,
-)
-from vllm_omni.entrypoints.duplex.commit_policy import (
-    CommitAction,
-    CommitSnapshot,
-    decide_commit_action,
-)
-from vllm_omni.entrypoints.duplex.protocol import (
-    DuplexOverlapPolicy,
-    DuplexPlaybackCommitPolicy,
-    DuplexSession,
-    DuplexSessionState,
-    DuplexTurnEventType,
-)
-from vllm_omni.entrypoints.duplex.realtime_session import (
-    NativeRealtimeSessionProtocol,
-)
-from vllm_omni.entrypoints.duplex.runtime_adapter import (
-    PcmAppendReservation,
-    ServingRuntimeConfigError,
-    ServingRuntimeSessionState,
-    payload_turn_id,
-)
-from vllm_omni.entrypoints.duplex.server_vad import ServerVADPipeline
-from vllm_omni.entrypoints.duplex.session_attachment import (
-    DuplexJournalOverflowError,
-)
-from vllm_omni.entrypoints.duplex.websocket import (
-    DuplexWebSocketActor,
-    is_input_event,
-    normalize_duplex_input_event,
-)
-
-logger = init_logger(__name__)
-
-_MAX_EVENT_BYTES = 15 * 1024 * 1024
-
-
-class DuplexSessionRunnerMixin:
-    """Run one ordered WebSocket mailbox for a duplex session."""
-
-    async def handle_session(
-        self,
-        websocket: WebSocket,
-        *,
-        realtime_protocol: NativeRealtimeSessionProtocol | None = None,
-    ) -> None:
-        await websocket.accept()
-        session: DuplexSession | None = None
-        actor = DuplexWebSocketActor(
-            websocket,
-            current_epoch=lambda: session.epoch if session is not None else None,
-            session_closed=lambda: session is not None and session.state == DuplexSessionState.CLOSED,
-            outbound_protocol=realtime_protocol,
-        )
-        runtime_opened = False
-        runtime_closed = False
-        attachment_ready = False
-        attachment_generation: int | None = None
-        resume_credential_delivered = False
-        transport_detached = False
-        pending_turn_reservations = 0
-
-        async def attachment_send(payload: dict[str, object]) -> None:
-            nonlocal resume_credential_delivered
-            try:
-                await websocket.send_json(payload)
-            except RuntimeError as exc:
-                message = str(exc)
-                if "after sending 'websocket.close'" in message or "response already completed" in message:
-                    raise WebSocketDisconnect(code=1006) from exc
-                raise
-            if payload.get("type") == "session.created" and isinstance(payload.get("resume_token"), str):
-                resume_credential_delivered = True
-
-        async def attachment_close(reason: str) -> None:
-            close = getattr(websocket, "close", None)
-            if callable(close):
-                await close(code=1000, reason=reason)
-
-        async def send_attachment_payload(payload: dict[str, object], *, journal: bool) -> None:
-            assert session is not None
-            session_id = session.session_id
-            should_journal = journal and session_id not in self._resync_required_sessions
-            try:
-                await self._attachment_registry.send_event(
-                    session_id,
-                    payload,
-                    journal=should_journal,
-                )
-            except DuplexJournalOverflowError:
-                first_overflow = session_id not in self._resync_required_sessions
-                self._resync_required_sessions.add(session_id)
-                if first_overflow:
-                    resync_payload: dict[str, object] = {
-                        "type": "session.resync_required",
-                        "session_id": session_id,
-                        "reason": "journal_overflow",
-                    }
-                    if realtime_protocol is not None:
-                        resync_payload = realtime_protocol.encode_outbound_event(resync_payload)[0]
-                    await self._attachment_registry.send_event(
-                        session_id,
-                        resync_payload,
-                        journal=False,
-                    )
-                await self._attachment_registry.send_event(
-                    session_id,
-                    payload,
-                    journal=False,
-                )
-
-        if realtime_protocol is not None:
-
-            async def send_realtime_raw(payload: dict[str, object]) -> None:
-                if attachment_ready and session is not None:
-                    await send_attachment_payload(
-                        payload,
-                        journal=payload.get("type") not in {"session.created", "session.resumed"},
-                    )
-                    return
-                raw_payload = dict(payload)
-                raw_payload["_realtime_raw"] = True
-                await actor.send_json(raw_payload)
-
-            realtime_protocol.bind_sender(send_realtime_raw)
-        native: ServingRuntimeSessionState = self._create_runtime_session_state()
-
-        def begin_close(reason: str) -> None:
-            actor.closing = True
-            actor.close_reason = reason
-            if session is not None:
-                session.mark_closing()
-
-        event_emit_lock = asyncio.Lock()
-
-        async def send_outbound(payload: dict[str, object]) -> None:
-            if not attachment_ready or session is None:
-                await actor.send_json(dict(payload))
-                return
-            if realtime_protocol is None:
-                await send_attachment_payload(
-                    payload,
-                    journal=payload.get("type") not in {"session.created", "session.resumed"},
-                )
-                return
-            for projected in realtime_protocol.encode_outbound_event(payload):
-                await send_attachment_payload(
-                    projected,
-                    journal=projected.get("type") not in {"session.created", "session.resumed"},
-                )
-
-        async def emit_event(payload: dict[str, object]) -> None:
-            deferred_precreate_response = False
-            async with event_emit_lock:
-                accepted, deferred_overlap_payload = await self._apply_outbound_session_event(
-                    payload,
-                    session=session,
-                    actor=actor,
-                    native=native,
-                    realtime_protocol=realtime_protocol,
-                )
-                if not accepted:
-                    return
-                await send_outbound(payload)
-                if deferred_overlap_payload is not None:
-                    deferred_precreate_response = native.deferred_precreate_response
-                    native.deferred_precreate_response = False
-            if deferred_overlap_payload is not None and session is not None and not actor.closing:
-                await start_native_append(
-                    deferred_overlap_payload,
-                    final=True,
-                    precreate_response=deferred_precreate_response,
-                    operation_id=native.committed_audio_operation_id,
-                    retained_committed_payload=(
-                        deferred_overlap_payload if native.committed_audio_payload is deferred_overlap_payload else None
-                    ),
-                )
-
-        writer_task = asyncio.create_task(actor.writer_loop(), name="duplex-session-writer")
-        reader_task: asyncio.Task[None] | None = None
-
-        async def read_event_loop() -> None:
-            nonlocal pending_turn_reservations
-            assert session is not None
-            try:
-                while not actor.closing:
-                    raw = await self._receive_text(
-                        websocket,
-                        session.config.idle_timeout_s,
-                        realtime_protocol=realtime_protocol,
-                    )
-                    if raw is None:
-                        await actor.enqueue_event({"type": "__timeout__"})
-                        return
-                    if len(raw.encode("utf-8")) > _MAX_EVENT_BYTES:
-                        await emit_event(
-                            {"type": "error", "error": "Duplex event too large", "code": "event_too_large"}
-                        )
-                        continue
-                    try:
-                        event = json.loads(raw)
-                    except json.JSONDecodeError:
-                        await emit_event({"type": "error", "error": "Invalid JSON event", "code": "invalid_json"})
-                        continue
-                    if not isinstance(event, dict):
-                        await emit_event(
-                            {
-                                "type": "error",
-                                "error": "Duplex event must be a JSON object",
-                                "code": "bad_event",
-                            }
-                        )
-                        continue
-                    event = normalize_duplex_input_event(event)
-                    event_type = event.get("type")
-                    if not isinstance(event_type, str):
-                        await emit_event(
-                            {"type": "error", "error": "Duplex event missing string type", "code": "bad_event"}
-                        )
-                        continue
-                    if event_type in {"input.commit", "input_audio_buffer.commit"}:
-                        if not session.reserve_pending_turn(
-                            limit=self._duplex_session_config.max_pending_turns_per_session
-                        ):
-                            await emit_event(
-                                {
-                                    "type": "error",
-                                    "error": "Duplex session has too many pending input turns",
-                                    "code": "input_backpressure",
-                                }
-                            )
-                            continue
-                        event["_duplex_pending_turn_reserved"] = True
-                        pending_turn_reservations += 1
-                    if is_input_event(event_type) and native_response_in_progress():
-                        event["_duplex_overlap_candidate"] = True
-                    await actor.enqueue_event(event)
-            except WebSocketDisconnect:
-                await actor.enqueue_event({"type": "__disconnect__"})
-            except Exception as exc:
-                await emit_event({"type": "error", "error": str(exc), "code": "realtime_input_failed"})
-                await actor.enqueue_event({"type": "__disconnect__"})
-
-        async def next_actor_event() -> dict[str, object]:
-            nonlocal pending_turn_reservations, transport_detached
-            event = await actor.next_event()
-            if event.pop("_duplex_pending_turn_reserved", False) and session is not None:
-                session.release_pending_turn()
-                pending_turn_reservations = max(0, pending_turn_reservations - 1)
-            if (
-                attachment_ready
-                and attachment_generation is not None
-                and session is not None
-                and not await self._attachment_registry.is_current_attachment(
-                    session.session_id,
-                    attachment_generation,
-                )
-            ):
-                transport_detached = True
-                return {"type": "__replaced_attachment__"}
-            return event
-
-        def native_response_in_progress() -> bool:
-            if session is None:
-                return False
-            if session.active_response_id is not None:
-                return True
-            if (
-                session.config.playback_commit_policy == DuplexPlaybackCommitPolicy.ACK_ONLY.value
-                and session.playback.sent_ms > session.playback.committed_ms
-            ):
-                return True
-            if actor.active_response_task is not None and not actor.active_response_task.done():
-                return True
-            if actor.has_response_bound_append_tasks():
-                return True
-            return False
-
-        def start_chat_response() -> None:
-            assert session is not None
-
-            async def run_and_notify() -> None:
-                task = asyncio.current_task()
-                try:
-                    await self._run_response(session, emit_event)
-                finally:
-                    await actor.enqueue_event(
-                        {
-                            "type": "__chat_response_finished__",
-                            "_response_task": task,
-                        }
-                    )
-
-            actor.active_response_task = asyncio.create_task(run_and_notify())
-
-        def activate_waiting_server_vad_turn() -> None:
-            assert session is not None
-            pending_turn = session.activate_server_vad_turn()
-            if pending_turn is not None and pending_turn.create_response:
-                start_chat_response()
-
-        def correlate_realtime_error(
-            payload: dict[str, object],
-            event_id: object,
-        ) -> dict[str, object]:
-            if isinstance(event_id, str) and event_id:
-                payload["event_id"] = event_id
-            return payload
-
-        async def reject_and_clear_server_vad_input(
-            pipeline: ServerVADPipeline,
-            *,
-            code: str,
-            error: str,
-            metric_reason: str,
-            event_id: object,
-        ) -> None:
-            assert session is not None
-            session.cancel_pending_input()
-            pipeline.reset()
-            self._realtime_vad_metrics.error(metric_reason)
-            await emit_event(
-                correlate_realtime_error(
-                    {
-                        "type": "error",
-                        "session_id": session.session_id,
-                        "code": code,
-                        "error": error,
-                    },
-                    event_id,
-                )
-            )
-            await emit_event(
-                {
-                    "type": "input_audio_buffer.cleared",
-                    "session_id": session.session_id,
-                }
-            )
-
-        async def commit_server_vad_turn(
-            *,
-            item_id: str,
-            create_response: bool,
-            retain_input_bytes: int,
-            event_id: object = None,
-        ) -> None:
-            assert session is not None
-            # Retain ownership until the actor consumes the terminal event so
-            # queued audio cannot overtake pending-turn activation.
-            active_response = actor.active_response_task is not None
-            if active_response and session.pending_server_vad_turn is not None:
-                released = session.discard_uncommitted_server_vad_utterance()
-                session.release_input_bytes(released)
-                self._realtime_vad_metrics.error("pending_turn_backpressure")
-                await emit_event(
-                    correlate_realtime_error(
-                        {
-                            "type": "error",
-                            "session_id": session.session_id,
-                            "code": "input_backpressure",
-                            "error": "Only one committed Server VAD turn may wait for the active response",
-                        },
-                        event_id,
-                    )
-                )
-                return
-            if not session.stage_server_vad_audio_for_commit():
-                return
-            committed = session.commit_user_input(
-                append_history=not active_response,
-                retain_input_bytes=retain_input_bytes,
-            )
-            if committed is None:
-                return
-            if active_response:
-                session.stage_server_vad_turn(
-                    committed,
-                    create_response=create_response,
-                    item_id=item_id,
-                )
-            else:
-                session.register_history_item(item_id, committed.message)
-            await emit_event(
-                self._input_committed_payload(
-                    session,
-                    committed,
-                    item_id=item_id,
-                )
-            )
-            if create_response and not active_response:
-                start_chat_response()
-
-        def clear_completed_pending_silence() -> None:
-            task = native.pending_silence_task
-            if task is not None and task.done():
-                native.pending_silence_task = None
-                native.pending_silence_owner_id = None
-
-        def mark_pending_silence_superseded() -> None:
-            task = native.pending_silence_task
-            if task is None:
-                return
-            if task.done():
-                native.pending_silence_task = None
-            # Do not cancel the task or clear native_append_tail here. A
-            # silence append may already have reached the Engine, and local
-            # cancellation cannot retract that RPC. The sequencer preserves
-            # wire order; before_append will skip silence that has not started.
-            native.pending_silence_owner_id = None
-
-        def real_native_input_waiting() -> bool:
-            clear_completed_pending_silence()
-            return (
-                native.audio_buffer.has_pending()
-                or native.audio_buffer.has_reserved()
-                or actor.has_queued_input_events()
-            )
-
-        async def start_native_append(
-            payload: object,
-            *,
-            final: bool,
-            precreate_response: bool = False,
-            pcm_reservation: PcmAppendReservation | None = None,
-            operation_id: str | None = None,
-            retained_committed_payload: dict[str, object] | None = None,
-            silence_continuation: bool = False,
-            before_append=None,
-        ) -> asyncio.Task[bool] | None:
-            if session is None:
-                return
-            if not silence_continuation:
-                mark_pending_silence_superseded()
-            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 = self._native_stage0_request_id(session, append_epoch)
-            if final or precreate_response:
-                session.bind_request(request_id)
-            if precreate_response:
-                session.bind_response_turn(append_turn_id)
-            if precreate_response and session.active_response_id is None:
-                response_id = session.begin_response(turn_id=append_turn_id)
-                await emit_event(
-                    self._response_created_payload(
-                        session,
-                        response_id,
-                        epoch=append_epoch,
-                    )
-                )
-            precreated_response_id = session.active_response_id if precreate_response else None
-
-            def _discard_retained_committed_audio() -> None:
-                if (
-                    retained_committed_payload is not None
-                    and native.committed_audio_payload is retained_committed_payload
-                ):
-                    session.release_input_bytes(native.clear_committed_audio())
-
-            async def _run() -> bool:
-                nonlocal runtime_closed
-                try:
-                    append_ok, emitted_response = await self._append_runtime_input(
-                        session,
-                        payload,
-                        operation_id=(pcm_reservation.operation_id if pcm_reservation is not None else operation_id),
-                        final=final,
-                        send_json=emit_event,
-                        mode="append_audio_chunk",
-                        expected_epoch=append_epoch,
-                    )
-                    if append_ok:
-                        native.native_context_locked = True
-                        if pcm_reservation is not None:
-                            pcm_reservation.commit()
-                            session.release_input_bytes(pcm_reservation.byte_count)
-                        if (
-                            retained_committed_payload is not None
-                            and native.committed_audio_payload is retained_committed_payload
-                        ):
-                            session.release_input_bytes(native.clear_committed_audio())
-                    else:
-                        if pcm_reservation is not None:
-                            pcm_reservation.rollback()
-                        _discard_retained_committed_audio()
-                    if (
-                        not append_ok
-                        and precreated_response_id is not None
-                        and session.active_response_id == precreated_response_id
-                    ):
-                        session.end_response(commit_text=False)
-                        await emit_event(
-                            {
-                                "type": "response.done",
-                                "session_id": session.session_id,
-                                "response_id": precreated_response_id,
-                                "epoch": session.epoch,
-                                "committed": False,
-                                "status": "failed",
-                                "status_details": {
-                                    "type": "failed",
-                                    "reason": "runtime_append_failed",
-                                },
-                                "playback": session.playback.as_dict(),
-                            }
-                        )
-                    if not append_ok and session.state == DuplexSessionState.CLOSED:
-                        runtime_closed = True
-                        return False
-                    if not emitted_response and session.epoch == append_epoch:
-                        if session.active_request_id == self._native_stage0_request_id(session, append_epoch):
-                            session.clear_request(request_id)
-                        if final:
-                            await emit_event(
-                                self._turn_controller.signal(session, DuplexTurnEventType.USER_STARTED.value)
-                            )
-                    return append_ok
-                except asyncio.CancelledError:
-                    if pcm_reservation is not None:
-                        pcm_reservation.rollback()
-                    raise
-                except Exception as exc:
-                    if pcm_reservation is not None:
-                        pcm_reservation.rollback()
-                    _discard_retained_committed_audio()
-                    logger.exception("Native duplex append task failed: %s", exc)
-                    await self._send_runtime_error(emit_event, "runtime_append_task_failed", exc, session=session)
-                    if session.state != DuplexSessionState.CLOSED:
-                        begin_close("runtime_append_task_failed")
-                        if await self._close_runtime_session(
-                            session,
-                            reason="runtime_append_task_failed",
-                            send_json=emit_event,
-                        ):
-                            runtime_closed = True
-                            session.close()
-                            await emit_event(
-                                {
-                                    "type": "session.closed",
-                                    "session_id": session.session_id,
-                                    "reason": "runtime_append_task_failed",
-                                }
-                            )
-                    return False
-
-            async def _run_in_wire_order(predecessor: asyncio.Task[bool] | None) -> bool:
-                if predecessor is not None:
-                    try:
-                        predecessor_ok = await predecessor
-                    except asyncio.CancelledError:
-                        current = asyncio.current_task()
-                        if current is not None and current.cancelling():
-                            raise
-                        predecessor_ok = False
-                    except Exception:
-                        predecessor_ok = False
-                    if not predecessor_ok:
-                        if pcm_reservation is not None:
-                            pcm_reservation.rollback()
-                        _discard_retained_committed_audio()
-                        return False
-                if actor.closing or runtime_closed or session.state != DuplexSessionState.OPEN:
-                    if pcm_reservation is not None:
-                        pcm_reservation.rollback()
-                    _discard_retained_committed_audio()
-                    return False
-                if before_append is not None and not before_append():
-                    if pcm_reservation is not None:
-                        pcm_reservation.rollback()
-                    _discard_retained_committed_audio()
-                    return True
-                if pcm_reservation is not None and not pcm_reservation.active:
-                    _discard_retained_committed_audio()
-                    return False
-                return await _run()
-
-            def _release_cancelled_retained_audio(done: asyncio.Task[bool]) -> None:
-                if done.cancelled():
-                    _discard_retained_committed_audio()
-                    return
-                try:
-                    append_ok = done.result()
-                except Exception:
-                    append_ok = False
-                if not append_ok:
-                    _discard_retained_committed_audio()
-
-            predecessor = actor.native_append_tail
-            if predecessor is not None and predecessor.done():
-                try:
-                    predecessor_ok = predecessor.result()
-                except (asyncio.CancelledError, Exception):
-                    predecessor_ok = False
-                if not predecessor_ok:
-                    # Appends already queued behind a failed predecessor keep
-                    # their captured dependency and stop. A later wire command
-                    # is an explicit retry and starts a new chain.
-                    predecessor = None
-            task = asyncio.create_task(_run_in_wire_order(predecessor))
-            task.add_done_callback(_release_cancelled_retained_audio)
-            actor.native_append_tail = task
-            actor.track_append_task(
-                task,
-                epoch=append_epoch,
-                mode="append_audio_chunk",
-                final=final,
-                response_bound=final or precreate_response,
-            )
-            if silence_continuation:
-                native.pending_silence_task = task
-
-                def _clear_done_pending_silence(done: asyncio.Task[bool]) -> None:
-                    if native.pending_silence_task is done:
-                        native.pending_silence_task = None
-                        native.pending_silence_owner_id = None
-
-                task.add_done_callback(_clear_done_pending_silence)
-            # Let this wire-order effect start before the next mailbox event can
-            # cancel it. Later native appends still serialize on predecessor.
-            await asyncio.sleep(0)
-            return task
-
-        async def schedule_native_silence_continuation(
-            payload: object,
-            *,
-            request_id: str,
-            owner_id: str,
-            response_id: str | None,
-            response_owned: bool,
-            expected_epoch: int | None,
-            expected_incarnation: int,
-            expected_model_turn_id: int | None,
-            send_json,
-        ) -> bool:
-            del send_json
-            if session is None:
-                return False
-            clear_completed_pending_silence()
-            pending_silence = native.pending_silence_task
-            if pending_silence is not None and not pending_silence.done():
-                if pending_silence is asyncio.current_task():
-                    return False
-                try:
-                    if not await pending_silence:
-                        return False
-                except asyncio.CancelledError:
-                    current = asyncio.current_task()
-                    if current is not None and current.cancelling():
-                        raise
-                    return False
-                except Exception:
-                    return False
-                clear_completed_pending_silence()
-                pending_silence = native.pending_silence_task
-                if pending_silence is not None and not pending_silence.done():
-                    return False
-            append_tail = actor.native_append_tail
-            if (append_tail is None or append_tail.done()) and real_native_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 (
-                    actor.native_append_tail is not append_tail
-                    or ((append_tail is None or append_tail.done()) and real_native_input_waiting())
-                    or self._native_silence_continuation_is_stale(
-                        session,
-                        request_id=request_id,
-                        response_id=response_id,
-                        response_owned=response_owned,
-                        expected_epoch=expected_epoch,
-                        expected_incarnation=expected_incarnation,
-                        expected_model_turn_id=expected_model_turn_id,
-                    )
-                ):
-                    return False
-
-            def _still_valid() -> bool:
-                return not real_native_input_waiting() and not self._native_silence_continuation_is_stale(
-                    session,
-                    request_id=request_id,
-                    response_id=response_id,
-                    response_owned=response_owned,
-                    expected_epoch=expected_epoch,
-                    expected_incarnation=expected_incarnation,
-                    expected_model_turn_id=expected_model_turn_id,
-                )
-
-            native.pending_silence_owner_id = owner_id
-            task = await start_native_append(
-                payload,
-                final=False,
-                silence_continuation=True,
-                before_append=_still_valid,
-            )
-            if task is None:
-                native.pending_silence_owner_id = None
-                return False
-            return True
-
-        async def wait_for_native_append_tail() -> bool:
-            predecessor = actor.native_append_tail
-            if predecessor is None:
-                return True
-            try:
-                return await predecessor
-            except asyncio.CancelledError:
-                current = asyncio.current_task()
-                if current is not None and current.cancelling():
-                    raise
-                return False
-            except Exception:
-                # The append task already emitted its runtime error. Preserve
-                # wire order before the update path decides whether to continue.
-                return False
-
-        async def start_runtime_append(
-            payload: object,
-            *,
-            final: bool,
-            mode: str = "append_tokens",
-        ) -> None:
-            """Schedule non-native runtime appends without blocking WS input.
-
-            Model-native appends use ``start_native_append`` because they can
-            create data-plane response streams. Generic runtime appends still
-            need the same control-plane isolation so cancel/close can preempt a
-            slow engine append.
-            """
-            if session is None:
-                return
-            append_epoch = session.epoch
-
-            async def _run() -> None:
-                nonlocal runtime_closed
-                try:
-                    append_ok, emitted_response = await self._append_runtime_input(
-                        session,
-                        payload,
-                        final=final,
-                        send_json=emit_event,
-                        mode=mode,
-                        expected_epoch=append_epoch,
-                    )
-                    if not append_ok:
-                        if session.state == DuplexSessionState.CLOSED:
-                            runtime_closed = True
-                        return
-                    if not emitted_response and session.epoch == append_epoch:
-                        await emit_event(self._turn_controller.signal(session, DuplexTurnEventType.USER_STARTED.value))
-                except asyncio.CancelledError:
-                    raise
-                except Exception as exc:
-                    logger.exception("Duplex runtime append task failed: %s", exc)
-                    await self._send_runtime_error(emit_event, "runtime_append_task_failed", exc, session=session)
-
-            task = asyncio.create_task(_run())
-            actor.track_append_task(
-                task,
-                epoch=append_epoch,
-                mode=mode,
-                final=final,
-                response_bound=final,
-            )
-
-        try:
-            handshake = await self._open_session(
-                websocket,
-                emit_event,
-                realtime_protocol=realtime_protocol,
-                attachment_send=attachment_send,
-                attachment_close=attachment_close,
-            )
-            if handshake is None:
-                return
-            session = handshake.session
-            if initial_update_error := self._runtime_session_candidate_update_error(
-                session, session.config, realtime_protocol=realtime_protocol
-            ):
-                await emit_event(
-                    correlate_realtime_error(
-                        initial_update_error,
-                        handshake.event_id,
-                    )
-                )
-                return
-            if handshake.resumed:
-                native = self._serving_session_states[session.session_id]
-                actor.tasks = self._session_tasks[session.session_id]
-                persisted_protocol = self._realtime_protocols.get(session.session_id)
-                if persisted_protocol is None:
-                    raise RuntimeError(f"Missing Realtime protocol state for resumed session {session.session_id}")
-                realtime_protocol = persisted_protocol
-                realtime_protocol.bind_sender(send_realtime_raw)
-                attachment_generation = handshake.attachment_generation
-                attachment_ready = True
-                resume_credential_delivered = True
-                runtime_opened = True
-                self._ensure_lifecycle_listener()
-                reader_task = asyncio.create_task(read_event_loop(), name="duplex-session-reader")
-            else:
-                self._serving_session_states[session.session_id] = native
-                self._session_tasks[session.session_id] = actor.tasks
-                if realtime_protocol is not None:
-                    self._realtime_protocols[session.session_id] = realtime_protocol
-            native.silence_continuation_scheduler = schedule_native_silence_continuation
-            if realtime_protocol is not None:
-                realtime_protocol.bind_native_input_append(self._uses_native_input_append(session))
-                session.config.playback_commit_policy = DuplexPlaybackCommitPolicy.ACK_ONLY.value
-            if not handshake.resumed:
-                open_result = await self._open_runtime_session(session, emit_event)
-                if open_result is False:
-                    return
-                runtime_opened = True
-                try:
-                    await self._configure_server_vad(session)
-                except Exception as exc:
-                    logger.exception("Server VAD initialization failed: %s", exc)
-                    self._realtime_vad_metrics.error("initialization")
-                    await emit_event(
-                        correlate_realtime_error(
-                            {
-                                "type": "error",
-                                "session_id": session.session_id,
-                                "code": "server_vad_initialization_failed",
-                                "error": str(exc),
-                            },
-                            handshake.event_id,
-                        )
-                    )
-                    return
-                created_attachment = await self._attachment_registry.create(
-                    session.session_id,
-                    incarnation=session.incarnation,
-                    send=attachment_send,
-                    close=attachment_close,
-                )
-                attachment_generation = created_attachment.attachment_generation
-                attachment_ready = True
-                self._lease_generations[session.session_id] = 0
-                self._ensure_lifecycle_listener()
-                created_payload: dict[str, object] = {
-                    "type": "session.created",
-                    "session": session.as_public_dict(),
-                }
-                if session.capabilities.supports_session_resume:
-                    created_payload.update(
-                        {
-                            "incarnation": session.incarnation,
-                            "attachment_generation": attachment_generation,
-                            "resume_token": created_attachment.resume_token.plaintext,
-                        }
-                    )
-                if isinstance(open_result, dict):
-                    created_payload["runtime_control"] = self._redact_runtime_control_result(open_result)
-                if realtime_protocol is not None:
-                    realtime_protocol.commit_realtime_turn_detection_update(session.config.server_vad)
-                await emit_event(created_payload)
-                resume_credential_delivered = session.capabilities.supports_session_resume
-                reader_task = asyncio.create_task(read_event_loop(), name="duplex-session-reader")
-
-            while True:
-                event = await next_actor_event()
-                event_type = event.get("type")
-
-                if event_type == "__replaced_attachment__":
-                    return
-
-                if event_type == "__chat_response_finished__":
-                    completed_task = event.get("_response_task")
-                    if completed_task is not actor.active_response_task:
-                        continue
-                    actor.active_response_task = None
-                    activate_waiting_server_vad_turn()
-                    continue
-
-                if event_type == "__timeout__":
-                    begin_close("timeout")
-                    native.audio_buffer.clear()
-                    session.release_all_input_bytes()
-                    native.input_since_commit = False
-                    native.speech_since_commit = False
-                    native.clear_committed_audio()
-                    await actor.cancel_append_tasks()
-                    await self._cancel_native_data_plane_stream(session)
-                    await self._cancel_active_response(
-                        session,
-                        actor.active_response_task,
-                        emit_event,
-                        reason="timeout",
-                        notify=True,
-                    )
-                    actor.active_response_task = None
-                    runtime_closed = await self._close_runtime_session(
-                        session,
-                        reason="timeout",
-                        send_json=emit_event,
-                    )
-                    if not runtime_closed:
-                        return
-                    session.close()
-                    await emit_event(
-                        {
-                            "type": "session.closed",
-                            "session_id": session.session_id,
-                            "reason": "timeout",
-                        }
-                    )
-                    return
-
-                if event_type == "__disconnect__":
-                    transport_detached = True
-                    return
-
-                if not isinstance(event_type, str):
-                    continue
-
-                if event_type == "session.heartbeat":
-                    touch_session = getattr(self._chat_service.engine_client, "touch_duplex_session_async", None)
-                    if not callable(touch_session):
-                        await emit_event(
-                            {
-                                "type": "error",
-                                "error": "Duplex runtime does not expose heartbeat control",
-                                "code": "runtime_touch_unsupported",
-                            }
-                        )
-                        continue
-                    try:
-                        await touch_session(
-                            session.session_id,
-                            fence=DuplexFence(
-                                session.session_id,
-                                epoch=session.epoch,
-                                turn_id=session.turn_id,
-                                incarnation=session.incarnation,
-                            ),
-                            activity=DuplexLeaseActivity.HEARTBEAT,
-                        )
-                    except Exception as exc:
-                        await emit_event(
-                            {
-                                "type": "error",
-                                "error": str(exc),
-                                "code": "runtime_touch_failed",
-                            }
-                        )
-                        continue
-                    await emit_event(
-                        {
-                            "type": "session.heartbeat_ack",
-                            "session_id": session.session_id,
-                        }
-                    )
-                    continue
-
-                if event_type == "session.event_ack":
-                    acknowledged = event.get("server_event_seq")
-                    if not isinstance(acknowledged, int) or acknowledged < 0:
-                        await emit_event(
-                            {
-                                "type": "error",
-                                "error": "session.event_ack requires a non-negative server_event_seq",
-                                "code": "invalid_event_ack",
-                            }
-                        )
-                        continue
-                    try:
-                        await self._attachment_registry.acknowledge(session.session_id, acknowledged)
-                    except ValueError as exc:
-                        await emit_event(
-                            {
-                                "type": "error",
-                                "error": str(exc),
-                                "code": "invalid_event_ack",
-                            }
-                        )
-                    continue
-
-                if event_type == "turn.signal" and event.get("event") in {
-                    "input.cancel",
-                    "response.cancel",
-                    "barge_in",
-                }:
-                    payload = event.get("payload")
-                    normalized_event = dict(payload) if isinstance(payload, dict) else {}
-                    normalized_event.update(event)
-                    normalized_event["type"] = event["event"]
-                    event = normalized_event
-                    event_type = str(event["type"])
-
-                if event_type == "session.close":
-                    with suppress(asyncio.TimeoutError):
-                        await asyncio.wait_for(actor.output_queue.join(), timeout=1.0)
-                    begin_close("session_close")
-                    if session.state == DuplexSessionState.CLOSED:
-                        runtime_closed = True
-                        return
-                    native.audio_buffer.clear()
-                    session.release_all_input_bytes()
-                    native.input_since_commit = False
-                    native.speech_since_commit = False
-                    native.clear_committed_audio()
-                    await actor.cancel_append_tasks()
-                    await self._cancel_native_data_plane_stream(session)
-                    await self._cancel_active_response(
-                        session,
-                        actor.active_response_task,
-                        emit_event,
-                        reason="session_close",
-                    )
-                    runtime_closed = await self._close_runtime_session(
-                        session,
-                        reason="session_close",
-                        send_json=emit_event,
-                    )
-                    actor.active_response_task = None
-                    if not runtime_closed:
-                        return
-                    await emit_event({"type": "session.closed", "session_id": session.session_id})
-                    session.close()
-                    return
-
-                if event_type == "input_audio_buffer.clear":
-                    native.audio_buffer.clear()
-                    session.release_all_input_bytes()
-                    server_vad_pipeline = self._server_vad_pipelines.get(session.session_id)
-                    if server_vad_pipeline is not None:
-                        server_vad_pipeline.reset()
-                    native.input_since_commit = False
-                    native.speech_since_commit = False
-                    native.clear_committed_audio()
-                    cancelled = session.cancel_pending_input()
-                    await emit_event(
-                        {
-                            "type": "input_audio_buffer.cleared",
-                            "session_id": session.session_id,
-                            "epoch": session.epoch,
-                            "drained_input_events": 0,
-                            "cancelled": cancelled,
-                        }
-                    )
-                    continue
-
-                if event_type == "barge_in" and not session.capabilities.supports_barge_in:
-                    await emit_event(self._barge_in_unsupported_error(session))
-                    continue
-
-                if event_type in {"input.cancel", "response.cancel", "barge_in", "output_audio_buffer.clear"}:
-                    cancel_reason = (
-                        "output_audio_buffer_clear"
-                        if event_type == "output_audio_buffer.clear"
-                        else "client_cancelled"
-                        if event_type == "response.cancel"
-                        else "barge_in"
-                    )
-                    cancelled_fence = DuplexFence(
-                        session.session_id,
-                        epoch=session.epoch,
-                        turn_id=session.turn_id,
-                        incarnation=session.incarnation,
-                    )
-                    if event_type == "response.cancel":
-                        requested_response_id = event.get("response_id")
-                        has_active_response_work = native_response_in_progress()
-                        if isinstance(requested_response_id, str) and (
-                            session.active_response_id is None or requested_response_id != session.active_response_id
-                        ):
-                            await emit_event(
-                                {
-                                    "type": "error",
-                                    "session_id": session.session_id,
-                                    "code": "response_not_active",
-                                    "error": f"Response is not active: {requested_response_id}",
-                                }
-                            )
-                            continue
-                    if event_type == "response.cancel":
-                        if not has_active_response_work:
-                            if realtime_protocol is not None and isinstance(requested_response_id, str):
-                                continue
-                            await emit_event(
-                                {
-                                    "type": "error",
-                                    "session_id": session.session_id,
-                                    "code": "response_not_active",
-                                    "error": "response.cancel requires an active response",
-                                }
-                            )
-                            continue
-                    had_native_unbuffered_append = (
-                        self._uses_native_input_append(session)
-                        and native.input_since_commit
-                        and not native.audio_buffer.has_pending()
-                    )
-                    playback_was_active = self._assistant_playback_active(session)
-                    if event_type in {"input.cancel", "barge_in"}:
-                        native.audio_buffer.clear()
-                        session.release_all_input_bytes()
-                        native.input_since_commit = False
-                        native.speech_since_commit = False
-                        native.clear_committed_audio()
-                    had_native_append = await actor.cancel_append_tasks(
-                        response_bound_only=event_type in {"response.cancel", "output_audio_buffer.clear"},
-                    )
-                    if event_type == "response.cancel":
-                        session.release_input_bytes(native.clear_committed_audio())
-                    had_native_stream = native.data_plane_task is not None
-                    cancelled = await self._cancel_active_response(
-                        session,
-                        actor.active_response_task,
-                        emit_event,
-                        reason=cancel_reason,
-                    )
-                    had_native_stream = await self._cancel_native_data_plane_stream(session) or had_native_stream
-                    if not cancelled and (had_native_stream or had_native_append or had_native_unbuffered_append):
-                        old_epoch = session.epoch
-                        old_response_id = session.active_response_id
-                        committed_ms = session.playback.committed_ms
-                        self._commit_played_response_history(session, old_response_id, committed_ms)
-                        new_epoch, old_playback = self._advance_barge_in_epoch(session)
-                        await emit_event(
-                            {
-                                "type": "audio.cancelled",
-                                "session_id": session.session_id,
-                                "response_id": old_response_id,
-                                "reason": cancel_reason,
-                                "cancelled_epoch": old_epoch,
-                                "epoch": new_epoch,
-                                "committed_ms": committed_ms,
-                                "playback": old_playback,
-                            }
-                        )
-                        cancelled = True
-                    if not cancelled and playback_was_active:
-                        old_epoch = session.epoch
-                        committed_ms = session.playback.committed_ms
-                        self._commit_played_response_history(session, session.last_response_id, committed_ms)
-                        new_epoch, old_playback = self._advance_barge_in_epoch(session)
-                        await emit_event(
-                            {
-                                "type": "audio.cancelled",
-                                "session_id": session.session_id,
-                                "response_id": session.last_response_id,
-                                "reason": cancel_reason,
-                                "cancelled_epoch": old_epoch,
-                                "epoch": new_epoch,
-                                "committed_ms": committed_ms,
-                                "playback": old_playback,
-                            }
-                        )
-                        cancelled = True
-                    if not cancelled and event_type == "response.cancel":
-                        old_epoch = session.epoch
-                        old_response_id = session.active_response_id
-                        committed_ms = session.playback.committed_ms
-                        self._commit_played_response_history(session, old_response_id, committed_ms)
-                        new_epoch, old_playback = self._advance_barge_in_epoch(session)
-                        await emit_event(
-                            {
-                                "type": "audio.cancelled",
-                                "session_id": session.session_id,
-                                "response_id": old_response_id,
-                                "reason": cancel_reason,
-                                "cancelled_epoch": old_epoch,
-                                "epoch": new_epoch,
-                                "committed_ms": committed_ms,
-                                "playback": old_playback,
-                            }
-                        )
-                        cancelled = True
-                    if not cancelled and event_type == "output_audio_buffer.clear":
-                        old_playback = session.playback.as_dict()
-                        committed_ms = session.playback.committed_ms
-                        session.clear_playback_cursor()
-                        await emit_event(
-                            {
-                                "type": "audio.cancelled",
-                                "session_id": session.session_id,
-                                "response_id": session.active_response_id,
-                                "reason": cancel_reason,
-                                "cancelled_epoch": session.epoch,
-                                "epoch": session.epoch,
-                                "committed_ms": committed_ms,
-                                "playback": old_playback,
-                            }
-                        )
-                        actor.active_response_task = None
-                        activate_waiting_server_vad_turn()
-                        continue
-                    if not cancelled:
-                        await self._cancel_pending_input(session, emit_event, reason="barge_in")
-                    if not await self._signal_runtime_session(
-                        session,
-                        "barge_in",
-                        emit_event,
-                        fence=cancelled_fence,
-                        next_fence=(
-                            DuplexFence(
-                                session.session_id,
-                                epoch=session.epoch,
-                                turn_id=session.turn_id,
-                                incarnation=session.incarnation,
-                            )
-                            if session.epoch > cancelled_fence.epoch
-                            else None
-                        ),
-                    ):
-                        continue
-                    actor.active_response_task = None
-                    activate_waiting_server_vad_turn()
-                    continue
-
-                if event_type == "turn.signal":
-                    turn_event = event.get("event")
-                    if isinstance(turn_event, str):
-                        if turn_event == "barge_in" and not session.capabilities.supports_barge_in:
-                            await emit_event(self._barge_in_unsupported_error(session))
-                            continue
-                        if turn_event == "session.update":
-                            realtime_event_id = event.get("realtime_event_id")
-
-                            async def emit_update_event(update_event: dict[str, object]) -> None:
-                                if isinstance(realtime_event_id, str) and realtime_event_id:
-                                    update_event = {**update_event, "realtime_event_id": realtime_event_id}
-                                await emit_event(update_event)
-
-                            def reject_update() -> None:
-                                if realtime_protocol is not None:
-                                    realtime_protocol.reject_realtime_turn_detection_update()
-
-                            payload = event.get("payload")
-                            if not isinstance(payload, dict):
-                                await emit_update_event(
-                                    {
-                                        "type": "error",
-                                        "session_id": session.session_id,
-                                        "code": "bad_event",
-                                        "error": "session.update requires a session payload",
-                                    }
-                                )
-                                reject_update()
-                                continue
-                            if not await wait_for_native_append_tail():
-                                await emit_update_event(
-                                    {
-                                        "type": "error",
-                                        "code": "session_update_aborted",
-                                        "error": "session.update was not applied because the preceding append failed",
-                                    }
-                                )
-                                reject_update()
-                                continue
-                            if (
-                                realtime_protocol is not None
-                                and not self._uses_native_input_append(session)
-                                and session.config.server_vad is not None
-                                and session.turn_detection_config_locked
-                                and realtime_protocol.pending_realtime_input_audio_config_changed()
-                            ):
-                                await emit_update_event(
-                                    {
-                                        "type": "error",
-                                        "session_id": session.session_id,
-                                        "code": "unsupported_audio_format",
-                                        "error": (
-                                            "session.update cannot change Server VAD input format or sample rate "
-                                            "after the first audio append"
-                                        ),
-                                        "param": "audio.input.format",
-                                    }
-                                )
-                                reject_update()
-                                continue
-                            runtime_update_error = self._runtime_session_update_error(session, payload)
-                            if runtime_update_error is not None:
-                                await emit_update_event(runtime_update_error)
-                                reject_update()
-                                continue
-                            previous_config = session.config
-                            candidate_config = deepcopy(previous_config)
-                            session.replace_config(candidate_config)
-                            try:
-                                update_error = self._apply_session_update(session, payload)
-                            finally:
-                                session.replace_config(previous_config)
-                            server_vad_changed = candidate_config.server_vad != previous_config.server_vad
-                            if update_error is not None:
-                                await emit_update_event(update_error)
-                                reject_update()
-                                continue
-                            runtime_update_error = self._runtime_session_candidate_update_error(
-                                session,
-                                candidate_config,
-                                realtime_protocol=realtime_protocol,
-                            )
-                            if runtime_update_error is not None:
-                                await emit_update_event(runtime_update_error)
-                                reject_update()
-                                continue
-                            try:
-                                candidate_runtime_config = self._runtime_config_for_session_update(
-                                    session,
-                                    candidate_config,
-                                )
-                            except ServingRuntimeConfigError as exc:
-                                await emit_update_event(
-                                    {
-                                        "type": "error",
-                                        "session_id": session.session_id,
-                                        "code": exc.code,
-                                        "error": str(exc),
-                                    }
-                                )
-                                reject_update()
-                                continue
-                            candidate_server_vad_pipeline = None
-                            if server_vad_changed:
-                                try:
-                                    candidate_server_vad_pipeline = await self._prepare_server_vad_pipeline(
-                                        session,
-                                        candidate_config,
-                                    )
-                                except Exception as exc:
-                                    logger.exception("Server VAD session update failed: %s", exc)
-                                    self._realtime_vad_metrics.error("initialization")
-                                    await emit_update_event(
-                                        {
-                                            "type": "error",
-                                            "session_id": session.session_id,
-                                            "code": "server_vad_initialization_failed",
-                                            "error": str(exc),
-                                        }
-                                    )
-                                    reject_update()
-                                    continue
-                            runtime_updated = await self._signal_runtime_session(
-                                session,
-                                turn_event,
-                                emit_update_event,
-                                session_config=candidate_config.as_dict(),
-                                runtime_config=candidate_runtime_config,
-                            )
-                            if not runtime_updated:
-                                reject_update()
-                                continue
-                            session.replace_config(candidate_config)
-                            session.replace_runtime_config(candidate_runtime_config)
-                            if server_vad_changed:
-                                self._install_server_vad_pipeline(
-                                    session,
-                                    candidate_server_vad_pipeline,
-                                )
-                            if realtime_protocol is not None:
-                                realtime_protocol.bind_native_input_append(self._uses_native_input_append(session))
-                                realtime_protocol.commit_realtime_turn_detection_update(session.config.server_vad)
-                            await emit_update_event(
-                                {
-                                    "type": "session.updated",
-                                    "session": session.as_public_dict(),
-                                }
-                            )
-                            continue
-                        if turn_event == "conversation.item.create":
-                            payload = event.get("payload")
-                            item = payload.get("item") if isinstance(payload, dict) else None
-                            item_type = item.get("type") if isinstance(item, dict) else None
-                            prepare_function_output = getattr(
-                                self._serving_runtime_adapter,
-                                "runtime_config_for_function_output",
-                                None,
-                            )
-                            if item_type == "function_call_output" and callable(prepare_function_output):
-                                if not await wait_for_native_append_tail():
-                                    continue
-                                try:
-                                    candidate_runtime_config = prepare_function_output(
-                                        item,
-                                        dict(session.runtime_config),
-                                    )
-                                except ServingRuntimeConfigError as exc:
-                                    await emit_event(
-                                        {
-                                            "type": "error",
-                                            "session_id": session.session_id,
-                                            "code": exc.code,
-                                            "error": str(exc),
-                                        }
-                                    )
-                                    continue
-                                if not await self._signal_runtime_session(
-                                    session,
-                                    "session.update",
-                                    emit_event,
-                                    runtime_config=candidate_runtime_config,
-                                ):
-                                    continue
-                                session.replace_runtime_config(candidate_runtime_config)
-                                await emit_event(
-                                    {
-                                        "type": "conversation.item.created",
-                                        "session_id": session.session_id,
-                                        "item": item,
-                                        "created": True,
-                                    }
-                                )
-                                await self._maybe_continue_native_response(
-                                    emit_event,
-                                    session=session,
-                                    expected_epoch=session.epoch,
-                                    expected_model_turn_id=session.turn_id,
-                                )
-                                continue
-                            history_item = payload.get("history_item") if isinstance(payload, dict) else None
-                            if not isinstance(history_item, dict):
-                                history_item = item
-                            message = self._realtime_item_to_history_message(history_item)
-                            item_id = item.get("id") if isinstance(item, dict) else None
-                            if message is not None:
-                                session.append_history_message(message)
-                                session.register_history_item(item_id if isinstance(item_id, str) else None, message)
-                            await emit_event(
-                                {
-                                    "type": "conversation.item.created",
-                                    "session_id": session.session_id,
-                                    "item": item,
-                                    "created": message is not None,
-                                }
-                            )
-                            continue
-                        if turn_event == "conversation.item.delete":
-                            payload = event.get("payload")
-                            item_id = payload.get("item_id") if isinstance(payload, dict) else None
-                            deleted = session.delete_history_item(item_id) if isinstance(item_id, str) else False
-                            await emit_event(
-                                {
-                                    "type": "conversation.item.deleted",
-                                    "session_id": session.session_id,
-                                    "item_id": item_id,
-                                    "deleted": deleted,
-                                }
-                            )
-                            continue
-                        if turn_event == "conversation.item.truncate":
-                            payload = event.get("payload")
-                            item_id = payload.get("item_id") if isinstance(payload, dict) else None
-                            audio_end_ms = payload.get("audio_end_ms") if isinstance(payload, dict) else None
-                            truncated = (
-                                session.truncate_history_item(
-                                    item_id,
-                                    audio_end_ms=int(audio_end_ms) if isinstance(audio_end_ms, int | float) else 0,
-                                    hard=True,
-                                )
-                                if isinstance(item_id, str)
-                                else False
-                            )
-                            await emit_event(
-                                {
-                                    "type": "conversation.item.truncated",
-                                    "session_id": session.session_id,
-                                    "item_id": item_id,
-                                    "content_index": (
-                                        payload.get("content_index", 0) if isinstance(payload, dict) else 0
-                                    ),
-                                    "audio_end_ms": audio_end_ms,
-                                    "truncated": truncated,
-                                }
-                            )
-                            continue
-                        await emit_event(self._turn_controller.signal(session, turn_event, event))
-                    else:
-                        await emit_event({"type": "error", "error": "turn.signal requires event", "code": "bad_event"})
-                    continue
-
-                if event_type == "playback.ack":
-                    await self._handle_playback_ack(session, event, emit_event)
-                    continue
-
-                if event_type == "input.text.append":
-                    session.mark_user_input_activity()
-                    text = event.get("text")
-                    if not isinstance(text, str):
-                        await emit_event(
-                            {
-                                "type": "error",
-                                "error": "input.text.append requires text",
-                                "code": "bad_event",
-                            }
-                        )
-                        continue
-                    if self._uses_native_input_append(session):
-                        await emit_event(
-                            {
-                                "type": "error",
-                                "error": "The selected native duplex runtime accepts audio append only",
-                                "code": "native_text_append_unsupported",
-                            }
-                        )
-                        continue
-                    else:
-                        session.append_text(text)
-                    if session.capabilities.supports_input_append:
-                        await start_runtime_append(text, final=False, mode="append_tokens")
-                    continue
-
-                if event_type == "input_audio_buffer.append":
-                    session.mark_user_input_activity()
-                    audio = event.get("audio") or event.get("data")
-                    if not isinstance(audio, str):
-                        await emit_event(
-                            {
-                                "type": "error",
-                                "error": "input.audio.append requires audio",
-                                "code": "bad_event",
-                            }
-                        )
-                        continue
-                    if not session.capabilities.supports_barge_in and self._event_requests_barge_in(event):
-                        await emit_event(self._barge_in_unsupported_error(session))
-                        event = dict(event)
-                        event.pop("force_barge_in", None)
-                        for key in ("overlap_action", "overlap"):
-                            value = event.get(key)
-                            if isinstance(value, str) and value.strip().lower() in {
-                                "barge_in",
-                                "interrupt",
-                                "cancel",
-                            }:
-                                event.pop(key, None)
-                    fmt = event.get("format") if isinstance(event.get("format"), str) else "pcm16"
-                    default_sample_rate_hz = 16000
-                    sr_raw = event.get("sample_rate_hz") or event.get("sample_rate")
-                    sample_rate_hz = sr_raw if isinstance(sr_raw, int | float) else default_sample_rate_hz
-                    native_input = self._uses_native_input_append(session)
-                    server_vad_config = session.config.server_vad
-                    turn_based_server_vad = server_vad_config is not None and not native_input
-                    if not turn_based_server_vad:
-                        try:
-                            audio, fmt, sample_rate_hz = convert_input_audio_with_rate(
-                                audio,
-                                fmt,
-                                sample_rate_hz=sample_rate_hz,
-                            )
-                        except ValueError as exc:
-                            await emit_event({"type": "error", "error": str(exc), "code": "bad_event"})
-                            continue
-                        if isinstance(fmt, str) and fmt.lower() in {"pcm16", "pcm_s16le", "s16le"}:
-                            await emit_event(
-                                {
-                                    "type": "error",
-                                    "error": "input_audio_buffer.append pcm16 audio could not be decoded",
-                                    "code": "bad_audio",
-                                }
-                            )
-                            continue
-                        if server_vad_config is None:
-                            session.lock_turn_detection_config()
-                    force_listen = bool(event.get("force_listen", False))
-                    payload = {
-                        "type": "audio",
-                        "audio": audio,
-                        "format": fmt,
-                        "sample_rate_hz": sample_rate_hz,
-                        "force_listen": force_listen,
-                    }
-                    video_frames = event.get("video_frames")
-                    if isinstance(video_frames, list):
-                        frames = [frame for frame in video_frames if isinstance(frame, str) and frame]
-                        if frames:
-                            payload["video_frames"] = frames
-                    if server_vad_config is not None:
-                        realtime_event_id = event.get("_realtime_event_id")
-                        pipeline = self._server_vad_pipelines.get(session.session_id)
-                        if pipeline is None:
-                            await emit_event(
-                                correlate_realtime_error(
-                                    {
-                                        "type": "error",
-                                        "session_id": session.session_id,
-                                        "code": "internal_error",
-                                        "error": "server_vad is configured but its detector pipeline is unavailable",
-                                    },
-                                    realtime_event_id,
-                                )
-                            )
-                            continue
-                        speech_was_active = pipeline.speech_active
-                        reserved_bytes = 0
-                        previous_scratch_bytes = pipeline.scratch_bytes
-                        try:
-                            if native_input:
-                                if fmt != "pcm_f32le" or sample_rate_hz != pipeline.sample_rate_hz:
-                                    raise ValueError("native server_vad input must be mono PCM float32 at 16000 Hz")
-                                raw_audio = base64.b64decode(audio, validate=True)
-                                if len(raw_audio) % np.dtype("<f4").itemsize:
-                                    raise ValueError("native server_vad input contains an incomplete float32 sample")
-                                normalized_audio = np.frombuffer(raw_audio, dtype="<f4")
-                                accepted_audio = normalized_audio.size > 0
-                            else:
-                                if fmt != "pcm16":
-                                    raise ValueError("server_vad input must be mono PCM16")
-                                source_sample_rate_hz = validate_input_sample_rate_hz(sample_rate_hz)
-                                if source_sample_rate_hz not in {16_000, 24_000}:
-                                    raise ValueError("server_vad PCM16 input sample rate must be 16000 or 24000 Hz")
-                                if (
-                                    pipeline.source_sample_rate_hz is not None
-                                    and source_sample_rate_hz != pipeline.source_sample_rate_hz
-                                ):
-                                    raise ValueError(
-                                        "server_vad input sample rate cannot change within a continuous audio stream"
-                                    )
-                                try:
-                                    raw_audio = base64.b64decode(audio, validate=True)
-                                except (binascii.Error, ValueError) as exc:
-                                    raise ValueError(
-                                        "server_vad input audio must be valid base64-encoded PCM16"
-                                    ) from exc
-                                if len(raw_audio) % np.dtype("<i2").itemsize:
-                                    raise ValueError("server_vad PCM16 input contains an incomplete sample")
-                                source_samples = len(raw_audio) // np.dtype("<i2").itemsize
-                                accepted_audio = source_samples > 0
-                        except (binascii.Error, ValueError) as exc:
-                            await emit_event(
-                                correlate_realtime_error(
-                                    {
-                                        "type": "error",
-                                        "session_id": session.session_id,
-                                        "code": "bad_audio",
-                                        "error": str(exc),
-                                        "param": "audio",
-                                    },
-                                    realtime_event_id,
-                                )
-                            )
-                            continue
-                        if not native_input:
-                            normalized_sample_upper_bound = (
-                                source_samples
-                                if source_sample_rate_hz == pipeline.sample_rate_hz
-                                else ((source_samples + 2) // 3) * 2
-                            )
-                            reserved_bytes = normalized_sample_upper_bound * np.dtype(np.float32).itemsize
-                            if not session.reserve_input_bytes(
-                                reserved_bytes,
-                                limit=self._duplex_session_config.max_pending_input_bytes_per_session,
-                            ):
-                                await reject_and_clear_server_vad_input(
-                                    pipeline,
-                                    code="input_backpressure",
-                                    error="Server VAD input exceeds the per-session input limit",
-                                    metric_reason="input_backpressure",
-                                    event_id=realtime_event_id,
-                                )
-                                continue
-                        try:
-                            vad_batch = (
-                                await pipeline.push(normalized_audio)
-                                if native_input
-                                else await pipeline.push_pcm16(
-                                    raw_audio,
-                                    source_sample_rate_hz=source_sample_rate_hz,
-                                )
-                            )
-                        except Exception as exc:
-                            logger.exception("Server VAD inference failed: %s", exc)
-                            await reject_and_clear_server_vad_input(
-                                pipeline,
-                                code="server_vad_inference_failed",
-                                error=str(exc),
-                                metric_reason="inference",
-                                event_id=realtime_event_id,
-                            )
-                            continue
-                        if not native_input:
-                            retained_delta = (
-                                sum(frame.samples.nbytes for frame in vad_batch.frames)
-                                + pipeline.scratch_bytes
-                                - previous_scratch_bytes
-                            )
-                            session.release_input_bytes(max(0, reserved_bytes - retained_delta))
-                        self._realtime_vad_metrics.observe_inference(vad_batch.inference_ms)
-                        prefix_samples = round(server_vad_config.prefix_padding_ms * pipeline.sample_rate_hz / 1000)
-                        speech_started = False
-                        speech_stopped = False
-                        for frame_index, vad_frame in enumerate(vad_batch.frames):
-                            decision = vad_frame.decision
-                            if not native_input:
-                                released_bytes = session.append_server_vad_frame(
-                                    vad_frame.samples,
-                                    speech_started=decision.speech_started,
-                                    speech_stopped=decision.speech_stopped,
-                                    prefix_samples=prefix_samples,
-                                )
-                                session.release_input_bytes(released_bytes)
-                            if decision.speech_started:
-                                speech_started = True
-                                item_id = f"item_{uuid.uuid4().hex}"
-                                session.begin_server_vad_speech(item_id)
-                                await emit_event(
-                                    {
-                                        "type": "input_audio_buffer.speech_started",
-                                        "session_id": session.session_id,
-                                        "item_id": item_id,
-                                        "audio_start_ms": decision.audio_start_ms or 0,
-                                    }
-                                )
-                            if decision.speech_stopped:
-                                speech_stopped = True
-                                item_id = session.finish_server_vad_speech() or f"item_{uuid.uuid4().hex}"
-                                await emit_event(
-                                    {
-                                        "type": "input_audio_buffer.speech_stopped",
-                                        "session_id": session.session_id,
-                                        "item_id": item_id,
-                                        "audio_end_ms": decision.audio_end_ms or 0,
-                                    }
-                                )
-                                if decision.endpoint_delay_ms is not None:
-                                    self._realtime_vad_metrics.observe_endpoint_delay(decision.endpoint_delay_ms)
-                                if not native_input:
-                                    remaining_frame_bytes = sum(
-                                        frame.samples.nbytes for frame in vad_batch.frames[frame_index + 1 :]
-                                    )
-                                    await commit_server_vad_turn(
-                                        item_id=item_id,
-                                        create_response=server_vad_config.create_response,
-                                        retain_input_bytes=remaining_frame_bytes + pipeline.scratch_bytes,
-                                        event_id=realtime_event_id,
-                                    )
-                        if accepted_audio:
-                            session.lock_turn_detection_config()
-                        if not native_input:
-                            continue
-                        speech_active = pipeline.speech_active
-                        contained_speech = speech_was_active or speech_started or speech_stopped or speech_active
-                        payload["is_speech"] = contained_speech
-                        payload["vad"] = {
-                            "backend": "silero",
-                            "is_speech": contained_speech,
-                            "speech_active": speech_active,
-                            "speech_started": speech_started,
-                            "speech_stopped": speech_stopped,
-                        }
-                        if speech_active:
-                            payload["force_listen"] = True
-                    # Speech/silence tag for the Stage0 turn-ended latch.
-                    payload["is_speech"] = self._input_looks_like_speech(event, payload, session=session)
-                    defer_native_append = False
-                    buffer_overlap_audio = True
-                    if native_input:
-                        mark_pending_silence_superseded()
-                        overlap_active = native_response_in_progress() and (
-                            not self._session_auto_responds(session)
-                            or (
-                                session.capabilities.supports_barge_in
-                                and (
-                                    session.config.overlap_policy == DuplexOverlapPolicy.BARGE_IN_ON_SPEECH.value
-                                    or self._event_requests_barge_in(event)
-                                )
-                            )
-                        )
-                        if overlap_active:
-                            decision = self._overlap_decision(session, event, payload)
-                            await self._emit_overlap_decision(emit_event, session, decision)
-                            action = decision.get("action")
-                            if action == "drop":
-                                if realtime_protocol is not None:
-                                    await realtime_protocol.discard_pending_input_audio(
-                                        audio_end_ms=self._input_audio_duration_ms(event, payload)
-                                    )
-                                continue
-                            if action == "listen":
-                                buffer_overlap_audio = bool(decision.get("buffer_audio", True))
-                                defer_native_append = bool(decision.get("defer_runtime_append", True))
-                                if (
-                                    not buffer_overlap_audio
-                                    and realtime_protocol is not None
-                                    and decision.get("preserve_realtime_input") is not True
-                                ):
-                                    await realtime_protocol.discard_pending_input_audio(
-                                        audio_end_ms=self._input_audio_duration_ms(event, payload)
-                                    )
-                                if decision.get("force_listen", True) is True:
-                                    payload["force_listen"] = True
-                            else:
-                                event["force_barge_in"] = True
-                                cancelled_fence = DuplexFence(
-                                    session.session_id,
-                                    epoch=session.epoch,
-                                    turn_id=session.turn_id,
-                                    incarnation=session.incarnation,
-                                )
-                                playback_was_active = self._assistant_playback_active(session)
-                                buffer_overlap_audio = True
-                                defer_native_append = False
-                                native.audio_buffer.clear_force_listen()
-                                session.reset_overlap_speech()
-                                native.input_since_commit = False
-                                native.speech_since_commit = False
-                                await actor.cancel_append_tasks()
-                                had_native_stream = native.data_plane_task is not None
-                                cancel_reason = str(decision.get("cancel_reason") or "barge_in")
-                                cancelled = await self._cancel_active_response(
-                                    session,
-                                    actor.active_response_task,
-                                    emit_event,
-                                    reason=cancel_reason,
-                                )
-                                had_native_stream = (
-                                    await self._cancel_native_data_plane_stream(session) or had_native_stream
-                                )
-                                if not cancelled and had_native_stream:
-                                    old_epoch = session.epoch
-                                    old_response_id = session.active_response_id
-                                    committed_ms = session.playback.committed_ms
-                                    self._commit_played_response_history(session, old_response_id, committed_ms)
-                                    new_epoch, old_playback = self._advance_barge_in_epoch(session)
-                                    await emit_event(
-                                        {
-                                            "type": "audio.cancelled",
-                                            "session_id": session.session_id,
-                                            "response_id": old_response_id,
-                                            "reason": cancel_reason,
-                                            "cancelled_epoch": old_epoch,
-                                            "epoch": new_epoch,
-                                            "committed_ms": committed_ms,
-                                            "playback": old_playback,
-                                        }
-                                    )
-                                    cancelled = True
-                                if not cancelled and playback_was_active:
-                                    old_epoch = session.epoch
-                                    committed_ms = session.playback.committed_ms
-                                    self._commit_played_response_history(
-                                        session, session.last_response_id, committed_ms
-                                    )
-                                    new_epoch, old_playback = self._advance_barge_in_epoch(session)
-                                    await emit_event(
-                                        {
-                                            "type": "audio.cancelled",
-                                            "session_id": session.session_id,
-                                            "response_id": session.last_response_id,
-                                            "reason": cancel_reason,
-                                            "cancelled_epoch": old_epoch,
-                                            "epoch": new_epoch,
-                                            "committed_ms": committed_ms,
-                                            "playback": old_playback,
-                                        }
-                                    )
-                                    cancelled = True
-                                if session.epoch > cancelled_fence.epoch:
-                                    if not await self._signal_runtime_session(
-                                        session,
-                                        "barge_in",
-                                        emit_event,
-                                        fence=cancelled_fence,
-                                        next_fence=DuplexFence(
-                                            session.session_id,
-                                            epoch=session.epoch,
-                                            turn_id=session.turn_id,
-                                            incarnation=session.incarnation,
-                                        ),
-                                    ):
-                                        continue
-                                actor.active_response_task = None
-                        elif not self._session_auto_responds(session) and not self._input_looks_like_speech(
-                            event, payload, session=session
-                        ):
-                            # Turn-mode only: skip silent chunks so they don't open a
-                            # response. In auto-respond (full-duplex) mode the model owns
-                            # the speak/listen decision and MUST receive silence units --
-                            # the official model typically starts speaking during the
-                            # silence after a question.
-                            # No response_id: a silence-skip listen can arrive
-                            # while a response is still streaming and must not
-                            # read as that response's terminal decision.
-                            await emit_event(
-                                {
-                                    "type": "response.listen",
-                                    "session_id": session.session_id,
-                                    "epoch": session.epoch,
-                                    "reason": "silence_or_noise",
-                                }
-                            )
-                            continue
-                        if self._should_force_listen_for_auto_response_overlap(session, event, payload):
-                            # Auto-response keeps a long-lived native Stage0 stream.
-                            # While assistant audio is still active, silence from the
-                            # browser should advance the model in listen mode rather
-                            # than letting the same stream start another assistant
-                            # segment. Speech/barge-in chunks remain model-owned.
-                            payload["force_listen"] = True
-                        if not buffer_overlap_audio:
-                            continue
-                        session.mark_user_input_activity()
-                        native.input_since_commit = True
-                        native.speech_since_commit = native.speech_since_commit or self._input_looks_like_speech(
-                            event, payload, session=session
-                        )
-                        try:
-                            raw_audio_bytes = self._native_audio_payload_size_bytes(payload)
-                            if not session.reserve_input_bytes(
-                                raw_audio_bytes,
-                                limit=self._duplex_session_config.max_pending_input_bytes_per_session,
-                            ):
-                                await emit_event(
-                                    {
-                                        "type": "error",
-                                        "error": "Duplex session pending input exceeds server limit",
-                                        "code": "input_backpressure",
-                                    }
-                                )
-                                continue
-                            allow_emit = not defer_native_append and (
-                                realtime_protocol is None
-                                or event_type != "input_audio_buffer.append"
-                                # Full-duplex: emit each ~chunk_period of audio so the model
-                                # runs per-chunk generation (speak/listen) without an explicit
-                                # response.create, matching the official duplex_generate loop.
-                                or self._session_auto_responds(session)
-                            )
-                            pcm_reservation = native.audio_buffer.prepare_append(
-                                payload,
-                                operation_id=uuid.uuid4().hex,
-                                chunk_period_ms=session.capabilities.chunk_period_ms or 1000,
-                                allow_emit=allow_emit,
-                            )
-                        except ValueError as exc:
-                            session.release_input_bytes(raw_audio_bytes)
-                            await emit_event({"type": "error", "error": str(exc), "code": "bad_event"})
-                            continue
-                        if pcm_reservation is None:
-                            continue
-                        if pcm_reservation.byte_count == 0:
-                            session.release_input_bytes(raw_audio_bytes)
-                        payload = pcm_reservation.payload
-                    else:
-                        session.append_audio(audio, fmt=fmt, sample_rate_hz=sample_rate_hz)
-                    if native_input:
-                        await start_native_append(
-                            payload,
-                            final=False,
-                            pcm_reservation=pcm_reservation,
-                        )
-                        continue
-                    if session.capabilities.supports_input_append:
-                        await start_runtime_append(payload, final=False, mode="append_audio_chunk")
-                    continue
-
-                if event_type in {"input.commit", "input_audio_buffer.commit", "response.create"}:
-                    if (
-                        event_type == "response.create"
-                        and session.config.server_vad is not None
-                        and actor.active_response_task is not None
-                    ):
-                        await emit_event(
-                            {
-                                "type": "error",
-                                "session_id": session.session_id,
-                                "code": "response_already_active",
-                                "error": "response.create must wait for the active response to complete",
-                            }
-                        )
-                        continue
-                    item_id = event.get("item_id")
-                    realtime_validated_audio_commit = (
-                        event_type == "input_audio_buffer.commit" and isinstance(item_id, str) and bool(item_id)
-                    )
-                    if (
-                        self._uses_native_input_append(session)
-                        and event_type in {"input.commit", "input_audio_buffer.commit"}
-                        and not await wait_for_native_append_tail()
-                    ):
-                        continue
-                    if event_type == "input_audio_buffer.commit" and event.get("is_speech") is False:
-                        native.input_since_commit = False
-                        native.speech_since_commit = False
-                        native.audio_buffer.clear()
-                        session.release_all_input_bytes()
-                        native.clear_committed_audio()
-                        await emit_event(
-                            {
-                                "type": "input.committed",
-                                "session_id": session.session_id,
-                                "item_id": item_id,
-                                "turn_id": session.turn_id,
-                                "epoch": session.epoch,
-                                "empty": True,
-                                "is_speech": False,
-                                "no_response": True,
-                            }
-                        )
-                        # No response_id: this silence listen answers an empty
-                        # commit, it is not a response terminal.
-                        await emit_event(
-                            {
-                                "type": "response.listen",
-                                "session_id": session.session_id,
-                                "epoch": session.epoch,
-                                "reason": "silence_or_noise",
-                            }
-                        )
-                        continue
-                    should_create_response = (
-                        event_type == "response.create"
-                        or bool(event.get("response_create", event_type == "input.commit"))
-                        or (event_type == "input_audio_buffer.commit" and self._session_auto_responds(session))
-                    )
-                    precreate_response_requested = event_type == "response.create" or bool(
-                        event.get("response_create", event_type == "input.commit")
-                    )
-                    if event_type == "response.create":
-                        response_payload = event.get("response")
-                        if isinstance(response_payload, dict):
-                            response_options_error = self._apply_response_create_options(session, response_payload)
-                            if response_options_error is not None:
-                                error_message = (
-                                    "The selected native duplex runtime does not support generation "
-                                    "overrides for instructions, voice, temperature, max tokens, tools, or "
-                                    "tool_choice."
-                                    if response_options_error == "unsupported_native_response_options"
-                                    else "response.create cannot reserve options while another response is active."
-                                )
-                                await emit_event(
-                                    {
-                                        "type": "error",
-                                        "session_id": session.session_id,
-                                        "epoch": session.epoch,
-                                        "code": response_options_error,
-                                        "error": error_message,
-                                    }
-                                )
-                                continue
-                    if self._uses_native_input_append(session) and event_type == "input_audio_buffer.commit":
-                        has_pending_native_audio = (
-                            native.input_since_commit
-                            or native.audio_buffer.has_pending()
-                            or native.committed_audio_payload is not None
-                            or realtime_validated_audio_commit
-                        )
-                        if (
-                            not has_pending_native_audio
-                            and not actor.native_append_tasks
-                            and native.data_plane_task is None
-                        ):
-                            await emit_event(
-                                {
-                                    "type": "error",
-                                    "session_id": session.session_id,
-                                    "epoch": session.epoch,
-                                    "code": "input_audio_buffer_empty",
-                                    "error": "input_audio_buffer.commit requires a non-empty input audio buffer.",
-                                }
-                            )
-                            continue
-                        commit_action = decide_commit_action(
-                            CommitSnapshot(
-                                auto_responds=self._session_auto_responds(session),
-                                speech_since_commit=native.speech_since_commit,
-                                active_response_id=session.active_response_id,
-                                overlap_speech_ms=session.overlap_speech_ms,
-                                native_response_in_progress=native_response_in_progress(),
-                                playback_active=self._assistant_playback_active(session),
-                            )
-                        )
-                        if commit_action is CommitAction.DEFER_ACTIVE_RESPONSE:
-                            if session.overlap_speech_ms <= session.config.overlap_short_ack_ms:
-                                native.audio_buffer.clear()
-                                session.release_all_input_bytes()
-                                native.input_since_commit = False
-                                native.speech_since_commit = False
-                                native.clear_committed_audio()
-                                if realtime_protocol is not None:
-                                    await realtime_protocol.discard_pending_input_audio(
-                                        audio_end_ms=session.overlap_speech_ms
-                                    )
-                                await emit_event(
-                                    {
-                                        "type": "input.committed",
-                                        "session_id": session.session_id,
-                                        "item_id": item_id,
-                                        "turn_id": session.turn_id,
-                                        "epoch": session.epoch,
-                                        "empty": True,
-                                        "is_speech": False,
-                                        "overlap_ack": True,
-                                        "no_response": True,
-                                    }
-                                )
-                                session.reset_overlap_speech()
-                                session.discard_response_options()
-                                continue
-
-                            commit_reservation = native.audio_buffer.prepare_commit(
-                                operation_id=uuid.uuid4().hex,
-                                chunk_period_ms=session.capabilities.chunk_period_ms or 1000,
-                            )
-                            deferred_payload = commit_reservation.payload
-                            if deferred_payload is None:
-                                commit_reservation.commit()
-                            else:
-                                if native.committed_audio_payload is not None:
-                                    deferred_payload = self._merge_native_audio_payloads(
-                                        native.committed_audio_payload,
-                                        deferred_payload,
-                                    )
-                                native.retain_committed_audio(
-                                    deferred_payload,
-                                    operation_id=commit_reservation.operation_id,
-                                    reserved_bytes=commit_reservation.byte_count,
-                                )
-                                commit_reservation.commit()
-                                native.deferred_response_create = should_create_response
-                                native.deferred_precreate_response = precreate_response_requested
-                                native.input_since_commit = False
-                                native.speech_since_commit = False
-                                committed = self._commit_native_audio_input(
-                                    session,
-                                    item_id=event.get("item_id"),
-                                    transcript=event.get("transcript"),
-                                )
-                                committed_payload = self._native_audio_committed_payload(
-                                    session,
-                                    committed=committed,
-                                    item_id=event.get("item_id"),
-                                    transcript=event.get("transcript"),
-                                )
-                                committed_payload["overlap_deferred"] = True
-                                committed_payload["response_create_deferred"] = should_create_response
-                                await emit_event(committed_payload)
-                                continue
-                        if commit_action is CommitAction.START_AUTO_RESPONSE:
-                            commit_reservation = native.audio_buffer.prepare_commit(
-                                operation_id=uuid.uuid4().hex,
-                                chunk_period_ms=session.capabilities.chunk_period_ms or 1000,
-                            )
-                            committed_input = commit_reservation.payload
-                            final_payload = committed_input
-                            if native.committed_audio_payload is not None:
-                                if final_payload is not None:
-                                    final_payload = self._merge_native_audio_payloads(
-                                        native.committed_audio_payload,
-                                        final_payload,
-                                    )
-                                else:
-                                    final_payload = native.committed_audio_payload
-                            commit_reservation.commit()
-                            if final_payload is not None:
-                                native.retain_committed_audio(
-                                    final_payload,
-                                    operation_id=commit_reservation.operation_id,
-                                    reserved_bytes=commit_reservation.byte_count,
-                                )
-                            native.deferred_response_create = False
-                            native.input_since_commit = False
-                            native.speech_since_commit = False
-                            data_plane_turn_id = session.turn_id
-                            committed = self._commit_native_audio_input(
-                                session,
-                                item_id=event.get("item_id"),
-                                transcript=event.get("transcript"),
-                                turn_id=data_plane_turn_id,
-                            )
-                            await emit_event(
-                                self._native_audio_committed_payload(
-                                    session,
-                                    committed=committed,
-                                    item_id=event.get("item_id"),
-                                    transcript=event.get("transcript"),
-                                )
-                            )
-                            if final_payload is not None:
-                                await start_native_append(
-                                    {
-                                        **final_payload,
-                                        "duplex_turn_id": data_plane_turn_id,
-                                    },
-                                    final=True,
-                                    precreate_response=False,
-                                    operation_id=commit_reservation.operation_id,
-                                    retained_committed_payload=final_payload,
-                                )
-                            continue
-                    if self._uses_native_input_append(session) and event_type == "response.create":
-                        if (
-                            native_response_in_progress()
-                            or actor.native_append_tasks
-                            or native.data_plane_task is not None
-                        ):
-                            if session.active_response_id is None and (
-                                session.active_request_id is not None
-                                or actor.native_append_tasks
-                                or native.data_plane_task is not None
-                            ):
-                                continue
-                            await emit_event(
-                                {
-                                    "type": "error",
-                                    "session_id": session.session_id,
-                                    "epoch": session.epoch,
-                                    "code": "response_already_active",
-                                    "error": "response.create cannot start while another response is active.",
-                                }
-                            )
-                            session.discard_response_options()
-                            continue
-                        if native.committed_audio_payload is not None:
-                            committed_payload = native.committed_audio_payload
-                            operation_id = native.committed_audio_operation_id
-                            if operation_id is None:
-                                operation_id = uuid.uuid4().hex
-                                native.committed_audio_operation_id = operation_id
-                            await start_native_append(
-                                committed_payload,
-                                final=True,
-                                precreate_response=True,
-                                operation_id=operation_id,
-                                retained_committed_payload=committed_payload,
-                            )
-                            continue
-                        await emit_event(
-                            {
-                                "type": "error",
-                                "session_id": session.session_id,
-                                "epoch": session.epoch,
-                                "code": "response_create_without_input",
-                                "error": "Native duplex response.create requires committed audio input.",
-                            }
-                        )
-                        session.discard_response_options()
-                        continue
-                    if self._uses_native_input_append(session) and not native_response_in_progress():
-                        commit_reservation = (
-                            native.audio_buffer.prepare_commit(
-                                operation_id=uuid.uuid4().hex,
-                                chunk_period_ms=session.capabilities.chunk_period_ms or 1000,
-                            )
-                            if event_type in {"input.commit", "input_audio_buffer.commit"}
-                            else None
-                        )
-                        flushed_buffer_reserved_bytes = (
-                            native.audio_buffer.pending_byte_count if commit_reservation is None else 0
-                        )
-                        flushed = (
-                            commit_reservation.payload
-                            if commit_reservation is not None
-                            else native.audio_buffer.flush(chunk_period_ms=session.capabilities.chunk_period_ms or 1000)
-                        )
-                        if native.committed_audio_payload is not None:
-                            if flushed is not None:
-                                flushed = self._merge_native_audio_payloads(
-                                    native.committed_audio_payload,
-                                    flushed,
-                                )
-                            else:
-                                flushed = native.committed_audio_payload
-                        if commit_reservation is not None:
-                            commit_reservation.commit()
-                        if flushed is not None:
-                            if self._should_force_listen_for_short_commit(session, event, flushed):
-                                flushed = dict(flushed)
-                                flushed["force_listen"] = True
-                            native.input_since_commit = False
-                            committed = self._commit_native_audio_input(
-                                session,
-                                item_id=event.get("item_id"),
-                                transcript=event.get("transcript"),
-                            )
-                            await emit_event(
-                                self._native_audio_committed_payload(
-                                    session,
-                                    committed=committed,
-                                    item_id=event.get("item_id"),
-                                    transcript=event.get("transcript"),
-                                )
-                            )
-                            if should_create_response:
-                                native.retain_committed_audio(
-                                    flushed,
-                                    operation_id=(
-                                        commit_reservation.operation_id
-                                        if commit_reservation is not None
-                                        else uuid.uuid4().hex
-                                    ),
-                                    reserved_bytes=(
-                                        commit_reservation.byte_count
-                                        if commit_reservation is not None
-                                        else flushed_buffer_reserved_bytes
-                                    ),
-                                )
-                                await start_native_append(
-                                    flushed,
-                                    final=True,
-                                    precreate_response=True,
-                                    operation_id=native.committed_audio_operation_id,
-                                    retained_committed_payload=flushed,
-                                )
-                            else:
-                                native.retain_committed_audio(
-                                    flushed,
-                                    operation_id=(
-                                        commit_reservation.operation_id
-                                        if commit_reservation is not None
-                                        else uuid.uuid4().hex
-                                    ),
-                                    reserved_bytes=(
-                                        commit_reservation.byte_count
-                                        if commit_reservation is not None
-                                        else flushed_buffer_reserved_bytes
-                                    ),
-                                )
-                                native.deferred_response_create = False
-                            continue
-                    native_had_uncommitted_audio = self._uses_native_input_append(session) and (
-                        native.input_since_commit
-                        or native.audio_buffer.has_pending()
-                        or native.committed_audio_payload is not None
-                        or realtime_validated_audio_commit
-                    )
-                    committed = session.commit_user_input()
-                    if self._uses_native_input_append(session) and event_type in {
-                        "input_audio_buffer.commit",
-                        "input.commit",
-                    }:
-                        native.input_since_commit = False
-                        native.speech_since_commit = False
-                    if committed is None and event_type != "response.create":
-                        if self._uses_native_input_append(session):
-                            committed = (
-                                self._commit_native_audio_input(
-                                    session,
-                                    item_id=event.get("item_id"),
-                                    transcript=event.get("transcript"),
-                                )
-                                if native_had_uncommitted_audio
-                                else None
-                            )
-                            await emit_event(
-                                self._native_audio_committed_payload(
-                                    session,
-                                    committed=committed,
-                                    item_id=event.get("item_id"),
-                                    transcript=event.get("transcript"),
-                                )
-                            )
-                        else:
-                            await emit_event(
-                                {
-                                    "type": "input.committed",
-                                    "session_id": session.session_id,
-                                    "item_id": item_id,
-                                    "empty": True,
-                                }
-                            )
-                        continue
-                    if committed is not None:
-                        item_id = event.get("item_id")
-                        if isinstance(item_id, str):
-                            session.register_history_item(item_id, committed.message)
-                        await emit_event(
-                            self._input_committed_payload(
-                                session,
-                                committed,
-                                item_id=item_id,
-                            )
-                        )
-                    if not should_create_response:
-                        continue
-                    if actor.active_response_task is not None and not actor.active_response_task.done():
-                        await self._cancel_active_response(
-                            session,
-                            actor.active_response_task,
-                            emit_event,
-                            reason="new_response",
-                        )
-                    if session.config.server_vad is not None and not self._uses_native_input_append(session):
-                        start_chat_response()
-                    else:
-                        actor.active_response_task = asyncio.create_task(self._run_response(session, emit_event))
-                    continue
-
-                await emit_event(
-                    {
-                        "type": "error",
-                        "error": f"Unknown duplex event: {event_type}",
-                        "code": "unknown_event",
-                    }
-                )
-
-        except WebSocketDisconnect:
-            logger.info("Duplex session disconnected")
-            transport_detached = True
-        except Exception as exc:
-            logger.exception("Duplex session failed: %s", exc)
-            with suppress(Exception):
-                await emit_event({"type": "error", "error": str(exc), "code": "internal_error"})
-        finally:
-            if realtime_protocol is not None:
-                realtime_protocol.reject_realtime_turn_detection_update()
-            if session is not None:
-                if reader_task is not None and not reader_task.done():
-                    reader_task.cancel()
-                    with suppress(asyncio.CancelledError):
-                        await reader_task
-                while pending_turn_reservations > 0:
-                    session.release_pending_turn()
-                    pending_turn_reservations -= 1
-                resumable_detach = (
-                    transport_detached
-                    and runtime_opened
-                    and not runtime_closed
-                    and session.state == DuplexSessionState.OPEN
-                    and session.capabilities.supports_session_resume
-                    and attachment_generation is not None
-                    and resume_credential_delivered
-                )
-                if resumable_detach:
-
-                    async def cancel_orphan_response_after_grace() -> None:
-                        tasks = self._session_tasks.get(session.session_id)
-                        current_session = self._registry.get(session.session_id)
-                        if tasks is None or current_session is not session or session.state != DuplexSessionState.OPEN:
-                            return
-                        await tasks.cancel_append_tasks(response_bound_only=True)
-                        await self._cancel_native_data_plane_stream(session)
-                        await self._cancel_active_response(
-                            session,
-                            tasks.active_response_task,
-                            emit_event,
-                            reason="disconnect_grace_expired",
-                            notify=False,
-                        )
-                        tasks.active_response_task = None
-
-                    detached = await self._attachment_registry.detach(
-                        session.session_id,
-                        attachment_generation=attachment_generation,
-                        on_grace_expired=cancel_orphan_response_after_grace,
-                    )
-                    touch_session = getattr(self._chat_service.engine_client, "touch_duplex_session_async", None)
-                    if detached and callable(touch_session):
-                        with suppress(Exception):
-                            await touch_session(
-                                session.session_id,
-                                fence=DuplexFence(
-                                    session.session_id,
-                                    epoch=session.epoch,
-                                    turn_id=session.turn_id,
-                                    incarnation=session.incarnation,
-                                ),
-                                activity=DuplexLeaseActivity.DETACH,
-                            )
-                else:
-                    begin_close(actor.close_reason or "disconnect")
-                    await actor.cancel_append_tasks()
-                    await self._cancel_native_data_plane_stream(session)
-                    await self._cancel_active_response(
-                        session,
-                        actor.active_response_task,
-                        emit_event,
-                        reason="disconnect",
-                        notify=False,
-                    )
-                    if runtime_opened and not runtime_closed and session.state != DuplexSessionState.CLOSED:
-                        await self._close_runtime_session(session, reason="disconnect")
-                    self._cleanup_duplex_session_state(session)
-                    self._registry.close(session.session_id)
-                    self._session_tasks.pop(session.session_id, None)
-                    self._realtime_protocols.pop(session.session_id, None)
-                    self._lease_generations.pop(session.session_id, None)
-                    self._resync_required_sessions.discard(session.session_id)
-                    with suppress(Exception):
-                        await self._attachment_registry.close(session.session_id)
-                    self._stop_lifecycle_listener_if_idle()
-            await actor.close_writer()
-            with suppress(Exception):
-                await asyncio.wait_for(actor.output_queue.join(), timeout=2.0)
-            if not writer_task.done():
-                writer_task.cancel()
-            with suppress(asyncio.CancelledError):
-                await writer_task
diff --git a/vllm_omni/entrypoints/duplex/warmup.py b/vllm_omni/entrypoints/duplex/warmup.py
index c380775ef..f711cfccb 100644
--- a/vllm_omni/entrypoints/duplex/warmup.py
+++ b/vllm_omni/entrypoints/duplex/warmup.py
@@ -43,10 +43,12 @@ async def _warmup_duplex_realtime(app, args, warmup_frames: int) -> None:
             model_name = served
         else:
             model_name = args.model
-        adapter = getattr(getattr(app.state, "openai_serving_duplex", None), "_serving_runtime_adapter", None)
-        frame_samples = int(getattr(adapter, "silence_continuation_samples", 16000))
+        # 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.experimental.fullduplex.client import build_realtime_url
+        from vllm_omni.clients.duplex import build_realtime_url
 
         url = (
             build_realtime_url(f"ws://127.0.0.1:{args.port}/v1/realtime", model_name, autostart=False)
@@ -80,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},
                         },
                     }
                 )
@@ -107,8 +109,10 @@ 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.audio.delta", 30)
+            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
             # session in its disconnect grace window, where it would keep
             # occupying the max_sessions=1 slot and block the first client.
diff --git a/vllm_omni/entrypoints/duplex/websocket.py b/vllm_omni/entrypoints/duplex/websocket.py
index df50fd0c3..8ec9cc780 100644
--- a/vllm_omni/entrypoints/duplex/websocket.py
+++ b/vllm_omni/entrypoints/duplex/websocket.py
@@ -1,268 +1,60 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
+"""WebSocket transport helpers for the duplex Realtime handler.
+
+The ordered session mailbox and the per-session task handles that used to be
+defined here now live engine-side (``vllm_omni.engine.duplex.session.runner``).
+"""
+
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Callable
-from dataclasses import dataclass, field
-from typing import Any
+from collections.abc import Awaitable, Callable
+from contextlib import suppress
 
-from fastapi import WebSocketDisconnect
+from fastapi import WebSocket, WebSocketDisconnect
 
-INPUT_EVENTS = frozenset(
-    {
-        "input.text.append",
-        "input_audio_buffer.append",
-        "input.commit",
-        "input_audio_buffer.commit",
-        "response.create",
-    }
-)
+#: Largest client frame accepted before it is parsed (base64 audio + video frames).
+MAX_EVENT_BYTES = 15 * 1024 * 1024
 
-_INPUT_EVENT_ALIASES = {
-    "signal_turn": "turn.signal",
-    "close_session": "session.close",
-    "audio.playback_ack": "playback.ack",
-    "input_text.append": "input.text.append",
-    "push_text": "input.text.append",
-    "input.audio.append": "input_audio_buffer.append",
-    "push_chunk": "input_audio_buffer.append",
-}
-_WAV_AUDIO_ALIASES = frozenset({"input.audio.append", "push_chunk"})
+SendJson = Callable[[dict[str, object]], Awaitable[None]]
+CloseFn = Callable[[str], Awaitable[None]]
 
 
-def normalize_duplex_input_event(event: dict[str, object]) -> dict[str, object]:
-    """Normalize compatibility aliases before an event enters the mailbox."""
-    event_type = event.get("type")
-    if not isinstance(event_type, str):
-        return event
-    canonical_type = _INPUT_EVENT_ALIASES.get(event_type)
-    if canonical_type is None:
-        return event
-    normalized = dict(event)
-    normalized["type"] = canonical_type
-    if event_type in _WAV_AUDIO_ALIASES:
-        normalized.setdefault("format", "wav")
-    return normalized
+async def receive_text_with_timeout(websocket: WebSocket, timeout_s: float | None) -> str | None:
+    """Receive one text frame; ``None`` on idle timeout. Disconnects propagate."""
+    if timeout_s is None or timeout_s <= 0:
+        return await websocket.receive_text()
+    try:
+        return await asyncio.wait_for(websocket.receive_text(), timeout=timeout_s)
+    except TimeoutError:
+        return None
 
 
-MODEL_OUTPUT_EVENTS = frozenset(
-    {
-        "response.created",
-        "response.listen",
-        "response.speak",
-        "response.output_item.added",
-        "response.content_part.added",
-        "response.output_audio.delta",
-        "response.audio.delta",
-        "response.output_audio.done",
-        "response.audio.done",
-        "response.output_text.delta",
-        "response.output_text.done",
-        "response.text.delta",
-        "response.text.done",
-        "response.message",
-        "response.output_item.done",
-        "response.content_part.done",
-        "response.done",
-        "runtime.control",
-    }
-)
-DOMAIN_TERMINAL_EVENTS = frozenset(
-    {
-        "response.done",
-        "response.listen",
-        "audio.cancelled",
-        "input.cancelled",
-        "session.closed",
-    }
-)
+def attachment_callbacks(websocket: WebSocket) -> tuple[SendJson, CloseFn]:
+    """``send`` / ``close`` callables for a ``DuplexSessionAttachmentRegistry`` attachment.
 
+    A send on a socket that already closed surfaces as ``WebSocketDisconnect``
+    so the caller's disconnect path runs instead of a generic failure.
+    """
 
-def is_input_event(event_type: object) -> bool:
-    return isinstance(event_type, str) and event_type in INPUT_EVENTS
-
-
-@dataclass(frozen=True, slots=True)
-class DuplexAppendTaskMeta:
-    epoch: int
-    mode: str
-    final: bool
-    response_bound: bool
-
-
-@dataclass
-class DuplexSessionTasks:
-    """Connection-independent task handles for one resumable session."""
-
-    native_append_tasks: dict[asyncio.Task[bool], DuplexAppendTaskMeta] = field(default_factory=dict)
-    native_append_tail: asyncio.Task[bool] | None = None
-    active_response_task: asyncio.Task[None] | None = None
-
-    def track_append_task(
-        self,
-        task: asyncio.Task[bool],
-        *,
-        epoch: int,
-        mode: str,
-        final: bool,
-        response_bound: bool,
-    ) -> None:
-        self.native_append_tasks[task] = DuplexAppendTaskMeta(epoch, mode, final, response_bound)
-        task.add_done_callback(self.native_append_tasks.pop)
-
-    def has_response_bound_append_tasks(self) -> bool:
-        return any(meta.response_bound for meta in self.native_append_tasks.values())
-
-    async def cancel_append_tasks(self, timeout_s: float = 0.25, *, response_bound_only: bool = False) -> bool:
-        tasks = [
-            task for task, meta in self.native_append_tasks.items() if not response_bound_only or meta.response_bound
-        ]
-        if not tasks:
-            return False
-        cancelled_tail = self.native_append_tail if self.native_append_tail in tasks else None
-        for task in tasks:
-            task.cancel()
+    async def attachment_send(payload: dict[str, object]) -> None:
         try:
-            await asyncio.wait_for(asyncio.gather(*tasks, return_exceptions=True), timeout=timeout_s)
-        except TimeoutError:
-            pass
-        if cancelled_tail is not None and self.native_append_tail is cancelled_tail:
-            self.native_append_tail = None
-        return True
+            await websocket.send_json(payload)
+        except RuntimeError as exc:
+            message = str(exc)
+            if "after sending 'websocket.close'" in message or "response already completed" in message:
+                raise WebSocketDisconnect(code=1006) from exc
+            raise
+
+    async def attachment_close(reason: str) -> None:
+        close = getattr(websocket, "close", None)
+        if callable(close):
+            with suppress(Exception):
+                await close(code=1000, reason=reason)
+
+    return attachment_send, attachment_close
 
 
-@dataclass
-class DuplexWebSocketActor:
-    """Own ordered WebSocket I/O queues, but no domain identity."""
-
-    websocket: Any
-    current_epoch: Callable[[], int | None] | None = None
-    session_closed: Callable[[], bool] | None = None
-    output_queue: asyncio.Queue[dict[str, object] | None] = field(default_factory=asyncio.Queue)
-    mailbox: asyncio.Queue[dict[str, object]] = field(default_factory=asyncio.Queue)
-    outbound_protocol: Any | None = None
-    tasks: DuplexSessionTasks = field(default_factory=DuplexSessionTasks)
-    closing: bool = False
-    close_reason: str | None = None
-    stale_output_dropped: int = 0
-    _queued_input_events: int = 0
-
-    @property
-    def native_append_tasks(self) -> dict[asyncio.Task[bool], DuplexAppendTaskMeta]:
-        return self.tasks.native_append_tasks
-
-    @property
-    def active_response_task(self) -> asyncio.Task[None] | None:
-        return self.tasks.active_response_task
-
-    @active_response_task.setter
-    def active_response_task(self, task: asyncio.Task[None] | None) -> None:
-        self.tasks.active_response_task = task
-
-    @property
-    def native_append_tail(self) -> asyncio.Task[bool] | None:
-        return self.tasks.native_append_tail
-
-    @native_append_tail.setter
-    def native_append_tail(self, task: asyncio.Task[bool] | None) -> None:
-        self.tasks.native_append_tail = task
-
-    async def enqueue_event(self, event: dict[str, object]) -> None:
-        if is_input_event(event.get("type")):
-            self._queued_input_events += 1
-        await self.mailbox.put(event)
-
-    async def next_event(self) -> dict[str, object]:
-        event = await self.mailbox.get()
-        if is_input_event(event.get("type")):
-            self._queued_input_events = max(0, self._queued_input_events - 1)
-        self.mailbox.task_done()
-        return event
-
-    def has_queued_input_events(self) -> bool:
-        return self._queued_input_events > 0
-
-    async def send_json(self, payload: dict[str, object]) -> None:
-        await self.output_queue.put(payload)
-
-    async def close_writer(self) -> None:
-        await self.output_queue.put(None)
-
-    async def writer_loop(self) -> None:
-        while True:
-            payload = await self.output_queue.get()
-            try:
-                if payload is None:
-                    return
-                raw_realtime = payload.pop("_realtime_raw", False) is True
-                if not raw_realtime and self._is_stale_model_output(payload):
-                    self.stale_output_dropped += 1
-                    continue
-                try:
-                    if raw_realtime:
-                        await self.websocket.send_json(payload)
-                    elif self.outbound_protocol is not None:
-                        for projected in self.outbound_protocol.encode_outbound_event(payload):
-                            await self.websocket.send_json(projected)
-                    else:
-                        await self.websocket.send_json(payload)
-                except (WebSocketDisconnect, RuntimeError):
-                    return
-            finally:
-                self.output_queue.task_done()
-
-    def _is_stale_model_output(self, payload: dict[str, object]) -> bool:
-        event_type = payload.get("type")
-        if event_type in DOMAIN_TERMINAL_EVENTS:
-            return False
-        if event_type not in MODEL_OUTPUT_EVENTS:
-            return False
-        if self.closing and event_type not in {"response.listen", "runtime.control"}:
-            return True
-        expected_epoch = self.current_epoch() if self.current_epoch is not None else None
-        if (
-            self.session_closed is not None
-            and self.session_closed()
-            and event_type
-            not in {
-                "response.listen",
-                "runtime.control",
-            }
-        ):
-            return True
-        epoch = payload.get("epoch")
-        return isinstance(epoch, int) and isinstance(expected_epoch, int) and epoch != expected_epoch
-
-    def track_append_task(
-        self,
-        task: asyncio.Task[bool],
-        *,
-        epoch: int,
-        mode: str,
-        final: bool,
-        response_bound: bool,
-    ) -> None:
-        self.tasks.track_append_task(
-            task,
-            epoch=epoch,
-            mode=mode,
-            final=final,
-            response_bound=response_bound,
-        )
-
-    def has_response_bound_append_tasks(self) -> bool:
-        return self.tasks.has_response_bound_append_tasks()
-
-    async def cancel_append_tasks(self, timeout_s: float = 0.25, *, response_bound_only: bool = False) -> bool:
-        return await self.tasks.cancel_append_tasks(timeout_s, response_bound_only=response_bound_only)
-
-
-__all__ = [
-    "DOMAIN_TERMINAL_EVENTS",
-    "DuplexAppendTaskMeta",
-    "DuplexSessionTasks",
-    "DuplexWebSocketActor",
-    "is_input_event",
-]
+__all__ = ["MAX_EVENT_BYTES", "CloseFn", "SendJson", "attachment_callbacks", "receive_text_with_timeout"]
diff --git a/vllm_omni/entrypoints/duplex_omni.py b/vllm_omni/entrypoints/duplex_omni.py
new file mode 100644
index 000000000..968b69f74
--- /dev/null
+++ b/vllm_omni/entrypoints/duplex_omni.py
@@ -0,0 +1,476 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""DuplexOmni: the Python API for full-duplex models.
+
+Sessions run inside the engine (``DuplexSessionRunner`` on the orchestrator
+loop of ``DuplexOrchestrator``). This class opens / resumes / closes them and
+pipes typed ``DuplexCommand`` objects in and typed ``DuplexEvent`` objects out
+through a ``DuplexSessionHandle``. It holds no session state beyond the
+handle registry, so the websocket handler and ``InlineDuplexClient`` are both
+thin consumers of the same surface.
+
+Example::
+
+    omni = DuplexOmni(model="openbmb/MiniCPM-o-4_5", trust_remote_code=True)
+    async with await omni.open_session({"modalities": ["audio", "text"]}) as session:
+        async def consume():
+            async for event in session.events():
+                if isinstance(event, AudioDelta):
+                    play(event.audio)
+        task = asyncio.create_task(consume())
+        await session.submit(AppendAudio(audio=pcm_bytes, format="pcm16", sample_rate_hz=16000))
+        await session.submit(Commit())
+"""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import AsyncIterator, Mapping, Sequence
+from contextlib import suppress
+from typing import Any
+from uuid import uuid4
+
+from vllm.logger import init_logger
+
+from vllm_omni.config.stage_config import DuplexSessionRuntimeConfig
+from vllm_omni.engine.duplex import commands as duplex_commands
+from vllm_omni.engine.duplex.commands import DuplexCommand
+from vllm_omni.engine.duplex.config import DuplexCapabilities, DuplexSessionConfig, ResponseCreateOptions
+from vllm_omni.engine.duplex.events import DuplexEvent, SessionClosed
+from vllm_omni.engine.duplex.messages import (
+    DuplexControlResultMessage,
+    DuplexSessionError,
+    DuplexSessionEventMessage,
+)
+from vllm_omni.engine.duplex_omni_engine import DuplexOmniEngine
+from vllm_omni.entrypoints.async_omni import AsyncOmni
+
+logger = init_logger(__name__)
+
+_DEFAULT_CONTROL_TIMEOUT_S = 10.0
+
+
+class DuplexSessionHandle:
+    """Client-side view of one engine-resident duplex session.
+
+    Connection-independent: a websocket may detach and a later one resume the
+    same handle. ``events()`` is single-consumer at any given time but may be
+    re-entered after the previous iterator was closed (resume).
+    """
+
+    def __init__(self, omni: DuplexOmni, session_id: str) -> None:
+        self._omni = omni
+        #: Allocated by ``DuplexOmni.open_session``; unique for the engine's lifetime.
+        self.session_id = session_id
+        self.capabilities: DuplexCapabilities = DuplexCapabilities()
+        self.public_session: dict[str, object] = {}
+        self.lease_generation: int = 0
+        self._outbox: asyncio.Queue[DuplexEvent | None] = asyncio.Queue()
+        self._closed = False
+        self._close_reason: str | None = None
+        self._closed_event = asyncio.Event()
+        self._consumer_active = False
+
+    # ---- state ----
+
+    @property
+    def closed(self) -> bool:
+        return self._closed
+
+    @property
+    def close_reason(self) -> str | None:
+        return self._close_reason
+
+    def __repr__(self) -> str:  # pragma: no cover - debugging aid
+        return f"DuplexSessionHandle(session_id={self.session_id!r}, closed={self._closed})"
+
+    # ---- input ----
+
+    async def submit(self, command: DuplexCommand) -> None:
+        """Enqueue one command in caller order; rejections arrive as ``ErrorEvent`` on ``events()``."""
+        if self._closed:
+            raise DuplexSessionError(
+                f"duplex session {self.session_id} is closed", code="session_closed", session_id=self.session_id
+            )
+        await self._omni.engine.submit_command_async(self.session_id, command)
+
+    async def append_audio(
+        self,
+        audio: bytes,
+        *,
+        format: str = "pcm16",
+        sample_rate_hz: int | None = None,
+        is_speech: bool | None = None,
+        video_frames: Sequence[str] | None = None,
+        duration_ms: int | None = None,
+        audio_end_ms: int | None = None,
+        hints: Mapping[str, object] | None = None,
+    ) -> None:
+        await self.submit(
+            duplex_commands.AppendAudio(
+                audio=audio,
+                format=format,
+                sample_rate_hz=sample_rate_hz,
+                is_speech=is_speech,
+                video_frames=tuple(video_frames or ()),
+                duration_ms=duration_ms,
+                audio_end_ms=audio_end_ms,
+                hints=dict(hints or {}),
+            )
+        )
+
+    async def append_text(self, text: str) -> None:
+        await self.submit(duplex_commands.AppendText(text=text))
+
+    async def commit(
+        self,
+        *,
+        final: bool = True,
+        create_response: bool | None = None,
+        is_speech: bool | None = None,
+    ) -> None:
+        await self.submit(duplex_commands.Commit(final=final, create_response=create_response, is_speech=is_speech))
+
+    async def create_response(self, options: ResponseCreateOptions | Mapping[str, object] | None = None) -> None:
+        if isinstance(options, ResponseCreateOptions):
+            payload: dict[str, object] = {
+                key: value
+                for key, value in (
+                    ("instructions", options.instructions),
+                    ("voice", options.voice),
+                    ("output_audio_format", options.response_format),
+                    ("temperature", options.temperature),
+                    ("max_output_tokens", options.max_tokens),
+                    ("speed", options.speed),
+                    ("modalities", list(options.modalities) if options.modalities is not None else None),
+                )
+                if value is not None
+            }
+            if options.extra_body:
+                payload["extra_body"] = dict(options.extra_body)
+        else:
+            payload = dict(options or {})
+        await self.submit(duplex_commands.CreateResponse(options=payload))
+
+    async def clear_input(self) -> None:
+        await self.submit(duplex_commands.ClearInput())
+
+    async def cancel_input(self) -> None:
+        await self.submit(duplex_commands.CancelInput())
+
+    async def cancel_response(self, response_id: str | None = None) -> None:
+        await self.submit(duplex_commands.CancelResponse(response_id=response_id))
+
+    async def barge_in(self) -> None:
+        await self.submit(duplex_commands.BargeIn())
+
+    async def clear_output_audio(self, response_id: str | None = None) -> None:
+        await self.submit(duplex_commands.ClearOutputAudio(response_id=response_id))
+
+    async def signal_turn(self, event: str, payload: Mapping[str, object] | None = None) -> None:
+        await self.submit(duplex_commands.SignalTurn(event=event, signal_payload=dict(payload or {})))
+
+    async def update(self, session_patch: Mapping[str, object]) -> None:
+        await self.submit(duplex_commands.UpdateSession(patch=dict(session_patch)))
+
+    async def ack_playback(
+        self,
+        played_ms: int,
+        *,
+        response_id: str | None = None,
+        item_id: str | None = None,
+        committed_ms: int | None = None,
+    ) -> None:
+        await self.submit(
+            duplex_commands.AckPlayback(
+                played_ms=int(played_ms),
+                committed_ms=int(committed_ms) if committed_ms is not None else None,
+                response_id=response_id,
+                item_id=item_id,
+            )
+        )
+
+    async def heartbeat(self) -> None:
+        await self.submit(duplex_commands.Heartbeat())
+
+    async def create_item(self, item: Mapping[str, object], *, previous_item_id: str | None = None) -> None:
+        await self.submit(duplex_commands.CreateItem(item=dict(item), previous_item_id=previous_item_id))
+
+    async def delete_item(self, item_id: str) -> None:
+        await self.submit(duplex_commands.DeleteItem(item_id=item_id))
+
+    async def truncate_item(self, item_id: str, *, audio_end_ms: int, content_index: int = 0) -> None:
+        await self.submit(
+            duplex_commands.TruncateItem(item_id=item_id, audio_end_ms=int(audio_end_ms), content_index=content_index)
+        )
+
+    async def close(self, *, reason: str = "client_close", timeout: float | None = _DEFAULT_CONTROL_TIMEOUT_S) -> None:
+        if self._closed:
+            return
+        await self._omni.close_session(self.session_id, reason=reason, timeout=timeout)
+
+    # ---- output ----
+
+    async def events(self) -> AsyncIterator[DuplexEvent]:
+        """Ordered public events; ends after ``session.closed`` / ``session.expired``."""
+        if self._consumer_active:
+            raise RuntimeError(f"duplex session {self.session_id} already has an active events() consumer")
+        self._consumer_active = True
+        try:
+            while True:
+                if self._closed and self._outbox.empty():
+                    return
+                event = await self._outbox.get()
+                if event is None:
+                    if self._closed and self._outbox.empty():
+                        return
+                    continue
+                yield event
+                if event.is_terminal:
+                    return
+        finally:
+            self._consumer_active = False
+
+    async def wait_closed(self) -> str:
+        await self._closed_event.wait()
+        return self._close_reason or "closed"
+
+    async def __aenter__(self) -> DuplexSessionHandle:
+        return self
+
+    async def __aexit__(self, exc_type, exc, traceback) -> None:
+        try:
+            await self.close()
+        except DuplexSessionError:
+            pass
+
+    # ---- internals used by DuplexOmni ----
+
+    def _adopt(self, result: DuplexControlResultMessage) -> None:
+        if result.capabilities is not None:
+            self.capabilities = result.capabilities
+        if result.public_session:
+            self.public_session = dict(result.public_session)
+        if result.lease_generation is not None:
+            self.lease_generation = int(result.lease_generation)
+
+    def _deliver(self, event: DuplexEvent) -> None:
+        self._outbox.put_nowait(event)
+        if isinstance(event, SessionClosed):  # SessionExpired is a SessionClosed
+            self._mark_closed(event.reason or event.type)
+
+    def _mark_closed(self, reason: str) -> None:
+        if self._closed:
+            return
+        self._closed = True
+        self._close_reason = reason
+        self._closed_event.set()
+        self._outbox.put_nowait(None)
+
+
+class DuplexOmni(AsyncOmni):
+    """Async Python API for full-duplex models (see module docstring).
+
+    Construct it like ``AsyncOmni``. The pipeline must declare
+    ``duplex_plugin`` and the deploy config ``session_mode: duplex``; the
+    engine raises at startup otherwise. There is no ``generate()``: duplex
+    serving is session-only.
+    """
+
+    engine: DuplexOmniEngine
+
+    def _create_engine(self, **engine_kwargs: Any) -> DuplexOmniEngine:
+        from vllm_omni.entrypoints.duplex.audio_encoding import encode_audio
+
+        return DuplexOmniEngine(duplex_audio_encoder=encode_audio, **engine_kwargs)
+
+    def __init__(self, model: str = "", *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, model=model, **kwargs)
+        self._handles: dict[str, DuplexSessionHandle] = {}
+
+    # ---- deployment facts ----
+
+    @property
+    def duplex_session_config(self) -> DuplexSessionRuntimeConfig:
+        return self.engine.duplex_session_config
+
+    @property
+    def duplex_capabilities(self) -> DuplexCapabilities:
+        return self.engine.duplex_capabilities
+
+    @property
+    def sessions(self) -> Mapping[str, DuplexSessionHandle]:
+        return dict(self._handles)
+
+    def active_session_count(self) -> int:
+        return sum(1 for handle in self._handles.values() if not handle.closed)
+
+    # ---- session lifecycle ----
+
+    @staticmethod
+    def _resolve_session_config(
+        config: DuplexSessionConfig | Mapping[str, object] | None,
+        *,
+        model: str,
+    ) -> DuplexSessionConfig:
+        """Build the normalized session config the engine will own (the one parse/normalize site).
+
+        A ``session_id`` / ``id`` key inside a Realtime session object is
+        ignored: Realtime clients echo the session object back, and the server
+        allocates every session id.
+        """
+        if config is None:
+            resolved = DuplexSessionConfig(model=model)
+        elif isinstance(config, DuplexSessionConfig):
+            resolved = config
+        elif isinstance(config, Mapping):
+            resolved = DuplexSessionConfig.from_realtime(config, model=model)
+        else:
+            raise TypeError(f"unsupported duplex session config: {type(config).__name__}")
+        if resolved.model is None:
+            resolved.model = model
+        return resolved.normalized()
+
+    async def open_session(
+        self,
+        config: DuplexSessionConfig | Mapping[str, object] | None = None,
+        *,
+        timeout: float | None = _DEFAULT_CONTROL_TIMEOUT_S,
+    ) -> DuplexSessionHandle:
+        """Open an engine-resident session and return its handle.
+
+        The session id is always allocated here (``duplex-<uuid4 hex>``; never
+        reused, so the id alone identifies a session) and the handle is
+        registered before the open RPC, so the first event (``session.created``,
+        which announces the id) can never arrive before it exists.
+        """
+        session_id = f"duplex-{uuid4().hex}"
+        session_config = self._resolve_session_config(config, model=self.model)
+        handle = DuplexSessionHandle(self, session_id)
+        self._handles[session_id] = handle
+        self._final_output_handler()
+        try:
+            result = await self.engine.open_session_async(session_id, session_config, timeout=timeout)
+        except BaseException:
+            if self._handles.get(session_id) is handle:
+                self._handles.pop(session_id, None)
+            # Dropping the handle only forgets the id here. The engine may still
+            # be admitting this session -- a control timeout unregisters the RPC
+            # waiter but cannot cancel the manager's open -- so a late admission
+            # would hold an admission slot and a Stage0 reservation until idle
+            # expiry. Send the compensating close; the manager applies it
+            # immediately if the session already landed, and records it for the
+            # open to honour on arrival if not.
+            with suppress(Exception):
+                await self.engine.close_session_async(session_id, reason="open_abandoned", timeout=timeout)
+            raise
+        handle._adopt(result)
+        return handle
+
+    def get_session(self, session_id: str) -> DuplexSessionHandle | None:
+        return self._handles.get(session_id)
+
+    async def resume_session(
+        self,
+        session_id: str,
+        *,
+        expected_lease_generation: int,
+        timeout: float | None = _DEFAULT_CONTROL_TIMEOUT_S,
+    ) -> DuplexSessionHandle:
+        """Engine lease resume (CAS on the lease generation); returns the existing handle."""
+        handle = self._require_handle(session_id)
+        result = await self.engine.resume_session_async(
+            session_id,
+            expected_lease_generation=expected_lease_generation,
+            timeout=timeout,
+        )
+        # The result carries the engine's current public session (state,
+        # epoch, turn ...), which a resumed client must see, not the open-time snapshot.
+        handle._adopt(result)
+        return handle
+
+    async def touch_session(
+        self,
+        session_id: str,
+        *,
+        activity: str = "heartbeat",
+        timeout: float | None = _DEFAULT_CONTROL_TIMEOUT_S,
+    ) -> None:
+        self._require_handle(session_id)
+        await self.engine.touch_session_async(session_id, activity=activity, timeout=timeout)
+
+    async def detach_session(self, session_id: str, *, timeout: float | None = _DEFAULT_CONTROL_TIMEOUT_S) -> None:
+        """Start the engine-owned disconnect grace; expiry arrives as ``session.expired``."""
+        await self.touch_session(session_id, activity="detach", timeout=timeout)
+
+    async def close_session(
+        self,
+        session_id: str,
+        *,
+        reason: str = "client_close",
+        timeout: float | None = _DEFAULT_CONTROL_TIMEOUT_S,
+    ) -> None:
+        handle = self._handles.get(session_id)
+        if handle is None or handle.closed:
+            return
+        try:
+            await self.engine.close_session_async(session_id, reason=reason, timeout=timeout)
+        except Exception:
+            # The engine refused or lost the close: the handle is unusable
+            # either way, and it must not shadow the id in ``sessions``.
+            handle._mark_closed(reason)
+            self._handles.pop(session_id, None)
+            raise
+        # The manager emits session.closed after the stage cleanup, but the
+        # event travels on the output queue: wait for it so ``events()`` ends
+        # with the typed SessionClosed rather than an abrupt stop.
+        try:
+            await asyncio.wait_for(handle.wait_closed(), timeout=timeout)
+        except asyncio.TimeoutError:
+            logger.warning("[DuplexOmni] session.closed for %s did not arrive in time", session_id)
+            handle._mark_closed(reason)
+            self._handles.pop(session_id, None)
+
+    async def close_all_sessions(self, *, reason: str = "shutdown") -> None:
+        for session_id in list(self._handles):
+            try:
+                await self.close_session(session_id, reason=reason)
+            except Exception:
+                logger.exception("[DuplexOmni] failed to close session %s", session_id)
+
+    def _require_handle(self, session_id: str) -> DuplexSessionHandle:
+        handle = self._handles.get(session_id)
+        if handle is None or handle.closed:
+            raise DuplexSessionError(
+                f"unknown or closed duplex session: {session_id}", code="unknown_session", session_id=session_id
+            )
+        return handle
+
+    # ---- engine output routing ----
+
+    def _route_engine_message(self, msg: object) -> bool:
+        if not isinstance(msg, DuplexSessionEventMessage):
+            return False
+        handle = self._handles.get(msg.session_id)
+        if handle is None:
+            logger.debug("[DuplexOmni] dropping event for unknown session %s", msg.session_id)
+            return True
+        handle._deliver(msg.event)
+        if handle.closed:
+            self._handles.pop(msg.session_id, None)
+        return True
+
+    def _on_engine_dead(self, error: str) -> None:
+        for handle in list(self._handles.values()):
+            handle._mark_closed(f"engine_dead: {error}")
+        self._handles.clear()
+
+    def shutdown(self, timeout: float | None = None) -> None:
+        for handle in list(self._handles.values()):
+            handle._mark_closed("shutdown")
+        self._handles.clear()
+        super().shutdown(timeout)
+
+
+__all__ = ["DuplexOmni", "DuplexSessionHandle"]
diff --git a/vllm_omni/entrypoints/duplex_request_client.py b/vllm_omni/entrypoints/duplex_request_client.py
deleted file mode 100644
index d9e70f672..000000000
--- a/vllm_omni/entrypoints/duplex_request_client.py
+++ /dev/null
@@ -1,383 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-from __future__ import annotations
-
-import asyncio
-import time
-from collections.abc import Callable, MutableMapping
-from typing import Protocol
-
-from vllm_omni.engine.duplex.contracts import (
-    duplex_data_plane_request_info,
-    duplex_resource_request_id,
-)
-from vllm_omni.engine.duplex.lease import DuplexLeaseActivity
-from vllm_omni.engine.duplex.messages import DuplexFence
-from vllm_omni.engine.messages import ErrorMessage, OutputMessage
-from vllm_omni.entrypoints.client_request_state import ClientRequestState
-from vllm_omni.metrics.stats import OrchestratorAggregator as OrchestratorMetrics
-from vllm_omni.outputs import OmniRequestOutput
-from vllm_omni.outputs.duplex import get_duplex_output_decision
-
-
-class DuplexEnginePort(Protocol):
-    """Engine control methods required by the experimental request client.
-
-    The protocol keeps request preregistration and output collection testable
-    without coupling this component to ``AsyncOmniEngine``.
-    """
-
-    async def open_duplex_session_async(self, session_id: str, **kwargs) -> dict[str, object]: ...
-
-    async def append_duplex_input_async(self, session_id: str, **kwargs) -> dict[str, object]: ...
-
-    async def signal_duplex_turn_async(self, session_id: str, **kwargs) -> dict[str, object]: ...
-
-    async def close_duplex_session_async(self, session_id: str, **kwargs) -> dict[str, object]: ...
-
-    async def touch_duplex_session_async(self, session_id: str, **kwargs) -> dict[str, object]: ...
-
-    async def resume_duplex_session_async(self, session_id: str, **kwargs) -> dict[str, object]: ...
-
-
-class DuplexRequestOutputPort:
-    """Narrow output-processing surface owned by the AsyncOmni entrypoint."""
-
-    def __init__(
-        self,
-        *,
-        request_states: MutableMapping[str, ClientRequestState],
-        num_stages: int,
-        log_stats: bool,
-        start_output_handler: Callable[[], object],
-        process_single_result: Callable[..., OmniRequestOutput | None],
-    ) -> None:
-        self.request_states = request_states
-        self.num_stages = num_stages
-        self.log_stats = log_stats
-        self._start_output_handler = start_output_handler
-        self._process_single_result = process_single_result
-
-    def start_output_handler(self) -> None:
-        self._start_output_handler()
-
-    def process_single_result(self, *args, **kwargs) -> OmniRequestOutput | None:
-        return self._process_single_result(*args, **kwargs)
-
-
-class DuplexRequestClient:
-    """Owns duplex request identity, preregistration and output collection."""
-
-    def __init__(self, engine: DuplexEnginePort, output_port: DuplexRequestOutputPort) -> None:
-        self.engine = engine
-        self.output_port = output_port
-
-    @staticmethod
-    def request_info(result: dict[str, object]) -> tuple[str | None, int | None]:
-        return duplex_data_plane_request_info(result)
-
-    async def open(
-        self,
-        session_id: str,
-        *,
-        session_mode: str,
-        capabilities: dict[str, object] | None,
-        session_config: dict[str, object] | None,
-        runtime_config: dict[str, object] | None,
-        fence: DuplexFence,
-        timeout: float | None,
-    ) -> dict[str, object]:
-        # Lifecycle expiry messages share the engine output channel. Start its
-        # sole dispatcher before open so an idle session can be reaped even if
-        # it never submits an append request.
-        self.output_port.start_output_handler()
-        kwargs: dict[str, object] = {
-            "session_mode": session_mode,
-            "capabilities": capabilities,
-            "session_config": session_config,
-            "fence": fence,
-            "timeout": timeout,
-        }
-        if runtime_config is not None:
-            kwargs["runtime_config"] = runtime_config
-        return await self.engine.open_duplex_session_async(session_id, **kwargs)
-
-    async def append(
-        self,
-        session_id: str,
-        *,
-        mode: str,
-        payload: object,
-        operation_id: str | None,
-        final: bool,
-        expected_epoch: int | None,
-        fence: DuplexFence,
-        timeout: float | None,
-        collect_outputs: bool,
-    ) -> dict[str, object]:
-        kwargs: dict[str, object] = {
-            "mode": mode,
-            "payload": payload,
-            "final": final,
-            "expected_epoch": expected_epoch,
-            "timeout": timeout,
-            "fence": fence,
-        }
-        if operation_id is not None:
-            kwargs["operation_id"] = operation_id
-
-        expected_request_id = duplex_resource_request_id(fence, "stage0")
-        request_state = self.output_port.request_states.get(expected_request_id)
-        created_request_state = request_state is None
-        if request_state is None:
-            request_state = ClientRequestState(expected_request_id)
-            self.output_port.request_states[expected_request_id] = request_state
-        if request_state.metrics is None:
-            wall_start_ts = time.time()
-            request_state.metrics = OrchestratorMetrics(
-                self.output_port.num_stages,
-                self.output_port.log_stats,
-                wall_start_ts,
-                max(0, self.output_port.num_stages - 1),
-            )
-            request_state.request_arrival_ts = wall_start_ts
-        self.output_port.start_output_handler()
-        try:
-            result = await self.engine.append_duplex_input_async(session_id, **kwargs)
-        except BaseException:
-            if created_request_state and request_state.queue.empty():
-                self.output_port.request_states.pop(expected_request_id, None)
-            raise
-
-        request_id, response_stage_id = duplex_data_plane_request_info(result)
-        if request_id is None:
-            if created_request_state and request_state.queue.empty():
-                self.output_port.request_states.pop(expected_request_id, None)
-            return result
-        if request_id != expected_request_id:
-            if created_request_state and request_state.queue.empty():
-                self.output_port.request_states.pop(expected_request_id, None)
-            raise RuntimeError(
-                f"duplex data-plane request id mismatch: expected {expected_request_id!r}, got {request_id!r}"
-            )
-        if not collect_outputs:
-            return result
-        outputs = await self.collect_outputs(
-            request_id,
-            request_state,
-            response_stage_id=response_stage_id,
-            timeout=timeout,
-        )
-        if outputs:
-            result = dict(result)
-            result["data_plane_outputs"] = outputs
-        return result
-
-    async def collect_registered_outputs(
-        self,
-        request_id: str,
-        *,
-        response_stage_id: int | None,
-        timeout: float | None,
-    ) -> list[OmniRequestOutput]:
-        self.output_port.start_output_handler()
-        request_state = self.output_port.request_states.get(request_id)
-        if request_state is None:
-            return []
-        return await self.collect_outputs(
-            request_id,
-            request_state,
-            response_stage_id=response_stage_id,
-            timeout=timeout,
-        )
-
-    async def signal(
-        self,
-        session_id: str,
-        *,
-        event: str,
-        fence: DuplexFence,
-        next_fence: DuplexFence | None,
-        session_config: dict[str, object] | None,
-        runtime_config: dict[str, object] | None,
-        timeout: float | None,
-    ) -> dict[str, object]:
-        kwargs: dict[str, object] = {"event": event, "fence": fence, "timeout": timeout}
-        if next_fence is not None:
-            kwargs["next_fence"] = next_fence
-        if session_config is not None:
-            kwargs["session_config"] = session_config
-        if runtime_config is not None:
-            kwargs["runtime_config"] = runtime_config
-        result = await self.engine.signal_duplex_turn_async(session_id, **kwargs)
-        if event in {"barge_in", "input.cancel", "response.cancel"}:
-            self.output_port.request_states.pop(duplex_resource_request_id(fence, "stage0"), None)
-        return result
-
-    async def close(
-        self,
-        session_id: str,
-        *,
-        reason: str,
-        fence: DuplexFence,
-        timeout: float | None,
-    ) -> dict[str, object]:
-        result = await self.engine.close_duplex_session_async(
-            session_id,
-            reason=reason,
-            fence=fence,
-            timeout=timeout,
-        )
-        self.output_port.request_states.pop(duplex_resource_request_id(fence, "stage0"), None)
-        return result
-
-    async def touch(
-        self,
-        session_id: str,
-        *,
-        fence: DuplexFence,
-        activity: DuplexLeaseActivity,
-        timeout: float | None,
-    ) -> dict[str, object]:
-        return await self.engine.touch_duplex_session_async(
-            session_id,
-            fence=fence,
-            activity=activity,
-            timeout=timeout,
-        )
-
-    async def resume(
-        self,
-        session_id: str,
-        *,
-        fence: DuplexFence,
-        expected_lease_generation: int,
-        timeout: float | None,
-    ) -> dict[str, object]:
-        return await self.engine.resume_duplex_session_async(
-            session_id,
-            fence=fence,
-            expected_lease_generation=expected_lease_generation,
-            timeout=timeout,
-        )
-
-    async def collect_outputs(
-        self,
-        request_id: str,
-        request_state: ClientRequestState,
-        *,
-        response_stage_id: int | None,
-        timeout: float | None,
-    ) -> list[OmniRequestOutput]:
-        deadline = None if timeout is None else time.monotonic() + timeout
-        wall_start_ts = request_state.request_arrival_ts or time.time()
-        final_stage_id = response_stage_id if response_stage_id is not None else max(0, self.output_port.num_stages - 1)
-        num_stages = max(self.output_port.num_stages, final_stage_id + 1)
-        metrics = getattr(request_state, "metrics", None) or OrchestratorMetrics(
-            num_stages,
-            self.output_port.log_stats,
-            wall_start_ts,
-            final_stage_id,
-        )
-        stage_event_cursor = metrics.stage_event_cursor(request_id)
-        request_start_ts = {request_id: wall_start_ts}
-        outputs: list[OmniRequestOutput] = []
-        while True:
-            remaining = None if deadline is None else max(0.0, deadline - time.monotonic())
-            if remaining == 0.0:
-                break
-            try:
-                message = await asyncio.wait_for(request_state.queue.get(), timeout=remaining)
-            except asyncio.TimeoutError:
-                break
-            if isinstance(message, ErrorMessage):
-                raise RuntimeError(message.error)
-            if not isinstance(message, OutputMessage):
-                continue
-            engine_outputs = message.engine_outputs
-            is_response_stage = response_stage_id is None or message.stage_id >= response_stage_id
-            is_direct_response = self.is_direct_response(engine_outputs)
-            output_to_collect = None
-            if isinstance(engine_outputs, OmniRequestOutput):
-                output_to_collect = engine_outputs
-                if message.metrics is not None:
-                    existing_metrics = dict(output_to_collect.metrics)
-                    metrics.process_stage_metrics(
-                        result={"metrics": message.metrics},
-                        stage_type="",
-                        stage_id=message.stage_id,
-                        req_id=request_id,
-                        engine_outputs=engine_outputs,
-                        finished=message.finished,
-                        final_output_type=engine_outputs.final_output_type,
-                        output_to_yield=output_to_collect,
-                        event_cursor=stage_event_cursor,
-                    )
-                    generated_metrics = dict(output_to_collect.metrics)
-                    existing_stage_metrics = existing_metrics.get("stage_metrics")
-                    generated_stage_metrics = generated_metrics.get("stage_metrics")
-                    if isinstance(existing_stage_metrics, dict) and isinstance(generated_stage_metrics, dict):
-                        generated_metrics["stage_metrics"] = {
-                            **existing_stage_metrics,
-                            **generated_stage_metrics,
-                        }
-                    output_to_collect.metrics = {
-                        **existing_metrics,
-                        **generated_metrics,
-                    }
-            elif is_response_stage:
-                output_to_collect = self.output_port.process_single_result(
-                    message,
-                    message.stage_id,
-                    metrics,
-                    request_start_ts,
-                    wall_start_ts,
-                    final_stage_id,
-                    stage_event_cursor,
-                )
-            if output_to_collect is not None and (is_response_stage or is_direct_response):
-                if message.finished:
-                    output_to_collect.finished = True
-                outputs.append(output_to_collect)
-            if message.finished or outputs:
-                break
-        return outputs
-
-    @classmethod
-    def is_direct_response(cls, output: object) -> bool:
-        multimodal_output = cls.multimodal_output(output)
-        if not multimodal_output:
-            return False
-        return multimodal_output.get("duplex_direct_response") is True or multimodal_output.get(
-            "duplex_native_decision"
-        ) in {"listen", "speak"}
-
-    @classmethod
-    def multimodal_output(cls, output: object) -> dict[str, object]:
-        if isinstance(output, OmniRequestOutput):
-            decision = get_duplex_output_decision(output)
-            if decision is not None:
-                return dict(decision.metadata)
-            private_output = getattr(output, "_multimodal_output", None)
-            multimodal_output = output.multimodal_output
-            if isinstance(multimodal_output, dict) and multimodal_output:
-                return multimodal_output
-            inner_output = getattr(output, "request_output", None)
-            if inner_output is not None and inner_output is not output:
-                inner_multimodal_output = cls.multimodal_output(inner_output)
-                if inner_multimodal_output:
-                    return inner_multimodal_output
-            if isinstance(private_output, dict):
-                return private_output
-            return multimodal_output if isinstance(multimodal_output, dict) else {}
-        multimodal_output = getattr(output, "multimodal_output", None)
-        if isinstance(multimodal_output, dict):
-            return multimodal_output
-        outputs = getattr(output, "outputs", None)
-        completion = outputs[0] if isinstance(outputs, list) and outputs else None
-        multimodal_output = getattr(completion, "multimodal_output", None) if completion is not None else None
-        return multimodal_output if isinstance(multimodal_output, dict) else {}
-
-
-__all__ = ["DuplexEnginePort", "DuplexRequestClient", "DuplexRequestOutputPort"]
diff --git a/vllm_omni/entrypoints/omni.py b/vllm_omni/entrypoints/omni.py
index 28bbe9219..ca9fc0196 100644
--- a/vllm_omni/entrypoints/omni.py
+++ b/vllm_omni/entrypoints/omni.py
@@ -1,15 +1,19 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 from __future__ import annotations
 
 import copy
 import time
 import uuid
 from collections.abc import Callable, Generator, Iterable, Sequence
-from typing import TYPE_CHECKING, Literal, overload
+from typing import TYPE_CHECKING, Any, Literal, overload
 
 from tqdm.auto import tqdm
 from vllm.logger import init_logger
 from vllm.sampling_params import RequestOutputKind
 
+from vllm_omni.engine.async_omni_engine import AsyncOmniEngine
 from vllm_omni.engine.messages import OutputMessage
 from vllm_omni.entrypoints.client_request_state import ClientRequestState
 from vllm_omni.entrypoints.omni_base import OmniBase
@@ -25,6 +29,9 @@ logger = init_logger(__name__)
 class Omni(OmniBase):
     """Synchronous entrypoint for offline generation."""
 
+    def _create_engine(self, **engine_kwargs: Any) -> AsyncOmniEngine:
+        return AsyncOmniEngine(**engine_kwargs)
+
     def _maybe_force_final_only_for_llm_stages(
         self,
         sampling_params_list: Sequence[OmniSamplingParams],
@@ -99,11 +106,11 @@ class Omni(OmniBase):
         sampling_params_list: Sequence[OmniSamplingParams],
         use_tqdm: bool | Callable[..., tqdm] = True,
     ) -> Generator[OmniRequestOutput, None, None]:
-        gen = self._run_generation(prompts, sampling_params_list, use_tqdm)
-        try:
-            yield from gen
-        finally:
-            self.close()
+        yield from self._run_generation(
+            prompts,
+            sampling_params_list,
+            use_tqdm,
+        )
 
     def _run_generation(
         self,
@@ -198,6 +205,10 @@ class Omni(OmniBase):
                     if pbar is not None:
                         pbar.update(1)
                     self._log_summary_and_cleanup(req_id)
+        except GeneratorExit:
+            if "active_reqs" in locals() and active_reqs:
+                self.abort(list(active_reqs))
+            raise
         except Exception:
             if "active_reqs" in locals() and active_reqs:
                 for req_id in active_reqs:
diff --git a/vllm_omni/entrypoints/omni_base.py b/vllm_omni/entrypoints/omni_base.py
index 264b37fb5..79217ca8b 100644
--- a/vllm_omni/entrypoints/omni_base.py
+++ b/vllm_omni/entrypoints/omni_base.py
@@ -18,13 +18,14 @@ from vllm.transformers_utils.repo_utils import file_or_path_exists
 from vllm.transformers_utils.runai_utils import is_runai_obj_uri
 from vllm.v1.engine.exceptions import EngineDeadError, EngineGenerateError
 
-from vllm_omni.engine.async_omni_engine import AsyncOmniEngine
+from vllm_omni.config.stage_config import merge_sampling_constraints
 from vllm_omni.engine.messages import (
     EngineQueueMessage,
     ErrorMessage,
     OutputMessage,
     StageMetricsMessage,
 )
+from vllm_omni.engine.omni_engine_base import OmniEngineBase
 from vllm_omni.entrypoints.client_request_state import ClientRequestState
 from vllm_omni.entrypoints.pd_utils import PDDisaggregationMixin
 from vllm_omni.entrypoints.utils import coerce_param_message_types, get_final_stage_id_for_e2e
@@ -65,7 +66,7 @@ class OmniEngineDeadError(EngineDeadError):
         self.error_stage_id = error_stage_id
 
 
-def _weak_shutdown_engine(engine: AsyncOmniEngine) -> None:
+def _weak_shutdown_engine(engine: OmniEngineBase) -> None:
     """Best-effort engine cleanup for GC finalization."""
     try:
         engine.shutdown()
@@ -205,13 +206,13 @@ class OmniBase(PDDisaggregationMixin):
         self.tts_batch_max_items: int = kwargs.pop("tts_batch_max_items", 32)
 
         logger.info("[%s] Initializing with model %s", self.__class__.__name__, model)
-        # Construct transfer_metrics first so we can hand it to AsyncOmniEngine
+        # Construct transfer_metrics first so we can hand it to the engine
         # (which forwards it to the Orchestrator background thread for
-        # TX-side emit; see Orchestrator._forward_to_next_stage).
+        # TX-side emit; see OrchestratorBase._forward_to_next_stage).
         self.transfer_metrics = OmniTransferMetrics(model_name=model, log_stats=log_stats)
         self.prom_metrics = OmniPrometheusMetrics(model_name=model, log_stats=log_stats)
         st = time.time()
-        self.engine = AsyncOmniEngine(
+        self.engine = self._create_engine(
             model=model,
             init_timeout=init_timeout,
             stage_init_timeout=stage_init_timeout,
@@ -223,15 +224,14 @@ class OmniBase(PDDisaggregationMixin):
         self._shutdown_called = False
         self._weak_finalizer = weakref.finalize(self, _weak_shutdown_engine, self.engine)
         et = time.time()
-        logger.info("[%s] AsyncOmniEngine initialized in %.2f seconds", self.__class__.__name__, et - st)
-        # Authoritative: ``AsyncOmniEngine`` resolves (pipeline + deploy YAML +
+        logger.info("[%s] %s initialized in %.2f seconds", self.__class__.__name__, type(self.engine).__name__, et - st)
+        # Authoritative: the engine resolves (pipeline + deploy YAML +
         # CLI overrides) through ``StageConfigFactory`` and stores the final
         # value on ``engine.async_chunk``; mirror it here so ``--no-async-chunk``
         # (explicit ``False``) is not fallen-back-through by ``or``.
         self.async_chunk = bool(getattr(self.engine, "async_chunk", False))
 
         self.request_states: dict[str, ClientRequestState] = {}
-        self._consumed_metric_messages: dict[str, set[int]] = {}
         self.mod_metrics = OmniModalityMetrics(model_name=model, log_stats=log_stats)
 
         self.default_sampling_params_list = self.engine.default_sampling_params_list
@@ -253,6 +253,10 @@ class OmniBase(PDDisaggregationMixin):
         # PD disaggregation state (detects if a prefill/decode stage pair is configured)
         self._init_pd_state()
 
+    def _create_engine(self, **engine_kwargs: Any) -> OmniEngineBase:
+        """Construct this entrypoint's engine (``AsyncOmniEngine`` for turn-based use)."""
+        raise NotImplementedError
+
     @property
     def num_stages(self) -> int:
         return self.engine.num_stages
@@ -298,13 +302,6 @@ class OmniBase(PDDisaggregationMixin):
         """True when a non-empty stage pool has lost all of its replicas."""
         return len(pool.clients) > 0 and self._live_replica_count(pool) == 0
 
-    def _consumed_metric_message_ids(self, request_id: str) -> set[int]:
-        consumed_by_request = getattr(self, "_consumed_metric_messages", None)
-        if consumed_by_request is None:
-            consumed_by_request = {}
-            self._consumed_metric_messages = consumed_by_request
-        return consumed_by_request.setdefault(request_id, set())
-
     @property
     def is_running(self) -> bool:
         return self.engine.is_alive()
@@ -380,12 +377,12 @@ class OmniBase(PDDisaggregationMixin):
 
     @staticmethod
     def _apply_sampling_constraints(params: Any, constraints: Mapping[str, Any]) -> Any:
-        """Rebuild params with pipeline-required settings without mutating caller input."""
+        """Apply pipeline requirements, merging required stops with caller stops."""
         if not constraints:
             return params
         if isinstance(params, Mapping):
-            return {**params, **constraints}
-        if is_dataclass(params):
+            values = dict(params)
+        elif is_dataclass(params):
             values = {field.name: getattr(params, field.name) for field in fields(params) if field.init}
         elif struct_fields := getattr(params, "__struct_fields__", None):
             values = {
@@ -395,7 +392,11 @@ class OmniBase(PDDisaggregationMixin):
             }
         else:
             raise TypeError(f"Expected a mapping, dataclass, or msgspec struct, got {type(params).__name__}")
-        return type(params)(**{**values, **constraints})
+
+        resolved = merge_sampling_constraints(values, constraints)
+        if isinstance(params, Mapping):
+            return resolved
+        return type(params)(**resolved)
 
     def _record_request_failure_once(self, request_id: str, reason: str) -> None:
         req_state = self.request_states.get(request_id)
@@ -449,9 +450,6 @@ class OmniBase(PDDisaggregationMixin):
             )
         finally:
             self.request_states.pop(request_id, None)
-            consumed_by_request = getattr(self, "_consumed_metric_messages", None)
-            if consumed_by_request is not None:
-                consumed_by_request.pop(request_id, None)
             # Republish gauges so any stale value left by the per-stage
             # publish in _process_single_result (which runs while the request
             # is still in self.request_states) is corrected after the pop.
@@ -532,7 +530,7 @@ class OmniBase(PDDisaggregationMixin):
             stage_meta = self.engine.get_stage_metadata(stage_id)
             output_type = getattr(msg.engine_outputs, "final_output_type", stage_meta.final_output_type)
             msg_id = id(msg)
-            consumed = self._consumed_metric_message_ids(req_id)
+            consumed = req_state.consumed_metric_message_ids
             if msg_id not in consumed:
                 req_state.metrics.on_stage_metrics(stage_id, req_id, msg.metrics, output_type)
                 submit_ts = msg.stage_submit_ts
@@ -642,8 +640,9 @@ class OmniBase(PDDisaggregationMixin):
         output_type = getattr(engine_outputs, "final_output_type", stage_meta.final_output_type)
         if finished and _m is not None:
             msg_id = id(result)
-            consumed = self._consumed_metric_message_ids(req_id)
-            if msg_id not in consumed:
+            req_state = self.request_states.get(req_id)
+            consumed = req_state.consumed_metric_message_ids if req_state is not None else None
+            if consumed is not None and msg_id not in consumed:
                 metrics.accumulate_diffusion_metrics(stage_meta.stage_type, req_id, engine_outputs)
                 metrics.on_stage_metrics(stage_id, req_id, _m, output_type)
                 consumed.add(msg_id)
diff --git a/vllm_omni/entrypoints/openai/api_server.py b/vllm_omni/entrypoints/openai/api_server.py
index 7aeed4b85..d733c2be6 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,16 +85,18 @@ 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.entrypoints.async_omni import AsyncOmni
-from vllm_omni.entrypoints.duplex.capability import should_enable_duplex_endpoint
+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
+from vllm_omni.entrypoints.duplex_omni import DuplexOmni
 from vllm_omni.entrypoints.openai import app_state as openai_app_state
 from vllm_omni.entrypoints.openai.app_state import (
     ENDPOINT_LOAD_METRICS_FORMAT_HEADER_LABEL,
@@ -138,6 +145,10 @@ from vllm_omni.entrypoints.openai.protocol.images import (
     ImageGenerationResponse,
     ResponseFormat,
 )
+from vllm_omni.entrypoints.openai.protocol.rollout import (
+    CreateSessionRequest,
+    RolloutStepRequest,
+)
 from vllm_omni.entrypoints.openai.protocol.videos import (
     VideoDeleteResponse,
     VideoGenerationRequest,
@@ -146,11 +157,18 @@ from vllm_omni.entrypoints.openai.protocol.videos import (
     VideoResponse,
 )
 from vllm_omni.entrypoints.openai.realtime_connection import RealtimeConnection
+from vllm_omni.entrypoints.openai.rollout_session import (
+    RolloutSessionCapacityError,
+    RolloutSessionClosedError,
+    RolloutSessionNotFoundError,
+)
 from vllm_omni.entrypoints.openai.serving_audio_generate import OmniOpenAIServingAudioGenerate
 from vllm_omni.entrypoints.openai.serving_chat import OmniOpenAIServingChat
+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,
@@ -191,6 +209,8 @@ from vllm_omni.utils.tracking_parser import TrackingArgumentParser, TrackingName
 logger = init_logger(__name__)
 router = APIRouter()
 
+VIDEO_ABORT_TIMEOUT_S = ABORT_TIMEOUT_S
+
 profiler_router = APIRouter()
 
 
@@ -219,8 +239,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)
@@ -260,6 +327,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"})
@@ -335,6 +403,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
@@ -393,7 +462,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.
 
@@ -424,15 +493,49 @@ 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 _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"),
+    )
+    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
 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.
 
@@ -485,9 +588,16 @@ async def build_async_omni_from_stage_config(
 
     try:
         kwargs = args.get_explicit_kwargs_dict()
+        # This controls only the API-process WebSocket and is not an AsyncOmni option.
+        kwargs.pop("robot_openpi_idle_timeout", None)
         model = kwargs.pop("model", None) or args.model
         kwargs.setdefault("log_stats", not args.disable_log_stats)
-        async_omni = AsyncOmni(model=model, **kwargs)
+        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)
 
         # # Don't keep the dummy data in memory
         # await async_llm.reset_mm_cache()
@@ -498,6 +608,134 @@ async def build_async_omni_from_stage_config(
             async_omni.shutdown()
 
 
+async def _init_duplex_app_state(
+    engine_client: DuplexOmni,
+    state: State,
+    args: Namespace,
+    base_model_paths: list[BaseModelPath],
+    vllm_config: Any,
+    request_logger: RequestLogger | None,
+) -> None:
+    """Minimal app state for a duplex server: only the surfaces a duplex session backs."""
+    state.vllm_config = vllm_config
+    state.diffusion_engine = None
+    state.openai_serving_models = OpenAIServingModels(
+        engine_client=engine_client,  # type: ignore[arg-type]
+        base_model_paths=base_model_paths,
+        lora_modules=None,
+    )
+    state.serving_tokenization = None
+    state.serving_tokens = None
+    # Replaced by the chat init below when the model serves chat.
+    state.online_renderer = None
+    for attribute in (
+        "openai_serving_chat_batch",
+        "openai_serving_completion",
+        "openai_serving_responses",
+        "openai_serving_embedding",
+        "openai_serving_pooling",
+        "openai_serving_classification",
+        "openai_serving_scores",
+        "openai_serving_transcription",
+        "openai_serving_translation",
+        "openai_serving_speech",
+        "openai_serving_audio_generate",
+        "openai_serving_video",
+        "openai_streaming_speech",
+        "openai_streaming_video",
+        "openai_streaming_video_output",
+        "openai_serving_realtime",
+        "openai_serving_realtime_robot",
+        "anthropic_serving_messages",
+    ):
+        setattr(state, attribute, None)
+    state.openai_serving_duplex = OmniDuplexSessionHandler(duplex_omni=engine_client)
+    # One engine, both surfaces. ``DuplexOmni`` extends ``AsyncOmni``, so the
+    # ordinary chat service runs on it unchanged: a chat request is a turn-based
+    # request on the same pipeline, not a session, and costs no admission slot.
+    state.openai_serving_chat = await _init_duplex_chat(engine_client, state, args, request_logger)
+    state.enable_server_load_tracking = getattr(args, "enable_server_load_tracking", False)
+    state.server_load_metrics = 0
+    if state.openai_serving_chat is not None:
+        logger.info(
+            "Duplex mode: serving %s over /v1/realtime?duplex=1 and /v1/chat/completions",
+            engine_client.model,
+        )
+    else:
+        logger.info(
+            "Duplex mode: serving %s over /v1/realtime?duplex=1 only "
+            "(/v1/chat/completions unavailable: the model does not declare supports_chat_completions)",
+            engine_client.model,
+        )
+
+
+async def _init_duplex_chat(
+    engine_client: DuplexOmni,
+    state: State,
+    args: Namespace,
+    request_logger: RequestLogger | None,
+) -> OmniOpenAIServingChat | None:
+    """The ordinary chat service, on a duplex engine, when the model allows it.
+
+    Gated on ``DuplexCapabilities.supports_chat_completions`` so the decision
+    stays the model's: a duplex model that should not answer chat requests says
+    so in its plugin, and the route reports "not available" rather than
+    answering badly. ``endpoint_restrictions`` remains the per-deployment
+    opt-out on top of this.
+    """
+    if not engine_client.duplex_capabilities.supports_chat_completions:
+        return None
+    supported_tasks: set[str] = {"generate"}
+    if hasattr(engine_client, "get_supported_tasks"):
+        supported_tasks = set(await engine_client.get_supported_tasks())
+    if "generate" not in supported_tasks:
+        return None
+
+    resolved_chat_template = load_chat_template(args.chat_template)
+    if resolved_chat_template is None:
+        try:
+            tokenizer = await engine_client.get_tokenizer()
+        except Exception as exc:
+            logger.debug("Could not inspect tokenizer chat_template before duplex chat init: %s", exc)
+            tokenizer = None
+        if tokenizer is None or getattr(tokenizer, "chat_template", None) is None:
+            resolved_chat_template = _load_model_chat_template_json(args.model)
+
+    state.online_renderer = OnlineRenderer(
+        model_config=engine_client.model_config,
+        renderer=engine_client.renderer,
+        request_logger=request_logger,
+        chat_template=resolved_chat_template,
+        chat_template_content_format=args.chat_template_content_format,
+        trust_request_chat_template=args.trust_request_chat_template,
+        enable_auto_tools=args.enable_auto_tool_choice,
+        exclude_tools_when_tool_choice_none=args.exclude_tools_when_tool_choice_none,
+        tool_parser=args.tool_call_parser,
+        reasoning_parser=args.structured_outputs_config.reasoning_parser,
+        default_chat_template_kwargs=args.default_chat_template_kwargs,
+    )
+    return OmniOpenAIServingChat(
+        engine_client=engine_client,
+        models=state.openai_serving_models,
+        response_role=args.response_role,
+        online_renderer=state.online_renderer,
+        request_logger=request_logger,
+        chat_template=resolved_chat_template,
+        chat_template_content_format=args.chat_template_content_format,
+        default_chat_template_kwargs=args.default_chat_template_kwargs,
+        trust_request_chat_template=args.trust_request_chat_template,
+        return_tokens_as_token_ids=args.return_tokens_as_token_ids,
+        enable_auto_tools=args.enable_auto_tool_choice,
+        exclude_tools_when_tool_choice_none=args.exclude_tools_when_tool_choice_none,
+        tool_parser=args.tool_call_parser,
+        reasoning_parser=args.structured_outputs_config.reasoning_parser,
+        enable_prompt_tokens_details=args.enable_prompt_tokens_details,
+        enable_force_include_usage=args.enable_force_include_usage,
+        enable_log_outputs=args.enable_log_outputs,
+        enable_log_deltas=args.enable_log_deltas,
+    )
+
+
 async def omni_init_app_state(
     engine_client: EngineClient,
     state: State,
@@ -548,6 +786,11 @@ 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
 
+    # 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
+
     # Pure Diffusion mode: use simplified initialization logic
     if is_pure_diffusion:
         state.vllm_config = None
@@ -602,6 +845,10 @@ async def omni_init_app_state(
             engine_client=engine_client,
             model_name=model_name,
         )
+        if state.openai_serving_realtime_robot is not None:
+            state.rl_rollout_serving = ServingRLRollout(state.openai_serving_realtime_robot)
+        else:
+            state.rl_rollout_serving = None
 
         state.enable_server_load_tracking = getattr(args, "enable_server_load_tracking", False)
         state.server_load_metrics = 0
@@ -924,17 +1171,6 @@ async def omni_init_app_state(
         else None
     )
     state.openai_serving_duplex = None
-    if state.openai_serving_chat is not None and should_enable_duplex_endpoint(
-        state.stage_configs,
-        config_path=getattr(engine_client, "config_path", None) or getattr(args, "deploy_config", None),
-    ):
-        state.openai_serving_duplex = OmniDuplexSessionHandler(
-            chat_service=state.openai_serving_chat,
-            served_model_name=model_name,
-            log_stats=state.log_stats,
-            duplex_session_config=getattr(engine_client, "duplex_session_config", None),
-            serving_runtime_adapter_path=getattr(engine_client, "duplex_serving_adapter_path", None),
-        )
     state.openai_serving_realtime = OpenAIServingRealtime(
         engine_client=engine_client,
         models=state.openai_serving_models,
@@ -947,6 +1183,7 @@ async def omni_init_app_state(
         stage_configs=state.stage_configs,
     )
     state.openai_serving_realtime_robot = None
+    state.rl_rollout_serving = None
 
     state.enable_server_load_tracking = args.enable_server_load_tracking
     state.server_load_metrics = 0
@@ -1255,6 +1492,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={
@@ -1300,6 +1573,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(
@@ -1365,6 +1639,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(
@@ -1458,23 +1733,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."""
-    # Hold real clients until the startup duplex warmup finishes (the warmup
-    # connection marks itself with vllm_omni_warmup=1 and passes through).
-    warmup_done = getattr(websocket.app.state, "duplex_warmup_done", None)
-    if warmup_done is not None and not warmup_done.is_set() and websocket.query_params.get("vllm_omni_warmup") != "1":
-        try:
-            await asyncio.wait_for(warmup_done.wait(), timeout=120)
-        except (TimeoutError, asyncio.TimeoutError):
-            logger.warning("Duplex warmup still running after 120 s; admitting the client anyway.")
     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()
@@ -1485,6 +1761,34 @@ async def realtime_websocket(websocket: WebSocket):
     await connection.handle_connection()
 
 
+async def _wait_for_duplex_warmup(websocket: WebSocket) -> None:
+    """Hold real clients until the startup duplex warmup finishes.
+
+    The warmup connection marks itself with ``vllm_omni_warmup=1`` and passes through.
+    """
+    warmup_done = getattr(websocket.app.state, "duplex_warmup_done", None)
+    if warmup_done is not None and not warmup_done.is_set() and websocket.query_params.get("vllm_omni_warmup") != "1":
+        try:
+            await asyncio.wait_for(warmup_done.wait(), timeout=120)
+        except (TimeoutError, asyncio.TimeoutError):
+            logger.warning("Duplex warmup still running after 120 s; admitting the client anyway.")
+
+
+@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:
+        await websocket.accept()
+        await websocket.send_json({"type": "error", "error": "Duplex API is not available", "code": "unsupported"})
+        await websocket.close()
+        return
+    await handler.handle_realtime_session(websocket)
+
+
 @router.websocket("/v1/realtime/robot/openpi")
 async def realtime_robot_openpi(websocket: WebSocket):
     """WebSocket endpoint for robot policy inference via OpenPI messages."""
@@ -1494,24 +1798,115 @@ async def realtime_robot_openpi(websocket: WebSocket):
 
     serving = getattr(websocket.app.state, "openai_serving_realtime_robot", None)
     if serving is None:
+        logger.warning(
+            "Rejecting robot OpenPI WebSocket: policy serving is disabled. "
+            "The diffusion stage must provide model_config.policy_server_config."
+        )
         await websocket.accept()
-        await websocket.send_json({"type": "error", "error": "Robot policy not available", "code": "unsupported"})
+        await websocket.send_json(
+            {
+                "type": "error",
+                "error": "Robot policy not available",
+                "code": "unsupported",
+            }
+        )
         await websocket.close()
         return
-    connection = RobotRealtimeConnection(websocket, serving)
+    state_args = getattr(websocket.app.state, "args", None)
+    configured_timeout = getattr(state_args, "robot_openpi_idle_timeout", 30.0)
+    idle_timeout = None if configured_timeout == 0 else configured_timeout
+    connection = RobotRealtimeConnection(websocket, serving, idle_timeout=idle_timeout)
     await connection.handle_connection()
 
 
-@router.websocket("/v1/duplex")
-async def duplex_websocket(websocket: WebSocket):
-    """WebSocket endpoint for vLLM-Omni duplex session control."""
-    handler = getattr(websocket.app.state, "openai_serving_duplex", None)
-    if handler is None:
-        await websocket.accept()
-        await websocket.send_json({"type": "error", "error": "Duplex API is not available", "code": "unsupported"})
-        await websocket.close()
-        return
-    await handler.handle_session(websocket)
+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)
+
+
+def _rl_rollout_serving(request: Request) -> ServingRLRollout:
+    serving = getattr(request.app.state, "rl_rollout_serving", None)
+    if serving is None:
+        raise HTTPException(status_code=501, detail="RL rollout serving not available for this model.")
+    return serving
+
+
+@router.post("/v1/realtime/sessions")
+async def create_rollout_session(body: CreateSessionRequest, request: Request):
+    serving = _rl_rollout_serving(request)
+    try:
+        return (await serving.create_session(body)).model_dump()
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    except RolloutSessionCapacityError as exc:
+        raise HTTPException(status_code=503, detail=str(exc)) from exc
+
+
+@router.post("/v1/realtime/sessions/{session_id}/step")
+async def rollout_step(session_id: str, body: RolloutStepRequest, request: Request):
+    serving = _rl_rollout_serving(request)
+    response = await serving.step(session_id, body)
+    if response.error is not None:
+        status_code = None
+        if response.error.code == "session_not_found":
+            status_code = 404
+        elif response.error.code == "session_closed":
+            status_code = 410
+        elif response.error.code in {"invalid_request", "step_already_committed", "step_out_of_order"}:
+            status_code = 400
+        if status_code is not None:
+            return JSONResponse(content=response.model_dump(), status_code=status_code)
+    return response.model_dump()
+
+
+@router.post("/v1/realtime/sessions/{session_id}/reset")
+async def reset_rollout_session(session_id: str, request: Request):
+    serving = _rl_rollout_serving(request)
+    try:
+        return (await serving.reset_session(session_id)).model_dump()
+    except RolloutSessionNotFoundError:
+        raise HTTPException(status_code=404, detail=f"Session {session_id!r} not found.")
+    except RolloutSessionClosedError:
+        raise HTTPException(status_code=410, detail=f"Session {session_id!r} is closed.")
+
+
+@router.post("/v1/realtime/sessions/{session_id}/close")
+async def close_rollout_session(session_id: str, request: Request):
+    serving = _rl_rollout_serving(request)
+    try:
+        await serving.close_session(session_id)
+        return {"session_id": session_id, "closed": True}
+    except RolloutSessionNotFoundError:
+        raise HTTPException(status_code=404, detail=f"Session {session_id!r} not found.")
+    except RolloutSessionClosedError:
+        return {"session_id": session_id, "closed": True}
+
+
+@router.get("/v1/realtime/sessions/{session_id}/status")
+async def rollout_session_status(session_id: str, request: Request):
+    serving = _rl_rollout_serving(request)
+    try:
+        return (await serving.get_status(session_id)).model_dump()
+    except RolloutSessionNotFoundError:
+        raise HTTPException(status_code=404, detail=f"Session {session_id!r} not found.")
+    except RolloutSessionClosedError:
+        raise HTTPException(status_code=410, detail=f"Session {session_id!r} is closed.")
 
 
 # Health and Model endpoints for diffusion mode
@@ -1590,7 +1985,9 @@ def _build_image_generation_response(
     output_format = _choose_output_format(request.output_format or "png", None)
     image_data = [
         ImageData(
-            b64_json=encode_image_base64_with_compression(image, format=output_format),
+            b64_json=encode_image_base64_with_compression(
+                image, format=output_format, output_compression=request.output_compression
+            ),
             revised_prompt=None,
         )
         for image in images
@@ -1654,6 +2051,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:
@@ -1671,7 +2070,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)
@@ -1725,7 +2123,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)
@@ -1741,12 +2139,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}"
@@ -1914,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
@@ -1947,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()
@@ -2023,13 +2420,13 @@ 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)
@@ -2127,7 +2524,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,
@@ -2158,7 +2555,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)
@@ -2166,6 +2563,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
@@ -2209,6 +2608,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},
@@ -2226,6 +2626,7 @@ async def create_video(
         ReferenceVideo | None,
         ReferenceAudio | None,
         str | None,
+        LatentEditInput | None,
     ] = Depends(_parse_video_form),
 ) -> VideoResponse:
     """Create an asynchronous video generation job.
@@ -2241,6 +2642,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)
@@ -2254,6 +2656,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)
@@ -2279,6 +2682,7 @@ async def create_video_sync(
         ReferenceVideo | None,
         ReferenceAudio | None,
         str | None,
+        LatentEditInput | None,
     ] = Depends(_parse_video_form),
 ) -> Response:
     """Synchronous video generation endpoint.
@@ -2298,6 +2702,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)
@@ -2311,6 +2716,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,
             ),
@@ -2334,7 +2740,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(
@@ -2350,7 +2756,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),
@@ -2387,7 +2793,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.
 
@@ -2415,12 +2821,12 @@ async def retrieve_video(video_id: str) -> VideoResponse | JSONResponse:
     return job
 
 
-@router.delete("/v1/videos/{video_id}")
-async def delete_video(video_id: str) -> VideoDeleteResponse:
+@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.
 
-    If the job is still queued or running, this endpoint first attempts to
-    cancel the in-flight generation task before removing the stored metadata.
+    In-flight jobs get a bounded engine abort, then frontend cancel. The job
+    is re-read afterwards so a completed save is not orphaned.
 
     Args:
         video_id: Identifier of the video job to delete.
@@ -2437,19 +2843,37 @@ async def delete_video(video_id: str) -> VideoDeleteResponse:
         raise HTTPException(status_code=404, detail="Video not found")
 
     if job.status in (VideoGenerationStatus.QUEUED, VideoGenerationStatus.IN_PROGRESS):
+        handler = raw_request.app.state.openai_serving_video
+        try:
+            await asyncio.wait_for(handler.abort_request(video_id), timeout=VIDEO_ABORT_TIMEOUT_S)
+        except asyncio.TimeoutError:
+            logger.warning(
+                "Timed out aborting video request %s after %.1fs; "
+                "engine abort is best-effort until the current batch drains",
+                video_id,
+                VIDEO_ABORT_TIMEOUT_S,
+            )
+        except Exception:
+            logger.exception("Failed to abort in-flight video request %s", video_id)
         task = await VIDEO_TASKS.get(video_id)
         if task is not None:
             task.cancel()
             try:
-                await asyncio.wait_for(task, timeout=2.0)
+                # Cancel cleanup may spend a full abort budget; +2s covers scheduling slack.
+                await asyncio.wait_for(task, timeout=VIDEO_ABORT_TIMEOUT_S + 2.0)
             except asyncio.TimeoutError:
                 raise HTTPException(status_code=409, detail="Cancellation in progress. Please try again later.")
             except asyncio.CancelledError:
                 pass
 
+        job = await VIDEO_STORE.get(video_id)
+        if job is None:
+            return VideoDeleteResponse(id=video_id, deleted=True)
+        if job.status in (VideoGenerationStatus.QUEUED, VideoGenerationStatus.IN_PROGRESS):
             await VIDEO_STORE.pop(video_id)
             return VideoDeleteResponse(id=job.id, deleted=True)
-    elif job.status is VideoGenerationStatus.FAILED:
+
+    if job.status is VideoGenerationStatus.FAILED:
         if job.file_name is not None:
             try:
                 await STORAGE_MANAGER.delete(video_id)
@@ -2467,7 +2891,7 @@ async def delete_video(video_id: str) -> VideoDeleteResponse:
     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.
 
@@ -2560,6 +2984,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"):
@@ -2567,11 +2992,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):
@@ -2582,7 +3011,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/audio_utils_mixin.py b/vllm_omni/entrypoints/openai/audio_utils_mixin.py
index 4382afc57..b82842c42 100644
--- a/vllm_omni/entrypoints/openai/audio_utils_mixin.py
+++ b/vllm_omni/entrypoints/openai/audio_utils_mixin.py
@@ -21,7 +21,6 @@ LONGEVITY:
 See ``openai/README.md`` (utils vs helpers, no overlap).
 """
 
-import math
 from io import BytesIO
 
 import numpy as np
@@ -29,7 +28,15 @@ import torch
 import torchaudio
 from vllm.logger import init_logger
 
-from vllm_omni.entrypoints.openai.protocol.audio import DEFAULT_AUDIO_FORMAT, AudioResponse, CreateAudio
+from vllm_omni.entrypoints.openai.protocol.audio import (
+    DEFAULT_AUDIO_FORMAT,
+    AudioChunkMetadata,
+    AudioResponse,
+    CreateAudio,
+)
+
+# Re-exported: serving_speech and the audio tests import it from here.
+from vllm_omni.utils.audio_resample import StreamingAudioResampler  # noqa: F401
 
 try:
     import soundfile
@@ -39,155 +46,6 @@ except ImportError:
 logger = init_logger(__name__)
 
 
-class StreamingAudioResampler:
-    """Stateful polyphase resampler for streaming mono float audio.
-
-    Retains filter state so output is invariant to input chunk boundaries.
-    """
-
-    _half_filter_width = 10
-    _kaiser_beta = 5.0
-    _max_polyphase_factor = 2_048
-
-    def __init__(self, source_rate: int, target_rate: int):
-        if source_rate <= 0 or target_rate <= 0:
-            raise ValueError("Audio sample rates must be positive")
-        self.source_rate = source_rate
-        self.target_rate = target_rate
-        rate_gcd = math.gcd(source_rate, target_rate)
-        self._up = target_rate // rate_gcd
-        self._down = source_rate // rate_gcd
-        if max(self._up, self._down) > self._max_polyphase_factor:
-            raise ValueError("source and target sample rates have an unsupported resampling ratio")
-        self._half_len, self._phase_kernels = self._design_polyphase_filter()
-        self._history_samples = self._phase_kernels.shape[1] - 1
-        self.reset()
-
-    def _design_polyphase_filter(self) -> tuple[int, np.ndarray]:
-        if self._up == self._down:
-            return 0, np.ones((1, 1), dtype=np.float32)
-
-        max_rate = max(self._up, self._down)
-        half_len = self._half_filter_width * max_rate
-        offsets = np.arange(-half_len, half_len + 1, dtype=np.float64)
-        cutoff = 1.0 / max_rate
-        taps = cutoff * np.sinc(cutoff * offsets)
-        taps *= np.kaiser(taps.size, self._kaiser_beta)
-        taps /= np.sum(taps)
-        taps *= self._up
-        taps = np.ascontiguousarray(taps, dtype=np.float32)
-
-        phases = [taps[phase :: self._up] for phase in range(self._up)]
-        phase_width = max(phase.size for phase in phases)
-        kernels = np.zeros((self._up, phase_width), dtype=np.float32)
-        for phase_index, phase in enumerate(phases):
-            kernels[phase_index, -phase.size :] = phase[::-1]
-        return half_len, kernels
-
-    @property
-    def scratch_bytes(self) -> int:
-        pending_samples = self._ceil_div(self._input_samples * self._up, self._down) - self._output_samples
-        return max(0, pending_samples) * np.dtype(np.float32).itemsize
-
-    @staticmethod
-    def _ceil_div(numerator: int, denominator: int) -> int:
-        return -(-numerator // denominator)
-
-    def _render_outputs(
-        self,
-        combined: np.ndarray,
-        *,
-        first_output: int,
-        output_count: int,
-        input_start: int,
-    ) -> np.ndarray:
-        if output_count <= 0:
-            return np.empty(0, dtype=np.float32)
-
-        output_indexes = np.arange(first_output, first_output + output_count, dtype=np.int64)
-        filter_indexes = output_indexes * self._down + self._half_len
-        source_indexes = filter_indexes // self._up
-        phases = filter_indexes % self._up
-        windows = np.lib.stride_tricks.sliding_window_view(
-            combined,
-            self._phase_kernels.shape[1],
-        )
-        selected_windows = windows[source_indexes - input_start]
-        return np.sum(
-            selected_windows * self._phase_kernels[phases],
-            axis=1,
-            dtype=np.float32,
-        )
-
-    def _push(self, chunk: np.ndarray) -> np.ndarray:
-        if chunk.size == 0:
-            return np.empty(0, dtype=np.float32)
-        if self._flushed:
-            raise RuntimeError("cannot process audio after the resampler has been finalized; call reset first")
-
-        combined = np.concatenate((self._history, chunk))
-        next_input_samples = self._input_samples + chunk.size
-        stable_output_samples = max(
-            0,
-            self._ceil_div(next_input_samples * self._up - self._half_len, self._down),
-        )
-        output = self._render_outputs(
-            combined,
-            first_output=self._output_samples,
-            output_count=stable_output_samples - self._output_samples,
-            input_start=self._input_samples,
-        )
-        if self._history_samples:
-            self._history = combined[-self._history_samples :].copy()
-        self._input_samples = next_input_samples
-        self._output_samples = stable_output_samples
-        return output
-
-    def _flush(self) -> np.ndarray:
-        if self._flushed:
-            return np.empty(0, dtype=np.float32)
-
-        total_output_samples = self._ceil_div(self._input_samples * self._up, self._down)
-        output_count = total_output_samples - self._output_samples
-        if output_count:
-            last_output = total_output_samples - 1
-            last_source_index = (last_output * self._down + self._half_len) // self._up
-            right_padding = max(0, last_source_index - self._input_samples + 1)
-            combined = np.concatenate((self._history, np.zeros(right_padding, dtype=np.float32)))
-            output = self._render_outputs(
-                combined,
-                first_output=self._output_samples,
-                output_count=output_count,
-                input_start=self._input_samples,
-            )
-        else:
-            output = np.empty(0, dtype=np.float32)
-        self._output_samples = total_output_samples
-        self._flushed = True
-        return output
-
-    def process(self, audio: np.ndarray, *, final: bool = False) -> np.ndarray:
-        chunk = np.asarray(audio, dtype=np.float32)
-        if chunk.ndim != 1:
-            raise ValueError(f"Streaming audio resampling only supports mono audio, got shape {chunk.shape}")
-        chunk = np.ascontiguousarray(chunk, dtype=np.float32)
-        output = self._push(chunk)
-        if not final:
-            return output
-        tail = self._flush()
-        if not output.size:
-            return tail
-        if not tail.size:
-            return output
-        return np.concatenate((output, tail))
-
-    def reset(self) -> None:
-        self._history = np.zeros(self._history_samples, dtype=np.float32)
-        self._input_samples = 0
-        self._output_samples = 0
-        self._flushed = False
-
-
 class AudioMixin:
     """Mixin class to add audio-related utilities."""
 
@@ -244,7 +102,16 @@ class AudioMixin:
 
             audio_data = base64.b64encode(audio_data).decode("utf-8")
 
-        return AudioResponse(audio_data=audio_data, media_type=media_type)
+        return AudioResponse(
+            audio_data=audio_data,
+            media_type=media_type,
+            audio_metadata=AudioChunkMetadata(
+                format=response_format,
+                sample_rate_hz=int(sample_rate),
+                frame_count=int(audio_tensor.shape[0]),
+                channels=1 if audio_tensor.ndim == 1 else int(audio_tensor.shape[1]),
+            ),
+        )
 
     @staticmethod
     def _resample_audio(audio_tensor: np.ndarray, source_rate: int, target_rate: int) -> np.ndarray:
diff --git a/vllm_omni/entrypoints/openai/protocol/audio.py b/vllm_omni/entrypoints/openai/protocol/audio.py
index 459f9d4ae..8a1b48304 100644
--- a/vllm_omni/entrypoints/openai/protocol/audio.py
+++ b/vllm_omni/entrypoints/openai/protocol/audio.py
@@ -421,9 +421,23 @@ class CreateAudio(BaseModel):
         arbitrary_types_allowed = True
 
 
+class AudioChunkMetadata(BaseModel):
+    """Waveform dimensions after transforms, before encoding.
+
+    Frames count samples per channel, not interleaved scalar samples or bytes.
+    For compressed formats this excludes any padding introduced by the codec.
+    """
+
+    format: str = Field(min_length=1, strict=True)
+    sample_rate_hz: int = Field(gt=0, strict=True)
+    frame_count: int = Field(ge=0, strict=True)
+    channels: int = Field(gt=0, strict=True)
+
+
 class AudioResponse(BaseModel):
     audio_data: bytes | str
     media_type: str
+    audio_metadata: AudioChunkMetadata | None = None
 
 
 # --- Batch Speech Models ---
diff --git a/vllm_omni/entrypoints/openai/protocol/chat_completion.py b/vllm_omni/entrypoints/openai/protocol/chat_completion.py
index 462e53af9..eaa15eea9 100644
--- a/vllm_omni/entrypoints/openai/protocol/chat_completion.py
+++ b/vllm_omni/entrypoints/openai/protocol/chat_completion.py
@@ -1,12 +1,33 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 from typing import Any
 
-from vllm.entrypoints.openai.chat_completion.protocol import ChatCompletionResponse, ChatCompletionStreamResponse
+from pydantic import SerializeAsAny
+from vllm.entrypoints.openai.chat_completion.protocol import (
+    ChatCompletionResponse,
+    ChatCompletionResponseChoice,
+    ChatCompletionResponseStreamChoice,
+    ChatCompletionStreamResponse,
+)
+
+from vllm_omni.entrypoints.openai.protocol.audio import AudioChunkMetadata
+
+
+class OmniChatCompletionResponseStreamChoice(ChatCompletionResponseStreamChoice):
+    audio_metadata: AudioChunkMetadata | None = None
+
+
+class OmniChatCompletionResponseChoice(ChatCompletionResponseChoice):
+    audio_metadata: AudioChunkMetadata | None = None
 
 
 class OmniChatCompletionStreamResponse(ChatCompletionStreamResponse):
+    choices: list[SerializeAsAny[ChatCompletionResponseStreamChoice]]
     modality: str | None = "text"
     metrics: dict[str, Any] | None = None
 
 
 class OmniChatCompletionResponse(ChatCompletionResponse):
+    choices: list[SerializeAsAny[ChatCompletionResponseChoice]]
     metrics: dict[str, Any] | None = None
diff --git a/vllm_omni/entrypoints/openai/protocol/images.py b/vllm_omni/entrypoints/openai/protocol/images.py
index 0215e1ce0..067098f78 100644
--- a/vllm_omni/entrypoints/openai/protocol/images.py
+++ b/vllm_omni/entrypoints/openai/protocol/images.py
@@ -11,6 +11,7 @@ import base64
 import io
 import uuid
 import zipfile
+from collections.abc import AsyncIterator
 from enum import Enum
 from http import HTTPStatus
 from typing import Any, Literal
@@ -25,6 +26,8 @@ from vllm_omni.entrypoints.openai.image_api_utils import validate_layered_layers
 _INT64_MIN = -(2**63)
 _INT64_MAX = 2**63 - 1
 
+_FILE_RESPONSE_CHUNK_SIZE = 64 * 1024
+
 _IMAGE_FILE_METADATA = {
     "jpg": ("jpg", "image/jpeg"),
     "jpeg": ("jpeg", "image/jpeg"),
@@ -33,6 +36,13 @@ _IMAGE_FILE_METADATA = {
 }
 
 
+async def _iter_file_chunks(data: bytes) -> AsyncIterator[memoryview]:
+    """Yield fixed-size chunks of an in-memory payload."""
+    view = memoryview(data)
+    for offset in range(0, len(view), _FILE_RESPONSE_CHUNK_SIZE):
+        yield view[offset : offset + _FILE_RESPONSE_CHUNK_SIZE]
+
+
 class ResponseFormat(str, Enum):
     """Image response format"""
 
@@ -175,6 +185,17 @@ class ImageGenerationRequest(BaseModel):
         default=None,
         description="Output image format: 'png', 'jpeg', or 'webp'. Defaults to 'png'.",
     )
+    output_compression: int = Field(
+        default=100,
+        ge=0,
+        le=100,
+        description=(
+            "Compression level 0-100. For 'jpeg'/'webp' this is the encoder "
+            "quality. For 'png' 100 keeps the fastest, least-compressed "
+            "encode and lower values trade encode time for smaller payloads "
+            "(100 -> compress_level 0, 1 -> compress_level 9)."
+        ),
+    )
     return_stage_metrics: bool | None = Field(
         default=None,
         description="Return stage metrics for benchmark clients.",
@@ -224,7 +245,7 @@ class ImageGenerationResponse(BaseModel):
             image_bytes = base64.b64decode(self.data[0].b64_json)
             filename = f"image_{uuid.uuid4().hex[:8]}.{extension}"
             return StreamingResponse(
-                io.BytesIO(image_bytes),
+                _iter_file_chunks(image_bytes),
                 media_type=media_type,
                 headers={
                     "Content-Disposition": f'attachment; filename="{filename}"',
@@ -240,7 +261,7 @@ class ImageGenerationResponse(BaseModel):
             zip_bytes = zip_buffer.getvalue()
             filename = f"images_{uuid.uuid4().hex[:8]}.zip"
             return StreamingResponse(
-                io.BytesIO(zip_bytes),
+                _iter_file_chunks(zip_bytes),
                 media_type="application/zip",
                 headers={
                     "Content-Disposition": f'attachment; filename="{filename}"',
diff --git a/vllm_omni/entrypoints/openai/protocol/rollout.py b/vllm_omni/entrypoints/openai/protocol/rollout.py
new file mode 100644
index 000000000..819981d7b
--- /dev/null
+++ b/vllm_omni/entrypoints/openai/protocol/rollout.py
@@ -0,0 +1,111 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Pydantic schemas for RL rollout serving (RFC #3747).
+
+P0 scope: world_model_env mode only (observation + action -> next observation).
+
+P0 maps rollout observations/actions onto DreamZero's DROID robot_obs schema:
+camera images retain their DreamZero observation/* keys, joint/gripper state is
+passed through observation/joint_position and observation/gripper_position, and
+the returned video payload is the DreamZero VAE latent unless a later endpoint
+adds explicit latent decoding.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+
+
+class Observation(BaseModel):
+    """Single-step robot observation."""
+
+    images: dict[str, list] | None = Field(
+        default=None,
+        description="Named DreamZero camera images as nested numeric lists. Base64 strings are not accepted in P0.",
+    )
+    state: list[float] | None = Field(
+        default=None,
+        description="Proprioceptive state vector (joint positions, velocities, etc.).",
+    )
+    prompt: str = Field(default="", description="Optional language conditioning.")
+    extra: dict[str, Any] = Field(
+        default_factory=dict,
+        description="Pass-through fields forwarded verbatim to robot_obs.",
+    )
+
+
+class Action(BaseModel):
+    """Executed action for world_model_env conditioning."""
+
+    joint_positions: list[float] | None = Field(
+        default=None,
+        description="Executed joint positions; forwarded as observation/joint_position for DreamZero.",
+    )
+    gripper_position: float | list[float] | None = Field(
+        default=None,
+        description="Executed gripper position; forwarded as observation/gripper_position for DreamZero.",
+    )
+    extra: dict[str, Any] = Field(default_factory=dict)
+
+
+class SessionMetadata(BaseModel):
+    latency_ms: float
+    steps_generated: int
+    context_length: int
+    committed_step_id: int = Field(
+        description="Highest step_id whose context has been atomically committed. "
+        "-1 means no step has been committed yet (fresh or reset session).",
+    )
+    session_memory_bytes: int | None = None
+    uncertainty: float | None = None
+
+
+class ErrorObject(BaseModel):
+    code: str
+    message: str
+    step_id: int | None = None
+    committed_step_id: int = -1
+
+
+class CreateSessionRequest(BaseModel):
+    model: str
+    mode: Literal["world_model_env"] = "world_model_env"
+
+
+class CreateSessionResponse(BaseModel):
+    session_id: str
+    mode: str
+    created_at: float
+
+
+class RolloutStepRequest(BaseModel):
+    step_id: int = Field(ge=0, description="Monotonically increasing per session.")
+    observation: Observation
+    action: Action = Field(
+        description="Required for world_model_env: executed action that produced this observation.",
+    )
+    use_session_context: bool = True
+
+
+class RolloutStepResponse(BaseModel):
+    step_id: int
+    next_observation: dict[str, Any] | None = Field(
+        default=None,
+        description="Predicted next observation metadata. P0 returns DreamZero video_latent, not RGB frames.",
+    )
+    model_metadata: SessionMetadata
+    error: ErrorObject | None = None
+
+
+class ResetSessionResponse(BaseModel):
+    session_id: str
+    committed_step_id: int
+
+
+class SessionStatusResponse(BaseModel):
+    session_id: str
+    committed_step_id: int
+    context_length: int
+    closed: bool
diff --git a/vllm_omni/entrypoints/openai/realtime_connection.py b/vllm_omni/entrypoints/openai/realtime_connection.py
index 86a8ba031..3d37fbe37 100644
--- a/vllm_omni/entrypoints/openai/realtime_connection.py
+++ b/vllm_omni/entrypoints/openai/realtime_connection.py
@@ -176,7 +176,7 @@ class RealtimeConnection(VllmRealtimeConnection):
                     sent_audio = True
                     await self.send_json(
                         {
-                            "type": "response.audio.delta",
+                            "type": "response.output_audio.delta",
                             "audio": self._pcm16_b64(chunk),
                             "format": "pcm16",
                             "sample_rate_hz": sample_rate,
@@ -194,7 +194,7 @@ class RealtimeConnection(VllmRealtimeConnection):
             await self.send(TranscriptionDone(text=full_text, usage=usage))
 
             if sent_audio:
-                await self.send_json({"type": "response.audio.done", "has_audio": True})
+                await self.send_json({"type": "response.output_audio.done", "has_audio": True})
                 audio_done_sent = True
         except Exception as e:
             logger.exception("Error in generation: %s", e)
@@ -213,9 +213,9 @@ class RealtimeConnection(VllmRealtimeConnection):
             # Always send terminal event so clients don't hang forever.
             if self._is_connected and not audio_done_sent:
                 try:
-                    await self.send_json({"type": "response.audio.done", "has_audio": sent_audio})
+                    await self.send_json({"type": "response.output_audio.done", "has_audio": sent_audio})
                 except Exception:
-                    logger.exception("Failed to send response.audio.done")
+                    logger.exception("Failed to send response.output_audio.done")
             while not self.audio_queue.empty():
                 self.audio_queue.get_nowait()
 
diff --git a/vllm_omni/entrypoints/openai/rollout_session.py b/vllm_omni/entrypoints/openai/rollout_session.py
new file mode 100644
index 000000000..76848ba31
--- /dev/null
+++ b/vllm_omni/entrypoints/openai/rollout_session.py
@@ -0,0 +1,107 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""In-memory session store for RL rollout serving (RFC #3747, P0).
+
+Each RolloutSession holds a per-session asyncio.Lock so that concurrent step
+requests for the same session are serialised. committed_step_id advances only
+on successful step completion; failed or timed-out steps leave it unchanged,
+preserving the atomic-context-commit guarantee from section 6.5 of the RFC.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from collections import OrderedDict
+from dataclasses import dataclass, field
+from typing import Literal
+
+
+class RolloutSessionNotFoundError(KeyError):
+    pass
+
+
+class RolloutSessionClosedError(RuntimeError):
+    pass
+
+
+class RolloutSessionStepError(ValueError):
+    pass
+
+
+class RolloutSessionCapacityError(RuntimeError):
+    pass
+
+
+@dataclass
+class RolloutSession:
+    session_id: str
+    model: str
+    mode: Literal["world_model_env"]
+    created_at: float = field(default_factory=time.time)
+    committed_step_id: int = -1
+    context_length: int = 0
+    closed: bool = False
+    lock: asyncio.Lock = field(default_factory=asyncio.Lock)
+
+
+class RolloutSessionStore:
+    """Thread-safe (asyncio) store for active rollout sessions."""
+
+    def __init__(self, max_sessions: int = 64) -> None:
+        self._sessions: OrderedDict[str, RolloutSession] = OrderedDict()
+        self._max_sessions = max_sessions
+        self._store_lock = asyncio.Lock()
+
+    async def create(self, session_id: str, model: str, mode: Literal["world_model_env"]) -> RolloutSession:
+        async with self._store_lock:
+            self._evict_closed_sessions_for_create()
+            if len(self._sessions) >= self._max_sessions:
+                raise RolloutSessionCapacityError(f"Maximum active rollout sessions reached: {self._max_sessions}.")
+            session = RolloutSession(
+                session_id=session_id,
+                model=model,
+                mode=mode,
+            )
+            self._sessions[session_id] = session
+            self._sessions.move_to_end(session_id)
+            return session
+
+    async def get(self, session_id: str, *, include_closed: bool = False) -> RolloutSession:
+        session = self._sessions.get(session_id)
+        if session is None:
+            raise RolloutSessionNotFoundError(session_id)
+        self._sessions.move_to_end(session_id)
+        if session.closed and not include_closed:
+            raise RolloutSessionClosedError(session_id)
+        return session
+
+    async def reset(self, session_id: str) -> RolloutSession:
+        session = await self.get(session_id)
+        async with session.lock:
+            session.committed_step_id = -1
+            session.context_length = 0
+        return session
+
+    async def close(self, session_id: str) -> None:
+        session = await self.get(session_id, include_closed=True)
+        async with session.lock:
+            session.closed = True
+
+    async def advance(self, session_id: str, step_id: int) -> None:
+        """Commit a successfully completed step. Called only on success."""
+        session = await self.get(session_id)
+        expected_step_id = session.committed_step_id + 1
+        if step_id != expected_step_id:
+            raise RolloutSessionStepError(f"Expected step_id {expected_step_id}, got {step_id}.")
+        session.committed_step_id = step_id
+        session.context_length += 1
+
+    def _evict_closed_sessions_for_create(self) -> None:
+        while len(self._sessions) >= self._max_sessions:
+            for session_id, session in self._sessions.items():
+                if session.closed:
+                    del self._sessions[session_id]
+                    break
+            else:
+                break
diff --git a/vllm_omni/entrypoints/openai/serving_chat.py b/vllm_omni/entrypoints/openai/serving_chat.py
index ac605975c..ae3b0a8ea 100644
--- a/vllm_omni/entrypoints/openai/serving_chat.py
+++ b/vllm_omni/entrypoints/openai/serving_chat.py
@@ -34,7 +34,11 @@ from vllm_omni.entrypoints.openai.diffusion_request_utils import (
     apply_normalized_diffusion_request_extra_args,
     normalize_diffusion_request_args,
 )
-from vllm_omni.entrypoints.openai.protocol.chat_completion import OmniChatCompletionResponse
+from vllm_omni.entrypoints.openai.protocol.chat_completion import (
+    OmniChatCompletionResponse,
+    OmniChatCompletionResponseChoice,
+    OmniChatCompletionResponseStreamChoice,
+)
 from vllm_omni.entrypoints.utils import coerce_param_message_types
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams, OmniTextPrompt
 from vllm_omni.metrics import definitions as _metric_defs
@@ -244,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
@@ -320,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":
@@ -798,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:
@@ -1373,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,
@@ -2860,18 +2909,20 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
 
         for output in final_res.outputs:
             if stream:
-                choice_data = ChatCompletionResponseStreamChoice(
+                choice_data = OmniChatCompletionResponseStreamChoice(
                     index=output.index,
                     delta=DeltaMessage(role=role, content=audio_base64),
+                    audio_metadata=audio_response.audio_metadata,
                     logprobs=None,
                     finish_reason=output.finish_reason,
                     stop_reason=output.stop_reason,
                     token_ids=(as_list(output.token_ids) if request.return_token_ids else None),
                 )
             else:
-                choice_data = ChatCompletionResponseChoice(
+                choice_data = OmniChatCompletionResponseChoice(
                     index=output.index,
                     message=ChatMessage(role=role, audio=audio_obj),
+                    audio_metadata=audio_response.audio_metadata,
                     logprobs=None,
                     finish_reason="stop",
                     stop_reason=output.stop_reason,
@@ -3080,11 +3131,20 @@ class OmniOpenAIServingChat(OpenAIServingChat, AudioMixin):
             ar_image_size: str | None = None
             if height is not None and width is not None:
                 ar_image_size = f"{width}x{height}"
+            # Reuse build_kwargs's own (possibly-omitted) "bot_task" entry rather
+            # than the raw outer `bot_task` variable: build_prompt_tokens/build_prompt
+            # above default an omitted bot_task per-task (e.g. "think" for t2i), and
+            # resolve_stop_token_ids must normalize from that same omitted-or-not
+            # starting point to agree on which stop tokens apply -- passing the raw
+            # `bot_task` (still None when omitted) made the two calls disagree.
+            ar_stop_kwargs: dict[str, Any] = {}
+            if "bot_task" in build_kwargs:
+                ar_stop_kwargs["bot_task"] = build_kwargs["bot_task"]
             ar_stop_token_ids = resolve_stop_token_ids(
                 task=ar_task,
-                bot_task=bot_task,
                 tokenizer=tokenizer,
                 image_size=ar_image_size,
+                **ar_stop_kwargs,
             )
 
         engine_prompt: OmniTextPrompt = {"prompt": prompt}
@@ -3111,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_rl_rollout.py b/vllm_omni/entrypoints/openai/serving_rl_rollout.py
new file mode 100644
index 000000000..38b53d9bd
--- /dev/null
+++ b/vllm_omni/entrypoints/openai/serving_rl_rollout.py
@@ -0,0 +1,370 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Serving layer for RL rollout (RFC #3747, P0).
+
+P0 scope: world_model_env mode, single-session, DreamZero backbone.
+
+P0 maps client rollout input onto DreamZero's DROID robot_obs schema and returns
+DreamZero video latents explicitly. RGB/frame decoding can be added as a later
+contract without pretending the latent is already an image observation.
+"""
+
+from __future__ import annotations
+
+import binascii
+import time
+from collections import abc
+from typing import Any
+
+import numpy as np
+from vllm.logger import init_logger
+from vllm.utils import random_uuid
+
+from vllm_omni.entrypoints.openai.protocol.rollout import (
+    Action,
+    CreateSessionRequest,
+    CreateSessionResponse,
+    ErrorObject,
+    Observation,
+    ResetSessionResponse,
+    RolloutStepRequest,
+    RolloutStepResponse,
+    SessionMetadata,
+    SessionStatusResponse,
+)
+from vllm_omni.entrypoints.openai.rollout_session import (
+    RolloutSession,
+    RolloutSessionClosedError,
+    RolloutSessionNotFoundError,
+    RolloutSessionStore,
+)
+from vllm_omni.entrypoints.openpi.serving import ServingRealtimeRobotOpenPI
+
+logger = init_logger(__name__)
+
+
+def _merge_action_into_obs(obs: Observation, action: Action | None) -> dict[str, Any]:
+    """Build DreamZero-compatible robot_obs."""
+    robot_obs: dict[str, Any] = {"prompt": obs.prompt}
+
+    if obs.images:
+        robot_obs.update(obs.images)
+
+    if obs.extra:
+        for key, value in obs.extra.items():
+            if key.startswith("observation/") or key in {"seed", "embodiment_name"}:
+                robot_obs[key] = value
+
+    joint_positions = action.joint_positions if action is not None else None
+    gripper_position = action.gripper_position if action is not None else None
+
+    if joint_positions is None and obs.state:
+        joint_positions = obs.state[:7]
+        if len(obs.state) > 7 and gripper_position is None:
+            gripper_position = obs.state[7:8]
+
+    if joint_positions is not None:
+        joint_arr = np.asarray(joint_positions, dtype=np.float64).flatten()
+        if joint_arr.size != 7:
+            raise ValueError(f"DreamZero DROID joint_positions must have 7 values, got {joint_arr.size}.")
+        robot_obs["observation/joint_position"] = joint_arr
+
+    if gripper_position is not None:
+        gripper_arr = np.asarray(gripper_position, dtype=np.float64).flatten()
+        if gripper_arr.size != 1:
+            raise ValueError(f"DreamZero DROID gripper_position must have 1 value, got {gripper_arr.size}.")
+        robot_obs["observation/gripper_position"] = gripper_arr
+
+    return robot_obs
+
+
+def _encode_video_output(video: Any) -> dict[str, Any]:
+    """Encode DreamZero video latent tensor / ndarray to JSON metadata."""
+    if video is None:
+        return {}
+    if hasattr(video, "detach") and callable(video.detach):
+        video = video.detach()
+    if hasattr(video, "float") and callable(video.float):
+        video = video.float()
+    if hasattr(video, "cpu") and callable(video.cpu):
+        video = video.cpu()
+    if hasattr(video, "numpy"):
+        video = video.numpy()
+    if isinstance(video, np.ndarray):
+        return {
+            "video_latent": binascii.b2a_base64(video.tobytes(), newline=False).decode(),
+            "shape": list(video.shape),
+            "dtype": str(video.dtype),
+            "encoding": "base64_raw_tensor",
+        }
+    return {"video_latent": str(video), "encoding": "string"}
+
+
+class ServingRLRollout:
+    """HTTP serving layer for RL rollout sessions.
+
+    Wraps ServingRealtimeRobotOpenPI for world_model_env mode.
+    Session state and committed_step_id tracking live in RolloutSessionStore.
+    """
+
+    def __init__(self, openpi_serving: ServingRealtimeRobotOpenPI) -> None:
+        self._openpi = openpi_serving
+        self._store = RolloutSessionStore()
+
+    # ------------------------------------------------------------------ #
+    # Session lifecycle                                                    #
+    # ------------------------------------------------------------------ #
+
+    async def create_session(self, req: CreateSessionRequest) -> CreateSessionResponse:
+        self._validate_model(req.model)
+        session_id = random_uuid()
+        session = await self._store.create(
+            session_id=session_id,
+            model=req.model,
+            mode=req.mode,
+        )
+        logger.info("Created rollout session %s mode=%s", session_id, req.mode)
+        return CreateSessionResponse(
+            session_id=session_id,
+            mode=session.mode,
+            created_at=session.created_at,
+        )
+
+    async def reset_session(self, session_id: str) -> ResetSessionResponse:
+        session = await self._store.reset(session_id)
+        # Next infer still passes reset=True; drop GPU KV now if the engine
+        # session is reachable from this process.
+        self._drop_engine_session(session_id)
+        logger.info("Reset rollout session %s", session_id)
+        return ResetSessionResponse(
+            session_id=session_id,
+            committed_step_id=session.committed_step_id,
+        )
+
+    async def close_session(self, session_id: str) -> None:
+        await self._store.close(session_id)
+        self._drop_engine_session(session_id)
+        self._drop_engine_session(f"{session_id}:stateless")
+        logger.info("Closed rollout session %s", session_id)
+
+    async def get_status(self, session_id: str) -> SessionStatusResponse:
+        session = await self._store.get(session_id, include_closed=True)
+        return SessionStatusResponse(
+            session_id=session_id,
+            committed_step_id=session.committed_step_id,
+            context_length=session.context_length,
+            closed=session.closed,
+        )
+
+    # ------------------------------------------------------------------ #
+    # Step                                                                 #
+    # ------------------------------------------------------------------ #
+
+    async def step(
+        self,
+        session_id: str,
+        req: RolloutStepRequest,
+    ) -> RolloutStepResponse:
+        try:
+            session = await self._store.get(session_id)
+        except RolloutSessionNotFoundError:
+            return self._error_response(
+                req.step_id,
+                -1,
+                0,
+                "session_not_found",
+                f"Session {session_id!r} does not exist.",
+            )
+        except RolloutSessionClosedError:
+            return self._error_response(
+                req.step_id,
+                -1,
+                0,
+                "session_closed",
+                f"Session {session_id!r} is closed.",
+            )
+
+        async with session.lock:
+            return await self._run_step(session, req)
+
+    async def _run_step(
+        self,
+        session: RolloutSession,
+        req: RolloutStepRequest,
+    ) -> RolloutStepResponse:
+        t0 = time.perf_counter()
+        committed = session.committed_step_id
+
+        if req.use_session_context:
+            expected_step_id = committed + 1
+            if req.step_id != expected_step_id:
+                if req.step_id <= committed:
+                    code = "step_already_committed"
+                    message = f"Step {req.step_id} is already committed; highest committed step is {committed}."
+                else:
+                    code = "step_out_of_order"
+                    message = f"Expected step_id {expected_step_id}, got {req.step_id}."
+                return self._error_response(
+                    req.step_id,
+                    committed,
+                    session.context_length,
+                    code,
+                    message,
+                )
+
+        # reset=True on first call after session create/reset
+        reset = committed == -1 or not req.use_session_context
+        engine_session_id = session.session_id
+        if not req.use_session_context:
+            engine_session_id = f"{session.session_id}:stateless"
+        try:
+            robot_obs = _merge_action_into_obs(req.observation, req.action)
+            video_out = await self._infer_world_model(
+                obs=robot_obs,
+                session_id=engine_session_id,
+                reset=reset,
+            )
+            next_observation = _encode_video_output(video_out)
+        except ValueError as exc:
+            logger.info("Invalid rollout step %d for session %s: %s", req.step_id, session.session_id, exc)
+            return self._error_response(
+                req.step_id,
+                committed,
+                session.context_length,
+                "invalid_request",
+                str(exc),
+            )
+        except Exception as exc:
+            logger.exception("Step %d failed for session %s", req.step_id, session.session_id)
+            # Do NOT advance committed_step_id on failure (RFC section 6.5).
+            return self._error_response(
+                req.step_id,
+                committed,
+                session.context_length,
+                "inference_error",
+                str(exc),
+            )
+
+        if req.use_session_context:
+            # Only advance committed_step_id on successful contextual steps.
+            await self._store.advance(session.session_id, req.step_id)
+            committed = req.step_id
+
+        latency_ms = (time.perf_counter() - t0) * 1000.0
+        metadata = SessionMetadata(
+            latency_ms=round(latency_ms, 2),
+            steps_generated=1,
+            context_length=session.context_length,
+            committed_step_id=committed,
+        )
+        return RolloutStepResponse(
+            step_id=req.step_id,
+            next_observation=next_observation,
+            model_metadata=metadata,
+        )
+
+    async def _infer_world_model(
+        self,
+        obs: dict[str, Any],
+        *,
+        session_id: str,
+        reset: bool,
+    ) -> Any:
+        """Call the engine and return the video (next-observation) output.
+
+        Reuses ServingRealtimeRobotOpenPI.build_request() so request routing,
+        session_id threading, and OmniDiffusionSamplingParams construction are
+        identical to the policy_inference path. DreamZero's formatter peels
+        ``video`` into ``result.images`` and leaves only ``actions`` on
+        ``multimodal_output``; read images first and fall back to the raw key.
+        """
+        request = self._openpi.build_request(obs, session_id=session_id, reset=reset)
+        result = None
+        async for output in self._openpi.engine_client.generate(
+            prompt=self._request_prompt(request),
+            request_id=request.request_id,
+            sampling_params_list=[request.sampling_params],
+        ):
+            result = output
+
+        if result is None:
+            raise RuntimeError("World model request produced no output.")
+        return self._extract_video_output(result)
+
+    @staticmethod
+    def _request_prompt(request: Any) -> Any:
+        prompt = getattr(request, "prompt", None)
+        if prompt is not None:
+            return prompt
+        return request.prompts[0]
+
+    @staticmethod
+    def _extract_video_output(result: Any) -> Any:
+        """Prefer formatter-placed ``images``; fall back to multimodal video."""
+        images = getattr(result, "images", None)
+        if isinstance(images, (list, tuple)):
+            if images:
+                return images[0]
+        elif images is not None and not isinstance(images, abc.Mapping):
+            # Formatter assigns the peeled video tensor directly to images.
+            return images
+
+        multimodal_output = getattr(result, "multimodal_output", None)
+        if isinstance(multimodal_output, abc.Mapping):
+            video = multimodal_output.get("video")
+            if video is not None:
+                return video
+
+        raise RuntimeError(
+            "No video on result.images or multimodal_output['video']. "
+            "Confirm DreamZero formatter placement for world_model_env."
+        )
+
+    def _drop_engine_session(self, session_id: str) -> None:
+        drop = getattr(self._openpi, "drop_session", None)
+        if not callable(drop):
+            return
+        try:
+            drop(session_id)
+        except Exception:
+            logger.exception("Failed to drop engine session %s", session_id)
+
+    # ------------------------------------------------------------------ #
+    # Helpers                                                              #
+    # ------------------------------------------------------------------ #
+
+    def _validate_model(self, requested_model: str) -> None:
+        served_model = getattr(self._openpi, "model_name", None)
+        if served_model is None:
+            return
+        if requested_model == served_model:
+            return
+        if requested_model.lower() == "dreamzero" and "dreamzero" in served_model.lower():
+            return
+        raise ValueError(f"Requested rollout model {requested_model!r} does not match served model {served_model!r}.")
+
+    @staticmethod
+    def _error_response(
+        step_id: int,
+        committed_step_id: int,
+        context_length: int,
+        code: str,
+        message: str,
+    ) -> RolloutStepResponse:
+        metadata = SessionMetadata(
+            latency_ms=0.0,
+            steps_generated=0,
+            context_length=context_length,
+            committed_step_id=committed_step_id,
+        )
+        return RolloutStepResponse(
+            step_id=step_id,
+            next_observation=None,
+            model_metadata=metadata,
+            error=ErrorObject(
+                code=code,
+                message=message,
+                step_id=step_id,
+                committed_step_id=committed_step_id,
+            ),
+        )
diff --git a/vllm_omni/entrypoints/openai/serving_speech.py b/vllm_omni/entrypoints/openai/serving_speech.py
index a9256d953..d3c23ca39 100644
--- a/vllm_omni/entrypoints/openai/serving_speech.py
+++ b/vllm_omni/entrypoints/openai/serving_speech.py
@@ -13,12 +13,14 @@ import struct
 import time
 from collections import OrderedDict
 from concurrent.futures import ThreadPoolExecutor
+from contextlib import aclosing
 from http import HTTPStatus
 from pathlib import Path
-from typing import Any
+from typing import Any, cast
 from urllib.parse import urlparse
 from urllib.request import url2pathname
 
+import anyio
 import numpy as np
 import soundfile as sf
 import torch
@@ -30,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,
@@ -51,6 +55,7 @@ from vllm_omni.entrypoints.openai.speech_usage import (
     qwen3_tts_input_token_details,
 )
 from vllm_omni.entrypoints.openai.tts_adapters import (
+    OutputPolicy,
     SpeechServingContext,
     TTSGenerationError,
     all_tts_stage_keys,
@@ -59,6 +64,7 @@ from vllm_omni.entrypoints.openai.tts_adapters import (
     tts_entry_stage_archs,
 )
 from vllm_omni.entrypoints.utils import coerce_param_message_types
+from vllm_omni.metrics.modality import observe_audio_first_packet, observe_audio_streaming_finalize
 from vllm_omni.outputs import OmniRequestOutput
 from vllm_omni.utils.speaker_cache import get_speaker_cache
 
@@ -71,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
@@ -86,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"
 
@@ -194,6 +218,17 @@ def _validate_path_within_directory(file_path: Path, directory: Path) -> bool:
         return False
 
 
+class _SpeechStreamingResponse(StreamingResponse):
+    async def stream_response(self, send) -> None:
+        try:
+            await super().stream_response(send)
+        finally:
+            # A disconnect during send leaves the iterator suspended at yield.
+            # Close it explicitly, even inside Starlette's cancelled scope.
+            with anyio.CancelScope(shield=True):
+                await cast(Any, self.body_iterator).aclose()
+
+
 class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
     _diffusion_mode: bool = False
     _media_connector: MediaConnector | None = None
@@ -213,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
@@ -382,6 +417,11 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
         self._max_instructions_length = self._compute_max_instructions_length()
 
         self._tts_tokenizer = None
+        # Per-request output policy from the adapter's PreparedRequest. Keyed
+        # by request_id so concurrent speech requests cannot overwrite each
+        # other. Stored only for non-streaming requests and consumed (popped)
+        # by the non-streaming accumulator in `_generate_audio_bytes`.
+        self._speech_output_policies: dict[str, OutputPolicy] = {}
 
         # Batch configuration
         self._batch_max_items: int = getattr(self.engine_client, "tts_batch_max_items", 32)
@@ -452,13 +492,12 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
         tts_stage_keys = all_tts_stage_keys()
         entry_stage_archs = tts_entry_stage_archs()
         all_stages = frozenset(
-            getattr(stage.engine_args, "model_stage", None) for stage in self.engine_client.stage_configs
+            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
@@ -482,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.
@@ -499,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"]
 
@@ -1083,7 +1124,7 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
             return "sample_rate is not supported by the current TTS model"
         return None
 
-    def _validate_ref_audio_format(self, ref_audio: str) -> str | None:
+    def _validate_ref_audio_format(self, ref_audio: str | list[str] | None) -> str | None:
         """Validate ref_audio is a supported URI format. Returns error or None."""
         if not isinstance(ref_audio, str):
             return "ref_audio must be a URL (http/https), base64 data URL (data:...), or file URI (file://...)"
@@ -1181,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)
@@ -1197,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``).
@@ -1225,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 = ""
@@ -1234,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
@@ -1253,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,
@@ -1278,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:
@@ -1304,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)
@@ -1317,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)
@@ -1362,6 +1423,57 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
             resolved.append((wav_list, sr))
         return resolved
 
+    def _observe_speech_audio_ttfp(
+        self,
+        *,
+        request_id: str,
+        result: Any,
+        request_arrival_ts: float | None = None,
+        first_packet_ts: float | None = None,
+    ) -> tuple[int | None, int | None, bool]:
+        """Emit the Speech API TTFP sample once the first PCM payload exists."""
+        engine_client = getattr(self, "engine_client", None)
+        mod_metrics = getattr(engine_client, "mod_metrics", None)
+        if mod_metrics is None:
+            return None, None, False
+
+        req_state = next(
+            (
+                state
+                for state in getattr(engine_client, "request_states", {}).values()
+                if state.external_request_id == request_id
+            ),
+            None,
+        )
+        if req_state is not None and req_state.first_audio_ts is not None:
+            return req_state.audio_emit_stage_id, req_state.audio_emit_replica_id, True
+
+        arrival_ts = request_arrival_ts
+        if arrival_ts is None and req_state is not None:
+            arrival_ts = req_state.request_arrival_ts
+        stage_id = getattr(result, "stage_id", None)
+        replica_id = getattr(result, "replica_id", None)
+        if replica_id is None and req_state is not None and stage_id is not None:
+            stage_pools = getattr(getattr(engine_client, "engine", None), "stage_pools", None)
+            if stage_pools is not None and 0 <= stage_id < len(stage_pools):
+                replica_id = stage_pools[stage_id].get_bound_replica_id(req_state.request_id)
+        if arrival_ts is None or arrival_ts <= 0 or stage_id is None or replica_id is None:
+            return stage_id, replica_id, False
+
+        now_ts = first_packet_ts if first_packet_ts is not None else time.time()
+        observe_audio_first_packet(
+            mod_metrics,
+            stage_id=stage_id,
+            replica_id=replica_id,
+            arrival_ts=arrival_ts,
+            now_ts=now_ts,
+        )
+        if req_state is not None:
+            req_state.first_audio_ts = now_ts
+            req_state.audio_emit_stage_id = stage_id
+            req_state.audio_emit_replica_id = replica_id
+        return stage_id, replica_id, True
+
     async def _generate_audio_chunks(
         self,
         generator,
@@ -1369,19 +1481,21 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
         response_format: str = "pcm",
         raw_request: Request | None = None,
         request_start_s: float | None = None,
+        request_arrival_ts: float | None = None,
         include_sample_rate: bool = False,
         usage_acc: SpeechOutputTokenCounter | None = None,
         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
@@ -1392,13 +1506,46 @@ 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
+        first_audio_packet_ts: float | None = None
+        ttfp_observed = False
         stream_start_s = request_start_s if request_start_s is not None else time.perf_counter()
         artifact_ready = False
+        audio_chunk_arrivals_s: list[float] = []
+        audio_chunk_bytes: list[int] = []
+        audio_stage_id: int | None = None
+        audio_replica_id: int | None = None
+        audio_channels = 1
         source_sample_rate: int | None = None
         resampler: StreamingAudioResampler | None = None
+        last_audio_result: Any = None
+
+        def record_stream_abort(reason: str) -> None:
+            mod_metrics = getattr(getattr(self, "engine_client", None), "mod_metrics", None)
+            if mod_metrics is not None:
+                mod_metrics.inc_speech_stream_aborted(reason)
+
+        def record_audio_chunk(audio_bytes: bytes, chunk_np: np.ndarray, result: Any) -> None:
+            nonlocal first_audio_chunk_s, first_audio_packet_ts, ttfp_observed
+            nonlocal audio_stage_id, audio_replica_id, audio_channels
+            if not audio_bytes:
+                return
+            if first_audio_chunk_s is None:
+                first_audio_chunk_s = time.perf_counter()
+                first_audio_packet_ts = time.time()
+                audio_channels = _infer_audio_num_channels(np.asarray(chunk_np))
+            if not ttfp_observed:
+                audio_stage_id, audio_replica_id, ttfp_observed = self._observe_speech_audio_ttfp(
+                    request_id=request_id,
+                    result=result,
+                    request_arrival_ts=request_arrival_ts,
+                    first_packet_ts=first_audio_packet_ts,
+                )
+            audio_chunk_arrivals_s.append(max(time.perf_counter() - stream_start_s, 0.0))
+            audio_chunk_bytes.append(len(audio_bytes))
 
         # SSE supplies an accumulator for usage output. Raw-audio and WebSocket
         # streams retain terminal metrics only when their model adapter needs
@@ -1419,6 +1566,7 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
                     if collect is not None and self._is_timestamps_output(res):
                         collect["aligner_res"] = res
                     continue
+                audio_output = cast(dict, audio_output)
 
                 sr_raw = audio_output.get("sr")
                 if sr_raw is not None:
@@ -1452,11 +1600,20 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
                 output_sample_rate = target_sample_rate or sample_rate_val
 
                 for chunk_tensor in new_chunks:
+                    # Flush may run after a non-audio (e.g. aligner) result.
+                    # Retain the producer of the audio buffered by the resampler.
+                    last_audio_result = res
                     chunk_np = (
                         chunk_tensor.float().detach().cpu().numpy() if hasattr(chunk_tensor, "float") else chunk_tensor
                     )
                     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:
@@ -1466,6 +1623,7 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
                         # as first audio; the post-loop guard below needs to
                         # see an audio-less stream to fail the request.
                         continue
+                    wav_header: bytes | None = None
                     # For WAV format, emit header before first audio chunk
                     if response_format == "wav" and first_chunk:
                         num_channels = _infer_audio_num_channels(np.asarray(chunk_np))
@@ -1474,7 +1632,6 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
                             num_channels=num_channels,
                             bits_per_sample=16,
                         )
-                        yield wav_header
                         first_chunk = False
 
                     # Convert audio to PCM bytes
@@ -1485,9 +1642,10 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
                         speed=1.0,
                         base64_encode=False,
                     )
-                    if first_audio_chunk_s is None:
-                        first_audio_chunk_s = time.perf_counter()
-                    audio_bytes = self.create_audio(audio_obj).audio_data
+                    audio_bytes = cast(bytes, self.create_audio(audio_obj).audio_data)
+                    record_audio_chunk(audio_bytes, chunk_np, res)
+                    if wav_header is not None:
+                        yield wav_header
                     if include_sample_rate:
                         yield audio_bytes, output_sample_rate
                     else:
@@ -1497,8 +1655,9 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
                 final_chunk = resampler.process(np.empty((0,), dtype=np.float32), final=True)
                 if final_chunk.size:
                     output_sample_rate = target_sample_rate or sample_rate_val
+                    wav_header = None
                     if response_format == "wav" and first_chunk:
-                        yield _create_wav_header(
+                        wav_header = _create_wav_header(
                             sample_rate=output_sample_rate,
                             num_channels=1,
                             bits_per_sample=16,
@@ -1511,9 +1670,10 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
                         speed=1.0,
                         base64_encode=False,
                     )
-                    if first_audio_chunk_s is None:
-                        first_audio_chunk_s = time.perf_counter()
-                    audio_bytes = self.create_audio(audio_obj).audio_data
+                    audio_bytes = cast(bytes, self.create_audio(audio_obj).audio_data)
+                    record_audio_chunk(audio_bytes, final_chunk, last_audio_result)
+                    if wav_header is not None:
+                        yield wav_header
                     if include_sample_rate:
                         yield audio_bytes, output_sample_rate
                     else:
@@ -1527,8 +1687,21 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
             # bytes, but they must terminate as an error rather than cleanly.
             if tts_params is not None and usage_acc is not None:
                 self._validate_tts_generation(tts_params, usage_acc)
+            mod_metrics = getattr(getattr(self, "engine_client", None), "mod_metrics", None)
+            if mod_metrics is not None and audio_stage_id is not None and audio_replica_id is not None:
+                observe_audio_streaming_finalize(
+                    mod_metrics,
+                    stage_id=audio_stage_id,
+                    replica_id=audio_replica_id,
+                    chunk_arrival_times_s=audio_chunk_arrivals_s,
+                    chunk_bytes=audio_chunk_bytes,
+                    sample_rate=target_sample_rate or sample_rate_val,
+                    channels=audio_channels,
+                )
             self._mark_ref_audio_artifact_ready_for_request(request_id)
             artifact_ready = True
+            if mod_metrics is not None:
+                mod_metrics.inc_speech_stream_completed()
             total_ms = (time.perf_counter() - stream_start_s) * 1000.0
             if first_audio_chunk_s is not None:
                 first_chunk_ms = (first_audio_chunk_s - stream_start_s) * 1000.0
@@ -1544,7 +1717,11 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
                     request_id,
                     total_ms,
                 )
+        except GeneratorExit:
+            record_stream_abort("closed")
+            raise
         except asyncio.CancelledError:
+            record_stream_abort("cancelled")
             total_ms = (time.perf_counter() - stream_start_s) * 1000.0
             logger.info(
                 "[SpeechE2E] request_id=%s stream=true status=cancelled total_ms=%.2f",
@@ -1554,6 +1731,7 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
             logger.info("Streaming request %s cancelled by client", request_id)
             raise
         except EngineDeadError as e:
+            record_stream_abort("engine_dead")
             total_ms = (time.perf_counter() - stream_start_s) * 1000.0
             logger.error(
                 "[SpeechE2E] request_id=%s stream=true status=engine_dead total_ms=%.2f",
@@ -1573,6 +1751,7 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
                 )
             raise
         except Exception as e:
+            record_stream_abort("error")
             total_ms = (time.perf_counter() - stream_start_s) * 1000.0
             logger.exception(
                 "[SpeechE2E] request_id=%s stream=true status=error total_ms=%.2f error=%s",
@@ -1585,6 +1764,10 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
         finally:
             if not artifact_ready:
                 self._discard_ref_audio_artifact_warmup(request_id)
+            close = getattr(generator, "aclose", None)
+            if close is not None:
+                with anyio.CancelScope(shield=True):
+                    await close()
 
     async def _generate_audio_sse_events(
         self,
@@ -1593,6 +1776,7 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
         response_format: str = "pcm",
         raw_request: Request | None = None,
         request_start_s: float | None = None,
+        request_arrival_ts: float | None = None,
         request: OpenAICreateSpeechRequest | None = None,
         tts_params: dict[str, Any] | None = None,
     ):
@@ -1600,7 +1784,7 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
 
         Field naming follows the OpenAI ``speech.audio.delta`` schema, which
         carries the base64 chunk in ``audio`` (not ``delta`` — that is the
-        Realtime API ``response.audio.delta`` convention, a different event).
+        Realtime API ``response.output_audio.delta`` convention, a different event).
         See https://platform.openai.com/docs/api-reference/audio-streaming.
 
         The terminal ``speech.audio.done`` event carries a ``usage`` object
@@ -1613,24 +1797,28 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
         usage_acc = SpeechOutputTokenCounter()
         emitted_audio = False
         try:
-            async for chunk in self._generate_audio_chunks(
-                generator,
-                request_id,
-                response_format,
-                raw_request=raw_request,
-                request_start_s=request_start_s,
-                usage_acc=usage_acc,
-                tts_params=tts_params,
-                target_sample_rate=request.sample_rate if request is not None else None,
-            ):
-                payload = {
-                    "type": "speech.audio.delta",
-                    "audio": base64.b64encode(chunk).decode("ascii"),
-                    "response_format": response_format,
-                }
-                data = json.dumps(payload, separators=(",", ":"))
-                emitted_audio = True
-                yield f"event: speech.audio.delta\ndata: {data}\n\n"
+            async with aclosing(
+                self._generate_audio_chunks(
+                    generator,
+                    request_id,
+                    response_format,
+                    raw_request=raw_request,
+                    request_start_s=request_start_s,
+                    request_arrival_ts=request_arrival_ts,
+                    usage_acc=usage_acc,
+                    tts_params=tts_params,
+                    target_sample_rate=request.sample_rate if request is not None else None,
+                )
+            ) as chunks:
+                async for chunk in chunks:
+                    payload = {
+                        "type": "speech.audio.delta",
+                        "audio": base64.b64encode(chunk).decode("ascii"),
+                        "response_format": response_format,
+                    }
+                    data = json.dumps(payload, separators=(",", ":"))
+                    emitted_audio = True
+                    yield f"event: speech.audio.delta\ndata: {data}\n\n"
             done_payload: dict[str, Any] = {"type": "speech.audio.done"}
             if request is not None:
                 # Streaming path: output_tokens = sum of stage-0 deltas.
@@ -1695,6 +1883,7 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
         request: OpenAICreateSpeechRequest,
         request_id: str | None = None,
         has_inline_ref_audio: bool | None = None,
+        arrival_time: float | None = None,
     ) -> tuple[str, Any, dict[str, Any]]:
         if self.engine_client.errored:
             raise self.engine_client.dead_error
@@ -1740,6 +1929,7 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
             tts_params = prepared.tts_params
             model_type = prepared.model_type
             qwen3_ref_audio_warmup_artifact_key = prepared.warmup_artifact_key
+            output_policy = prepared.output_policy
         else:
             # Qwen omni models (Qwen3-Omni, Qwen2.5-Omni) use a "talker"
             # stage whose preprocess requires chat-templated tokens.  The
@@ -1748,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 "
@@ -1761,6 +1949,7 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
                 )
             tts_params = {}
             prompt = {"prompt": request.input}
+            output_policy = OutputPolicy()
 
         if model_type is None:
             if self._is_tts:
@@ -1817,18 +2006,35 @@ 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,
             request_id=request_id,
             sampling_params_list=sampling_params_list,
             output_modalities=output_modalities,
+            arrival_time=arrival_time,
         )
         self._track_ref_audio_artifact_warmup(
             request_id,
             qwen3_ref_audio_warmup_artifact_key,
             x_vector_only=self._tts_x_vector_only(tts_params),
         )
+        # Only the non-streaming path consumes output policies (in
+        # `_generate_audio_bytes`); streaming never reads them. Store late —
+        # after every fallible step above — and skip streaming requests
+        # entirely, so no caller has to discard entries (request ids are
+        # unique per request, so a stranded entry would never be reclaimed).
+        if not request.is_streaming():
+            self._speech_output_policies[request_id] = output_policy
         return request_id, generator, tts_params
 
     async def _generate_pcm_chunks(
@@ -1836,10 +2042,13 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
         generator,
         request_id: str,
         *,
+        request_start_s: float | None = None,
+        request_arrival_ts: float | None = None,
         include_sample_rate: bool = False,
         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.
 
@@ -1848,28 +2057,38 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
         ``collect`` (when given) receives the forced-aligner stage's pooling
         output under ``"aligner_res"`` for downstream word-timestamp extraction.
         """
-        async for chunk in self._generate_audio_chunks(
-            generator,
-            request_id,
-            response_format="pcm",
-            include_sample_rate=include_sample_rate,
-            tts_params=tts_params,
-            collect=collect,
-            target_sample_rate=target_sample_rate,
-        ):
-            yield chunk
+        async with aclosing(
+            self._generate_audio_chunks(
+                generator,
+                request_id,
+                response_format="pcm",
+                request_start_s=request_start_s,
+                request_arrival_ts=request_arrival_ts,
+                include_sample_rate=include_sample_rate,
+                tts_params=tts_params,
+                collect=collect,
+                target_sample_rate=target_sample_rate,
+                cumulative_audio=cumulative_audio,
+            )
+        ) as chunks:
+            async for chunk in chunks:
+                yield chunk
 
     async def _iter_pcm_audio_bytes(self, request: OpenAICreateSpeechRequest):
         """Yield raw PCM bytes for a speech request as soon as chunks are decoded."""
         request_id, generator, tts_params = await self._prepare_speech_generation(request)
         try:
-            async for chunk in self._generate_pcm_chunks(
-                generator,
-                request_id,
-                tts_params=tts_params,
-                target_sample_rate=request.sample_rate,
-            ):
-                yield chunk
+            async with aclosing(
+                self._generate_pcm_chunks(
+                    generator,
+                    request_id,
+                    tts_params=tts_params,
+                    target_sample_rate=request.sample_rate,
+                    cumulative_audio=request.word_timestamps,
+                )
+            ) as chunks:
+                async for chunk in chunks:
+                    yield chunk
         finally:
             self._discard_ref_audio_artifact_warmup(request_id)
 
@@ -1881,25 +2100,34 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
         usage_out: list[SpeechTokenUsage] | None = None,
         has_inline_ref_audio: bool | None = None,
         collect: dict | None = None,
+        request_arrival_ts: float | None = None,
     ) -> tuple[bytes | str, str]:
         # ``usage_out`` is an opt-in output channel: when a list is passed, the
         # computed SpeechTokenUsage is appended to it. The return stays a
         # 2-tuple so existing callers (and their test mocks) are unaffected;
         # batch and non-streaming response-header paths opt in when surfacing
         # usage outside the raw audio body.
+        request_arrival_ts = request_arrival_ts if request_arrival_ts is not None else time.time()
         request_id, generator, bytes_tts_params = await self._prepare_speech_generation(
-            request, request_id=request_id, has_inline_ref_audio=has_inline_ref_audio
+            request,
+            request_id=request_id,
+            has_inline_ref_audio=has_inline_ref_audio,
+            arrival_time=request_arrival_ts,
         )
         artifact_ready = False
 
         try:
-            # MOSS-TTS-Nano emits delta chunks per yield (single-stage,
-            # async_chunk=false). The engine surfaces each yield as its own
-            # RequestOutput, so we need to accumulate across the async-for loop —
-            # final_output alone only carries the last (often empty) sentinel.
-            is_moss = self._tts_model_type == "moss_tts_nano"
-            moss_chunks: list[Any] = []
-            moss_sample_rate: int | None = None
+            # Sparse-audio models (MOSS-TTS-Nano, Gepard) emit delta chunks per
+            # yield with async_chunk=false. The engine surfaces each yield as its
+            # own RequestOutput, so we accumulate across the async-for loop when
+            # the adapter asks for it — final_output alone may only carry the
+            # last (often empty) sentinel. Prefer the engine's own concatenated
+            # waveform when FINAL_ONLY already produced one.
+            accumulate_nonstreaming = self._speech_output_policies.pop(
+                request_id, OutputPolicy()
+            ).accumulate_nonstreaming
+            delta_chunks: list[Any] = []
+            delta_sample_rate: int | None = None
 
             final_output: OmniRequestOutput | None = None
             # Non-streaming is FINAL_ONLY, so the stage-0 output carries the full
@@ -1919,7 +2147,7 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
                     _, audio_key = self._extract_audio_output(res)
                     if audio_key is not None:
                         audio_res = res
-                if not is_moss:
+                if not accumulate_nonstreaming:
                     continue
                 try:
                     step_audio, step_key = self._extract_audio_output(res)
@@ -1927,15 +2155,16 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
                     continue
                 if step_key is None:
                     continue
+                step_audio = cast(dict, step_audio)
                 chunk = step_audio[step_key]
                 candidates = chunk if isinstance(chunk, list) else [chunk]
                 for cand in candidates:
                     if hasattr(cand, "numel") and cand.numel() > 0:
-                        moss_chunks.append(cand)
+                        delta_chunks.append(cand)
                 sr_step = step_audio.get("sr")
                 if sr_step is not None:
                     sr_val_step = sr_step[-1] if isinstance(sr_step, list) and sr_step else sr_step
-                    moss_sample_rate = int(sr_val_step.item()) if hasattr(sr_val_step, "item") else int(sr_val_step)
+                    delta_sample_rate = int(sr_val_step.item()) if hasattr(sr_val_step, "item") else int(sr_val_step)
 
             if final_output is None:
                 raise ValueError("No output generated from the model.")
@@ -1948,6 +2177,7 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
             audio_output, audio_key = self._extract_audio_output(audio_source)
             if audio_key is None:
                 raise ValueError("TTS model did not produce audio output.")
+            audio_output = cast(dict, audio_output)
 
             # Surface forced-aligner word timestamps to the caller (set as a
             # response header) when requested and an aligner stage produced them.
@@ -1967,7 +2197,7 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
             sr_val = sr_raw[-1] if isinstance(sr_raw, list) and sr_raw else sr_raw
             sample_rate = sr_val.item() if hasattr(sr_val, "item") else int(sr_val)
 
-            if is_moss:
+            if accumulate_nonstreaming:
                 # Prefer the engine's own consolidated audio when present. After the
                 # vllm 0.20 rebase non-stream requests resolve to FINAL_ONLY, so
                 # final_output already carries the full concatenated waveform; the
@@ -1983,12 +2213,12 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
 
                 if final_audio is not None:
                     audio_tensor = final_audio
-                elif moss_chunks:
-                    audio_tensor = torch.cat(moss_chunks, dim=-1)
+                elif delta_chunks:
+                    audio_tensor = torch.cat(delta_chunks, dim=-1)
                 else:
                     audio_tensor = np.zeros((0,), dtype=np.float32)
-                if moss_sample_rate is not None:
-                    sample_rate = moss_sample_rate
+                if delta_sample_rate is not None:
+                    sample_rate = delta_sample_rate
             elif isinstance(audio_tensor, list):
                 async_chunk = bool(getattr(self.engine_client.model_config, "async_chunk", False))
                 if async_chunk:
@@ -2074,7 +2304,7 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
             request_id = f"speech-{random_uuid()}"
             prompt: dict[str, Any] = {"input": request.input}
             if request.ref_audio:
-                wav, sr, _ = await self._resolve_ref_audio(request.ref_audio)
+                wav, sr, _ = await self._resolve_ref_audio(cast(str, request.ref_audio))
                 prompt["ref_audio"] = (np.asarray(wav, dtype=np.float32), sr)
             if request.ref_text:
                 prompt["ref_text"] = request.ref_text
@@ -2151,6 +2381,7 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
             audio_output, audio_key = self._extract_audio_output(final_output)
             if audio_key is None:
                 raise ValueError("TTS model did not produce audio output.")
+            audio_output = cast(dict, audio_output)
 
             audio_tensor = audio_output[audio_key]
             sr_raw = audio_output.get("sr", 24000)
@@ -2265,6 +2496,11 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
 
         request_id = f"speech-{random_uuid()}"
         request_start_s = time.perf_counter()
+        request_arrival_ts = (
+            float(getattr(raw_request.state, "request_timestamp", time.time()))
+            if raw_request is not None
+            else time.time()
+        )
         if raw_request:
             raw_request.state.request_metadata = RequestResponseMetadata(
                 request_id=request_id,
@@ -2292,14 +2528,19 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
                     return error
 
                 media_type = "audio/wav" if response_format == "wav" else "audio/pcm"
-                _, generator, raw_tts_params = await self._prepare_speech_generation(request, request_id=request_id)
-                return StreamingResponse(
+                _, generator, raw_tts_params = await self._prepare_speech_generation(
+                    request,
+                    request_id=request_id,
+                    arrival_time=request_arrival_ts,
+                )
+                return _SpeechStreamingResponse(
                     self._generate_audio_chunks(
                         generator,
                         request_id,
                         response_format,
                         raw_request=raw_request,
                         request_start_s=request_start_s,
+                        request_arrival_ts=request_arrival_ts,
                         tts_params=raw_tts_params,
                         target_sample_rate=request.sample_rate,
                     ),
@@ -2314,14 +2555,19 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
                 if error is not None:
                     return error
 
-                _, generator, sse_tts_params = await self._prepare_speech_generation(request, request_id=request_id)
-                return StreamingResponse(
+                _, generator, sse_tts_params = await self._prepare_speech_generation(
+                    request,
+                    request_id=request_id,
+                    arrival_time=request_arrival_ts,
+                )
+                return _SpeechStreamingResponse(
                     self._generate_audio_sse_events(
                         generator,
                         request_id,
                         response_format,
                         raw_request=raw_request,
                         request_start_s=request_start_s,
+                        request_arrival_ts=request_arrival_ts,
                         request=request,
                         tts_params=sse_tts_params,
                     ),
@@ -2332,7 +2578,11 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
             usage_box: list[SpeechTokenUsage] = []
             try:
                 audio_bytes, media_type = await self._generate_audio_bytes(
-                    request, request_id=request_id, usage_out=usage_box, collect=collect
+                    request,
+                    request_id=request_id,
+                    usage_out=usage_box,
+                    collect=collect,
+                    request_arrival_ts=request_arrival_ts,
                 )
             except TTSGenerationError as error:
                 # An adapter can reject otherwise completed audio. Retry only
@@ -2358,6 +2608,7 @@ class OmniOpenAIServingSpeech(OpenAIServing, AudioMixin):
                     request_id=retry_request_id,
                     usage_out=usage_box,
                     collect=collect,
+                    request_arrival_ts=request_arrival_ts,
                 )
             total_ms = (time.perf_counter() - request_start_s) * 1000.0
             logger.info(
diff --git a/vllm_omni/entrypoints/openai/serving_speech_stream.py b/vllm_omni/entrypoints/openai/serving_speech_stream.py
index 32e9fa40d..45bdd4e90 100644
--- a/vllm_omni/entrypoints/openai/serving_speech_stream.py
+++ b/vllm_omni/entrypoints/openai/serving_speech_stream.py
@@ -55,6 +55,7 @@ Protocol:
 import asyncio
 import base64
 import json
+import time
 from contextlib import aclosing
 
 from fastapi import WebSocket, WebSocketDisconnect
@@ -284,6 +285,8 @@ class OmniStreamingSpeechHandler:
         ``utterance_index`` identifies the flush this sentence belongs to and
         ``sentence_index`` its position inside that flush.
         """
+        request_arrival_ts = time.time()
+        request_start_s = time.perf_counter()
         response_format = config.response_format or "wav"
 
         # Reject unmet word-timestamps preconditions early with a clear reason.
@@ -346,7 +349,10 @@ class OmniStreamingSpeechHandler:
         request_id = None
         try:
             if config.stream_audio:
-                request_id, generator, tts_params = await self._speech_service._prepare_speech_generation(request)
+                request_id, generator, tts_params = await self._speech_service._prepare_speech_generation(
+                    request,
+                    arrival_time=request_arrival_ts,
+                )
                 if config.word_timestamps:
                     total_bytes = await self._stream_audio_with_alignments(
                         websocket=websocket,
@@ -356,6 +362,8 @@ class OmniStreamingSpeechHandler:
                         utterance_index=utterance_index,
                         sentence_index=sentence_index,
                         language=config.language,
+                        request_start_s=request_start_s,
+                        request_arrival_ts=request_arrival_ts,
                         tts_params=tts_params,
                     )
                 else:
@@ -363,6 +371,8 @@ class OmniStreamingSpeechHandler:
                         self._speech_service._generate_pcm_chunks(
                             generator,
                             request_id,
+                            request_start_s=request_start_s,
+                            request_arrival_ts=request_arrival_ts,
                             tts_params=tts_params,
                         )
                     ) as stream:
@@ -370,7 +380,10 @@ class OmniStreamingSpeechHandler:
                             total_bytes += len(chunk)
                             await websocket.send_bytes(chunk)
             else:
-                audio_bytes, _ = await self._speech_service._generate_audio_bytes(request)
+                audio_bytes, _ = await self._speech_service._generate_audio_bytes(
+                    request,
+                    request_arrival_ts=request_arrival_ts,
+                )
                 total_bytes = len(audio_bytes)
                 await websocket.send_bytes(audio_bytes)
         except WebSocketDisconnect:
@@ -416,6 +429,8 @@ class OmniStreamingSpeechHandler:
         sentence_text: str,
         utterance_index: int,
         sentence_index: int,
+        request_start_s: float,
+        request_arrival_ts: float,
         language: str | None = None,
         tts_params: dict | None = None,
     ) -> int:
@@ -463,9 +478,12 @@ class OmniStreamingSpeechHandler:
             self._speech_service._generate_pcm_chunks(
                 generator,
                 request_id,
+                request_start_s=request_start_s,
+                request_arrival_ts=request_arrival_ts,
                 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 b3afe8b40..c90a4d162 100644
--- a/vllm_omni/entrypoints/openai/serving_video.py
+++ b/vllm_omni/entrypoints/openai/serving_video.py
@@ -6,20 +6,23 @@ from __future__ import annotations
 import copy
 import math
 import time
-from collections.abc import Mapping
+from collections.abc import Awaitable, Callable, Mapping
 from dataclasses import dataclass
 from functools import cached_property
 from http import HTTPStatus
 from types import SimpleNamespace
 from typing import TYPE_CHECKING, Any, cast
 
+import pybase64 as base64
 from fastapi import HTTPException
 from PIL import Image
 from vllm.engine.protocol import EngineClient
 from vllm.logger import init_logger
 
-from vllm_omni.diffusion.model_metadata import get_diffusion_model_metadata
-from vllm_omni.entrypoints.async_omni import AsyncOmni
+from vllm_omni.diffusion.data import is_diffusion_request_started_output
+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 (
     VideoAction,
     VideoData,
@@ -50,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
 
@@ -77,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."""
@@ -99,7 +137,12 @@ def _video_metadata_from_artifacts(artifacts: VideoGenerationArtifacts) -> dict[
     if not artifacts.videos:
         return metadata
 
-    num_frames = count_video_frames(artifacts.videos[0])
+    video = artifacts.videos[0]
+    # Pre-encoded outputs arrive as MP4 bytes, which carry no tensor shape.
+    if isinstance(video, (bytes, bytearray, memoryview)):
+        num_frames = count_mp4_frames(bytes(video))
+    else:
+        num_frames = count_video_frames(video)
     if num_frames is not None and num_frames > 0:
         metadata["num_frames"] = num_frames
         if artifacts.output_fps > 0:
@@ -135,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,
@@ -179,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]:
@@ -212,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
@@ -249,6 +275,9 @@ class OmniOpenAIServingVideo:
     def shutdown(self) -> None:
         self._video_frame_converter.shutdown()
 
+    async def abort_request(self, request_id: str) -> None:
+        await self._engine_client.abort(request_id, timeout=ABORT_TIMEOUT_S)
+
     async def _run_and_extract(
         self,
         request: VideoGenerationRequest,
@@ -257,6 +286,8 @@ class OmniOpenAIServingVideo:
         reference_image: ReferenceImage | None = None,
         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"])
@@ -337,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:
@@ -402,6 +446,11 @@ class OmniOpenAIServingVideo:
                     status_code=HTTPStatus.BAD_REQUEST.value,
                     detail="extra_params must be a JSON object/dict.",
                 )
+            if request.extra_params.get("preencode_mp4") and "preencode_batch_frames" in request.extra_params:
+                try:
+                    normalize_preencode_batch_frames(request.extra_params["preencode_batch_frames"])
+                except ValueError as exc:
+                    raise HTTPException(status_code=HTTPStatus.BAD_REQUEST.value, detail=str(exc)) from exc
             # Merge extra_params into extra_args
             gen_params.extra_args.update(request.extra_params)
 
@@ -432,7 +481,12 @@ class OmniOpenAIServingVideo:
             gen_params.seed,
         )
 
-        result = await self._run_generation(prompt, gen_params, reference_id)
+        result = await self._run_generation(
+            prompt,
+            gen_params,
+            reference_id,
+            on_started=on_started,
+        )
         multimodal_output = self._extract_multimodal_output(result)
         metadata = multimodal_output.get("metadata") if isinstance(multimodal_output, dict) else {}
         common_metadata = metadata.get("common") if isinstance(metadata, dict) else {}
@@ -465,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,
@@ -472,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"}
@@ -479,26 +535,22 @@ class OmniOpenAIServingVideo:
             if "video_codec_options" in request.extra_params:
                 video_codec_options = request.extra_params["video_codec_options"]
 
+        def encode_video_result(idx: int, video: Any) -> str:
+            if isinstance(video, bytes):
+                return base64.b64encode(video).decode("utf-8")
+            return encode_video_base64(
+                video,
+                fps=artifacts.output_fps,
+                audio=artifacts.audios[idx],
+                audio_sample_rate=artifacts.audio_sample_rate,
+                video_codec_options=video_codec_options,
+                frame_converter=self._video_frame_converter,
+            )
+
         _t_encode_start = time.perf_counter()
         video_data = [
             VideoData(
-                b64_json=(
-                    encode_video_base64(
-                        video,
-                        fps=artifacts.output_fps,
-                        video_codec_options=video_codec_options,
-                        frame_converter=self._video_frame_converter,
-                    )
-                    if artifacts.audios[idx] is None
-                    else encode_video_base64(
-                        video,
-                        fps=artifacts.output_fps,
-                        audio=artifacts.audios[idx],
-                        audio_sample_rate=artifacts.audio_sample_rate,
-                        video_codec_options=video_codec_options,
-                        frame_converter=self._video_frame_converter,
-                    )
-                ),
+                b64_json=encode_video_result(idx, video),
                 action=artifacts.actions[idx],
             )
             for idx, video in enumerate(artifacts.videos)
@@ -520,6 +572,8 @@ class OmniOpenAIServingVideo:
         reference_image: ReferenceImage | None = None,
         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(
@@ -528,6 +582,8 @@ class OmniOpenAIServingVideo:
             reference_image=reference_image,
             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(
@@ -549,6 +605,17 @@ class OmniOpenAIServingVideo:
             return b"", artifacts.stage_durations, artifacts.peak_memory_mb, action, video_metadata
 
         _t_encode_start = time.perf_counter()
+        if isinstance(artifacts.videos[0], bytes):
+            video_bytes = artifacts.videos[0]
+            _t_encode_ms = (time.perf_counter() - _t_encode_start) * 1000
+            logger.info("Video response received pre-encoded MP4 bytes: %.2f ms", _t_encode_ms)
+            return (
+                video_bytes,
+                artifacts.stage_durations,
+                artifacts.peak_memory_mb,
+                artifacts.actions[0],
+                video_metadata,
+            )
         video_bytes = _encode_video_bytes(
             artifacts.videos[0],
             fps=artifacts.output_fps,
@@ -622,6 +689,8 @@ class OmniOpenAIServingVideo:
         prompt: OmniTextPrompt,
         gen_params: OmniDiffusionSamplingParams,
         request_id: str,
+        *,
+        on_started: Callable[[], Awaitable[None]] | None = None,
     ) -> object:
         stage_configs = self._stage_configs or getattr(self._engine_client, "stage_configs", None)
 
@@ -641,6 +710,7 @@ class OmniOpenAIServingVideo:
 
         # Common generation logic for both paths
         engine_client = cast(AsyncOmni, self._engine_client)
+        gen_params.emit_request_lifecycle = on_started is not None
         sampling_params_list = build_stage_sampling_params_list(
             list(stage_configs),
             get_default_sampling_params_list(engine_client),
@@ -649,11 +719,17 @@ class OmniOpenAIServingVideo:
         )
 
         result = None
+        started_notified = False
         async for output in engine_client.generate(
             prompt=prompt,
             request_id=request_id,
             sampling_params_list=sampling_params_list,
         ):
+            if is_diffusion_request_started_output(output):
+                if on_started is not None and not started_notified:
+                    await on_started()
+                    started_notified = True
+                continue
             result = output
 
         if result is None:
diff --git a/vllm_omni/entrypoints/openai/serving_video_output_stream.py b/vllm_omni/entrypoints/openai/serving_video_output_stream.py
index a9abad146..2647ec11c 100644
--- a/vllm_omni/entrypoints/openai/serving_video_output_stream.py
+++ b/vllm_omni/entrypoints/openai/serving_video_output_stream.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
 """WebSocket handler for streaming generated video chunks.
 
 Protocol:
@@ -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:
@@ -556,6 +592,14 @@ class OmniStreamingVideoOutputHandler:
                     status_code=HTTPStatus.BAD_REQUEST.value,
                     detail="extra_params must be a JSON object/dict.",
                 )
+            # Worker-side pre-encoding produces one progressive MP4, which this
+            # path's incremental fMP4 encoder cannot consume; streaming already
+            # overlaps encoding through that encoder instead.
+            if request.extra_params.get("preencode_mp4"):
+                raise HTTPException(
+                    status_code=HTTPStatus.BAD_REQUEST.value,
+                    detail="preencode_mp4 is not supported for streaming video sessions.",
+                )
             gen_params.extra_args.update(request.extra_params)
 
         self._apply_lora(request.lora, gen_params)
@@ -564,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/serving_video_stream.py b/vllm_omni/entrypoints/openai/serving_video_stream.py
index af0083fcb..5f7334bd2 100644
--- a/vllm_omni/entrypoints/openai/serving_video_stream.py
+++ b/vllm_omni/entrypoints/openai/serving_video_stream.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
 """Qwen-Omni streaming video WebSocket handler.
 
 Accepts video frames incrementally via WebSocket, buffers them, and
@@ -18,20 +18,21 @@ Protocol:
         {"type": "response.start"}
         {"type": "response.text.delta", "delta": "..."}
         {"type": "response.text.done", "text": "..."}
-        {"type": "response.audio.delta", "data": "...", "format": "wav"}
-        {"type": "response.audio.done"}
+        {"type": "response.output_audio.delta", "data": "...", "format": "wav"}
+        {"type": "response.output_audio.done"}
         {"type": "session.done"}
         {"type": "error", "message": "..."}
 """
 
 from __future__ import annotations
 
+from collections.abc import Mapping
 from typing import Any
 
 from vllm_omni.entrypoints.openai.video_stream_base import (
-    _BAD_FRAME,
     _DEFAULT_CONFIG_TIMEOUT,
     _DEFAULT_IDLE_TIMEOUT,
+    PrewarmedFrame,
     StreamingVideoSessionConfig,
     VideoStreamTurnTrigger,
 )
@@ -59,23 +60,20 @@ class QwenOmniStreamingVideoHandler(OmniStreamingVideoHandlerBase):
         audio_buffer: bytearray,
         message_history: list[dict[str, Any]],
         query_text: str,
-        prewarmed_frames: dict[str, tuple[Any, str]],
+        prewarmed_frames: Mapping[str, PrewarmedFrame],
+        *,
+        frame_indices: list[int] | None = None,
     ) -> tuple[list[dict[str, Any]], dict[str, Any]]:
-        n_buf = len(frame_buffer)
-        if n_buf <= config.num_frames:
-            frames = list(frame_buffer)
-        else:
-            stride = max(1, n_buf // config.num_frames)
-            idx = [i * stride for i in range(config.num_frames - 1)] + [n_buf - 1]
-            frames = [frame_buffer[i] for i in idx]
-
         prewarmed = prewarmed_frames or {}
+        if frame_indices is None:
+            frame_indices = self._sample_frame_indices(frame_buffer, config.num_frames, prewarmed)
         user_content: list[dict] = []
-        for frame_b64 in frames:
+        for index in frame_indices:
+            frame_b64 = frame_buffer[index]
             cached = prewarmed.get(frame_b64)
-            if cached is _BAD_FRAME:
-                continue
             if cached is not None:
+                # The shared selector excludes failed decodes before this point.
+                assert isinstance(cached, tuple)
                 pil, pil_uuid = cached
                 user_content.append(
                     {
diff --git a/vllm_omni/entrypoints/openai/tts_adapters/__init__.py b/vllm_omni/entrypoints/openai/tts_adapters/__init__.py
index 39882274d..2b7f93a62 100644
--- a/vllm_omni/entrypoints/openai/tts_adapters/__init__.py
+++ b/vllm_omni/entrypoints/openai/tts_adapters/__init__.py
@@ -105,10 +105,11 @@ from vllm_omni.entrypoints.openai.tts_adapters import (  # noqa: E402,F401
     audex,
     audex_tta,
     audio8_tts,
+    breeze_tts_2,
     cosyvoice3,
     covo_audio,
-    dots_tts,
     fish_speech,
+    gepard,
     glm_tts,
     higgs_audio_v2,
     higgs_audio_v3,
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
new file mode 100644
index 000000000..03f0d3c4b
--- /dev/null
+++ b/vllm_omni/entrypoints/openai/tts_adapters/breeze_tts_2.py
@@ -0,0 +1,262 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""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
+
+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,
+    conditioning_cache_salt,
+)
+from vllm_omni.model_executor.models.breeze_tts_2.audio_tokenizer import (
+    BreezeReferenceAudioTokenizer,
+)
+from vllm_omni.model_executor.models.breeze_tts_2.prompt_builder import (
+    BreezeTTS2PromptBuilder,
+)
+
+if TYPE_CHECKING:
+    from vllm_omni.entrypoints.openai.protocol.audio import OpenAICreateSpeechRequest
+
+
+@register_tts_adapter
+class BreezeTTS2Adapter(ARTTSAdapter):
+    """Build Breeze prompts before scheduler submission.
+
+    The adapter owns only request-facing concerns. Model workers still own the
+    stage-0 embeddings and stage-1 waveform decode.
+    """
+
+    stage_keys = frozenset({"breeze_tts_2"})
+    model_archs = frozenset({"BreezeForConditionalGeneration"})
+    name = "breeze_tts_2"
+    # Breeze's architecture and stage key are unique, so this detector cannot
+    # collide with another adapter. Lower priority runs first; 9 keeps it
+    # ahead of the default-priority (100) detectors.
+    detect_priority = 9
+    supported_output_sample_rates = frozenset({24000})
+
+    def _load_supported_speakers(self) -> set[str]:
+        # Breeze accepts arbitrary speaker tags such as S0/S1 in its prompt;
+        # there is no finite checkpoint speaker inventory to advertise.
+        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):
+            frame_rate = codec.get("_frame_rate")
+            if frame_rate is not None:
+                return float(frame_rate)
+        return 12.5
+
+    def validate(self, request: "OpenAICreateSpeechRequest") -> str | None:
+        if not request.input or not request.input.strip():
+            return "Breeze-TTS-2 input text cannot be empty"
+        if request.ref_text is not None and not request.ref_text.strip():
+            return "Breeze-TTS-2 ref_text cannot be empty"
+        if request.ref_text is not None and request.ref_audio is None:
+            return "Breeze-TTS-2 ref_text requires ref_audio"
+        if request.ref_audio is not None and (request.ref_text is None or not request.ref_text.strip()):
+            return "Breeze-TTS-2 ref_audio requires ref_text"
+        if isinstance(request.ref_audio, list) and len(request.ref_audio) != 1:
+            # The prompt path conditions on exactly one reference waveform;
+            # extra clips would be silently discarded otherwise.
+            return f"Breeze-TTS-2 supports exactly one reference clip, got {len(request.ref_audio)}"
+        if request.task_type == "Base" and request.ref_audio is None:
+            return "Breeze-TTS-2 Base task requires ref_audio and ref_text"
+        if request.task_type == "VoiceDesign":
+            return "Breeze-TTS-2 does not support task_type=VoiceDesign"
+        if request.speed is not None and request.speed != 1.0:
+            return "Breeze-TTS-2 does not support speed adjustment"
+        if request.language is not None:
+            return "Breeze-TTS-2 does not support 'language'; the prompt language follows the input text"
+        if request.speaker_embedding is not None:
+            return "Breeze-TTS-2 does not support 'speaker_embedding' (voice-cloning helper field)"
+        if request.x_vector_only_mode:
+            return "Breeze-TTS-2 does not support 'x_vector_only_mode' (voice-cloning helper field)"
+        extra_params = request.extra_params or {}
+        guidance_scale = extra_params.get("guidance_scale", extra_params.get("cfg_scale", 1.0))
+        try:
+            unsupported_guidance = guidance_scale is not None and float(guidance_scale) != 1.0
+        except (TypeError, ValueError):
+            return "Breeze-TTS-2 guidance_scale must be a number"
+        if unsupported_guidance:
+            return "Breeze-TTS-2 currently supports only guidance_scale=1.0"
+        if extra_params.get("negative_prompt"):
+            return "Breeze-TTS-2 does not support negative_prompt/CFG yet"
+        # The talker selects codebook 0 by argmax inside make_omni_output and
+        # ignores the scheduler's sampled token, so non-greedy overrides would
+        # not change the audio while still letting the sampler draw an early
+        # EOS. Reject them until the talker consumes the sampled code.
+        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}"
+            if request.max_new_tokens > self.max_new_tokens_max:
+                return f"max_new_tokens cannot exceed {self.max_new_tokens_max}"
+        if request.ref_audio is not None:
+            ref_audio = request.ref_audio[0] if isinstance(request.ref_audio, list) else request.ref_audio
+            return self.ctx.server._validate_ref_audio_format(ref_audio)
+        return None
+
+    async def build(
+        self,
+        request: "OpenAICreateSpeechRequest",
+        sampling_params_list: list,
+        has_inline_ref_audio: bool,
+    ) -> PreparedRequest:
+        del has_inline_ref_audio
+        server = self.ctx.server
+        builder = await self._get_builder()
+        template = self._resolve_template(request)
+        payload: dict[str, Any] = {
+            "text": request.input,
+            "template": template,
+            "speaker": request.voice or "S0",
+        }
+        if request.instructions:
+            payload["instruction"] = request.instructions
+        if request.ref_text:
+            payload["ref_text"] = request.ref_text
+
+        if request.ref_audio is not None:
+            ref_audio = request.ref_audio[0] if isinstance(request.ref_audio, list) else request.ref_audio
+            wav_list, sr, cache_key = await server._resolve_ref_audio(ref_audio)
+            payload["ref_audio"] = np.asarray(wav_list, dtype=np.float32)
+            payload["ref_audio_sample_rate"] = int(sr)
+        else:
+            cache_key = None
+
+        prompt = await asyncio.to_thread(builder.build, payload, template=template)
+        # The AR scheduler's completion budget is measured in codebook-0
+        # frames for Breeze. Preserve it in the mutable request metadata so
+        # the talker can emit its own EOS before a scheduler length cutoff.
+        max_new_frames = request.max_new_tokens
+        if max_new_frames is None and sampling_params_list:
+            max_new_frames = getattr(sampling_params_list[0], "max_tokens", None)
+        if max_new_frames is not None:
+            prompt["additional_information"]["breeze_max_new_frames"] = int(max_new_frames)
+        tts_params = {
+            "template": [template],
+            "text": [request.input],
+        }
+        if cache_key:
+            tts_params["ref_audio_cache_key"] = cache_key
+        prompt["cache_salt"] = conditioning_cache_salt(request, tts_params)
+        return PreparedRequest(prompt=prompt, tts_params=tts_params, model_type=self.name)
+
+    async def _get_builder(self) -> BreezeTTS2PromptBuilder:
+        server = self.ctx.server
+        cached = getattr(server, "_breeze_tts_2_prompt_builder", None)
+        if cached is not None:
+            return cached
+        # Multiple speech requests can arrive while the first tokenizer load
+        # is still in progress.  Serialize the one-time CPU initialization so
+        # model files are not opened and decoded repeatedly.
+        lock = getattr(server, "_breeze_tts_2_prompt_builder_lock", None)
+        if lock is None:
+            lock = asyncio.Lock()
+            server._breeze_tts_2_prompt_builder_lock = lock
+        async with lock:
+            cached = getattr(server, "_breeze_tts_2_prompt_builder", None)
+            if cached is not None:
+                return cached
+            model_path = server.engine_client.model_config.model
+            config = server.engine_client.model_config.hf_config
+            audio_tokenizer = await asyncio.to_thread(
+                BreezeReferenceAudioTokenizer.from_pretrained,
+                model_path,
+                num_codebooks=int(getattr(config, "num_codebooks", 16)),
+                codebook_size=self._codebook_size(config),
+                device_map="cpu",
+            )
+            builder = await asyncio.to_thread(
+                BreezeTTS2PromptBuilder.from_pretrained,
+                model_path,
+                config,
+                reference_audio_encoder=audio_tokenizer,
+            )
+            server._breeze_tts_2_prompt_builder = builder
+            return builder
+
+    @staticmethod
+    def _codebook_size(config: Any) -> int:
+        codec = getattr(config, "codec_config", None)
+        if isinstance(codec, dict):
+            return int(codec.get("codebook_size", 2048))
+        return int(getattr(codec, "codebook_size", 2048))
+
+    @staticmethod
+    def _resolve_template(request: "OpenAICreateSpeechRequest") -> str:
+        if request.ref_audio is not None:
+            return "ref_edit_tata" if request.instructions else "ref_clone_tata"
+        return "tts_instruction" if request.instructions else "tts_plain"
+
+    def apply_sampling_overrides(
+        self,
+        sampling_params_list: list,
+        request: "OpenAICreateSpeechRequest",
+        prompt: dict[str, Any] | None = None,
+        request_id: str | None = None,
+    ) -> list:
+        del prompt, request_id
+        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:
+    """Return an error unless the sampling overrides keep decoding greedy."""
+    temperature = extra_params.get("temperature")
+    if temperature is not None:
+        try:
+            if float(temperature) != 0.0:
+                return "Breeze-TTS-2 currently supports only greedy decoding (temperature=0)"
+        except (TypeError, ValueError):
+            return "Breeze-TTS-2 temperature must be a number"
+    top_p = extra_params.get("top_p")
+    if top_p is not None:
+        try:
+            if float(top_p) != 1.0:
+                return "Breeze-TTS-2 currently supports only greedy decoding (top_p=1.0)"
+        except (TypeError, ValueError):
+            return "Breeze-TTS-2 top_p must be a number"
+    top_k = extra_params.get("top_k")
+    if top_k is not None:
+        try:
+            if int(top_k) not in (-1, 0, 1):
+                return "Breeze-TTS-2 currently supports only greedy decoding (top_k=-1)"
+        except (TypeError, ValueError):
+            return "Breeze-TTS-2 top_k must be an integer"
+    return None
+
+
+__all__ = ["BreezeTTS2Adapter"]
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/gepard.py b/vllm_omni/entrypoints/openai/tts_adapters/gepard.py
new file mode 100644
index 000000000..255525a0d
--- /dev/null
+++ b/vllm_omni/entrypoints/openai/tts_adapters/gepard.py
@@ -0,0 +1,168 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Gepard-1.0 serving adapter for ``/v1/audio/speech``.
+
+Zero-shot only: the trained ``null_prefix`` is the default voice. Prompt IDs
+are assembled with the same layout helper the offline path uses. Frame budget
+rides ``SamplingParams.max_tokens`` (one token = one 1024-sample frame).
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+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,
+    OutputPolicy,
+    PreparedRequest,
+    apply_max_new_tokens,
+    conditioning_cache_salt,
+)
+
+if TYPE_CHECKING:
+    from vllm_omni.entrypoints.openai.protocol.audio import OpenAICreateSpeechRequest
+    from vllm_omni.model_executor.models.gepard.configuration_gepard import GepardConfig
+
+_DEFAULT_VOICE = "default"
+
+# Declared schema fields Gepard does not consume. Rejecting them here is
+# load-bearing: the pydantic model silently drops undeclared keys, so a
+# declared-but-ignored field would otherwise succeed and mislead.
+_UNSUPPORTED_OPTIONAL_FIELDS: tuple[tuple[str, str], ...] = (
+    ("ref_audio", "ref_audio"),
+    ("ref_text", "ref_text"),
+    ("ref_audio_2", "ref_audio_2"),
+    ("speaker_embedding", "speaker_embedding"),
+    ("x_vector_only_mode", "x_vector_only_mode"),
+    ("task_type", "task_type"),
+    ("non_streaming_mode", "non_streaming_mode"),
+    ("instructions", "instructions"),
+    ("language", "language"),
+    ("ambient_sound", "ambient_sound"),
+    ("duration_seconds", "duration_seconds"),
+    ("initial_codec_chunk_frames", "initial_codec_chunk_frames"),
+)
+
+
+@register_tts_adapter
+class GepardAdapter(ARTTSAdapter):
+    name = "gepard"
+    stage_keys = frozenset({"gepard"})
+    model_archs = frozenset({"GepardTalkerForConditionalGeneration"})
+
+    def __init__(self, ctx) -> None:
+        super().__init__(ctx)
+        self._tokenizer: Any = None
+        self._gepard_config: GepardConfig | None = None
+        self._build_prompt_async = make_async(self._build_prompt, executor=getattr(ctx.server, "_tts_executor", None))
+
+    def _load_supported_speakers(self) -> set[str]:
+        return {_DEFAULT_VOICE}
+
+    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 is not None:
+            voice = request.voice.lower()
+            if voice != _DEFAULT_VOICE:
+                return (
+                    f"Invalid voice '{request.voice}'. Supported: {_DEFAULT_VOICE}. "
+                    "Voice cloning from reference audio is not available yet."
+                )
+
+        if request.speed is not None and request.speed != 1.0:
+            return "Gepard does not support 'speed' adjustments; audio is rendered at the native 22.05 kHz rate"
+
+        if request.extra_params:
+            keys = ", ".join(sorted(request.extra_params))
+            return (
+                f"Gepard does not accept extra_params (got: {keys}). "
+                "Sampling is fixed in-model; temperature/top_p/top_k cannot be overridden."
+            )
+
+        if request.word_timestamps:
+            return "Gepard does not support 'word_timestamps'; there is no forced-aligner stage in this pipeline"
+
+        fmt = (request.response_format or "").lower()
+        if fmt == "opus":
+            return (
+                "Gepard does not support 'response_format'='opus'; "
+                "native 22.05 kHz is not an Opus sample rate (8000, 12000, 16000, 24000, 48000)"
+            )
+
+        if request.max_new_tokens is not None:
+            if request.max_new_tokens < self.max_new_tokens_min or request.max_new_tokens > self.max_new_tokens_max:
+                return f"max_new_tokens must be between {self.max_new_tokens_min} and {self.max_new_tokens_max} frames"
+
+        for attr, field in _UNSUPPORTED_OPTIONAL_FIELDS:
+            if getattr(request, attr, None) is not None:
+                return f"Gepard does not support '{field}'"
+
+        return None
+
+    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)
+
+    async def build(
+        self,
+        request: OpenAICreateSpeechRequest,
+        sampling_params_list: list,
+        has_inline_ref_audio: bool,
+    ) -> PreparedRequest:
+        tts_params: dict = {}
+        prompt = await self._build_prompt_async(request.input)
+        prompt["cache_salt"] = conditioning_cache_salt(request, tts_params)
+        return PreparedRequest(
+            prompt=prompt,
+            tts_params=tts_params,
+            model_type=self.name,
+            output_policy=OutputPolicy(accumulate_nonstreaming=True),
+        )
+
+    def _build_prompt(self, text: str) -> dict[str, Any]:
+        from vllm_omni.model_executor.models.gepard.prompt import build_gepard_prompt_ids
+
+        prompt_token_ids = build_gepard_prompt_ids(self._tokenize(text), config=self._config())
+        return {
+            "prompt_token_ids": prompt_token_ids,
+            "additional_information": {"text": [text]},
+        }
+
+    def _model_config(self) -> Any:
+        engine = self.ctx.engine_client
+        assert engine is not None
+        return engine.model_config
+
+    def _config(self) -> GepardConfig:
+        if self._gepard_config is None:
+            from vllm_omni.model_executor.models.gepard.configuration_gepard import GepardConfig
+
+            model_config = self._model_config()
+            self._gepard_config = GepardConfig.from_checkpoint(
+                model_config.model, revision=getattr(model_config, "revision", None)
+            )
+        return self._gepard_config
+
+    def _tokenize(self, text: str) -> list[int]:
+        tokenizer = self._tokenizer
+        if tokenizer is None:
+            from transformers import AutoTokenizer
+
+            model_config = self._model_config()
+            tokenizer = AutoTokenizer.from_pretrained(
+                model_config.model,
+                revision=getattr(model_config, "revision", None),
+                trust_remote_code=True,
+            )
+            self._tokenizer = tokenizer
+        return tokenizer(text, add_special_tokens=False)["input_ids"]
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 07e4bb197..ea7ff29ec 100644
--- a/vllm_omni/entrypoints/openai/tts_adapters/moss_tts.py
+++ b/vllm_omni/entrypoints/openai/tts_adapters/moss_tts.py
@@ -6,27 +6,39 @@ 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 (
     ARTTSAdapter,
+    OutputPolicy,
     PreparedRequest,
     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
+
     def __init__(self, ctx) -> None:
         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):
@@ -41,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)
@@ -60,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,
         )
@@ -134,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:
@@ -150,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",
@@ -193,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)
@@ -369,7 +483,12 @@ class _MossTTSAdapterBase(ARTTSAdapter):
             prompt = tokens_input(prompt_token_ids=[1])
         prompt["additional_information"] = tts_params
         prompt["cache_salt"] = conditioning_cache_salt(request, tts_params)
-        return PreparedRequest(prompt=prompt, tts_params=tts_params, model_type=self.name)
+        return PreparedRequest(
+            prompt=prompt,
+            tts_params=tts_params,
+            model_type=self.name,
+            output_policy=OutputPolicy(accumulate_nonstreaming=self.accumulate_nonstreaming),
+        )
 
     def apply_sampling_overrides(
         self,
@@ -385,6 +504,7 @@ class _MossTTSAdapterBase(ARTTSAdapter):
 class MossTTSNanoAdapter(_MossTTSAdapterBase):
     stage_keys = frozenset({"moss_tts_nano"})
     name = "moss_tts_nano"
+    accumulate_nonstreaming = True
 
 
 @register_tts_adapter
diff --git a/vllm_omni/entrypoints/openai/tts_adapters/qwen3_tts.py b/vllm_omni/entrypoints/openai/tts_adapters/qwen3_tts.py
index 3a2bb9860..07ee715ea 100644
--- a/vllm_omni/entrypoints/openai/tts_adapters/qwen3_tts.py
+++ b/vllm_omni/entrypoints/openai/tts_adapters/qwen3_tts.py
@@ -374,6 +374,12 @@ class Qwen3TTSAdapter(ARTTSAdapter):
         elif params["task_type"][0] == "VoiceDesign":
             params["non_streaming_mode"] = [True]
 
+        # Do not set ``full_utterance_decode`` here. That flag is an explicit
+        # Code2Wav emit opt-in (offline / advanced callers via
+        # additional_information) and must stay independent of prompt-mode
+        # ``non_streaming_mode`` (#4198 / #6898). Online serving keeps the
+        # default windowed async-chunk path (incl. #5202 incremental decode).
+
         return params
 
     def _estimate_prompt_len(self, tts_params: dict[str, Any]) -> int:
diff --git a/vllm_omni/entrypoints/openai/tts_adapters/voxtral.py b/vllm_omni/entrypoints/openai/tts_adapters/voxtral.py
index f9d7639ca..4cdf990f2 100644
--- a/vllm_omni/entrypoints/openai/tts_adapters/voxtral.py
+++ b/vllm_omni/entrypoints/openai/tts_adapters/voxtral.py
@@ -22,6 +22,7 @@ class VoxtralTTSAdapter(ARTTSAdapter):
     def __init__(self, ctx) -> None:
         super().__init__(ctx)
         self._build_prompt_async = make_async(self._build_prompt, executor=getattr(ctx.server, "_tts_executor", None))
+        self._encoder_loaded = None
 
     def _build_prompt(self, request: "OpenAICreateSpeechRequest") -> dict[str, Any]:
         """Build a Voxtral prompt for either a preset voice or inline reference audio."""
@@ -31,13 +32,24 @@ class VoxtralTTSAdapter(ARTTSAdapter):
         ref_audio = request.ref_audio
         if not request.voice and not ref_audio:
             raise ValueError("Voxtral requires either a voice name or ref_audio.")
-        if isinstance(ref_audio, str) and ref_audio.startswith("data:"):
-            _, _, ref_audio = ref_audio.partition(",")
+
+        if ref_audio is not None and not self._encoder_loaded:
+            validation_error = (
+                "Voice cloning with 'ref_audio' requires the full Voxtral checkpoint "
+                "with encoder weights. The open-source variant only supports "
+                "preset voices via the 'voice' parameter."
+            )
+            raise ValueError(validation_error)
+
         server = self.ctx.server
         if server._tts_tokenizer is None:
             from vllm.tokenizers import cached_tokenizer_from_config
 
             server._tts_tokenizer = cached_tokenizer_from_config(self.ctx.engine_client.model_config).instruct
+
+        if isinstance(ref_audio, str) and ref_audio.startswith("data:"):
+            _, _, ref_audio = ref_audio.partition(",")
+
         if request.voice is not None:
             tokenized = server._tts_tokenizer.encode_speech_request(
                 SpeechRequest(input=request.input, voice=request.voice)
@@ -45,6 +57,7 @@ class VoxtralTTSAdapter(ARTTSAdapter):
             prompt = tokens_input(prompt_token_ids=tokenized.tokens)
             prompt["additional_information"] = {"voice": [request.voice]}
             return prompt
+
         tokenized = server._tts_tokenizer.encode_speech_request(SpeechRequest(input=request.input, ref_audio=ref_audio))
         audio = tokenized.audios[0]
         return {
@@ -84,6 +97,13 @@ class VoxtralTTSAdapter(ARTTSAdapter):
     async def build(
         self, request: "OpenAICreateSpeechRequest", sampling_params_list: list, has_inline_ref_audio: bool
     ) -> PreparedRequest:
+        # Cache encoder_loaded property to avoid RPC call on every request with ref_audio
+        if self._encoder_loaded is None:
+            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 e23d876e5..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,16 +402,20 @@ 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
 
-    await VIDEO_STORE.update_fields(video_id, {"status": VideoGenerationStatus.IN_PROGRESS})
     started_at = time.perf_counter()
     try:
+
+        async def _mark_started() -> None:
+            await VIDEO_STORE.update_fields(video_id, {"status": VideoGenerationStatus.IN_PROGRESS})
+
         video_bytes, stage_durations, peak_memory_mb, action, video_metadata = _unpack_video_generation_result(
             await handler.generate_video_bytes(
                 request,
@@ -340,6 +423,8 @@ async def _run_video_generation_job(
                 reference_image=reference_image,
                 reference_video=reference_video,
                 reference_audio=reference_audio,
+                on_started=_mark_started,
+                latent_edit_input=latent_edit_input,
             )
         )
 
@@ -399,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]:
@@ -422,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,
     *,
@@ -438,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(
@@ -493,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(
@@ -731,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",
@@ -739,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.
@@ -750,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)
@@ -834,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
@@ -841,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,
@@ -975,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,
@@ -983,4 +1194,5 @@ async def _parse_video_form(
         reference_video,
         reference_audio,
         control_path,
+        latent_edit_input,
     )
diff --git a/vllm_omni/entrypoints/openai/video_stream_base.py b/vllm_omni/entrypoints/openai/video_stream_base.py
index f975adbef..52ae9d894 100644
--- a/vllm_omni/entrypoints/openai/video_stream_base.py
+++ b/vllm_omni/entrypoints/openai/video_stream_base.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
 """Base WebSocket handler for streaming video input understanding.
 
 Shared session loop, frame/audio buffering, EVS pre-filter, prewarm,
@@ -21,8 +21,8 @@ Protocol:
         {"type": "response.start"}
         {"type": "response.text.delta", "delta": "..."}
         {"type": "response.text.done", "text": "..."}
-        {"type": "response.audio.delta", "data": "...", "format": "wav"}
-        {"type": "response.audio.done"}
+        {"type": "response.output_audio.delta", "data": "...", "format": "wav"}
+        {"type": "response.output_audio.done"}
         {"type": "session.done"}
         {"type": "error", "message": "..."}
 """
@@ -37,7 +37,8 @@ import uuid
 import wave
 from collections.abc import Mapping
 from dataclasses import dataclass
-from typing import Any, Protocol, runtime_checkable
+from enum import Enum
+from typing import Any, Final, Protocol, TypeAlias, runtime_checkable
 
 import torch
 from fastapi import WebSocket, WebSocketDisconnect
@@ -50,6 +51,7 @@ from vllm_omni.entrypoints.openai.video_frame_filter import FrameSimilarityFilte
 from vllm_omni.entrypoints.openai.video_stream_context import (
     text_only_message,
 )
+from vllm_omni.entrypoints.utils import coerce_param_message_types
 from vllm_omni.outputs import OmniRequestOutput
 
 logger = init_logger(__name__)
@@ -61,7 +63,14 @@ _MAX_BUFFER_FRAMES = 64
 _MAX_AUDIO_BUFFER_BYTES = 4 * 1024 * 1024
 _MAX_MSG_QUEUE = 200
 _CODEC_FRAME_SAMPLES = 1920  # CausalConv leading-edge artifact length
-_BAD_FRAME = object()
+
+
+class _FrameStatus(Enum):
+    BAD = "bad"
+
+
+_BAD_FRAME: Final = _FrameStatus.BAD
+PrewarmedFrame: TypeAlias = tuple[Any, str] | _FrameStatus
 
 
 def _decode_frame_bytes(raw_bytes: bytes) -> Any:
@@ -83,9 +92,11 @@ class VideoStreamPipelineHooks(Protocol):
         audio_buffer: bytearray,
         message_history: list[dict[str, Any]],
         query_text: str,
-        prewarmed_frames: dict[str, tuple[Any, str]],
+        prewarmed_frames: Mapping[str, PrewarmedFrame],
+        *,
+        frame_indices: list[int] | None = None,
     ) -> tuple[list[dict[str, Any]], dict[str, Any]]:
-        """Build OpenAI-style messages and the current user message."""
+        """Build messages using the supplied frame selection, or sample if omitted."""
         ...
 
     def on_turn_complete(
@@ -169,7 +180,9 @@ class OmniStreamingVideoHandler:
         audio_buffer: bytearray,
         message_history: list[dict[str, Any]],
         query_text: str,
-        prewarmed_frames: dict[str, tuple[Any, str]],
+        prewarmed_frames: Mapping[str, PrewarmedFrame],
+        *,
+        frame_indices: list[int] | None = None,
     ) -> tuple[list[dict[str, Any]], dict[str, Any]]:
         raise NotImplementedError
 
@@ -219,7 +232,7 @@ class OmniStreamingVideoHandler:
             frame_buffer: list[str] = []  # base64-encoded JPEG frames
             frame_metadata: list[dict[str, Any]] = []
             # Per-frame PIL cache + uuid for mm_hash reuse. Aligned with frame_buffer by index.
-            frame_pil_cache: dict[str, tuple[Any, str] | object] = {}  # b64 -> (PIL.Image, uuid) or _BAD_FRAME
+            frame_pil_cache: dict[str, PrewarmedFrame] = {}  # b64 -> (PIL.Image, uuid) or _BAD_FRAME
             frame_filter = (
                 FrameSimilarityFilter(threshold=config.frame_filter_threshold) if config.enable_frame_filter else None
             )
@@ -306,7 +319,6 @@ class OmniStreamingVideoHandler:
                         await self._engine_client.abort(prev_request_id)
                     except Exception:
                         pass
-                    await asyncio.sleep(0.1)
                 prev_was_interrupted = False
 
                 request_id = f"video-{uuid.uuid4().hex[:12]}"
@@ -429,8 +441,12 @@ class OmniStreamingVideoHandler:
                             async def _prewarm(b64: str, b: bytes, u: str) -> None:
                                 try:
                                     pil = await asyncio.to_thread(_decode_frame_bytes, b)
-                                    frame_pil_cache[b64] = (pil, u)
+                                    # The frame may have been evicted while decoding.
+                                    if b64 in frame_buffer:
+                                        frame_pil_cache[b64] = (pil, u)
                                 except Exception:
+                                    if b64 not in frame_buffer:
+                                        return
                                     frame_pil_cache[b64] = _BAD_FRAME
                                     logger.warning("prewarm decode failed for frame (len=%d)", len(b))
                                     try:
@@ -577,7 +593,7 @@ class OmniStreamingVideoHandler:
         query_text: str,
         request_id: str,
         interrupt_event: asyncio.Event,
-        prewarmed_frames: dict[str, tuple[Any, str]],
+        prewarmed_frames: Mapping[str, PrewarmedFrame],
         frame_metadata: list[dict[str, Any]] | None = None,
     ) -> None:
         """Build prompt, run inference, stream text + audio response."""
@@ -616,14 +632,20 @@ class OmniStreamingVideoHandler:
         query_text: str,
         request_id: str,
         interrupt_event: asyncio.Event,
-        prewarmed_frames: dict[str, tuple[Any, str]],
+        prewarmed_frames: Mapping[str, PrewarmedFrame],
         frame_metadata: list[dict[str, Any]] | None = None,
     ) -> None:
         """Direct engine_client.generate() path for async_chunk audio."""
+        engine_client = self._engine_client
+        assert engine_client is not None, "_process_query must validate the engine client"
+
         from vllm.entrypoints.openai.chat_completion.protocol import (
             ChatCompletionRequest,
         )
 
+        # Select once from this turn's snapshot so prompt images and the
+        # consumed event refer to exactly the same frames, including decode failures.
+        frame_indices = self._sample_frame_indices(frame_buffer, config.num_frames, prewarmed_frames)
         messages, user_message = self.build_engine_prompt(
             config,
             frame_buffer,
@@ -631,6 +653,7 @@ class OmniStreamingVideoHandler:
             message_history,
             query_text,
             prewarmed_frames,
+            frame_indices=frame_indices,
         )
 
         request_kwargs: dict[str, Any] = {
@@ -646,11 +669,13 @@ class OmniStreamingVideoHandler:
             request_kwargs["mm_processor_kwargs"] = {
                 "use_audio_in_video": True,
             }
-        if config.sampling_params_list:
-            request_kwargs["sampling_params_list"] = config.sampling_params_list
-
+        sampling_kwargs: dict[str, Any] = {}
         try:
             chat_request = ChatCompletionRequest(**request_kwargs)
+            if config.sampling_params_list:
+                params = self._chat_service._to_sampling_params_list(config.sampling_params_list)
+                # Explicit params must retain the engine's streaming output mode.
+                sampling_kwargs["sampling_params_list"] = coerce_param_message_types(params, is_streaming=True)
         except Exception as e:
             await self._send_error(websocket, f"Failed to build request: {e}")
             return
@@ -661,7 +686,7 @@ class OmniStreamingVideoHandler:
             await self._send_error(websocket, f"Preprocess failed: {e}")
             return
         decoded_ready_ts_ms = _time.monotonic() * 1000
-        selected_metadata = self._sample_frame_metadata(frame_metadata or [], config.num_frames)
+        selected_metadata = [frame_metadata[index] for index in frame_indices] if frame_metadata else []
         model_selected_ts_ms = _time.monotonic() * 1000
 
         await websocket.send_json({"type": "response.start"})
@@ -686,10 +711,11 @@ class OmniStreamingVideoHandler:
         audio_tail_tensors: list[Any] = []
 
         try:
-            result_gen = self._engine_client.generate(
+            result_gen = engine_client.generate(
                 prompt=engine_prompt,
                 request_id=request_id,
                 output_modalities=config.modalities,
+                **sampling_kwargs,
             )
 
             async for output in result_gen:
@@ -749,7 +775,7 @@ class OmniStreamingVideoHandler:
                         if b64:
                             await websocket.send_json(
                                 {
-                                    "type": "response.audio.delta",
+                                    "type": "response.output_audio.delta",
                                     "data": b64,
                                     "format": "wav",
                                 }
@@ -793,7 +819,7 @@ class OmniStreamingVideoHandler:
                     if b64:
                         await websocket.send_json(
                             {
-                                "type": "response.audio.delta",
+                                "type": "response.output_audio.delta",
                                 "data": b64,
                                 "format": "wav",
                             }
@@ -802,7 +828,7 @@ class OmniStreamingVideoHandler:
                     logger.exception("Failed to coalesce off-path audio")
 
             if audio_chunk_count > 0:
-                await websocket.send_json({"type": "response.audio.done"})
+                await websocket.send_json({"type": "response.output_audio.done"})
 
             response_text = "".join(text_parts)
             self.on_turn_complete(message_history, user_message, response_text)
@@ -989,6 +1015,8 @@ class OmniStreamingVideoHandler:
         )
         mixin = AudioMixin()
         resp = mixin.create_audio(audio_obj)
+        # base64_encode=True selects the string result of create_audio().
+        assert isinstance(resp.audio_data, str)
         return resp.audio_data
 
     @staticmethod
@@ -1051,15 +1079,19 @@ class OmniStreamingVideoHandler:
             pass
 
     @staticmethod
-    def _sample_frame_metadata(
-        frame_metadata: list[dict[str, Any]],
+    def _sample_frame_indices(
+        frame_buffer: list[str],
         num_frames: int,
-    ) -> list[dict[str, Any]]:
-        if len(frame_metadata) <= num_frames:
-            return list(frame_metadata)
-        stride = max(1, len(frame_metadata) // num_frames)
-        indices = [index * stride for index in range(num_frames - 1)] + [len(frame_metadata) - 1]
-        return [frame_metadata[index] for index in indices]
+        prewarmed_frames: Mapping[str, PrewarmedFrame],
+    ) -> list[int]:
+        """Stride-sample with the last frame, then drop known bad frames without refilling."""
+        n_buf = len(frame_buffer)
+        if n_buf <= num_frames:
+            indices = list(range(n_buf))
+        else:
+            stride = max(1, n_buf // num_frames)
+            indices = [index * stride for index in range(num_frames - 1)] + [n_buf - 1]
+        return [index for index in indices if prewarmed_frames.get(frame_buffer[index]) is not _BAD_FRAME]
 
     @staticmethod
     async def _send_frame_ack(
diff --git a/vllm_omni/entrypoints/openpi/connection.py b/vllm_omni/entrypoints/openpi/connection.py
index 9b8bfe0d8..112254fbe 100644
--- a/vllm_omni/entrypoints/openpi/connection.py
+++ b/vllm_omni/entrypoints/openpi/connection.py
@@ -29,6 +29,7 @@ mappings.
 from __future__ import annotations
 
 import asyncio
+from collections import OrderedDict
 from typing import Any
 
 import msgspec
@@ -45,10 +46,12 @@ logger = init_logger(__name__)
 _DEFAULT_IDLE_TIMEOUT = 30.0
 MAX_OPENPI_PAYLOAD_BYTES = 64 * 1024 * 1024
 _MISSING = object()
+# Upper bound on the per-connection set of seen session ids.
+MAX_TRACKED_SESSIONS = 1024
 
 
 def _pack_numpy(obj: Any) -> Any:
-    if isinstance(obj, (np.ndarray, np.generic)) and obj.dtype.kind in ("V", "O", "c"):
+    if isinstance(obj, np.ndarray | np.generic) and obj.dtype.kind in ("V", "O", "c"):
         raise ValueError(f"Unsupported dtype: {obj.dtype}")
     if isinstance(obj, np.ndarray):
         if not obj.flags.c_contiguous:
@@ -165,17 +168,38 @@ class RobotRealtimeConnection:
         self,
         websocket: WebSocket,
         serving: ServingRealtimeRobotOpenPI,
-        idle_timeout: float = _DEFAULT_IDLE_TIMEOUT,
+        idle_timeout: float | None = _DEFAULT_IDLE_TIMEOUT,
     ) -> None:
         self.websocket = websocket
         self.serving = serving
         self._idle_timeout = idle_timeout
         self._current_session_id: str | None = None
-        self._call_count = 0
+        # Session ids seen on this connection, most-recently-used last.
+        self._seen_sessions: OrderedDict[str, None] = OrderedDict()
 
     def reset(self) -> None:
         self._current_session_id = None
-        self._call_count = 0
+        self._seen_sessions.clear()
+
+    def _mark_session_seen(self, session_id: str) -> bool:
+        """Record ``session_id``; return True when it is the first sighting.
+
+        A session's first observation is the one that carries ``reset`` to the
+        policy, so this needs per-session memory.
+        """
+        if session_id in self._seen_sessions:
+            self._seen_sessions.move_to_end(session_id)
+            return False
+
+        self._seen_sessions[session_id] = None
+        if len(self._seen_sessions) > MAX_TRACKED_SESSIONS:
+            evicted, _ = self._seen_sessions.popitem(last=False)
+            logger.debug(
+                "Robot OpenPI connection is tracking more than %d sessions; dropped least-recently-used %s",
+                MAX_TRACKED_SESSIONS,
+                evicted,
+            )
+        return True
 
     async def _send_error(self, message: str) -> None:
         await self.websocket.send_bytes(_pack({"type": "error", "message": message}))
@@ -199,18 +223,22 @@ class RobotRealtimeConnection:
             await self.websocket.send_bytes(_pack(metadata))
 
             while True:
-                try:
-                    msg = await asyncio.wait_for(
-                        self.websocket.receive(),
-                        timeout=self._idle_timeout,
-                    )
-                except asyncio.TimeoutError:
-                    logger.info("Robot OpenPI connection idle timeout after %.1f seconds", self._idle_timeout)
+                idle_timeout = self._idle_timeout
+                if idle_timeout is None:
+                    msg = await self.websocket.receive()
+                else:
                     try:
-                        await self.websocket.close()
-                    except Exception:
-                        logger.debug("Failed to close idle robot OpenPI websocket", exc_info=True)
-                    return
+                        msg = await asyncio.wait_for(
+                            self.websocket.receive(),
+                            timeout=idle_timeout,
+                        )
+                    except asyncio.TimeoutError:
+                        logger.info("Robot OpenPI connection idle timeout after %.1f seconds", idle_timeout)
+                        try:
+                            await self.websocket.close()
+                        except Exception:
+                            logger.debug("Failed to close idle robot OpenPI websocket", exc_info=True)
+                        return
 
                 if msg.get("type") == "websocket.disconnect":
                     break
@@ -245,13 +273,12 @@ class RobotRealtimeConnection:
                                     session_id,
                                 )
                             self._current_session_id = session_id
-                            self._call_count = 0
 
-                        self._call_count += 1
+                        reset = self._mark_session_seen(session_id)
                         actions = await self.serving.infer(
                             obs,
                             session_id=session_id,
-                            reset=self._call_count <= 1,
+                            reset=reset,
                         )
                         await self.websocket.send_bytes(_pack(actions))
                 except Exception:
diff --git a/vllm_omni/entrypoints/openpi/serving.py b/vllm_omni/entrypoints/openpi/serving.py
index f2448dfa1..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:
@@ -119,10 +127,32 @@ class ServingRealtimeRobotOpenPI:
     def reset(self, obs: dict) -> None:
         """Compatibility hook; per-connection state lives in RobotRealtimeConnection."""
 
+    def drop_session(self, session_id: str) -> None:
+        """Best-effort release of model-side session state for a closed rollout."""
+        drop = getattr(self.engine_client, "drop_session", None)
+        if callable(drop):
+            drop(session_id)
+            return
+        pipeline = self._pipeline()
+        for name in ("close_ar_diffusion_session", "drop_session_state"):
+            close = getattr(pipeline, name, None)
+            if callable(close):
+                close(session_id)
+                return
+
+    def _pipeline(self) -> Any:
+        engine = self.engine_client
+        for attr in ("model_runner", "runner", "diffusion_model_runner"):
+            runner = getattr(engine, attr, None)
+            pipeline = getattr(runner, "pipeline", None) if runner is not None else None
+            if pipeline is not None:
+                return pipeline
+        return getattr(engine, "pipeline", None)
+
     async def infer(self, obs: dict, *, session_id: str, reset: bool) -> ActionOutput:
         """raw obs → engine → actions."""
         # Build request, run inference through AsyncOmni
-        request = self._build_request(obs, session_id=session_id, reset=reset)
+        request = self.build_request(obs, session_id=session_id, reset=reset)
         result = None
         # OpenPI policy serving is one request -> one action reply. AsyncOmni
         # exposes an async iterator, so consume it to completion and use the
@@ -141,6 +171,10 @@ class ServingRealtimeRobotOpenPI:
     def _next_request_id(self, session_id: str) -> str:
         return f"robot-{session_id}-{next(self._request_counter)}"
 
+    def build_request(self, obs: dict, *, session_id: str, reset: bool) -> Any:
+        """Build an engine request from raw robot obs."""
+        return self._build_request(obs, session_id=session_id, reset=reset)
+
     def _build_request(self, obs: dict, *, session_id: str, reset: bool) -> Any:
         """Build engine request from raw robot obs.
 
@@ -148,22 +182,42 @@ class ServingRealtimeRobotOpenPI:
         `AsyncOmni.generate()` and routed to the diffusion stage.
         """
         from vllm_omni.diffusion.request import OmniDiffusionRequest
+        from vllm_omni.entrypoints.openai.stage_params import (
+            clone_sampling_params,
+            get_default_sampling_params_list,
+        )
         from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 
-        # An optional integer ``seed`` in the inference message becomes the engine request's
-        # ``sampling_params.seed``; omitted, ``OmniDiffusionRequest`` assigns a random one.
+        # The engine applies stage default_sampling_params only to requests
+        # that carry no explicit params; this endpoint always passes explicit
+        # params, so start from a clone of the diffusion stage's defaults
+        # (e.g. a policy deploy yaml's ``extra_args``) and layer the OpenPI
+        # protocol fields on top.
         seed = obs.pop("seed", None)
-        extra_args = {
-            "reset": reset,
-            "session_id": session_id,
-            "robot_obs": obs,
-        }
+        # 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):
+                sampling_params = clone_sampling_params(default_params)
+                break
+
+        extra_args = sampling_params.extra_args or {}
+        extra_args.update(
+            {
+                "reset": reset,
+                "session_id": session_id,
+                "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/experimental/ar_diffusion/streaming_decode.py b/vllm_omni/experimental/ar_diffusion/streaming_decode.py
new file mode 100644
index 000000000..e4316c83c
--- /dev/null
+++ b/vllm_omni/experimental/ar_diffusion/streaming_decode.py
@@ -0,0 +1,272 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Session-owned streaming VAE decode for realtime AR-Diffusion.
+
+A causal video decoder already decodes one latent frame at a time, carrying a
+bounded temporal cache between frames. What it does not do today is carry that
+cache *between calls*: every decode call clears it, so a chunk can only be
+decoded as part of a whole clip.
+
+This module moves the cache from the decoder module to the session, which is
+the entire difference between "decode a clip" and "stream a session":
+
+* the cache becomes :class:`StreamingDecodeState`, threaded in and out by the
+  caller, so two concurrent sessions cannot overwrite each other's temporal
+  context -- a failure that produces a plausible but wrong video while every
+  timing metric stays green;
+* ``first_chunk`` becomes a property of the session's first frame rather than
+  of the call, which is what makes chunk ``N + 1`` continue chunk ``N``.
+
+Resident state is bounded by construction: each causal convolution retains at
+most ``CACHE_T`` temporal slices, so the cache is a function of resolution and
+never of session length. It is not free -- see :meth:`StreamingDecodeState.nbytes`,
+which is the quantity session admission has to account for.
+
+Measured on the reference checkpoint at 832x480 in bf16, on one RTX PRO 6000
+with torch 2.11: chunking is neutral -- a session decoded in four chunks is
+bit-identical to the same session decoded in one call -- and resident decoder
+state holds at 1801 MiB across every chunk. What a session gains is structural
+rather than a speedup: a chunk becomes decodable on its own, so pixels leave on
+the block that produced them instead of after the last one, and the session's
+opening frame is expanded once rather than once per block.
+
+Note what "neutral" is measured against. ``AutoencoderKLWan._decode`` applies
+``post_quant_conv`` to the whole latent at once, while the tiled path in this
+repo -- and this decoder -- apply it per frame. It is a 1x1x1 convolution, so
+the two are mathematically identical, but they can select different kernels;
+on bf16 CUDA that seeds a 0.004 difference which the causal convolutions
+downstream amplify to 0.047. Comparing against ``_decode`` therefore measures
+where ``post_quant_conv`` runs, not anything about streaming, and the result
+moves with the torch version. The control that isolates chunking is the same
+session decoded in a single call through this same path.
+
+The consumer is the stepwise execution path: one ``generate()`` is one
+session, ``post_decode`` emits one chunk per AR block, and the pipeline holds
+one state per ``request_id``, releasing it when the runner closes or resets
+that AR session -- so decoder state and KV state share a single lifetime.
+
+Only ``torch`` is imported here so the contract can be exercised without a
+device, a checkpoint, or the distributed VAE stack.
+"""
+
+from __future__ import annotations
+
+from contextlib import AbstractContextManager, nullcontext
+from dataclasses import dataclass, field
+from typing import Any, Protocol, runtime_checkable
+
+import torch
+
+
+@dataclass
+class StreamingDecodeState:
+    """One session's temporal decoder cache.
+
+    ``feat_map`` holds one entry per causal convolution. Entries are tensors,
+    ``None`` before that convolution has run, or a non-tensor sentinel the
+    decoder uses for its first upsample step, so byte accounting must skip
+    anything that is not a tensor.
+
+    The cache has **no recompute source**: it is the compressed tail of every
+    frame decoded so far and cannot be rebuilt from the prompt or the latents.
+    Releasing it ends the stream; there is no partial eviction.
+    """
+
+    session_id: str
+    feat_map: list[Any]
+    conv_idx: list[int] = field(default_factory=lambda: [0])
+    frames_decoded: int = 0
+    chunks_decoded: int = 0
+
+    def nbytes(self) -> int:
+        """Resident bytes of the cache, skipping non-tensor entries."""
+        return sum(t.numel() * t.element_size() for t in self.feat_map if torch.is_tensor(t))
+
+    def nbytes_by_device(self) -> dict[str, int]:
+        """Resident bytes grouped by device, for admission accounting."""
+        totals: dict[str, int] = {}
+        for tensor in self.feat_map:
+            if torch.is_tensor(tensor):
+                key = str(tensor.device)
+                totals[key] = totals.get(key, 0) + tensor.numel() * tensor.element_size()
+        return totals
+
+    @property
+    def started(self) -> bool:
+        return self.frames_decoded > 0
+
+    def release(self) -> None:
+        """Drop the cache and return the session to its pre-stream state."""
+        self.feat_map = [None] * len(self.feat_map)
+        self.conv_idx = [0]
+        self.frames_decoded = 0
+        self.chunks_decoded = 0
+
+
+@runtime_checkable
+class SupportsStreamingDecode(Protocol):
+    """A decoder that can emit a session's chunks incrementally.
+
+    The lifecycle mirrors the AR session's: ``new_decode_state`` at session
+    creation, ``decode_chunk`` per committed chunk, and ``release`` on reset or
+    close, so decoder state and KV state are released together rather than
+    through two independent lifecycles.
+    """
+
+    def new_decode_state(self, session_id: str) -> StreamingDecodeState:
+        """Create empty decoder state for a new session."""
+        ...
+
+    def decode_chunk(self, latent: torch.Tensor, state: StreamingDecodeState) -> torch.Tensor:
+        """Decode one committed chunk, advancing ``state`` in place."""
+        ...
+
+    def declared_state_bytes(self, *, height: int, width: int, dtype: torch.dtype) -> int:
+        """Upper bound on resident decoder bytes per session at this shape."""
+        ...
+
+    def release(self, state: StreamingDecodeState) -> None:
+        """Drop ``state``'s cache and return it to its pre-stream state.
+
+        Declared here, not just implemented on :class:`WanStreamingDecoder`,
+        so a caller programming against this protocol -- a session runtime
+        releasing decoder state alongside KV state on close or failure -- can
+        rely on it being present without depending on the concrete class.
+        """
+        ...
+
+
+class WanStreamingDecoder:
+    """Streaming decode over a Wan-family causal autoencoder.
+
+    Wraps any module exposing ``decoder``, ``post_quant_conv`` and the cached
+    causal-convolution counts. It never touches the module's own ``_feat_map``,
+    so a module shared by several sessions stays stateless between calls.
+    """
+
+    def __init__(self, vae: Any, *, bytes_per_pixel_fp32: float | None = None) -> None:
+        for attribute in ("decoder", "post_quant_conv"):
+            if not hasattr(vae, attribute):
+                raise TypeError(f"Streaming decode requires a Wan-family autoencoder exposing {attribute!r}.")
+        self._vae = vae
+        # A one-off measured constant for this checkpoint; see declared_state_bytes.
+        # Optional at construction because most callers never need admission
+        # accounting, but a constructor argument (rather than requiring an
+        # external attribute assignment after the fact) means the value can't
+        # be silently unset for a caller that does.
+        self._bytes_per_pixel_fp32 = bytes_per_pixel_fp32
+
+    def _execution_context(self) -> AbstractContextManager[None]:
+        """The autoencoder's own execution context, when it exposes one.
+
+        Every public compute entry point on ``OmniAutoencoderKLWan`` --
+        ``encode``, ``decode``, ``decode_with_chunks``, ``tile_exec`` -- runs
+        inside ``_execution_context()``, which is where autocast is entered for
+        fp16/bf16 parameters (and on NPU is the only place
+        ``torch.npu.amp.autocast`` is entered at all). This decoder drives
+        ``post_quant_conv`` and ``decoder`` directly, so it has to enter the
+        same context or streamed chunks compute under a different numeric and
+        dispatch context from the whole-clip decode they are compared against.
+
+        A plain ``diffusers`` autoencoder has no such hook, and then there is
+        nothing to enter.
+        """
+        context = getattr(self._vae, "_execution_context", None)
+        if callable(context):
+            return context()
+        return nullcontext()
+
+    @property
+    def num_causal_convs(self) -> int:
+        counts = getattr(self._vae, "_cached_conv_counts", None)
+        if not isinstance(counts, dict) or "decoder" not in counts:
+            raise TypeError("The autoencoder does not expose cached decoder convolution counts.")
+        return int(counts["decoder"])
+
+    def new_decode_state(self, session_id: str) -> StreamingDecodeState:
+        if not isinstance(session_id, str) or not session_id.strip():
+            raise ValueError("session_id must be a non-empty string.")
+        return StreamingDecodeState(session_id=session_id, feat_map=[None] * self.num_causal_convs)
+
+    def decode_chunk(self, latent: torch.Tensor, state: StreamingDecodeState) -> torch.Tensor:
+        """Decode ``latent`` as the continuation of ``state``'s session.
+
+        ``latent`` is ``[1, C, T, H, W]`` in latent space, already rescaled by
+        the pipeline's latent statistics. Frames are decoded one at a time, the
+        same loop the non-streaming path runs, with the cache carried across
+        calls instead of cleared. The returned tensor is ``[1, 3, T', H', W']``
+        where ``T'`` is smaller for a session's first chunk: the opening latent
+        frame expands to a single raw frame and every later one to the full
+        temporal factor.
+        """
+        if latent.ndim != 5:
+            raise ValueError(f"latent must be [B, C, T, H, W]; got shape {tuple(latent.shape)}.")
+        if latent.shape[0] != 1:
+            # One state is one session's temporal context, so a batch would
+            # thread several samples through a single cache. ``decode()``
+            # handles a batch by decoding each sample with its own cleared
+            # cache (``use_slicing``); there is no equivalent here, and the
+            # streaming contract is one session per state, so refuse rather
+            # than silently mix samples.
+            raise ValueError(
+                "streaming decode takes one sample per session state; "
+                f"got batch size {latent.shape[0]}. Decode each sample through its own state."
+            )
+        if len(state.feat_map) != self.num_causal_convs:
+            raise ValueError(
+                "Decoder state does not belong to this decoder: "
+                f"{len(state.feat_map)} cache slots against {self.num_causal_convs} causal convolutions."
+            )
+        num_frames = int(latent.shape[2])
+        if num_frames == 0:
+            raise ValueError("latent must carry at least one frame.")
+
+        decoded_frames = []
+        with self._execution_context():
+            for index in range(num_frames):
+                state.conv_idx[0] = 0
+                frame = self._vae.post_quant_conv(latent[:, :, index : index + 1])
+                # first_chunk marks the session's opening frame, not the call's:
+                # that is what makes chunk N + 1 continue chunk N rather than
+                # restart the causal expansion.
+                decoded_frames.append(
+                    self._vae.decoder(
+                        frame,
+                        feat_cache=state.feat_map,
+                        feat_idx=state.conv_idx,
+                        first_chunk=(state.frames_decoded == 0),
+                    )
+                )
+                state.frames_decoded += 1
+
+        out = torch.cat(decoded_frames, dim=2)
+        patch_size = getattr(getattr(self._vae, "config", None), "patch_size", None)
+        if patch_size is not None:
+            from diffusers.models.autoencoders.autoencoder_kl_wan import unpatchify
+
+            out = unpatchify(out, patch_size=patch_size)
+        out = torch.clamp(out, min=-1.0, max=1.0)
+        state.chunks_decoded += 1
+        return out
+
+    def release(self, state: StreamingDecodeState) -> None:
+        state.release()
+
+    def declared_state_bytes(self, *, height: int, width: int, dtype: torch.dtype) -> int:
+        """Resident decoder bytes per session at this output shape.
+
+        Every cached tensor is ``[B, C_l, <= CACHE_T, H_l, W_l]`` with ``H_l``
+        and ``W_l`` fixed fractions of the output, so the total scales exactly
+        with ``height * width``. Callers that need the constant should measure
+        it once for their checkpoint and pass it as ``bytes_per_pixel_fp32`` to
+        the constructor; this helper scales that measured constant so admission
+        does not have to re-measure per resolution.
+        """
+        constant = self._bytes_per_pixel_fp32
+        if constant is None:
+            raise RuntimeError(
+                "declared_state_bytes needs a measured bytes-per-pixel constant for this checkpoint; "
+                "pass bytes_per_pixel_fp32= to WanStreamingDecoder() from a one-off measurement."
+            )
+        element_ratio = torch.empty((), dtype=dtype).element_size() / 4
+        return int(constant * height * width * element_ratio)
diff --git a/vllm_omni/experimental/fullduplex/README.md b/vllm_omni/experimental/fullduplex/README.md
index b6c918fd6..b710924f1 100644
--- a/vllm_omni/experimental/fullduplex/README.md
+++ b/vllm_omni/experimental/fullduplex/README.md
@@ -16,16 +16,20 @@ video_stacking.py  camera-frame tiling for omni duplex video input
 To run JoyVL, see
 [`recipes/JD/JoyAI-VL-Interaction.md`](../../../recipes/JD/JoyAI-VL-Interaction.md).
 
-The MiniCPM-o 4.5 and PersonaPlex native full-duplex runtimes graduated out
-of this package. They now live in the stable tree:
+The native full-duplex runtimes graduated out of this package. They now live
+in the stable tree, where sessions are engine-resident (RFC
+[vllm-omni#7181](https://github.com/vllm-project/vllm-omni/issues/7181)):
 
 ```text
-vllm_omni/engine/duplex/                       engine control plane, sessions, leases
-vllm_omni/entrypoints/duplex/           WebSocket serving and Realtime projection
-vllm_omni/entrypoints/duplex_request_client.py request/output lifecycle
-vllm_omni/model_executor/models/minicpmo_4_5/duplex/  MiniCPM adapter
-vllm_omni/model_executor/models/personaplex/duplex/   PersonaPlex adapter
-vllm_omni/model_executor/models/nemotron_voicechat/duplex/  Nemotron VoiceChat adapter
+vllm_omni/engine/duplex/                       sessions, manager, runner, leases, typed contract
+vllm_omni/engine/duplex_omni_engine.py         DuplexOmniEngine (session message surface)
+vllm_omni/engine/duplex_orchestrator.py        DuplexOrchestrator (hosts the session manager)
+vllm_omni/entrypoints/duplex_omni.py           DuplexOmni + DuplexSessionHandle (Python API)
+vllm_omni/entrypoints/duplex/                  WebSocket transport (attachments, resume, replay)
+vllm_omni/clients/duplex.py                    DuplexClient / DuplexClientBase
+vllm_omni/model_executor/models/minicpmo_4_5/duplex/  MiniCPM-o 4.5 DuplexModelPlugin
+vllm_omni/model_executor/models/personaplex/duplex/   PersonaPlex (pre-framework, not ported yet)
+vllm_omni/model_executor/models/nemotron_voicechat/duplex/  Nemotron VoiceChat (pre-framework, not ported yet)
 vllm_omni/model_executor/duplex_sampling.py    AR-runner sampling hook helper
 vllm_omni/outputs/duplex.py                    typed output decision envelope
 ```
@@ -51,6 +55,9 @@ only model policy.
 3. Promote a helper from a model package up into `core/` only once a second
    model actually needs it.
 
-For production serving, prefer the stable plugin seams instead
-(`duplex_serving_adapter` / `duplex_runtime_extension` dotted strings in the
-model's `pipeline.py`), as MiniCPM-o 4.5 and PersonaPlex do.
+For production serving, prefer the stable plugin seam instead: implement one
+`vllm_omni.engine.duplex.plugin.DuplexModelPlugin` and name it in the model's
+`pipeline.py` as `duplex_plugin`, as MiniCPM-o 4.5 does. PersonaPlex and
+Nemotron VoiceChat still carry their pre-framework duplex code and are ported
+to the plugin contract in follow-up PRs. The contract is documented in
+[`docs/design/fullduplex.md`](../../../docs/design/fullduplex.md).
diff --git a/vllm_omni/experimental/fullduplex/client.py b/vllm_omni/experimental/fullduplex/client.py
index 252fc92df..45cdde482 100644
--- a/vllm_omni/experimental/fullduplex/client.py
+++ b/vllm_omni/experimental/fullduplex/client.py
@@ -234,7 +234,7 @@ class RealtimeEventCollector:
         event_type = stored_event.get("type")
         if event_type == "response.created" and response_id and response_id not in self.response_ids:
             self.response_ids.append(response_id)
-        if event_type == "response.audio.delta":
+        if event_type == "response.output_audio.delta":
             delta = stored_event.get("delta") or stored_event.get("audio")
             if isinstance(delta, str) and response_id:
                 try:
@@ -263,7 +263,7 @@ class RealtimeEventCollector:
             if self.response_id(event) == response_id
             and event.get("type")
             in {
-                "response.audio_transcript.delta",
+                "response.output_audio_transcript.delta",
                 "response.output_text.delta",
                 "response.text.delta",
             }
@@ -322,7 +322,7 @@ class RealtimeEventCollector:
             if (
                 event.get("type")
                 in {
-                    "response.audio_transcript.delta",
+                    "response.output_audio_transcript.delta",
                     "response.output_text.delta",
                     "response.text.delta",
                 }
@@ -337,7 +337,7 @@ class RealtimeEventCollector:
             if isinstance(stage0, dict):
                 stage0_metrics = stage0
 
-            if event.get("type") != "response.audio.delta" or (
+            if event.get("type") != "response.output_audio.delta" or (
                 response_id is not None and event_response_id != response_id
             ):
                 continue
diff --git a/vllm_omni/host_weight_runtime/filesystem/store.py b/vllm_omni/host_weight_runtime/filesystem/store.py
index 2b58b77e8..1542adefc 100644
--- a/vllm_omni/host_weight_runtime/filesystem/store.py
+++ b/vllm_omni/host_weight_runtime/filesystem/store.py
@@ -12,6 +12,7 @@ import logging
 import os
 import shutil
 import stat
+import tempfile
 import time
 import uuid
 from collections import defaultdict
@@ -23,7 +24,7 @@ import regex as re
 import torch
 from safetensors import SafetensorError, safe_open
 
-from ..config import CapacityPolicy, IntegrityPolicy, StorageClass, StorageDomainPolicy, ValidationLevel
+from ..config import CapacityPolicy, IntegrityPolicy, StorageClass, StorageDomainPolicy, ValidationLevel, WaitPolicy
 from ..errors import FailureCode, HostWeightError, HostWeightFailure, ResolutionStage
 from ..identity import CanonicalJson, WeightArtifactIdentity, canonical_json
 from ..inspection import (
@@ -298,25 +299,27 @@ def _move_artifact_locked(source: Path, destination: Path) -> None:
 
 def _write_atomic_json(path: Path, value: object, *, mode: int = 0o444) -> None:
     data = canonical_json(value)
-    temporary = path.parent / f".{path.name}.{os.getpid()}.{uuid.uuid4().hex}.tmp"
-    fd = os.open(temporary, os.O_CREAT | os.O_EXCL | os.O_WRONLY | os.O_CLOEXEC, 0o600)
+    handle = tempfile.NamedTemporaryFile(dir=path.parent, prefix=f".{path.name}.", suffix=".tmp", delete=False)
+    temporary = Path(handle.name)
+    write_error: BaseException | None = None
     try:
-        offset = 0
-        while offset < len(data):
-            count = os.write(fd, data[offset:])
-            if count <= 0:
-                raise OSError(errno.EIO, f"short write for {temporary}")
-            offset += count
-        os.fsync(fd)
-        os.fchmod(fd, mode)
-        os.fsync(fd)
+        with handle:
+            try:
+                handle.write(data)
+                handle.flush()
+                os.fsync(handle.fileno())
+                os.fchmod(handle.fileno(), mode)
+                os.fsync(handle.fileno())
+            except BaseException as error:
+                write_error = error
+                raise
+        os.replace(temporary, path)
     except BaseException:
-        os.close(fd)
-        temporary.unlink(missing_ok=True)
+        with contextlib.suppress(OSError):
+            temporary.unlink(missing_ok=True)
+        if write_error is not None:
+            raise write_error
         raise
-    else:
-        os.close(fd)
-    os.replace(temporary, path)
     _fsync_directory(path.parent)
 
 
@@ -429,6 +432,8 @@ class FilesystemHostWeightStore:
         domain: StorageDomainPolicy,
         capacity: CapacityPolicy,
         integrity: IntegrityPolicy,
+        *,
+        wait: WaitPolicy = WaitPolicy(),
     ) -> None:
         self.domain_policy = domain
         self.capacity_policy = capacity
@@ -464,7 +469,7 @@ class FilesystemHostWeightStore:
                 )
             )
         try:
-            self._initialize_domain()
+            self._initialize_domain(deadline=time.monotonic() + wait.coordination_timeout_seconds)
         except HostWeightError:
             raise
         except OSError as exc:
@@ -485,7 +490,7 @@ class FilesystemHostWeightStore:
                 )
             ) from exc
 
-    def _initialize_domain(self) -> None:
+    def _initialize_domain(self, *, deadline: float) -> None:
         try:
             self.filesystem_type = detect_filesystem_type(self.root)
             detected_storage_class = _storage_class_for_filesystem_type(self.filesystem_type)
@@ -545,7 +550,7 @@ class FilesystemHostWeightStore:
                         )
                     )
 
-        with FileLock(self.locks_dir / "domain-init.lock", exclusive=True, deadline=None):
+        with FileLock(self.locks_dir / "domain-init.lock", exclusive=True, deadline=deadline):
             domain_path = self.root / _DOMAIN_FILE
             if domain_path.exists():
                 domain_metadata = _read_json_file(domain_path)
diff --git a/vllm_omni/host_weight_runtime/runtime.py b/vllm_omni/host_weight_runtime/runtime.py
index fbc726669..17ababce9 100644
--- a/vllm_omni/host_weight_runtime/runtime.py
+++ b/vllm_omni/host_weight_runtime/runtime.py
@@ -70,7 +70,7 @@ class HostWeightRuntime:
         from .filesystem import FilesystemHostWeightStore  # noqa: PLC0415
 
         try:
-            store = FilesystemHostWeightStore(config.domain, config.capacity, config.integrity)
+            store = FilesystemHostWeightStore(config.domain, config.capacity, config.integrity, wait=config.wait)
         except HostWeightError as exc:
             return cls(
                 config,
diff --git a/vllm_omni/inputs/data.py b/vllm_omni/inputs/data.py
index f9f0a9a9a..287ddb3fb 100644
--- a/vllm_omni/inputs/data.py
+++ b/vllm_omni/inputs/data.py
@@ -349,6 +349,11 @@ class OmniDiffusionSamplingParams:
     # results
     output: torch.Tensor | None = None
 
+    # Internal control-plane event used by asynchronous APIs. When enabled,
+    # the diffusion engine emits a non-terminal output when the scheduler
+    # first admits this request for execution.
+    emit_request_lifecycle: bool = False
+
     def __post_init__(self) -> None:
         if self.quality is not None and self.quality not in DIFFUSION_QUALITY_LEVELS:
             raise ValueError(f"quality must be one of {list(DIFFUSION_QUALITY_LEVELS)}, got {self.quality!r}")
diff --git a/vllm_omni/metrics/definitions.py b/vllm_omni/metrics/definitions.py
index 6cc2825c1..a09fbcc2f 100644
--- a/vllm_omni/metrics/definitions.py
+++ b/vllm_omni/metrics/definitions.py
@@ -160,6 +160,8 @@ AUDIO_FRAMES_METRIC = METRIC_PREFIX + AUDIO_FRAMES
 AUDIO_UNDERRUN_S = METRIC_PREFIX + AUDIO_UNDERRUN + "_s"
 AUDIO_CONTINUITY_OK_METRIC = METRIC_PREFIX + AUDIO_CONTINUITY_OK
 AUDIO_SKIPPED_REQUESTS_METRIC = METRIC_PREFIX + AUDIO_SKIPPED_REQUESTS
+SPEECH_STREAM_ABORTED_METRIC = METRIC_PREFIX + "speech_stream_aborted"
+SPEECH_STREAM_COMPLETED_METRIC = METRIC_PREFIX + "speech_stream_completed"
 
 # Realtime Server VAD serving metrics.
 REALTIME_VAD_ACTIVE_SESSIONS = METRIC_PREFIX + "realtime_vad_active_sessions"
diff --git a/vllm_omni/metrics/modality.py b/vllm_omni/metrics/modality.py
index e0d51e2b0..bb7842e36 100644
--- a/vllm_omni/metrics/modality.py
+++ b/vllm_omni/metrics/modality.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 """OmniModalityMetrics — per-modality Prometheus families (audio path only).
 
 7 audio business-semantic metric families. Text-path metrics (TTFT / ITL /
@@ -76,6 +79,16 @@ _audio_skipped_family = Counter(
     "Silent-loss counter — code2wav rejected malformed codec input and returned 200 OK with empty audio.",
     labelnames=list(defs.AUDIO_SKIPPED_LABELS),
 )
+_speech_stream_aborted_family = Counter(
+    defs.SPEECH_STREAM_ABORTED_METRIC,
+    "Speech audio generators terminated before normal completion, including before the first PCM payload.",
+    labelnames=["model_name", "reason"],
+)
+_speech_stream_completed_family = Counter(
+    defs.SPEECH_STREAM_COMPLETED_METRIC,
+    "Speech audio generators that completed normally; does not confirm client receipt.",
+    labelnames=["model_name"],
+)
 
 
 # ----------------------------------------------------------------------------
@@ -153,6 +166,17 @@ class OmniModalityMetrics:
 
     # ---- Audio ------------------------------------------------------------
 
+    def inc_speech_stream_aborted(self, reason: str) -> None:
+        if not self._log_stats:
+            return
+        if reason not in {"cancelled", "closed", "engine_dead", "error"}:
+            reason = "error"
+        _speech_stream_aborted_family.labels(model_name=self._model_name, reason=reason).inc()
+
+    def inc_speech_stream_completed(self) -> None:
+        if self._log_stats:
+            _speech_stream_completed_family.labels(model_name=self._model_name).inc()
+
     def observe_audio_ttfp(self, stage: str, replica: str, ttfp_seconds: float) -> None:
         if not self._log_stats:
             return
@@ -335,6 +359,7 @@ def observe_audio_streaming_finalize(
     chunk_arrival_times_s: list[float],
     chunk_bytes: list[int],
     sample_rate: int,
+    channels: int = defs.DEFAULT_AUDIO_CHANNELS,
     threshold_s: float = defs.AUDIO_CONTINUITY_DEFAULT_THRESHOLD_S,
 ) -> None:
     """Emit audio_underrun_s + audio_continuity_ok_total at request end.
@@ -353,6 +378,7 @@ def observe_audio_streaming_finalize(
         chunk_arrival_times_s=chunk_arrival_times_s,
         chunk_bytes=chunk_bytes,
         sample_rate=sample_rate,
+        channels=channels,
         threshold_s=threshold_s,
     )
     stage_label = str(stage_id)
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/duplex_sampling.py b/vllm_omni/model_executor/duplex_sampling.py
index 7dbc185d1..dd48431f6 100644
--- a/vllm_omni/model_executor/duplex_sampling.py
+++ b/vllm_omni/model_executor/duplex_sampling.py
@@ -19,7 +19,6 @@ class DuplexSamplingRow:
     row_idx: int
     request_id: str
     session_id: str | None
-    incarnation: int
     seq: int | None
     payload: dict[str, object] | None
     max_tokens: int | None
@@ -73,10 +72,6 @@ class DuplexSamplingHelper:
             session_id = duplex.get("session_id")
             if not isinstance(session_id, str) or not session_id:
                 session_id = None
-            try:
-                incarnation = int(duplex.get("incarnation", 0))
-            except (TypeError, ValueError):
-                incarnation = 0
             try:
                 seq = int(duplex.get("seq"))
             except (TypeError, ValueError):
@@ -95,7 +90,6 @@ class DuplexSamplingHelper:
                     row_idx=row_idx,
                     request_id=req_id,
                     session_id=session_id,
-                    incarnation=incarnation,
                     seq=seq,
                     payload=payload,
                     max_tokens=max_tokens if max_tokens > 0 else None,
diff --git a/vllm_omni/model_executor/models/auk/__init__.py b/vllm_omni/model_executor/models/auk/__init__.py
new file mode 100644
index 000000000..d77d6a64d
--- /dev/null
+++ b/vllm_omni/model_executor/models/auk/__init__.py
@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+from vllm_omni.model_executor.models.auk.auk import AuKForConditionalGeneration
+
+__all__ = ["AuKForConditionalGeneration"]
diff --git a/vllm_omni/model_executor/models/auk/auk.py b/vllm_omni/model_executor/models/auk/auk.py
new file mode 100644
index 000000000..ebb20711d
--- /dev/null
+++ b/vllm_omni/model_executor/models/auk/auk.py
@@ -0,0 +1,304 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""AuK (Tencent): instruction-driven speech generation and editing.
+
+Stage 0 (``model_stage="encoder"``) runs the frozen Qwen2.5-Omni thinker as a
+prefill-only encoder. The outputs of all decoder layers are fused with learned
+softmax weights into one ``[tokens, hidden]`` text condition, emitted through
+``multimodal_outputs["hidden_states"]["output"]`` for the diffusion stage
+(``vllm_omni/diffusion/models/auk``). The stage samples exactly one token
+(``max_tokens=1``, forced to EOS); that token is discarded downstream.
+"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Iterable, Mapping
+from functools import cached_property
+from itertools import islice
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from safetensors import safe_open
+from transformers import PretrainedConfig
+from vllm.config import VllmConfig
+from vllm.logger import init_logger
+from vllm.model_executor.models.interfaces import SupportsMRoPE, SupportsMultiModal, SupportsPP
+from vllm.model_executor.models.utils import init_vllm_registered_model, maybe_prefix
+from vllm.multimodal import MULTIMODAL_REGISTRY
+from vllm.multimodal.inputs import MultiModalFeatureSpec
+from vllm.sequence import IntermediateTensors
+from vllm.v1.sample.sampler import Sampler
+
+from vllm_omni.model_executor.models.output_templates import OmniOutput
+from vllm_omni.model_executor.models.qwen2_5_omni.qwen2_5_omni import Qwen2_5OmniForConditionalGeneration
+from vllm_omni.model_executor.models.qwen2_5_omni.qwen2_5_omni_thinker import (
+    Qwen2_5OmniThinkerDummyInputsBuilder,
+    Qwen2_5OmniThinkerForConditionalGeneration,
+    Qwen2_5OmniThinkerMultiModalProcessor,
+    Qwen2_5OmniThinkerProcessingInfo,
+)
+from vllm_omni.model_executor.models.utils import add_prefix_to_loaded_weights
+
+logger = init_logger(__name__)
+
+# File next to the thinker shards in the assembled checkpoint directory that
+# carries the DiT (``transformer.*``) and the two layer-fusion tensors.
+AUK_WEIGHTS_FILE = "auk.safetensors"
+LAYER_WEIGHTS_KEY = "layer_weights"
+LAYER_SCALE_KEY = "layer_scale"
+# The fused text condition travels as ``multimodal_outputs["hidden_states"]["output"]``
+# (``HiddenStatesStruct.output``), the same stage-wire slot MiniMax H3 uses.
+TEXT_COND_KEY = "output"
+# ``F.layer_norm`` epsilon used by the upstream fusion (torch default).
+_FUSION_LN_EPS = 1e-5
+
+
+class AuKProcessingInfo(Qwen2_5OmniThinkerProcessingInfo):
+    """Qwen2.5-Omni thinker processing restricted to AuK's single audio input.
+
+    AuK conditions on text plus at most one reference or source clip; images
+    and video are not part of its contract, so they are not advertised (and the
+    thinker then builds no vision tower).
+    """
+
+    def get_supported_mm_limits(self) -> Mapping[str, int | None]:
+        return {"audio": 1}
+
+
+@MULTIMODAL_REGISTRY.register_processor(
+    Qwen2_5OmniThinkerMultiModalProcessor,
+    info=AuKProcessingInfo,
+    dummy_inputs=Qwen2_5OmniThinkerDummyInputsBuilder,
+)
+class AuKForConditionalGeneration(nn.Module, SupportsMultiModal, SupportsPP, SupportsMRoPE):
+    """Encoder stage of AuK: Qwen2.5-Omni thinker with learned layer fusion.
+
+    The forward pass re-implements the thinker language model's layer loop so
+    the per-layer outputs can be fused on the fly: vLLM's decoder layers carry
+    the residual stream separately, and ``hidden + residual`` after layer ``i``
+    is the HF ``output_hidden_states[i + 1]`` entry, while the last entry is
+    the final-normed state. Only one accumulator lives at a time.
+    """
+
+    have_multimodal_outputs = True
+    # The fused condition is the payload; the runner's default last-hidden
+    # copy and prefix-cached hidden states are not needed (MiniMax H3 pattern).
+    omni_pooler_payload_include_hidden = False
+    requires_full_prefix_cached_hidden_states = False
+
+    def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):
+        super().__init__()
+        self.has_preprocess = False
+        self.vllm_config = vllm_config
+        config = vllm_config.model_config.hf_config
+
+        self.model_stage = getattr(vllm_config.model_config, "model_stage", None) or "encoder"
+        if self.model_stage != "encoder":
+            raise ValueError(
+                f"AuKForConditionalGeneration only hosts the 'encoder' stage, got model_stage={self.model_stage!r}; "
+                "the DiT stage is the AuKPipeline diffusion model."
+            )
+
+        thinker_config = config.thinker_config
+        self.thinker_config = thinker_config
+        self.thinker = init_vllm_registered_model(
+            vllm_config=vllm_config,
+            prefix=maybe_prefix(prefix, "thinker"),
+            hf_config=thinker_config,
+            architectures=["Qwen2_5OmniThinkerModel"],
+        )
+        # The audio-only mm limits keep the thinker from building its vision
+        # tower; drop it explicitly as well, as the upstream implementation does,
+        # so no vision weights are loaded or resident.
+        if getattr(self.thinker, "visual", None) is not None:
+            del self.thinker.visual
+            self.thinker.visual = None
+        self.model = self.thinker
+        self.make_empty_intermediate_tensors = self.thinker.make_empty_intermediate_tensors
+
+        num_layers = thinker_config.text_config.num_hidden_layers
+        # Filled by load_weights() from AUK_WEIGHTS_FILE; buffers so the vLLM
+        # loader does not expect them among the thinker shards.
+        self.register_buffer("layer_weights", torch.zeros(num_layers, dtype=torch.float32))
+        self.register_buffer("layer_scale", torch.ones(1, dtype=torch.float32))
+        self._fusion_loaded = False
+
+    # -------------------- delegations to the thinker --------------------
+
+    @classmethod
+    def get_placeholder_str(cls, modality: str, i: int) -> str | None:
+        return Qwen2_5OmniThinkerForConditionalGeneration.get_placeholder_str(modality, i)
+
+    def get_language_model(self) -> nn.Module:
+        return self.thinker.get_language_model()
+
+    @cached_property
+    def sampler(self):
+        if hasattr(self.thinker, "sampler"):
+            return self.thinker.sampler
+        return Sampler()
+
+    def embed_input_ids(
+        self,
+        input_ids: torch.Tensor,
+        multimodal_embeddings=None,
+        is_multimodal=None,
+    ) -> torch.Tensor:
+        return self.thinker.embed_input_ids(
+            input_ids=input_ids,
+            multimodal_embeddings=multimodal_embeddings,
+            is_multimodal=is_multimodal,
+        )
+
+    def embed_multimodal(self, **kwargs):
+        return self.thinker.embed_multimodal(**kwargs)
+
+    def get_mrope_input_positions(
+        self,
+        input_tokens: list[int],
+        mm_features: list[MultiModalFeatureSpec] | None = None,
+        *,
+        hf_config: PretrainedConfig,
+        image_grid_thw: list[list[int]] | torch.Tensor,
+        video_grid_thw: list[list[int]] | torch.Tensor,
+        second_per_grid_ts: list[float] | None = None,
+        context_len: int = 0,
+        seq_len: int | None = None,
+        audio_feature_lengths: torch.Tensor | None = None,
+        use_audio_in_video: bool = False,
+    ) -> tuple[torch.Tensor, int]:
+        # The omni runner filters kwargs by this signature (the extended
+        # Qwen2.5-Omni form); the unified Qwen2.5-Omni class implements the
+        # audio-aware position math without touching instance state.
+        return Qwen2_5OmniForConditionalGeneration.get_mrope_input_positions(
+            self,
+            input_tokens,
+            mm_features,
+            hf_config=hf_config,
+            image_grid_thw=image_grid_thw,
+            video_grid_thw=video_grid_thw,
+            second_per_grid_ts=second_per_grid_ts,
+            context_len=context_len,
+            seq_len=seq_len,
+            audio_feature_lengths=audio_feature_lengths,
+            use_audio_in_video=use_audio_in_video,
+        )
+
+    def compute_logits(self, hidden_states: torch.Tensor | OmniOutput, **kwargs: object) -> torch.Tensor | None:
+        """Emit EOS immediately; the useful result is the prefill text condition."""
+        if isinstance(hidden_states, OmniOutput):
+            hidden_states = hidden_states.text_hidden_states
+        text_config = self.thinker_config.text_config
+        logits = hidden_states.new_full(
+            (hidden_states.shape[0], int(text_config.vocab_size)),
+            torch.finfo(hidden_states.dtype).min,
+        )
+        logits[:, self._eos_token_id()] = 0
+        return logits
+
+    def _eos_token_id(self) -> int:
+        for cfg in (self.thinker_config.text_config, self.thinker_config, self.vllm_config.model_config.hf_config):
+            eos = getattr(cfg, "eos_token_id", None)
+            if isinstance(eos, (list, tuple)) and eos:
+                eos = eos[0]
+            if isinstance(eos, int):
+                return eos
+        # Qwen2.5-Omni tokenizers end turns with <|im_end|>.
+        return 151645
+
+    # -------------------- forward --------------------
+
+    def forward(
+        self,
+        input_ids: torch.Tensor,
+        positions: torch.Tensor,
+        intermediate_tensors: IntermediateTensors | None = None,
+        inputs_embeds: torch.Tensor | None = None,
+        **kwargs: object,
+    ) -> OmniOutput:
+        if intermediate_tensors is not None:
+            raise NotImplementedError("AuK encoder does not support pipeline parallelism")
+        language_model = self.thinker.language_model.model
+        num_layers = len(language_model.layers)
+        if language_model.start_layer != 0 or language_model.end_layer != num_layers:
+            raise NotImplementedError("AuK encoder needs all decoder layers on one rank")
+
+        if inputs_embeds is None:
+            hidden_states = language_model.embed_input_ids(input_ids)
+        else:
+            hidden_states = inputs_embeds
+        residual: torch.Tensor | None = None
+
+        weights = torch.softmax(self.layer_weights, dim=0)
+        fused: torch.Tensor | None = None
+        normed_shape = (hidden_states.shape[-1],)
+        layers = islice(language_model.layers, language_model.start_layer, language_model.end_layer)
+        for idx, layer in enumerate(layers):
+            hidden_states, residual = layer(positions, hidden_states, residual)
+            if idx + 1 < num_layers:
+                layer_output = hidden_states + residual
+            else:
+                # HF's last hidden_states entry is post final norm.
+                hidden_states, _ = language_model.norm(hidden_states, residual)
+                layer_output = hidden_states
+            normed = F.layer_norm(layer_output.float(), normed_shape, eps=_FUSION_LN_EPS)
+            contribution = normed * weights[idx]
+            fused = contribution if fused is None else fused + contribution
+
+        assert fused is not None
+        text_cond = (fused * self.layer_scale).to(hidden_states.dtype)
+        # Stage-wire layout: [tokens, features] under hidden_states.output so
+        # the runner slices it per request (and concatenates across chunked
+        # prefill steps); the stage-1 processor reads the same path.
+        return OmniOutput(
+            text_hidden_states=hidden_states,
+            multimodal_outputs={"hidden_states": {"output": text_cond}},
+        )
+
+    # -------------------- weights --------------------
+
+    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
+        thinker_weights: list[tuple[str, torch.Tensor]] = []
+        skipped = 0
+        for name, tensor in weights:
+            if name.startswith("thinker."):
+                thinker_weights.append((name, tensor))
+            elif name.startswith(("talker.", "token2wav.", "transformer.")):
+                skipped += 1
+            else:
+                logger.warning("AuK encoder: ignoring unexpected weight %s", name)
+        if skipped:
+            logger.debug("AuK encoder: skipped %d non-thinker weights", skipped)
+
+        loaded = self.thinker.load_weights(thinker_weights)
+        loaded = add_prefix_to_loaded_weights(loaded, "thinker")
+        self._load_fusion_params()
+        return loaded
+
+    def _load_fusion_params(self) -> None:
+        model_dir = self.vllm_config.model_config.model
+        path = os.path.join(model_dir, AUK_WEIGHTS_FILE)
+        if not os.path.isfile(path):
+            raise FileNotFoundError(
+                f"AuK encoder: {AUK_WEIGHTS_FILE} not found in {model_dir!r}; assemble the checkpoint with "
+                "tools/prepare_auk_checkpoint.py"
+            )
+        with safe_open(path, framework="pt", device="cpu") as f:
+            layer_weights = f.get_tensor(LAYER_WEIGHTS_KEY).float()
+            layer_scale = f.get_tensor(LAYER_SCALE_KEY).float().reshape(1)
+        if layer_weights.shape != self.layer_weights.shape:
+            raise ValueError(
+                f"AuK encoder: {LAYER_WEIGHTS_KEY} has {tuple(layer_weights.shape)} entries, "
+                f"thinker has {tuple(self.layer_weights.shape)} layers"
+            )
+        self.layer_weights.copy_(layer_weights.to(self.layer_weights.device))
+        self.layer_scale.copy_(layer_scale.to(self.layer_scale.device))
+        self._fusion_loaded = True
+        logger.info(
+            "AuK encoder: loaded layer fusion (scale %.3f, top layer weight %.3f at layer %d)",
+            float(layer_scale[0]),
+            float(torch.softmax(layer_weights, 0).max()),
+            int(torch.softmax(layer_weights, 0).argmax()) + 1,
+        )
diff --git a/vllm_omni/model_executor/models/auk/pipeline.py b/vllm_omni/model_executor/models/auk/pipeline.py
new file mode 100644
index 000000000..8b9d6855b
--- /dev/null
+++ b/vllm_omni/model_executor/models/auk/pipeline.py
@@ -0,0 +1,60 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""AuK pipeline topology (frozen).
+
+Stage 0: Encoder — frozen Qwen2.5-Omni thinker, prefill only, emits the
+         learned layer fusion as ``multimodal_outputs["hidden_states"]["output"]``
+Stage 1: DiT     — rectified-flow transformer plus the BigVGAN-flow VAE,
+         emits a 24 kHz waveform
+"""
+
+from vllm_omni.config.stage_config import (
+    PipelineConfig,
+    StageExecutionType,
+    StagePipelineConfig,
+)
+
+_PROC = "vllm_omni.model_executor.stage_input_processors.auk"
+
+AUK_PIPELINE = PipelineConfig(
+    model_type="auk",
+    default_deploy_config_name="auk.yaml",
+    model_arch="AuKForConditionalGeneration",
+    hf_architectures=("AuKForConditionalGeneration",),
+    stages=(
+        StagePipelineConfig(
+            stage_id=0,
+            model_stage="encoder",
+            execution_type=StageExecutionType.LLM_AR,
+            input_sources=(),
+            final_output=False,
+            owns_tokenizer=True,
+            requires_multimodal_data=True,
+            hf_config_name="thinker_config",
+            engine_output_type="latent",
+            model_arch="AuKForConditionalGeneration",
+            # No model_subdir: tools/prepare_auk_checkpoint.py assembles one
+            # flat directory, so the encoder finds the thinker shards, the
+            # tokenizer, the audio processor and the layer-fusion tensors in
+            # auk.safetensors all under the pipeline root.
+            # One prefill step produces the text condition; the sampled token
+            # is discarded, and detokenizing it would only cost latency.
+            sampling_constraints={"max_tokens": 1, "temperature": 0.0, "detokenize": False},
+        ),
+        StagePipelineConfig(
+            stage_id=1,
+            model_stage="dit",
+            execution_type=StageExecutionType.DIFFUSION,
+            input_sources=(0,),
+            requires_multimodal_data=True,
+            final_output=True,
+            final_output_type="audio",
+            model_arch="AuKPipeline",
+            custom_process_input_func=f"{_PROC}.encoder2dit",
+            omni_kv_config={"need_recv_cache": False},
+            # Single replica, and the whole ODE runs inside one forward, so
+            # the stage stays in the orchestrator process.
+            inline_diffusion=True,
+        ),
+    ),
+)
diff --git a/vllm_omni/model_executor/models/breeze_tts_2/__init__.py b/vllm_omni/model_executor/models/breeze_tts_2/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/vllm_omni/model_executor/models/breeze_tts_2/audio_tokenizer.py b/vllm_omni/model_executor/models/breeze_tts_2/audio_tokenizer.py
new file mode 100644
index 000000000..ea2796a53
--- /dev/null
+++ b/vllm_omni/model_executor/models/breeze_tts_2/audio_tokenizer.py
@@ -0,0 +1,149 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Reference-audio encoding helpers for Breeze-TTS-2.
+
+The Breeze prompt uses a Qwen3-TTS tokenizer only for reference audio.  This
+module deliberately does not contain text tokenization or waveform decoding;
+the latter belongs to the pipeline's codec stage.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import torch
+
+
+def resolve_audio_tokenizer_path(model_path: str) -> Path | None:
+    """Resolve the bundled ``audio_tokenizer`` dir for a local path or HF repo id.
+
+    Local directories (dev checkouts) resolve directly: present returns the
+    subdirectory, absent returns ``None`` so callers can fall back.  Repo ids
+    resolve through the vLLM-tagged HF helpers: an already-complete cached
+    snapshot is preferred (offline deployments keep working), and a partial
+    cache falls through to a targeted online fetch restricted to the bundled
+    tokenizer subtree.  Returns ``None`` when the checkpoint carries no
+    ``audio_tokenizer`` subdirectory.
+    """
+    root = Path(model_path)
+    if root.is_dir():
+        bundled = root / "audio_tokenizer"
+        return bundled if bundled.is_dir() else None
+
+    from vllm.transformers_utils.repo_utils import hf_api
+
+    kwargs: dict[str, object] = {"allow_patterns": ["audio_tokenizer/*"]}
+    try:
+        cached = Path(hf_api().snapshot_download(model_path, local_files_only=True, **kwargs))
+    except Exception:
+        cached = None
+    if cached is not None and (cached / "audio_tokenizer").is_dir():
+        return cached / "audio_tokenizer"
+    online = Path(hf_api().snapshot_download(model_path, **kwargs))
+    bundled = online / "audio_tokenizer"
+    return bundled if bundled.is_dir() else None
+
+
+class BreezeReferenceAudioTokenizer:
+    """Small adapter that normalizes Qwen3-TTS encoder output to ``(T, Q)``.
+
+    The underlying tokenizer is created once per serving worker and is reused
+    for all requests.  Keeping this wrapper independent from the
+    prompt builder makes it straightforward to inject a fake encoder in tests
+    and to replace the upstream Qwen3 implementation later.
+    """
+
+    def __init__(self, tokenizer: Any, *, num_codebooks: int = 16, codebook_size: int = 2048) -> None:
+        self.tokenizer = tokenizer
+        self.num_codebooks = int(num_codebooks)
+        self.codebook_size = int(codebook_size)
+        if self.num_codebooks <= 0 or self.codebook_size <= 0:
+            raise ValueError("num_codebooks and codebook_size must be positive")
+
+    @classmethod
+    def from_pretrained(
+        cls,
+        model_path: str,
+        *,
+        num_codebooks: int = 16,
+        codebook_size: int = 2048,
+        **kwargs: Any,
+    ) -> BreezeReferenceAudioTokenizer:
+        """Load the bundled ``audio_tokenizer`` with the existing Qwen wrapper."""
+        from vllm_omni.model_executor.models.qwen3_tts.qwen3_tts_tokenizer import (
+            Qwen3TTSTokenizer,
+        )
+
+        resolved = resolve_audio_tokenizer_path(model_path)
+        if resolved is None:
+            raise FileNotFoundError(
+                "Breeze reference audio tokenizer was not found for "
+                f"{model_path} (expected an audio_tokenizer/ subdirectory)"
+            )
+        tokenizer = Qwen3TTSTokenizer.from_pretrained(str(resolved), **kwargs)
+        return cls(tokenizer, num_codebooks=num_codebooks, codebook_size=codebook_size)
+
+    @torch.inference_mode()
+    def encode(self, audio: Any, sample_rate: int | None = None) -> torch.Tensor:
+        """Encode one waveform or audio source into ``(T, Q)`` codes."""
+        if isinstance(audio, torch.Tensor):
+            audio = audio.detach().cpu().numpy()
+        elif isinstance(audio, list) and audio and all(isinstance(x, (int, float)) for x in audio):
+            audio = np.asarray(audio, dtype=np.float32)
+        if isinstance(audio, np.ndarray) and audio.ndim > 1:
+            # Accept both common layouts: (samples, channels) and
+            # (channels, samples).  Qwen3TTSTokenizer expects one 1-D clip.
+            channel_first = audio.shape[0] <= 8 and audio.shape[-1] > audio.shape[0]
+            audio = audio.mean(axis=0 if channel_first else -1)
+
+        if isinstance(audio, np.ndarray) and sample_rate is None:
+            raise ValueError("sample_rate is required when ref_audio is a numpy waveform")
+
+        encoded = self.tokenizer.encode(audio, sr=sample_rate)
+        return self._normalize_codes(encoded)
+
+    def _normalize_codes(self, encoded: Any) -> torch.Tensor:
+        codes = getattr(encoded, "audio_codes", None)
+        if codes is None and isinstance(encoded, Mapping):
+            codes = encoded.get("audio_codes")
+        if codes is None and isinstance(encoded, (tuple, list)):
+            codes = encoded[0] if encoded else None
+        if codes is None:
+            raise ValueError("reference audio tokenizer returned no audio_codes")
+
+        if isinstance(codes, (tuple, list)) and codes:
+            # Qwen3TTSTokenizer returns one tensor per input waveform.
+            if len(codes) != 1:
+                raise ValueError(f"only one reference waveform is supported, got {len(codes)}")
+            codes = codes[0]
+        codes = torch.as_tensor(codes)
+        if codes.ndim == 3:
+            if codes.shape[0] != 1:
+                raise ValueError(f"only one reference waveform is supported, got {tuple(codes.shape)}")
+            codes = codes[0]
+        if codes.ndim != 2:
+            raise ValueError(f"reference audio codes must be 2D, got {tuple(codes.shape)}")
+        if codes.shape[0] == 0:
+            raise ValueError("reference audio tokenizer returned no frames")
+        if codes.shape[-1] != self.num_codebooks:
+            if codes.shape[0] == self.num_codebooks:
+                codes = codes.transpose(0, 1)
+            else:
+                raise ValueError(
+                    f"reference audio codes must have {self.num_codebooks} codebooks, got {tuple(codes.shape)}"
+                )
+        codes = codes.to(device="cpu", dtype=torch.long).contiguous()
+        if codes.numel() and (int(codes.min()) < 0 or int(codes.max()) >= self.codebook_size):
+            raise ValueError(
+                f"reference audio code outside [0, {self.codebook_size}): "
+                f"min={int(codes.min())}, max={int(codes.max())}"
+            )
+        # int16 is enough for Mimi/Qwen3-TTS codes and halves IPC/cache memory.
+        return codes.to(dtype=torch.int16)
+
+
+__all__ = ["BreezeReferenceAudioTokenizer", "resolve_audio_tokenizer_path"]
diff --git a/vllm_omni/model_executor/models/breeze_tts_2/configuration_breeze_tts_2.py b/vllm_omni/model_executor/models/breeze_tts_2/configuration_breeze_tts_2.py
new file mode 100644
index 000000000..2c04768a9
--- /dev/null
+++ b/vllm_omni/model_executor/models/breeze_tts_2/configuration_breeze_tts_2.py
@@ -0,0 +1,366 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Configuration classes for Breeze-TTS-2."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from transformers import AutoConfig
+from transformers.configuration_utils import PretrainedConfig
+from transformers.models.qwen3 import Qwen3Config
+
+
+class BreezeTTS2Config(PretrainedConfig):
+    """Configuration for ``BreezeForConditionalGeneration``."""
+
+    model_type = "breeze"
+
+    def __init__(
+        self,
+        backbone_config: dict | Qwen3Config | None = None,
+        text_encoder_config: dict | BreezeTTS2TextEncoderConfig | None = None,
+        depth_decoder_config: dict | BreezeTTS2DepthDecoderConfig | None = None,
+        codec_config: dict | None = None,
+        architectures: list[str] | None = None,
+        attention_bias: bool = False,
+        attention_dropout: float = 0.0,
+        audio_embed_size: int = 2048,
+        audio_eos_token_id: int = 262145,
+        audio_num_codebooks: int = 16,
+        audio_token_id: int = 262144,
+        audio_vocab_size: int = 2051,
+        backbone_flavor: str = "llama-1B",
+        backbone_model_name_or_path: str | None = None,
+        backbone_model_type: str = "qwen3",
+        bos_token_id: int = 2,
+        codebook_eos_token_id: int = 0,
+        codebook_pad_token_id: int = 2050,
+        decoder_flavor: str = "llama-100M",
+        depth_header_loss_weight: float = 1.0,
+        dtype: str = "bfloat16",
+        eos_token_id: int = 1,
+        head_dim: int = 128,
+        hidden_act: str = "silu",
+        hidden_size: int = 2048,
+        initializer_range: float = 0.02,
+        intermediate_size: int = 6144,
+        max_position_embeddings: int = 2048,
+        mlp_bias: bool = False,
+        num_attention_heads: int = 16,
+        num_codebooks: int = 16,
+        num_hidden_layers: int = 28,
+        num_key_value_heads: int = 8,
+        pad_token_id: int = 0,
+        rms_norm_eps: float = 1e-5,
+        rope_scaling: dict | None = None,
+        rope_theta: float = 500_000.0,
+        text_encoder_bucket_max_length_ratio: float = 4.0,
+        text_encoder_lora_config: dict | None = None,
+        text_encoder_proj_type: str = "linear",
+        text_encoder_special_tokens_config: dict | None = None,
+        text_vocab_size: int = 262158,
+        tie_codebooks_embeddings: bool = True,
+        tie_word_embeddings: bool = False,
+        use_cache: bool = True,
+        vocab_size: int = 2051,
+        sampling_rate: int = 24000,
+        codec_model_name_or_path: str = "kyutai/mimi",
+        **kwargs: Any,
+    ) -> None:
+        serialized_rope_parameters = kwargs.pop("rope_parameters", None)
+        if rope_scaling is None and serialized_rope_parameters is not None:
+            rope_scaling = serialized_rope_parameters
+        # Breeze stores the Qwen3 backbone in backbone_config. This follows the
+        # MOSS-TTS pattern and deliberately does not declare sub_configs.
+        if backbone_config is None:
+            backbone_config = {}
+        if isinstance(backbone_config, dict):
+            backbone_config = dict(backbone_config)
+            backbone_config.pop("model_type", None)
+            self.backbone_config = Qwen3Config(**backbone_config)
+        else:
+            self.backbone_config = backbone_config
+
+        if text_encoder_config is None:
+            text_encoder_config = {}
+        if isinstance(text_encoder_config, dict):
+            text_encoder_config = dict(text_encoder_config)
+            text_encoder_config.pop("model_type", None)
+            self.text_encoder_config = BreezeTTS2TextEncoderConfig(**text_encoder_config)
+        else:
+            self.text_encoder_config = text_encoder_config
+
+        if depth_decoder_config is None:
+            depth_decoder_config = {}
+        if isinstance(depth_decoder_config, dict):
+            depth_decoder_config = dict(depth_decoder_config)
+            depth_decoder_config.pop("model_type", None)
+            self.depth_decoder_config = BreezeTTS2DepthDecoderConfig(**depth_decoder_config)
+        else:
+            self.depth_decoder_config = depth_decoder_config
+
+        # Nested configs must exist before the parent constructor: Transformers
+        # 5.x may call get_text_config() during config validation.
+        super().__init__(
+            architectures=architectures,
+            bos_token_id=bos_token_id,
+            eos_token_id=eos_token_id,
+            pad_token_id=pad_token_id,
+            tie_word_embeddings=tie_word_embeddings,
+            **kwargs,
+        )
+
+        self.attention_bias = attention_bias
+        self.attention_dropout = attention_dropout
+        self.audio_embed_size = audio_embed_size
+        self.audio_eos_token_id = audio_eos_token_id
+        self.audio_num_codebooks = audio_num_codebooks
+        self.audio_token_id = audio_token_id
+        self.audio_vocab_size = audio_vocab_size
+        # Keep Mimi's nested config as a plain checkpoint dictionary. Stage 1
+        # owns codec construction; stage 0 only needs codebook_size here.
+        self.codec_config = codec_config
+        self.backbone_flavor = backbone_flavor
+        self.backbone_model_name_or_path = backbone_model_name_or_path
+        self.backbone_model_type = backbone_model_type
+        self.codebook_eos_token_id = codebook_eos_token_id
+        self.codebook_pad_token_id = codebook_pad_token_id
+        self.decoder_flavor = decoder_flavor
+        self.depth_header_loss_weight = depth_header_loss_weight
+        self.dtype = dtype
+        self.head_dim = head_dim
+        self.hidden_act = hidden_act
+        self.hidden_size = hidden_size
+        self.initializer_range = initializer_range
+        self.intermediate_size = intermediate_size
+        self.max_position_embeddings = max_position_embeddings
+        self.mlp_bias = mlp_bias
+        self.num_attention_heads = num_attention_heads
+        self.num_codebooks = num_codebooks
+        self.num_hidden_layers = num_hidden_layers
+        self.num_key_value_heads = num_key_value_heads
+        self.rms_norm_eps = rms_norm_eps
+        if rope_scaling is not None:
+            # Preserve the upstream legacy field while also satisfying the
+            # normalized ``rope_parameters`` validation added in Transformers 5.
+            rope_scaling = dict(rope_scaling)
+            rope_scaling.setdefault("rope_type", rope_scaling.get("type", "default"))
+            rope_scaling.setdefault("rope_theta", rope_theta)
+        self.rope_scaling = rope_scaling
+        self.rope_theta = rope_theta
+        self.text_encoder_bucket_max_length_ratio = text_encoder_bucket_max_length_ratio
+        self.text_encoder_lora_config = text_encoder_lora_config or {}
+        self.text_encoder_proj_type = text_encoder_proj_type
+        self.text_encoder_special_tokens_config = text_encoder_special_tokens_config or {}
+        self.text_vocab_size = text_vocab_size
+        self.tie_codebooks_embeddings = tie_codebooks_embeddings
+        self.use_cache = use_cache
+        self.vocab_size = vocab_size
+        self.sampling_rate = sampling_rate
+        self.codec_model_name_or_path = codec_model_name_or_path
+
+        if not getattr(self, "architectures", None):
+            self.architectures = ["BreezeForConditionalGeneration"]
+
+    def get_text_config(self, **_: Any) -> Qwen3Config:
+        return self.backbone_config
+
+
+class BreezeTTS2TextEncoderConfig(PretrainedConfig):
+    """Configuration for Breeze's T5Gemma2 text encoder."""
+
+    model_type = "t5gemma2_text"
+
+    def __init__(
+        self,
+        hidden_size: int = 1152,
+        intermediate_size: int = 6912,
+        num_hidden_layers: int = 26,
+        num_attention_heads: int = 4,
+        num_key_value_heads: int = 1,
+        head_dim: int = 256,
+        max_position_embeddings: int = 32768,
+        hidden_activation: str = "gelu_pytorch_tanh",
+        rms_norm_eps: float = 1e-6,
+        rope_theta: float = 10_000.0,
+        sliding_window: int = 512,
+        query_pre_attn_scalar: int = 256,
+        eoi_token_index: int = 256000,
+        vocab_size: int = 262158,
+        layer_types: list[str] | None = None,
+        rope_parameters: dict | None = None,
+        attention_bias: bool = False,
+        attention_dropout: float = 0.0,
+        dropout_rate: float = 0.0,
+        initializer_range: float = 0.02,
+        tie_word_embeddings: bool = True,
+        use_bidirectional_attention: bool = False,
+        use_cache: bool = True,
+        requires_grad: bool = False,
+        preferred_attn_implementation: str = "flash_attention_2",
+        dtype: str = "bfloat16",
+        is_encoder_decoder: bool = False,
+        bos_token_id: int = 2,
+        eos_token_id: int = 1,
+        pad_token_id: int = 0,
+        **kwargs: Any,
+    ) -> None:
+        kwargs.pop("model_type", None)
+
+        super().__init__(
+            bos_token_id=bos_token_id,
+            eos_token_id=eos_token_id,
+            pad_token_id=pad_token_id,
+            is_encoder_decoder=is_encoder_decoder,
+            tie_word_embeddings=tie_word_embeddings,
+            **kwargs,
+        )
+        self.hidden_size = hidden_size
+        self.intermediate_size = intermediate_size
+        self.num_hidden_layers = num_hidden_layers
+        self.num_attention_heads = num_attention_heads
+        self.num_key_value_heads = num_key_value_heads
+        self.head_dim = head_dim
+        self.max_position_embeddings = max_position_embeddings
+        self.hidden_activation = hidden_activation
+        self.hidden_act = hidden_activation
+        self.rms_norm_eps = rms_norm_eps
+        self.rope_theta = rope_theta
+        self.sliding_window = sliding_window
+        self.query_pre_attn_scalar = query_pre_attn_scalar
+        self.eoi_token_index = eoi_token_index
+        self.vocab_size = vocab_size
+        if layer_types is None:
+            # T5Gemma2 uses sliding attention except every sixth layer.
+            layer_types = [
+                "full_attention" if (index + 1) % 6 == 0 else "sliding_attention" for index in range(num_hidden_layers)
+            ]
+        self.layer_types = list(layer_types)
+        if rope_parameters is None:
+            rope_parameters = {
+                "full_attention": {
+                    "factor": 8.0,
+                    "rope_theta": 1_000_000.0,
+                    "rope_type": "linear",
+                },
+                "sliding_attention": {
+                    "rope_theta": 10_000.0,
+                    "rope_type": "default",
+                },
+            }
+        self.rope_parameters = dict(rope_parameters)
+        self.attention_bias = attention_bias
+        self.attention_dropout = attention_dropout
+        self.dropout_rate = dropout_rate
+        self.initializer_range = initializer_range
+        self.use_bidirectional_attention = use_bidirectional_attention
+        self.use_cache = use_cache
+        self.requires_grad = requires_grad
+        self.preferred_attn_implementation = preferred_attn_implementation
+        self.dtype = dtype
+
+
+class BreezeTTS2DepthDecoderConfig(PretrainedConfig):
+    """Configuration for Breeze's per-frame depth decoder."""
+
+    model_type = "breeze_depth_decoder_model"
+
+    def __init__(
+        self,
+        hidden_size: int = 1024,
+        backbone_hidden_size: int = 2048,
+        audio_embed_size: int = 2048,
+        intermediate_size: int = 8192,
+        num_hidden_layers: int = 12,
+        num_attention_heads: int = 8,
+        num_key_value_heads: int = 2,
+        head_dim: int = 128,
+        max_position_embeddings: int = 33,
+        hidden_act: str = "silu",
+        rms_norm_eps: float = 1e-5,
+        rope_theta: float = 500_000.0,
+        rope_scaling: dict | None = None,
+        attention_bias: bool = False,
+        attention_dropout: float = 0.0,
+        mlp_bias: bool = False,
+        initializer_range: float = 0.02,
+        use_cache: bool = True,
+        num_codebooks: int = 16,
+        vocab_size: int = 2051,
+        codebook_loss_weights: list[int] | None = None,
+        dtype: str = "bfloat16",
+        tie_word_embeddings: bool = False,
+        pad_token_id: int | None = 0,
+        **kwargs: Any,
+    ) -> None:
+        kwargs.pop("model_type", None)
+        # Transformers 5 serializes the normalized field as
+        # ``rope_parameters`` while the upstream Breeze checkpoint calls it
+        # ``rope_scaling``.  Normalize before ``PretrainedConfig`` validates
+        # so ``to_dict() -> BreezeTTS2DepthDecoderConfig(**dict)`` round-trips.
+        serialized_rope_parameters = kwargs.pop("rope_parameters", None)
+        if rope_scaling is None:
+            rope_scaling = {
+                "factor": 32.0,
+                "high_freq_factor": 0.0078125,
+                "low_freq_factor": 0.001953125,
+                "original_max_position_embeddings": 16,
+                "rope_type": "llama3",
+            }
+        if codebook_loss_weights is None:
+            codebook_loss_weights = [3]
+        if num_codebooks <= 0 or vocab_size <= 0:
+            raise ValueError("num_codebooks and vocab_size must be positive")
+        rope_parameters = dict(serialized_rope_parameters or rope_scaling)
+        rope_parameters.setdefault("rope_type", rope_parameters.get("type", "default"))
+        rope_parameters.setdefault("rope_theta", rope_theta)
+
+        super().__init__(
+            vocab_size=vocab_size,
+            tie_word_embeddings=tie_word_embeddings,
+            pad_token_id=pad_token_id,
+            **kwargs,
+        )
+        # The vLLM depth decoder is a plain ``nn.Module``, so it does not get
+        # Transformers' PreTrainedModel default attention initialization.
+        self._attn_implementation = getattr(self, "_attn_implementation", None) or "eager"
+        self.hidden_size = hidden_size
+        self.backbone_hidden_size = backbone_hidden_size
+        self.audio_embed_size = audio_embed_size
+        self.intermediate_size = intermediate_size
+        self.num_hidden_layers = num_hidden_layers
+        self.num_attention_heads = num_attention_heads
+        self.num_key_value_heads = num_key_value_heads
+        self.head_dim = head_dim
+        self.max_position_embeddings = max_position_embeddings
+        self.hidden_act = hidden_act
+        self.rms_norm_eps = rms_norm_eps
+        self.rope_theta = rope_theta
+        self.rope_parameters = dict(getattr(self, "rope_parameters", None) or rope_parameters)
+        self.rope_parameters.setdefault("rope_theta", rope_theta)
+        # Transformers 4 exposes this as a plain attribute; Transformers 5
+        # implements ``rope_scaling`` as a property backed by rope_parameters.
+        if not hasattr(type(self), "rope_scaling"):
+            self.rope_scaling = self.rope_parameters
+        self.rope_type = rope_scaling.get("rope_type", "default")
+        self.attention_bias = attention_bias
+        self.attention_dropout = attention_dropout
+        self.mlp_bias = mlp_bias
+        self.initializer_range = initializer_range
+        self.use_cache = use_cache
+        self.num_codebooks = num_codebooks
+        self.vocab_size = vocab_size
+        self.codebook_loss_weights = list(codebook_loss_weights)
+        self.dtype = dtype
+
+
+AutoConfig.register("breeze", BreezeTTS2Config, exist_ok=True)
+
+
+__all__ = [
+    "BreezeTTS2Config",
+    "BreezeTTS2DepthDecoderConfig",
+    "BreezeTTS2TextEncoderConfig",
+]
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
new file mode 100644
index 000000000..860d64c44
--- /dev/null
+++ b/vllm_omni/model_executor/models/breeze_tts_2/modeling_breeze_tts_2_codec.py
@@ -0,0 +1,425 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Breeze-TTS-2 stage-1 codec (codec codes -> waveform).
+
+The talker emits a frame-major ``(T, 16)`` matrix.  The stage input
+processor flattens it codebook-major; this module restores the ``(T, 16)``
+layout and delegates decoding to Breeze's bundled Qwen3-TTS tokenizer.  A
+Mimi fallback remains available for checkpoints that omit ``audio_tokenizer``.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+from typing import Any
+
+import torch
+from torch import nn
+from vllm.config import VllmConfig
+
+from vllm_omni.model_executor.models.breeze_tts_2.audio_tokenizer import (
+    resolve_audio_tokenizer_path,
+)
+from vllm_omni.model_executor.models.output_templates import OmniOutput
+
+
+def _split_flat_ids(ids: torch.Tensor, counts: list[int] | None) -> list[torch.Tensor]:
+    if counts is None or len(counts) <= 1:
+        return [ids]
+    boundaries = [0]
+    for count in counts:
+        boundaries.append(boundaries[-1] + int(count))
+    return [ids[boundaries[i] : boundaries[i + 1]] for i in range(len(counts))]
+
+
+class BreezeTTS2MimiCodec(nn.Module):
+    """Synchronous Breeze codec stage used by ``GenerationModelRunner``."""
+
+    input_modalities = "audio"
+    requires_raw_input_tokens = True
+    # Stateful chunk decoding needs the scheduler-side request id, which is
+    # also used by on_requests_finished to release decoder state.
+    requires_request_ids = True
+    have_multimodal_outputs = True
+    has_preprocess = False
+    has_postprocess = False
+    enable_update_additional_information = True
+
+    def __init__(self, *, vllm_config: VllmConfig, prefix: str = "") -> None:
+        super().__init__()
+        del prefix
+        self.vllm_config = vllm_config
+        self.config = vllm_config.model_config.hf_config
+        self.model_path = vllm_config.model_config.model
+        self._async_chunk = bool(getattr(vllm_config.model_config, "async_chunk", False))
+        # Resolve once: a local directory works directly, an HF repo id
+        # resolves to its cached snapshot. ``None`` means the checkpoint has
+        # no bundled tokenizer and the Mimi fallback applies.
+        self._tokenizer_path = resolve_audio_tokenizer_path(self.model_path)
+        if self._async_chunk and self._tokenizer_path is None:
+            raise RuntimeError(
+                "Breeze-TTS-2 async_chunk requires the bundled Qwen3-TTS audio_tokenizer; "
+                "the stateless Mimi fallback cannot preserve chunk decoder state"
+            )
+
+        self._audio_tokenizer = None
+        codec_config = getattr(self.config, "codec_config", None)
+        if isinstance(codec_config, Mapping):
+            codec_kwargs = dict(codec_config)
+        elif codec_config is not None:
+            codec_kwargs = codec_config.to_dict()
+        else:
+            codec_kwargs = {}
+        codec_kwargs.pop("model_type", None)
+        codec_kwargs.pop("architectures", None)
+
+        # Breeze checkpoints normally carry a Qwen3-TTS decoder in this
+        # subdirectory.  Avoid constructing a second, unused Mimi network in
+        # that case; this saves both startup time and worker memory.
+        self._codec = None
+        if self._tokenizer_path is None:
+            # Import lazily: stage 0 does not need the Mimi implementation.
+            from transformers import MimiConfig, MimiModel
+
+            self._codec = MimiModel(MimiConfig(**codec_kwargs)).eval()
+            for parameter in self._codec.parameters():
+                parameter.requires_grad_(False)
+
+        self._num_codebooks = int(getattr(self.config, "num_codebooks", 16))
+        self._codebook_size = int(codec_kwargs.get("codebook_size", 2048))
+        self._sample_rate = int(codec_kwargs.get("sampling_rate", getattr(self.config, "sampling_rate", 24000)))
+        self._decoder_state_cache: dict[str, dict[str, Any]] = {}
+
+    def embed_input_ids(self, input_ids: torch.Tensor, **_: Any) -> torch.Tensor:
+        """Return stable dummy embeddings; this stage never samples."""
+        if input_ids.numel() == 0:
+            return torch.empty((0, 1), device=input_ids.device, dtype=torch.float32)
+        return torch.zeros((input_ids.shape[0], 1), device=input_ids.device, dtype=torch.float32)
+
+    def compute_logits(
+        self,
+        hidden_states: torch.Tensor | OmniOutput,
+        sampling_metadata: Any = None,
+    ) -> None:
+        del hidden_states, sampling_metadata
+        return None
+
+    @torch.inference_mode()
+    def forward(
+        self,
+        input_ids: torch.Tensor | None = None,
+        runtime_additional_information: list[dict[str, Any]] | None = None,
+        **kwargs: Any,
+    ) -> OmniOutput:
+        empty = torch.empty(0, dtype=torch.float32)
+        sr = torch.tensor(self._sample_rate, dtype=torch.int32)
+        if input_ids is None or input_ids.numel() == 0:
+            return OmniOutput(
+                text_hidden_states=None,
+                multimodal_outputs={"model_outputs": [empty], "sr": [sr]},
+            )
+        # The generation runner's profiling/dummy invocation has no request ids
+        # or runtime payload. Real requests always provide both.
+        if runtime_additional_information is None and kwargs.get("request_ids") is None:
+            return OmniOutput(
+                text_hidden_states=None,
+                multimodal_outputs={"model_outputs": [empty], "sr": [sr]},
+            )
+
+        ids = input_ids.reshape(-1).to(dtype=torch.long)
+        counts = kwargs.get("seq_token_counts")
+        if counts is not None:
+            counts = [int(item) for item in counts]
+        requests = _split_flat_ids(ids, counts)
+        waveforms: list[torch.Tensor] = []
+        sample_rates: list[torch.Tensor] = []
+        if self._async_chunk:
+            return self._forward_stateful_chunks(
+                ids=ids,
+                requests=requests,
+                runtime_additional_information=runtime_additional_information,
+                empty=empty,
+                sr=sr,
+                **kwargs,
+            )
+        for index, request_ids in enumerate(requests):
+            runtime_info = (
+                runtime_additional_information[index]
+                if runtime_additional_information is not None and index < len(runtime_additional_information)
+                else None
+            )
+            flat = self._payload_codes(request_ids, runtime_info)
+            if flat.numel() == 0:
+                waveforms.append(empty.to(device=ids.device))
+                sample_rates.append(sr)
+                continue
+            if flat.numel() % self._num_codebooks != 0:
+                raise ValueError(
+                    f"Breeze codec input length {int(flat.numel())} is not divisible by "
+                    f"num_codebooks {self._num_codebooks}"
+                )
+            if int(flat.min()) < 0 or int(flat.max()) >= self._codebook_size:
+                raise ValueError(
+                    f"Breeze codec id outside [0, {self._codebook_size}): min={int(flat.min())}, max={int(flat.max())}"
+                )
+            frames = flat.numel() // self._num_codebooks
+            codes = flat.reshape(self._num_codebooks, frames).unsqueeze(0)
+            waveform = self._decode_codes(codes)
+            if waveform.ndim == 3:
+                waveform = waveform[0, 0]
+            elif waveform.ndim == 2:
+                waveform = waveform[0]
+            if waveform.ndim != 1:
+                raise ValueError(f"Breeze Mimi waveform must be 1D, got {tuple(waveform.shape)}")
+            # Serving/output serialization consumes CPU tensors.  Move only
+            # the final waveform off the worker device; codec inference itself
+            # remains on the accelerator.
+            waveforms.append(waveform.detach().to(device="cpu", dtype=torch.float32).contiguous())
+            sample_rates.append(sr)
+
+        return OmniOutput(
+            text_hidden_states=None,
+            multimodal_outputs={"model_outputs": waveforms, "sr": sample_rates},
+        )
+
+    def _forward_stateful_chunks(
+        self,
+        *,
+        ids: torch.Tensor,
+        requests: list[torch.Tensor],
+        runtime_additional_information: list[dict[str, Any]] | None,
+        empty: torch.Tensor,
+        sr: torch.Tensor,
+        **kwargs: Any,
+    ) -> OmniOutput:
+        """Decode incremental codebook-major chunks with per-request state."""
+        decoder = self._audio_tokenizer.model.decoder
+        scheduler_request_ids = kwargs.get("request_ids")
+        if scheduler_request_ids is None:
+            raise ValueError("Breeze async_chunk codec inputs require scheduler request_ids")
+        request_ids = [str(request_id) for request_id in scheduler_request_ids]
+        if len(request_ids) != len(requests):
+            raise ValueError(
+                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]
+                if runtime_additional_information is not None and index < len(runtime_additional_information)
+                else {}
+            )
+            state_id = request_ids[index]
+            # The connector receiver strips ``meta.finished`` while merging
+            # runtime metadata, so the stream-terminated signal arrives on
+            # the model-visible ``stream_finished`` field (the same contract
+            # CosyVoice3 / Audex use). Fall back to ``finished`` for direct
+            # in-process callers that still set only the transport flag.
+            finished = self._meta_bool(runtime_info, "stream_finished") or self._meta_bool(runtime_info, "finished")
+            flat = self._payload_codes(request_ids_tensor, runtime_info)
+            if flat.numel() == 0:
+                # Terminal marker: the stage-0 processor sends an empty
+                # payload with ``finished=True`` once generation ends.
+                self._decoder_state_cache.pop(state_id, None)
+                continue
+            if flat.numel() % self._num_codebooks != 0:
+                # A partial frame means the transport payload is corrupt.
+                # Silently resetting decoder state would corrupt the rest of
+                # the stream; fail loudly instead. The scheduler aborts the
+                # request and ``on_requests_finished`` releases the state.
+                raise ValueError(
+                    f"Breeze codec chunk length {int(flat.numel())} is not divisible by "
+                    f"num_codebooks {self._num_codebooks}"
+                )
+            if int(flat.min()) < 0 or int(flat.max()) >= self._codebook_size:
+                raise ValueError(
+                    f"Breeze codec id outside [0, {self._codebook_size}): min={int(flat.min())}, max={int(flat.max())}"
+                )
+            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)
+        if not valid:
+            return OmniOutput(
+                text_hidden_states=None,
+                multimodal_outputs={"model_outputs": waveforms, "sr": sample_rates},
+            )
+        states: list[dict[str, Any]] = []
+        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):
+            batched_codes[row, :, : row_codes.shape[-1]].copy_(row_codes)
+            state = self._decoder_state_cache.get(state_id)
+            if state is None:
+                state = {}
+                self._decoder_state_cache[state_id] = state
+            state.setdefault("prefix_frames", 0)
+            states.append(state)
+
+        decoded = decoder.batched_chunked_decode(
+            batched_codes,
+            [int(codes.shape[-1]) for _, codes, _ in valid],
+            caches=states,
+            chunk_size=300,
+            left_context_size=25,
+        )
+        if len(decoded) != len(valid):
+            raise RuntimeError(f"Breeze codec returned {len(decoded)} chunks for {len(valid)} requests")
+        for request_index, waveform in zip(valid_indices, decoded, strict=True):
+            if waveform.ndim == 2 and waveform.shape[0] == 1:
+                waveform = waveform[0]
+            elif waveform.ndim != 1:
+                waveform = waveform.reshape(-1)
+            waveforms[request_index] = waveform.detach().to(device="cpu", dtype=torch.float32).contiguous()
+
+        for state_id, _, finished in valid:
+            if finished:
+                self._decoder_state_cache.pop(state_id, None)
+
+        return OmniOutput(
+            text_hidden_states=None,
+            multimodal_outputs={"model_outputs": waveforms, "sr": sample_rates},
+        )
+
+    @staticmethod
+    def _meta_bool(info: Mapping[str, Any] | None, key: str) -> bool:
+        if not isinstance(info, Mapping):
+            return False
+        meta = info.get("meta", {})
+        if not isinstance(meta, Mapping):
+            return False
+        value = meta.get(key, False)
+        if isinstance(value, torch.Tensor):
+            return bool(value.reshape(-1)[0].item()) if value.numel() else False
+        return bool(value)
+
+    def on_requests_finished(self, finished_req_ids: Iterable[str]) -> None:
+        for request_id in finished_req_ids:
+            self._decoder_state_cache.pop(str(request_id), None)
+
+    def _decode_codes(self, codes: torch.Tensor) -> torch.Tensor:
+        """Decode one ``(1, Q, T)`` sequence using Breeze's bundled codec."""
+        if self._audio_tokenizer is not None:
+            wavs, sample_rate = self._audio_tokenizer.decode({"audio_codes": [codes[0].transpose(0, 1).contiguous()]})
+            self._sample_rate = int(sample_rate)
+            if not wavs:
+                raise RuntimeError("Breeze Qwen3-TTS tokenizer returned no waveform")
+            return torch.as_tensor(wavs[0], device=codes.device, dtype=torch.float32).reshape(-1)
+
+        if self._codec is None:
+            raise RuntimeError("Breeze codec is not initialized; load_weights() was not completed")
+        decoded = self._codec.decode(codes)
+        waveform = getattr(decoded, "audio_values", decoded)
+        if isinstance(waveform, Mapping):
+            waveform = waveform.get("audio_values")
+        if waveform is None:
+            raise RuntimeError("MimiModel.decode returned no audio_values")
+        return torch.as_tensor(waveform, device=codes.device, dtype=torch.float32)
+
+    @staticmethod
+    def _payload_codes(input_ids: torch.Tensor, runtime_info: Mapping[str, Any] | None) -> torch.Tensor:
+        if isinstance(runtime_info, Mapping):
+            codes = runtime_info.get("codes")
+            if isinstance(codes, Mapping):
+                audio = codes.get("audio")
+                if audio is not None:
+                    return torch.as_tensor(audio, device=input_ids.device, dtype=torch.long).reshape(-1)
+            # Full-payload transport may flatten nested OmniPayload keys at
+            # the wire boundary and restore them only after this hook runs.
+            audio = runtime_info.get("codes.audio")
+            if audio is not None:
+                return torch.as_tensor(audio, device=input_ids.device, dtype=torch.long).reshape(-1)
+        return input_ids
+
+    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
+        """Load Breeze's bundled Qwen3-TTS codec, or fallback Mimi weights."""
+        if self._tokenizer_path is not None:
+            # The root checkpoint contains both the talker weights and a Mimi
+            # ``codec_model.*`` fallback.  When the bundled Qwen3-TTS tokenizer
+            # is present, it owns decoding; consume the root iterator without
+            # copying the unused fallback into worker memory.
+            if self._audio_tokenizer is None:
+                from vllm_omni.model_executor.models.qwen3_tts.qwen3_tts_tokenizer import (
+                    Qwen3TTSTokenizer,
+                )
+
+                device = self.vllm_config.device_config.device
+                self._audio_tokenizer = Qwen3TTSTokenizer.from_pretrained(
+                    str(self._tokenizer_path),
+                    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)
+            named_parameters = getattr(tokenizer_module, "named_parameters", None)
+            if callable(named_parameters):
+                return {f"_audio_tokenizer.model.{name}" for name, _ in named_parameters()}
+            return set()
+
+        params = dict(self._codec.named_parameters()) if self._codec is not None else {}
+        loaded: set[str] = set()
+        for name, tensor in weights:
+            if name.startswith("codec_model."):
+                target_name = name[len("codec_model.") :]
+            else:
+                continue
+            parameter = params.get(target_name)
+            if parameter is None:
+                raise ValueError(f"Unknown Breeze Mimi weight: {target_name}")
+            loader = getattr(parameter, "weight_loader", None)
+            if loader is None:
+                parameter.data.copy_(tensor.to(device=parameter.device, dtype=parameter.dtype))
+            else:
+                loader(parameter, tensor)
+            loaded.add(target_name)
+
+        if loaded:
+            return {f"_codec.{name}" for name in loaded}
+
+        # Breeze inference uses the bundled Qwen3-TTS tokenizer for both
+        # reference encoding and generated-code decoding.  Load it once per
+        # Stage-1 worker; unlike the request-side wrapper this instance is
+        # placed on the worker device and reused for the entire batch.
+        # A few Breeze distributions omit codec tensors and point to the
+        # standalone kyutai/mimi repository instead.  Load it once, never per
+        # request, and fail loudly if it cannot be resolved.
+        codec_name = getattr(self.config, "codec_model_name_or_path", None) or "kyutai/mimi"
+        from transformers import AutoModel
+
+        self._codec = AutoModel.from_pretrained(codec_name).eval()
+        for parameter in self._codec.parameters():
+            parameter.requires_grad_(False)
+        self._sample_rate = int(getattr(self._codec.config, "sampling_rate", self._sample_rate))
+        self._codebook_size = int(
+            getattr(getattr(self._codec.config, "quantizer", None), "cardinality", self._codebook_size)
+        )
+        return {f"_codec.{name}" for name, _ in self._codec.named_parameters()}
+
+
+__all__ = ["BreezeTTS2MimiCodec"]
diff --git a/vllm_omni/model_executor/models/breeze_tts_2/modeling_breeze_tts_2_depth.py b/vllm_omni/model_executor/models/breeze_tts_2/modeling_breeze_tts_2_depth.py
new file mode 100644
index 000000000..559c88b07
--- /dev/null
+++ b/vllm_omni/model_executor/models/breeze_tts_2/modeling_breeze_tts_2_depth.py
@@ -0,0 +1,523 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from inspect import signature
+from typing import Any
+
+import torch
+from torch import nn
+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
+from transformers.modeling_outputs import BaseModelOutputWithPast, CausalLMOutputWithPast
+from transformers.modeling_rope_utils import ROPE_INIT_FUNCTIONS, dynamic_rope_update
+from transformers.modeling_utils import ALL_ATTENTION_FUNCTIONS
+from transformers.processing_utils import Unpack
+from transformers.utils import TransformersKwargs, logging
+from transformers.utils.deprecation import deprecate_kwarg
+
+logger = logging.get_logger(__name__)
+
+
+def _create_depth_causal_mask(
+    *,
+    config: Any,
+    inputs_embeds: torch.Tensor,
+    attention_mask: torch.Tensor | None,
+    past_key_values: Cache | None,
+    position_ids: torch.LongTensor | None,
+    cache_position: torch.LongTensor,
+) -> torch.Tensor | None:
+    """Bridge Transformers 4.57 and 5.x ``create_causal_mask`` contracts."""
+    parameters = signature(create_causal_mask).parameters
+    kwargs: dict[str, Any] = {
+        "config": config,
+        "attention_mask": attention_mask,
+        "past_key_values": past_key_values,
+        "position_ids": position_ids,
+    }
+    if "inputs_embeds" in parameters:
+        kwargs["inputs_embeds"] = inputs_embeds
+    else:
+        kwargs["input_embeds"] = inputs_embeds
+        kwargs["cache_position"] = cache_position
+    return create_causal_mask(**kwargs)
+
+
+class BreezeDepthDecoderModel(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        self.padding_idx = config.pad_token_id
+        self.vocab_size = config.vocab_size
+        if hasattr(config, "audio_embed_size") and config.audio_embed_size:
+            self.audio_embed_size = config.audio_embed_size
+        else:
+            self.audio_embed_size = config.backbone_hidden_size
+        self.embed_tokens = nn.Embedding((config.num_codebooks * config.vocab_size), self.audio_embed_size)
+        self.layers = nn.ModuleList(
+            [BreezeDecoderLayer(config, layer_idx) for layer_idx in range(config.num_hidden_layers)]
+        )
+        self.norm = BreezeRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+        self.rotary_emb = BreezeRotaryEmbedding(config=config)
+        self.gradient_checkpointing = False
+        self.inputs_embeds_projector = nn.Linear(self.audio_embed_size, config.hidden_size, bias=False)
+
+        if config.backbone_hidden_size != self.audio_embed_size:
+            self.backbone_hidden_state_projector = nn.Linear(
+                config.backbone_hidden_size, self.audio_embed_size, bias=False
+            )
+        else:
+            self.backbone_hidden_state_projector = None
+
+        # Weights are loaded from the Breeze checkpoint by the parent talker.
+        # Avoid PreTrainedModel.post_init here because this module is a plain
+        # nn.Module used for eager per-frame inference.
+
+    def forward(
+        self,
+        input_ids: torch.LongTensor = None,
+        backbone_last_hidden_state: torch.FloatTensor | None = None,
+        attention_mask: torch.Tensor | None = None,
+        position_ids: torch.LongTensor | None = None,
+        past_key_values: Cache | None = None,
+        inputs_embeds: torch.FloatTensor | None = None,
+        use_cache: bool | None = None,
+        cache_position: torch.LongTensor | None = None,
+        **kwargs: Unpack[TransformersKwargs],
+    ) -> tuple | BaseModelOutputWithPast:
+        r"""
+        backbone_last_hidden_state (`torch.FloatTensor` of shape `(batch_size, backbone_hidden_size)`, *optional*):
+            The last hidden state of the backbone model. This is required when
+            the first codebook token (generated by the backbone model) is
+            provided in the `input_ids` argument.
+        """
+        if position_ids is not None and not torch.compiler.is_compiling():
+            logger.warning_once(
+                "Custom `position_ids` were provided but will be ignored. "
+                "Breeze depth decoder derives them from `cache_position`; "
+                "they must be identical across the batch."
+            )
+            position_ids = None
+        if (input_ids is None) ^ (inputs_embeds is not None):
+            raise ValueError("You must specify exactly one of input_ids or inputs_embeds.")
+
+        if use_cache and past_key_values is None:
+            past_key_values = DynamicCache(config=self.config)
+
+        if cache_position is None:
+            past_seen_tokens = past_key_values.get_seq_length() if past_key_values is not None else 0
+            inputs_seq_length = inputs_embeds.shape[1] if inputs_embeds is not None else input_ids.shape[1]
+            device = inputs_embeds.device if inputs_embeds is not None else input_ids.device
+            cache_position = torch.arange(past_seen_tokens, past_seen_tokens + inputs_seq_length, device=device)
+
+        if inputs_embeds is None:
+            codebook_idxs = torch.clamp(cache_position - 1, min=0)
+            offset = codebook_idxs * self.vocab_size
+            inputs_embeds = self.embed_tokens(input_ids + offset)
+
+            input_ids_are_first_codebook = cache_position[0] == 0
+            if backbone_last_hidden_state is not None:
+                if self.backbone_hidden_state_projector is not None:
+                    inputs_embeds[:, 0] = self.backbone_hidden_state_projector(backbone_last_hidden_state)
+                else:
+                    inputs_embeds[:, 0] = backbone_last_hidden_state
+            else:
+                if not torch.compiler.is_compiling() and input_ids_are_first_codebook:
+                    logger.warning(
+                        "When the first codebook token is provided, "
+                        "`backbone_last_hidden_state` is required for correct inference."
+                    )
+
+        inputs_embeds = self.inputs_embeds_projector(inputs_embeds)
+
+        causal_mask = _create_depth_causal_mask(
+            config=self.config,
+            inputs_embeds=inputs_embeds,
+            attention_mask=attention_mask,
+            past_key_values=past_key_values,
+            position_ids=position_ids,
+            cache_position=cache_position,
+        )
+
+        hidden_states = inputs_embeds
+
+        # create position embeddings to be shared across the decoder layers
+        position_ids = cache_position.unsqueeze(0)
+        position_embeddings = self.rotary_emb(hidden_states, position_ids)
+
+        for decoder_layer in self.layers[: self.config.num_hidden_layers]:
+            hidden_states = decoder_layer(
+                hidden_states,
+                attention_mask=causal_mask,
+                position_ids=position_ids,
+                past_key_values=past_key_values,
+                use_cache=use_cache,
+                cache_position=cache_position,
+                position_embeddings=position_embeddings,
+                **kwargs,
+            )
+
+        hidden_states = self.norm(hidden_states)
+        return BaseModelOutputWithPast(
+            last_hidden_state=hidden_states,
+            past_key_values=past_key_values if use_cache else None,
+        )
+
+
+@use_kernel_forward_from_hub("RMSNorm")
+class BreezeRMSNorm(nn.Module):
+    def __init__(self, hidden_size, eps=1e-6):
+        """
+        BreezeRMSNorm is equivalent to T5LayerNorm
+        """
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(hidden_size))
+        self.variance_epsilon = eps
+
+    def forward(self, hidden_states):
+        input_dtype = hidden_states.dtype
+        hidden_states = hidden_states.to(torch.float32)
+        variance = hidden_states.pow(2).mean(-1, keepdim=True)
+        hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
+        return self.weight * hidden_states.to(input_dtype)
+
+    def extra_repr(self):
+        return f"{tuple(self.weight.shape)}, eps={self.variance_epsilon}"
+
+
+class BreezeRotaryEmbedding(nn.Module):
+    inv_freq: torch.Tensor  # fix linting for `register_buffer`
+
+    def __init__(self, config, device=None):
+        super().__init__()
+        # BC: "rope_type" was originally "type"
+        if hasattr(config, "rope_scaling") and isinstance(config.rope_scaling, dict):
+            self.rope_type = config.rope_scaling.get("rope_type", config.rope_scaling.get("type"))
+        else:
+            self.rope_type = "default"
+        self.max_seq_len_cached = config.max_position_embeddings
+        self.original_max_seq_len = config.max_position_embeddings
+
+        self.config = config
+        self.rope_init_fn = ROPE_INIT_FUNCTIONS[self.rope_type]
+
+        inv_freq, self.attention_scaling = self.rope_init_fn(self.config, device)
+        self.register_buffer("inv_freq", inv_freq, persistent=False)
+        self.original_inv_freq = self.inv_freq
+
+    @torch.no_grad()
+    @dynamic_rope_update  # power user: used with advanced RoPE types (e.g. dynamic rope)
+    def forward(self, x, position_ids):
+        inv_freq_expanded = self.inv_freq[None, :, None].float().expand(position_ids.shape[0], -1, 1).to(x.device)
+        position_ids_expanded = position_ids[:, None, :].float()
+
+        device_type = x.device.type if isinstance(x.device.type, str) and x.device.type != "mps" else "cpu"
+        with torch.autocast(device_type=device_type, enabled=False):  # Force float32
+            freqs = (inv_freq_expanded.float() @ position_ids_expanded.float()).transpose(1, 2)
+            emb = torch.cat((freqs, freqs), dim=-1)
+            cos = emb.cos() * self.attention_scaling
+            sin = emb.sin() * self.attention_scaling
+
+        return cos.to(dtype=x.dtype), sin.to(dtype=x.dtype)
+
+
+class BreezeMLP(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        self.hidden_size = config.hidden_size
+        self.intermediate_size = config.intermediate_size
+        self.gate_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=config.mlp_bias)
+        self.up_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=config.mlp_bias)
+        self.down_proj = nn.Linear(self.intermediate_size, self.hidden_size, bias=config.mlp_bias)
+        self.act_fn = ACT2FN[config.hidden_act]
+
+    def forward(self, x):
+        down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))
+        return down_proj
+
+
+def rotate_half(x):
+    """Rotates half the hidden dims of the input."""
+    x1 = x[..., : x.shape[-1] // 2]
+    x2 = x[..., x.shape[-1] // 2 :]
+    return torch.cat((-x2, x1), dim=-1)
+
+
+def apply_rotary_pos_emb(q, k, cos, sin, position_ids=None, unsqueeze_dim=1):
+    """Applies Rotary Position Embedding to the query and key tensors.
+
+    Args:
+        q (`torch.Tensor`): The query tensor.
+        k (`torch.Tensor`): The key tensor.
+        cos (`torch.Tensor`): The cosine part of the rotary embedding.
+        sin (`torch.Tensor`): The sine part of the rotary embedding.
+        position_ids (`torch.Tensor`, *optional*):
+            Deprecated and unused.
+        unsqueeze_dim (`int`, *optional*, defaults to 1):
+            The 'unsqueeze_dim' argument specifies the dimension along which to unsqueeze cos[position_ids] and
+            sin[position_ids] so that they can be properly broadcasted to the dimensions of q and k. For example, note
+            that cos[position_ids] and sin[position_ids] have the shape [batch_size, seq_len, head_dim]. Then, if q and
+            k have the shape [batch_size, heads, seq_len, head_dim], then setting unsqueeze_dim=1 makes
+            cos[position_ids] and sin[position_ids] broadcastable to the shapes of q and k. Similarly, if q and k have
+            the shape [batch_size, seq_len, heads, head_dim], then set unsqueeze_dim=2.
+    Returns:
+        `tuple(torch.Tensor)` comprising of the query and key tensors rotated using the Rotary Position Embedding.
+    """
+    cos = cos.unsqueeze(unsqueeze_dim)
+    sin = sin.unsqueeze(unsqueeze_dim)
+    q_embed = (q * cos) + (rotate_half(q) * sin)
+    k_embed = (k * cos) + (rotate_half(k) * sin)
+    return q_embed, k_embed
+
+
+def repeat_kv(hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor:
+    """
+    This is the equivalent of torch.repeat_interleave(x, dim=1, repeats=n_rep). The hidden states go from (batch,
+    num_key_value_heads, seqlen, head_dim) to (batch, num_attention_heads, seqlen, head_dim)
+    """
+    batch, num_key_value_heads, slen, head_dim = hidden_states.shape
+    if n_rep == 1:
+        return hidden_states
+    hidden_states = hidden_states[:, :, None, :, :].expand(batch, num_key_value_heads, n_rep, slen, head_dim)
+    return hidden_states.reshape(batch, num_key_value_heads * n_rep, slen, head_dim)
+
+
+def eager_attention_forward(
+    module: nn.Module,
+    query: torch.Tensor,
+    key: torch.Tensor,
+    value: torch.Tensor,
+    attention_mask: torch.Tensor | None,
+    scaling: float,
+    dropout: float = 0.0,
+    **kwargs: Unpack[TransformersKwargs],
+):
+    key_states = repeat_kv(key, module.num_key_value_groups)
+    value_states = repeat_kv(value, module.num_key_value_groups)
+
+    attn_weights = torch.matmul(query, key_states.transpose(2, 3)) * scaling
+    if attention_mask is not None:
+        causal_mask = attention_mask[:, :, :, : key_states.shape[-2]]
+        attn_weights = attn_weights + causal_mask
+
+    attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query.dtype)
+    attn_weights = nn.functional.dropout(attn_weights, p=dropout, training=module.training)
+    attn_output = torch.matmul(attn_weights, value_states)
+    attn_output = attn_output.transpose(1, 2).contiguous()
+
+    return attn_output, attn_weights
+
+
+class BreezeAttention(nn.Module):
+    """Multi-headed attention from 'Attention Is All You Need' paper"""
+
+    def __init__(self, config, layer_idx: int):
+        super().__init__()
+        self.config = config
+        self.layer_idx = layer_idx
+        self.head_dim = getattr(config, "head_dim", config.hidden_size // config.num_attention_heads)
+        self.num_key_value_groups = config.num_attention_heads // config.num_key_value_heads
+        self.scaling = self.head_dim**-0.5
+        self.attention_dropout = config.attention_dropout
+        self.is_causal = True
+
+        self.q_proj = nn.Linear(
+            config.hidden_size,
+            config.num_attention_heads * self.head_dim,
+            bias=config.attention_bias,
+        )
+        self.k_proj = nn.Linear(
+            config.hidden_size,
+            config.num_key_value_heads * self.head_dim,
+            bias=config.attention_bias,
+        )
+        self.v_proj = nn.Linear(
+            config.hidden_size,
+            config.num_key_value_heads * self.head_dim,
+            bias=config.attention_bias,
+        )
+        self.o_proj = nn.Linear(
+            config.num_attention_heads * self.head_dim,
+            config.hidden_size,
+            bias=config.attention_bias,
+        )
+
+    @deprecate_kwarg("past_key_value", new_name="past_key_values", version="4.58")
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        position_embeddings: tuple[torch.Tensor, torch.Tensor],
+        attention_mask: torch.Tensor | None,
+        past_key_values: Cache | None = None,
+        cache_position: torch.LongTensor | None = None,
+        **kwargs: Unpack[TransformersKwargs],
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        input_shape = hidden_states.shape[:-1]
+        hidden_shape = (*input_shape, -1, self.head_dim)
+
+        query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+        key_states = self.k_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+        value_states = self.v_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+
+        cos, sin = position_embeddings
+        query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin)
+
+        if past_key_values is not None:
+            # sin and cos are specific to RoPE models; cache_position needed for the static cache
+            cache_kwargs = {"sin": sin, "cos": cos, "cache_position": cache_position}
+            key_states, value_states = past_key_values.update(key_states, value_states, self.layer_idx, cache_kwargs)
+
+        attention_interface: Callable = eager_attention_forward
+        if self.config._attn_implementation != "eager":
+            attention_interface = ALL_ATTENTION_FUNCTIONS[self.config._attn_implementation]
+
+        attn_output, attn_weights = attention_interface(
+            self,
+            query_states,
+            key_states,
+            value_states,
+            attention_mask,
+            dropout=0.0 if not self.training else self.attention_dropout,
+            scaling=self.scaling,
+            **kwargs,
+        )
+
+        attn_output = attn_output.reshape(*input_shape, -1).contiguous()
+        attn_output = self.o_proj(attn_output)
+        return attn_output, attn_weights
+
+
+class BreezeDecoderLayer(nn.Module):
+    def __init__(self, config, layer_idx: int):
+        super().__init__()
+        self.hidden_size = config.hidden_size
+
+        self.self_attn = BreezeAttention(config=config, layer_idx=layer_idx)
+
+        self.mlp = BreezeMLP(config)
+        self.input_layernorm = BreezeRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+        self.post_attention_layernorm = BreezeRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+    @deprecate_kwarg("past_key_value", new_name="past_key_values", version="4.58")
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: torch.Tensor | None = None,
+        position_ids: torch.LongTensor | None = None,
+        past_key_values: Cache | None = None,
+        use_cache: bool | None = False,
+        cache_position: torch.LongTensor | None = None,
+        position_embeddings: tuple[torch.Tensor, torch.Tensor] | None = None,  # necessary, but kept here for BC
+        **kwargs: Unpack[TransformersKwargs],
+    ) -> torch.Tensor:
+        residual = hidden_states
+        hidden_states = self.input_layernorm(hidden_states)
+        # Self Attention
+        hidden_states, _ = self.self_attn(
+            hidden_states=hidden_states,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            past_key_values=past_key_values,
+            use_cache=use_cache,
+            cache_position=cache_position,
+            position_embeddings=position_embeddings,
+            **kwargs,
+        )
+        hidden_states = residual + hidden_states
+
+        # Fully Connected
+        residual = hidden_states
+        hidden_states = self.post_attention_layernorm(hidden_states)
+        hidden_states = self.mlp(hidden_states)
+        hidden_states = residual + hidden_states
+        return hidden_states
+
+
+class BreezeCodebooksHead(nn.Module):
+    """Position-specific heads for codebooks 1..15."""
+
+    def __init__(self, hidden_size: int, num_codebooks: int, vocab_size: int) -> None:
+        super().__init__()
+        self.num_codebooks = int(num_codebooks)
+        self.weight = nn.Parameter(torch.empty(self.num_codebooks - 1, hidden_size, vocab_size))
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        # ``hidden_states`` contains the placeholder at position 0 followed
+        # by codebook-0..N tokens. Return logits for codebook-1..N.
+        depth_states = hidden_states[:, 1 : self.num_codebooks, :]
+        if depth_states.shape[1] > self.num_codebooks - 1:
+            raise ValueError(f"depth decoder received too many input positions: {hidden_states.shape[1]}")
+        return torch.einsum("bkh,khv->bkv", depth_states, self.weight[: depth_states.shape[1]])
+
+
+class BreezeDepthDecoderForCausalLM(nn.Module):
+    """Eager depth decoder used by the vLLM stage-0 talker."""
+
+    def __init__(self, config) -> None:
+        super().__init__()
+        self.config = config
+        self.model = BreezeDepthDecoderModel(config)
+        self.codebooks_head = BreezeCodebooksHead(
+            config.hidden_size,
+            config.num_codebooks,
+            config.vocab_size,
+        )
+
+    def forward(
+        self,
+        input_ids: torch.Tensor,
+        backbone_last_hidden_state: torch.Tensor,
+        *,
+        use_cache: bool = False,
+        **kwargs,
+    ) -> CausalLMOutputWithPast:
+        outputs = self.model(
+            input_ids=input_ids,
+            backbone_last_hidden_state=backbone_last_hidden_state,
+            use_cache=use_cache,
+            **kwargs,
+        )
+        logits = self.codebooks_head(outputs.last_hidden_state)
+        return CausalLMOutputWithPast(
+            logits=logits,
+            past_key_values=outputs.past_key_values,
+            hidden_states=getattr(outputs, "hidden_states", None),
+            attentions=getattr(outputs, "attentions", None),
+        )
+
+    def load_weights(self, weights):
+        params_dict = dict(self.named_parameters())
+        loaded: set[str] = set()
+        for name, tensor in weights:
+            param = params_dict.get(name)
+            if param is None:
+                continue
+            if name == "codebooks_head.weight":
+                expected = (
+                    int(self.config.num_codebooks) - 1,
+                    int(self.config.hidden_size),
+                    int(self.config.vocab_size),
+                )
+                actual = tuple(int(dim) for dim in tensor.shape)
+                if actual != expected:
+                    raise ValueError(f"Breeze depth weight {name!r} has shape {actual}, expected {expected}")
+            loader = getattr(param, "weight_loader", None)
+            if loader is None:
+                param.data.copy_(tensor.to(device=param.device, dtype=param.dtype))
+            else:
+                loader(param, tensor)
+            loaded.add(name)
+        return loaded
+
+
+__all__ = [
+    "BreezeCodebooksHead",
+    "BreezeDepthDecoderForCausalLM",
+    "BreezeDepthDecoderModel",
+]
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
new file mode 100644
index 000000000..765df5fbf
--- /dev/null
+++ b/vllm_omni/model_executor/models/breeze_tts_2/modeling_breeze_tts_2_talker.py
@@ -0,0 +1,641 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Breeze-TTS-2 stage-0 talker for vLLM-Omni.
+
+The scheduler samples Breeze codebook-0 tokens one at a time. The other 15
+codebooks are kept in the request-local Omni buffer: after each backbone step,
+the eager depth decoder completes the frame and the next backbone step
+consumes the summed 16-codebook embedding. This preserves the upstream Breeze
+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
+from typing import Any
+
+import torch
+from torch import nn
+from torch.nn.utils.rnn import pad_sequence
+from vllm.config import VllmConfig
+from vllm.model_executor.layers.logits_processor import LogitsProcessor
+from vllm.model_executor.layers.vocab_parallel_embedding import ParallelLMHead
+from vllm.model_executor.model_loader.weight_utils import default_weight_loader
+from vllm.model_executor.models.qwen3 import Qwen3Model
+from vllm.sequence import IntermediateTensors
+from vllm.v1.sample.metadata import SamplingMetadata
+
+from vllm_omni.model_executor.models.breeze_tts_2.configuration_breeze_tts_2 import (
+    BreezeTTS2Config,
+)
+from vllm_omni.model_executor.models.breeze_tts_2.modeling_breeze_tts_2_depth import (
+    BreezeDepthDecoderForCausalLM,
+)
+from vllm_omni.model_executor.models.breeze_tts_2.modeling_breeze_tts_2_text import (
+    BreezeTTS2TextEncoder,
+)
+from vllm_omni.model_executor.models.output_templates import OmniOutput
+
+
+def _prefixed(prefix: str, name: str) -> str:
+    return f"{prefix}.{name}" if prefix else name
+
+
+def _normalize_request_infos(infos: Any) -> list[dict[str, Any]] | None:
+    """Normalize runner metadata to one mutable dict per request."""
+    if not isinstance(infos, Sequence) or isinstance(infos, (str, bytes, bytearray)):
+        return None
+    if not all(isinstance(info, dict) for info in infos):
+        return None
+    return infos
+
+
+def _iter_request_rows(
+    states: Sequence[dict[str, Any]],
+    spans: Sequence[tuple[int, int]] | None,
+    num_rows: int,
+) -> Iterable[tuple[dict[str, Any], int, int]]:
+    """Map request state to logits rows for full or sampled hidden layouts."""
+    if num_rows <= 0 or not states:
+        return
+    if spans is not None and len(spans) == len(states):
+        if all(0 <= int(start) <= int(end) <= num_rows for start, end in spans):
+            for state, (start, end) in zip(states, spans, strict=True):
+                if int(start) < int(end):
+                    yield state, int(start), int(end)
+            return
+        # The runner passes full-sequence spans to make_omni_output but only
+        # one sampled row per request to compute_logits.
+        if num_rows == len(states):
+            for index, state in enumerate(states):
+                yield state, index, index + 1
+            return
+    if num_rows == len(states):
+        for index, state in enumerate(states):
+            yield state, index, index + 1
+        return
+    raise RuntimeError(
+        "Breeze talker cannot align request state with logits rows: "
+        f"states={len(states)}, rows={num_rows}, spans={spans}"
+    )
+
+
+def _check_weight_shape(name: str, tensor: torch.Tensor, expected: tuple[int, ...]) -> None:
+    """Fail early for Breeze-owned, non-sharded checkpoint tensors."""
+    actual = tuple(int(dim) for dim in tensor.shape)
+    if actual != expected:
+        raise ValueError(f"Breeze weight {name!r} has shape {actual}, expected {expected}")
+
+
+class BreezeTTS2TalkerForGeneration(nn.Module):
+    """Stage-0 Breeze talker: text/audio conditioning -> codec frames."""
+
+    have_multimodal_outputs = True
+    has_preprocess = True
+    has_postprocess = True
+    # Stage 0 emits a tiny per-frame codec payload. Let the AR runner snapshot
+    # it through the async-output path instead of the final-only client path.
+    use_async_omni_output = True
+    eager_omni_postprocess_before_async_output = True
+    omni_pooler_payload_include_hidden = False
+    input_modalities = "text"
+    gpu_resident_buffer_keys: set[tuple[str, str]] = {
+        ("hidden_states", "last"),
+    }
+
+    def __init__(self, *, vllm_config: VllmConfig, prefix: str = "") -> None:
+        super().__init__()
+        self.vllm_config = vllm_config
+        self.config: BreezeTTS2Config = vllm_config.model_config.hf_config
+        self._async_chunk = bool(vllm_config.model_config.async_chunk)
+        self._golden_dump_dir = os.environ.get("VLLM_OMNI_BREEZE_GOLDEN_DIR")
+
+        backbone_config = self.config.backbone_config
+        backbone_vllm_config = vllm_config.with_hf_config(
+            backbone_config,
+            architectures=["Qwen3ForCausalLM"],
+        )
+        backbone_vllm_config.model_config.hf_text_config = backbone_config
+        self.model = Qwen3Model(
+            vllm_config=backbone_vllm_config,
+            prefix=_prefixed(prefix, "model"),
+        )
+        # Upstream's Qwen3 adapter keeps only decoder layers/norm/RoPE and
+        # replaces the standard text embedding with Breeze's summed audio/text
+        # tables.  Breeze always supplies ``inputs_embeds`` through preprocess,
+        # so remove the unused Qwen embedding instead of allocating and then
+        # reporting an uninitialized 151936x2048 parameter at load time.
+        self.model.embed_tokens = nn.Identity()
+
+        self.hidden_size = int(backbone_config.hidden_size)
+        self.num_codebooks = int(self.config.num_codebooks)
+        self.codebook_vocab_size = int(self.config.vocab_size)
+        codec_config = self.config.codec_config
+        self.codebook_size = (
+            int(codec_config.get("codebook_size", self.codebook_vocab_size))
+            if isinstance(codec_config, Mapping)
+            else self.codebook_vocab_size
+        )
+        self.codebook_eos_token_id = int(self.config.codebook_eos_token_id)
+        self.audio_token_id = int(self.config.audio_token_id)
+        self.audio_eos_token_id = int(self.config.audio_eos_token_id)
+        self.text_pad_token_id = int(self.config.pad_token_id)
+
+        self.lm_head = ParallelLMHead(
+            self.codebook_vocab_size + 1,
+            self.hidden_size,
+            bias=False,
+            prefix=_prefixed(prefix, "lm_head"),
+        )
+        self.logits_processor = LogitsProcessor(self.codebook_vocab_size + 1)
+
+        # Upstream Breeze uses embedding(code_i + i * vocab_size) and sums
+        # over codebooks before entering the Qwen3 backbone.
+        self.embed_audio_tokens = nn.Embedding(
+            self.num_codebooks * self.codebook_vocab_size,
+            self.hidden_size,
+        )
+        # Keep Breeze's standalone text table even though the normal path
+        # uses T5Gemma2 outputs. It is part of the checkpoint contract and is
+        # also the correct fallback when a checkpoint omits text_encoder.
+        self.embed_text_tokens = nn.Embedding(int(self.config.text_vocab_size), self.hidden_size)
+        self.register_buffer(
+            "audio_token_offsets",
+            torch.arange(self.num_codebooks, dtype=torch.long) * self.codebook_vocab_size,
+            persistent=False,
+        )
+
+        self.text_encoder = BreezeTTS2TextEncoder(self.config.text_encoder_config)
+        self.text_encoder_proj = nn.Linear(
+            int(self.config.text_encoder_config.hidden_size),
+            self.hidden_size,
+            bias=False,
+        )
+        self.depth_decoder = BreezeDepthDecoderForCausalLM(self.config.depth_decoder_config)
+        if bool(self.config.tie_codebooks_embeddings):
+            # The upstream HF model ties these tables. Sharing the Parameter
+            # also prevents a tied checkpoint from leaving the depth input
+            # embedding randomly initialized when only one key is serialized.
+            self.depth_decoder.model.embed_tokens.weight = self.embed_audio_tokens.weight
+
+        self._codec_disallowed_mask: torch.Tensor | None = None
+        self._batch_state: list[dict[str, Any]] | None = None
+        self._batch_state_spans: Sequence[tuple[int, int]] | None = None
+
+    # ------------------------------------------------------------------
+    # Embedding and backbone hooks
+    # ------------------------------------------------------------------
+
+    def embed_input_ids(self, input_ids: torch.Tensor, **_: Any) -> torch.Tensor:
+        """Embed complete generated codec frames; scalar ids are invalid."""
+        if input_ids.ndim < 1 or input_ids.shape[-1] != self.num_codebooks:
+            raise ValueError(
+                "Breeze embed_input_ids requires complete codec frames with shape "
+                f"(..., {self.num_codebooks}), got {tuple(input_ids.shape)}"
+            )
+        codes = input_ids.to(dtype=torch.long)
+        offsets = self.audio_token_offsets.to(device=codes.device)
+        ids = codes.clamp(0, self.codebook_vocab_size - 1) + offsets
+        return self.embed_audio_tokens(ids).sum(dim=-2)
+
+    def forward(
+        self,
+        input_ids: torch.Tensor,
+        positions: torch.Tensor,
+        intermediate_tensors: IntermediateTensors | None = None,
+        inputs_embeds: torch.Tensor | None = None,
+        **_: Any,
+    ) -> torch.Tensor | IntermediateTensors:
+        return self.model(
+            input_ids=input_ids,
+            positions=positions,
+            intermediate_tensors=intermediate_tensors,
+            inputs_embeds=inputs_embeds,
+        )
+
+    # ------------------------------------------------------------------
+    # Prompt/text conditioning
+    # ------------------------------------------------------------------
+
+    def _encode_text_segments(
+        self,
+        input_ids: torch.Tensor,
+        text_mask: torch.Tensor,
+        text_lengths: torch.Tensor,
+    ) -> torch.Tensor:
+        text_ids = input_ids[text_mask.to(device=input_ids.device, dtype=torch.bool)].to(torch.long)
+        lengths = [int(x) for x in text_lengths.reshape(-1).tolist() if int(x) > 0]
+        if int(text_ids.numel()) != sum(lengths):
+            raise ValueError(f"Breeze text mask/length mismatch: {text_ids.numel()} != {sum(lengths)}")
+        if not lengths:
+            return input_ids.new_empty((0, self.hidden_size), dtype=self.text_encoder.dtype)
+        segments = list(torch.split(text_ids, lengths))
+        padded = pad_sequence(segments, batch_first=True, padding_value=0)
+        attn = torch.zeros_like(padded, dtype=torch.bool)
+        for row, length in enumerate(lengths):
+            attn[row, :length] = True
+        hidden = self.text_encoder(padded, attention_mask=attn)
+        projected = self.text_encoder_proj(hidden)
+        return torch.cat([projected[row, :length] for row, length in enumerate(lengths)], dim=0)
+
+    def _build_prompt_embeddings(self, prompt_ids: torch.Tensor, info: Mapping[str, Any]) -> torch.Tensor:
+        device = next(self.parameters()).device
+        prompt_ids = prompt_ids.reshape(-1).to(device=device, dtype=torch.long)
+        text_mask = torch.as_tensor(info.get("text_ids_mask"), device=device, dtype=torch.bool).reshape(-1)
+        text_lengths = torch.as_tensor(info.get("text_ids_len"), device=device, dtype=torch.long)
+        if text_mask.numel() != prompt_ids.numel():
+            raise ValueError("Breeze text_ids_mask length does not match prompt length")
+        output = torch.zeros(
+            (prompt_ids.numel(), self.hidden_size),
+            device=device,
+            dtype=self.embed_text_tokens.weight.dtype,
+        )
+        text_embeds = self._encode_text_segments(prompt_ids, text_mask, text_lengths)
+        output[text_mask] = text_embeds.to(dtype=output.dtype)
+
+        audio_mask = prompt_ids == self.audio_token_id
+        input_values = info.get("input_values")
+        if bool(audio_mask.any()):
+            if input_values is None:
+                raise ValueError("Breeze audio placeholders require input_values")
+            codes = torch.as_tensor(input_values, device=device, dtype=torch.long)
+            if codes.ndim != 2 or codes.shape[-1] != self.num_codebooks:
+                raise ValueError(f"Breeze input_values must be (T, {self.num_codebooks})")
+            if int(codes.shape[0]) != int(audio_mask.sum()):
+                raise ValueError("Breeze reference code count does not match audio placeholders")
+            output[audio_mask] = self.embed_input_ids(codes).to(dtype=output.dtype)
+
+        eos_mask = prompt_ids == self.audio_eos_token_id
+        if bool(eos_mask.any()):
+            eos_codes = torch.full(
+                (1, self.num_codebooks),
+                self.codebook_eos_token_id,
+                dtype=torch.long,
+                device=device,
+            )
+            output[eos_mask] = self.embed_input_ids(eos_codes).expand(int(eos_mask.sum()), -1)
+        return output
+
+    def preprocess(
+        self,
+        input_ids: torch.Tensor,
+        input_embeds: torch.Tensor | None,
+        **info_dict: Any,
+    ) -> tuple[torch.Tensor, torch.Tensor, dict[str, Any]]:
+        """Build prefill embeddings and consume one completed frame per decode."""
+        del input_embeds
+        info = dict(info_dict)
+        span_len = int(input_ids.shape[0])
+        is_prefill = bool(info.get("_omni_is_prefill", span_len > 1))
+        if is_prefill:
+            full_ids = info.get("prompt_ids")
+            if not isinstance(full_ids, torch.Tensor):
+                raise RuntimeError("Breeze prefill is missing prompt_ids")
+            full_embeds = info.get("breeze_prompt_embeds")
+            if not isinstance(full_embeds, torch.Tensor):
+                full_embeds = self._build_prompt_embeddings(full_ids, info).detach().cpu().contiguous()
+            offset = int(info.get("breeze_prefill_offset", info.get("_omni_num_computed_tokens", 0)) or 0)
+            take = full_embeds[offset : offset + span_len].to(device=input_ids.device)
+            if take.shape[0] != span_len:
+                raise RuntimeError("Breeze prompt embedding slice is shorter than scheduled span")
+            return (
+                torch.full_like(input_ids, self.text_pad_token_id),
+                take,
+                {
+                    "breeze_prompt_embeds": full_embeds,
+                    "breeze_prefill_offset": offset + span_len,
+                    "breeze_generated_frames": int(info.get("breeze_generated_frames", 0) or 0),
+                    "breeze_max_new_frames": int(info.get("breeze_max_new_frames", -1)),
+                },
+            )
+
+        frame = info.get("breeze_current_frame")
+        if isinstance(frame, torch.Tensor) and frame.numel() == self.num_codebooks:
+            frame = frame.to(device=input_ids.device, dtype=torch.long).reshape(1, 1, -1)
+            embeds = self.embed_input_ids(frame).reshape(1, -1)
+            safe_id = frame[..., 0].reshape_as(input_ids).to(dtype=input_ids.dtype)
+            return safe_id, embeds, {}
+        has_breeze_state = any(
+            key in info
+            for key in (
+                "breeze_current_frame",
+                "breeze_audio_codes",
+                "breeze_generated_frames",
+                "breeze_prompt_embeds",
+            )
+        )
+        if has_breeze_state:
+            # A real decode must consume the full frame produced from the
+            # preceding backbone hidden state. A scalar fallback would silently
+            # fill codebooks 1..15 with EOS and corrupt AR state.
+            raise RuntimeError(
+                "Breeze decode is missing breeze_current_frame; refusing scalar fallback "
+                "because it would fill codebooks 1..15 with EOS"
+            )
+        # Runner-only dummy execution has no Breeze codec state. It must not
+        # invent a semantically invalid audio frame; a stable zero embedding is
+        # sufficient for shape/profiling warmup.
+        dummy_embeds = torch.zeros(
+            (*input_ids.shape, self.hidden_size),
+            device=input_ids.device,
+            dtype=self.embed_audio_tokens.weight.dtype,
+        )
+        return input_ids, dummy_embeds, {}
+
+    def postprocess(self, hidden_states: torch.Tensor, **_: Any) -> dict[str, Any]:
+        if hidden_states.numel() == 0:
+            return {}
+        return {"hidden_states": {"last": hidden_states[-1].detach()}}
+
+    # ------------------------------------------------------------------
+    # Main head, depth decoder and Omni output
+    # ------------------------------------------------------------------
+
+    def compute_logits(
+        self,
+        hidden_states: torch.Tensor | OmniOutput,
+        sampling_metadata: SamplingMetadata | None = None,
+    ) -> torch.Tensor | None:
+        del sampling_metadata
+        if isinstance(hidden_states, OmniOutput):
+            hidden_states = hidden_states.text_hidden_states
+        if hidden_states is None:
+            return None
+        logits = self._main_head_logits(hidden_states)
+
+        # ``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(
+                states,
+                getattr(self, "_batch_state_spans", None),
+                int(logits.shape[0]),
+            ):
+                selected_code0 = state.get("breeze_selected_code0")
+                if selected_code0 is not None:
+                    row = logits[row_start:row_end]
+                    row.fill_(float("-inf"))
+                    row[:, int(selected_code0)] = 0.0
+        return logits
+
+    def _main_head_logits(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        logits = self.logits_processor(self.lm_head, hidden_states)
+        if logits is None:
+            raise RuntimeError("Breeze main head returned no logits")
+        if self._codec_disallowed_mask is None or self._codec_disallowed_mask.device != logits.device:
+            mask = torch.zeros(logits.shape[-1], dtype=torch.bool, device=logits.device)
+            if self.codebook_size < self.codebook_vocab_size:
+                mask[self.codebook_size : self.codebook_vocab_size] = True
+            self._codec_disallowed_mask = mask
+        return logits.masked_fill(self._codec_disallowed_mask, float("-inf"))
+
+    @torch.no_grad()
+    def _generate_depth_codes(self, backbone_hidden: torch.Tensor, code0: int) -> torch.Tensor:
+        sequence = torch.tensor([[0, code0]], dtype=torch.long, device=backbone_hidden.device)
+        generated = [int(code0)]
+        for _ in range(self.num_codebooks - 1):
+            depth_out = self.depth_decoder(
+                input_ids=sequence,
+                backbone_last_hidden_state=backbone_hidden.reshape(1, -1),
+                use_cache=False,
+            )
+            logits = depth_out.logits[:, -1, :].clone()
+            if self.codebook_size < logits.shape[-1]:
+                logits[:, self.codebook_size :] = float("-inf")
+            next_code = int(torch.argmax(logits, dim=-1).item())
+            generated.append(next_code)
+            sequence = torch.cat([sequence, torch.tensor([[next_code]], device=sequence.device)], dim=1)
+        return torch.tensor(generated, dtype=torch.long, device=backbone_hidden.device).unsqueeze(0)
+
+    @staticmethod
+    def _accumulate_codes(info: dict[str, Any], frame: torch.Tensor) -> torch.Tensor:
+        """Append one ``(1, Q)`` frame to the request's cumulative codes."""
+        accumulated = info.get("breeze_audio_codes")
+        accumulated = (
+            torch.cat([accumulated.to(frame.device), frame], dim=0)
+            if isinstance(accumulated, torch.Tensor) and accumulated.numel()
+            else frame
+        )
+        info["breeze_audio_codes"] = accumulated
+        return accumulated
+
+    def make_omni_output(self, model_outputs: torch.Tensor | OmniOutput, **kwargs: Any) -> OmniOutput:
+        if isinstance(model_outputs, OmniOutput):
+            self._batch_state = None
+            self._batch_state_spans = None
+            return model_outputs
+        hidden = model_outputs
+        infos = kwargs.get("model_intermediate_buffer", [])
+        spans = kwargs.get("request_token_spans")
+        info_items = _normalize_request_infos(infos)
+        if info_items is None:
+            self._batch_state = None
+            self._batch_state_spans = None
+            return OmniOutput(text_hidden_states=hidden, multimodal_outputs={})
+        # The runner invokes compute_logits after this method, so retain the
+        # same request ordering and spans for per-request EOS masking.
+        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):
+                row_start = max(0, int(spans[index][0]))
+                row_end = min(int(spans[index][1]), int(hidden.shape[0]))
+            elif len(info_items) == 1:
+                row_start, row_end = 0, int(hidden.shape[0])
+            else:
+                raise RuntimeError("Breeze make_omni_output requires request_token_spans for batched decode")
+            if row_end <= row_start:
+                per_request_codes.append(hidden.new_empty((0, self.num_codebooks), dtype=torch.long))
+                continue
+            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)).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")
+                per_request_codes.append(
+                    existing
+                    if isinstance(existing, torch.Tensor) and existing.numel() and not self._async_chunk
+                    else hidden.new_empty((0, self.num_codebooks), dtype=torch.long)
+                )
+                continue
+            if code0 < 0 or code0 >= self.codebook_size:
+                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
+            if self._async_chunk:
+                # Streaming consumers only ever read the per-frame tail. The
+                # cumulative buffer exists for full-payload transport and the
+                # opt-in golden dump; maintaining it here would also cost an
+                # O(T^2) tensor-cat per request.
+                if self._golden_dump_dir:
+                    self._accumulate_codes(info, frame)
+                per_request_codes.append(frame)
+            else:
+                per_request_codes.append(self._accumulate_codes(info, frame))
+        if self._golden_dump_dir:
+            for info in info_items:
+                self._dump_golden_frames(info)
+        return OmniOutput(text_hidden_states=hidden, multimodal_outputs={"codes": {"audio": per_request_codes}})
+
+    def _dump_golden_frames(self, info: dict[str, Any]) -> None:
+        """Write terminal codec frames for opt-in golden-parity diagnostics."""
+        codes = info.get("breeze_audio_codes")
+        if not info.get("breeze_force_eos", False) or not isinstance(codes, torch.Tensor) or codes.numel() == 0:
+            return
+        prompt_ids = info.get("prompt_ids")
+        if not isinstance(prompt_ids, torch.Tensor):
+            raise RuntimeError("Breeze golden dump is missing prompt_ids")
+        digest = hashlib.sha256(prompt_ids.detach().cpu().numpy().tobytes()).hexdigest()[:16]
+        output_dir = Path(self._golden_dump_dir)  # type: ignore[arg-type]
+        output_dir.mkdir(parents=True, exist_ok=True)
+        torch.save(
+            {
+                "template": info.get("template"),
+                "prompt_ids": prompt_ids.cpu(),
+                "codes": codes.detach().cpu().to(torch.long).contiguous(),
+                "generated_frames": int(info.get("breeze_generated_frames", 0) or 0),
+                "finished": True,
+            },
+            output_dir / f"breeze_{digest}.pt",
+        )
+
+    def _dump_golden_prefill(self, info: dict[str, Any], hidden: torch.Tensor) -> None:
+        """Write the terminal-prompt hidden row for opt-in parity diagnostics."""
+        prompt_ids = info.get("prompt_ids")
+        if not isinstance(prompt_ids, torch.Tensor):
+            raise RuntimeError("Breeze golden dump is missing prompt_ids")
+        digest = hashlib.sha256(prompt_ids.detach().cpu().numpy().tobytes()).hexdigest()[:16]
+        output_dir = Path(self._golden_dump_dir)  # type: ignore[arg-type]
+        output_dir.mkdir(parents=True, exist_ok=True)
+        torch.save(
+            {
+                "template": info.get("template"),
+                "prompt_ids": prompt_ids.cpu(),
+                "hidden": hidden.detach().reshape(-1).cpu().to(torch.float32).contiguous(),
+            },
+            output_dir / f"prefill_{digest}.pt",
+        )
+
+    def on_requests_finished(self, finished_req_ids: Iterable[str]) -> None:
+        """Drop cross-step references retained for the finished AR requests."""
+        del finished_req_ids
+        # Codec/frame state lives in request-local additional_information and is
+        # freed with the Request. Only the short logits-to-state mapping is
+        # model-owned and must not leak into the next micro-batch.
+        self._batch_state = None
+        self._batch_state_spans = None
+
+    # ------------------------------------------------------------------
+    # Weight loading
+    # ------------------------------------------------------------------
+
+    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
+        loaded: set[str] = set()
+        params = dict(self.named_parameters())
+        backbone_weights: list[tuple[str, torch.Tensor]] = []
+        text_weights: list[tuple[str, torch.Tensor]] = []
+        depth_weights: list[tuple[str, torch.Tensor]] = []
+        for name, tensor in weights:
+            # This table belongs to Breeze's custom audio embedding module,
+            # although its checkpoint key is nested under backbone_model.
+            # Handle it before forwarding the remaining backbone weights to
+            # Qwen3Model.
+            if name == "backbone_model.embed_tokens.embed_audio_tokens.weight":
+                target = "embed_audio_tokens.weight"
+                param = params.get(target)
+                if param is None:
+                    raise ValueError(f"Missing Breeze parameter: {target}")
+                _check_weight_shape(name, tensor, tuple(param.shape))
+                default_weight_loader(param, tensor)
+                loaded.add(target)
+                continue
+            if name.startswith("backbone_model."):
+                # Qwen3Model.load_weights() is called on the nested module and
+                # therefore expects names relative to that module (the same
+                # convention used by MOSS-TTS), not the outer ``model.``
+                # namespace used by ``named_parameters()``.
+                backbone_weights.append((name[len("backbone_model.") :], tensor))
+                continue
+            if name.startswith("text_encoder."):
+                text_name = name[len("text_encoder.") :]
+                text_weights.append((text_name, tensor))
+                continue
+            if name.startswith("depth_decoder."):
+                depth_weights.append((name[len("depth_decoder.") :], tensor))
+                continue
+            if name in {"lm_head.weight", "embed_text_tokens.weight"} or name.startswith("text_encoder_proj."):
+                target = name
+            else:
+                continue
+            param = params.get(target)
+            if param is None:
+                continue
+            # ParallelLMHead stores a TP-local shard while checkpoint tensors
+            # are global; validate against the global Breeze head shape.
+            expected_shape = (
+                (self.codebook_vocab_size + 1, self.hidden_size) if name == "lm_head.weight" else tuple(param.shape)
+            )
+            _check_weight_shape(name, tensor, expected_shape)
+            loader = getattr(param, "weight_loader", default_weight_loader)
+            loader(param, tensor)
+            loaded.add(target)
+
+        if backbone_weights:
+            loaded.update("model." + key for key in self.model.load_weights(backbone_weights))
+        if text_weights:
+            loaded.update("text_encoder." + key for key in self.text_encoder.load_weights(text_weights))
+        if depth_weights:
+            loaded.update("depth_decoder." + key for key in self.depth_decoder.load_weights(depth_weights))
+            if bool(getattr(self.config, "tie_codebooks_embeddings", False)):
+                # The checkpoint serializes only one side of the tied table.
+                # ``named_parameters(remove_duplicate=True)`` exposes it as the
+                # talker-owned ``embed_audio_tokens.weight``, so report both
+                # aliases to the strict weight tracker.
+                if "depth_decoder.model.embed_tokens.weight" in loaded:
+                    loaded.add("embed_audio_tokens.weight")
+                if "embed_audio_tokens.weight" in loaded:
+                    loaded.add("depth_decoder.model.embed_tokens.weight")
+        return loaded
+
+
+__all__ = ["BreezeTTS2TalkerForGeneration"]
diff --git a/vllm_omni/model_executor/models/breeze_tts_2/modeling_breeze_tts_2_text.py b/vllm_omni/model_executor/models/breeze_tts_2/modeling_breeze_tts_2_text.py
new file mode 100644
index 000000000..0276e8278
--- /dev/null
+++ b/vllm_omni/model_executor/models/breeze_tts_2/modeling_breeze_tts_2_text.py
@@ -0,0 +1,350 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Breeze T5Gemma2 text encoder.
+
+The Breeze checkpoint contains a T5Gemma2 encoder, not the older T5Gemma
+implementation used by some diffusion models. This module keeps the encoder
+local to Breeze so checkpoint names and attention semantics stay explicit,
+while using vLLM tensor-parallel layers for the expensive projections.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Any
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+from vllm.distributed import get_tensor_model_parallel_world_size
+from vllm.model_executor.layers.activation import get_act_fn
+from vllm.model_executor.layers.linear import (
+    MergedColumnParallelLinear,
+    QKVParallelLinear,
+    RowParallelLinear,
+)
+from vllm.model_executor.layers.vocab_parallel_embedding import VocabParallelEmbedding
+from vllm.model_executor.model_loader.weight_utils import default_weight_loader
+
+
+class _RMSNorm(nn.Module):
+    """T5Gemma2 RMSNorm, whose checkpoint stores a zero-centered weight."""
+
+    def __init__(self, dim: int, eps: float) -> None:
+        super().__init__()
+        self.weight = nn.Parameter(torch.zeros(dim))
+        self.eps = float(eps)
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        normalized = hidden_states.float() * torch.rsqrt(
+            hidden_states.float().pow(2).mean(dim=-1, keepdim=True) + self.eps
+        )
+        return (normalized * (1.0 + self.weight.float())).to(hidden_states.dtype)
+
+
+class _RotaryEmbedding(nn.Module):
+    def __init__(self, config: Any) -> None:
+        super().__init__()
+        self.config = config
+        for layer_type in dict.fromkeys(config.layer_types):
+            params = dict(config.rope_parameters.get(layer_type, {}))
+            base = float(params.get("rope_theta", 10_000.0))
+            factor = float(params.get("factor", 1.0))
+            dim = int(config.head_dim)
+            inv_freq = 1.0 / (base ** (torch.arange(0, dim, 2, dtype=torch.float32) / dim))
+            if params.get("rope_type") == "linear":
+                inv_freq = inv_freq / factor
+            elif params.get("rope_type", "default") != "default":
+                raise ValueError(f"Unsupported T5Gemma2 rope type: {params.get('rope_type')!r}")
+            self.register_buffer(f"{layer_type}_inv_freq", inv_freq, persistent=False)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        position_ids: torch.Tensor,
+        layer_type: str,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        inv_freq = getattr(self, f"{layer_type}_inv_freq")
+        expanded = inv_freq[None, :, None].to(device=hidden_states.device)
+        positions = position_ids[:, None, :].float()
+        freqs = (expanded.float() @ positions).transpose(1, 2)
+        emb = torch.cat((freqs, freqs), dim=-1)
+        return emb.cos().to(hidden_states.dtype), emb.sin().to(hidden_states.dtype)
+
+
+def _rotate_half(value: torch.Tensor) -> torch.Tensor:
+    first, second = value[..., : value.shape[-1] // 2], value[..., value.shape[-1] // 2 :]
+    return torch.cat((-second, first), dim=-1)
+
+
+def _apply_rotary(
+    query: torch.Tensor,
+    key: torch.Tensor,
+    cos: torch.Tensor,
+    sin: torch.Tensor,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    cos = cos.unsqueeze(1)
+    sin = sin.unsqueeze(1)
+    return (query * cos) + (_rotate_half(query) * sin), (key * cos) + (_rotate_half(key) * sin)
+
+
+def _repeat_kv(hidden_states: torch.Tensor, repeats: int) -> torch.Tensor:
+    if repeats == 1:
+        return hidden_states
+    batch, heads, seq_len, head_dim = hidden_states.shape
+    return (
+        hidden_states[:, :, None, :, :]
+        .expand(batch, heads, repeats, seq_len, head_dim)
+        .reshape(batch, heads * repeats, seq_len, head_dim)
+    )
+
+
+def _attention_mask(
+    padding_mask: torch.Tensor | None,
+    *,
+    batch_size: int,
+    seq_len: int,
+    layer_type: str,
+    sliding_window: int | None,
+    dtype: torch.dtype,
+    device: torch.device,
+) -> torch.Tensor | None:
+    if layer_type == "full_attention" and padding_mask is None:
+        return None
+    valid = (
+        torch.ones((batch_size, seq_len), device=device, dtype=torch.bool)
+        if padding_mask is None
+        else padding_mask.to(device=device, dtype=torch.bool)
+    )
+    allowed = valid[:, None, None, :].expand(batch_size, 1, seq_len, seq_len)
+    if layer_type == "sliding_attention":
+        if sliding_window is None:
+            raise ValueError("T5Gemma2 sliding_attention requires sliding_window")
+        q_idx = torch.arange(seq_len, device=device)[:, None]
+        kv_idx = torch.arange(seq_len, device=device)[None, :]
+        left = (int(sliding_window) + 1) // 2
+        right = int(sliding_window) // 2 + 1
+        distance = q_idx - kv_idx
+        local = ((distance >= 0) & (distance < left)) | ((distance < 0) & (-distance < right))
+        allowed = allowed & local[None, None, :, :]
+    mask = torch.zeros((batch_size, 1, seq_len, seq_len), device=device, dtype=dtype)
+    mask.masked_fill_(~allowed, torch.finfo(dtype).min)
+    return mask
+
+
+class _SelfAttention(nn.Module):
+    def __init__(self, config: Any) -> None:
+        super().__init__()
+        tp_size = get_tensor_model_parallel_world_size()
+        if config.num_attention_heads % tp_size != 0:
+            raise ValueError("T5Gemma2 attention heads must be divisible by tensor parallel size")
+        self.layer_type = config.layer_type
+        self.head_dim = int(config.head_dim)
+        self.num_heads = int(config.num_attention_heads) // tp_size
+        self.num_kv_heads = max(1, int(config.num_key_value_heads) // tp_size)
+        self.num_key_value_groups = self.num_heads // self.num_kv_heads
+        self.scaling = float(config.query_pre_attn_scalar) ** -0.5
+        self.qkv_proj = QKVParallelLinear(
+            hidden_size=config.hidden_size,
+            head_size=self.head_dim,
+            total_num_heads=config.num_attention_heads,
+            total_num_kv_heads=config.num_key_value_heads,
+            bias=config.attention_bias,
+        )
+        self.o_proj = RowParallelLinear(
+            input_size=config.num_attention_heads * self.head_dim,
+            output_size=config.hidden_size,
+            bias=config.attention_bias,
+            input_is_parallel=True,
+        )
+        self.q_norm = _RMSNorm(self.head_dim, config.rms_norm_eps)
+        self.k_norm = _RMSNorm(self.head_dim, config.rms_norm_eps)
+        self.sliding_window = config.sliding_window if self.layer_type == "sliding_attention" else None
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        position_embeddings: tuple[torch.Tensor, torch.Tensor],
+        attention_mask: torch.Tensor | None,
+    ) -> torch.Tensor:
+        qkv, _ = self.qkv_proj(hidden_states)
+        q_size = self.num_heads * self.head_dim
+        kv_size = self.num_kv_heads * self.head_dim
+        query, key, value = qkv.split((q_size, kv_size, kv_size), dim=-1)
+        shape = (*hidden_states.shape[:-1], -1, self.head_dim)
+        query = self.q_norm(query.view(shape).transpose(1, 2))
+        key = self.k_norm(key.view(shape).transpose(1, 2))
+        value = value.view(shape).transpose(1, 2)
+        query, key = _apply_rotary(query, key, *position_embeddings)
+        key = _repeat_kv(key, self.num_key_value_groups)
+        value = _repeat_kv(value, self.num_key_value_groups)
+        # SDPA scales by head_dim**-0.5; adjust Q to T5Gemma2's scalar.
+        query = query * (self.scaling / (self.head_dim**-0.5))
+        output = F.scaled_dot_product_attention(
+            query,
+            key,
+            value,
+            attn_mask=attention_mask,
+            dropout_p=0.0,
+        )
+        output = output.transpose(1, 2).contiguous().reshape(*hidden_states.shape[:-1], -1)
+        output, _ = self.o_proj(output)
+        return output
+
+
+class _MLP(nn.Module):
+    def __init__(self, config: Any) -> None:
+        super().__init__()
+        self.gate_up_proj = MergedColumnParallelLinear(
+            input_size=config.hidden_size,
+            output_sizes=[config.intermediate_size, config.intermediate_size],
+            bias=False,
+        )
+        self.down_proj = RowParallelLinear(
+            input_size=config.intermediate_size,
+            output_size=config.hidden_size,
+            bias=False,
+            input_is_parallel=True,
+        )
+        self.act_fn = get_act_fn(config.hidden_activation)
+        self.dropout = nn.Dropout(float(config.dropout_rate))
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        gate_up, _ = self.gate_up_proj(hidden_states)
+        gate, up = gate_up.chunk(2, dim=-1)
+        output, _ = self.down_proj(self.dropout(self.act_fn(gate) * up))
+        return output
+
+
+class _EncoderLayer(nn.Module):
+    def __init__(self, config: Any, layer_idx: int) -> None:
+        super().__init__()
+        layer_config = type("LayerConfig", (), dict(vars(config)))()
+        layer_config.layer_type = config.layer_types[layer_idx]
+        self.attention_type = layer_config.layer_type
+        self.pre_self_attn_layernorm = _RMSNorm(config.hidden_size, config.rms_norm_eps)
+        self.self_attn = _SelfAttention(layer_config)
+        self.post_self_attn_layernorm = _RMSNorm(config.hidden_size, config.rms_norm_eps)
+        self.pre_feedforward_layernorm = _RMSNorm(config.hidden_size, config.rms_norm_eps)
+        self.mlp = _MLP(config)
+        self.post_feedforward_layernorm = _RMSNorm(config.hidden_size, config.rms_norm_eps)
+        self.dropout = nn.Dropout(float(config.dropout_rate))
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        position_embeddings: tuple[torch.Tensor, torch.Tensor],
+        attention_mask: torch.Tensor | None,
+    ) -> torch.Tensor:
+        residual = hidden_states
+        hidden_states = self.pre_self_attn_layernorm(hidden_states)
+        hidden_states = self.self_attn(hidden_states, position_embeddings, attention_mask)
+        hidden_states = residual + self.dropout(self.post_self_attn_layernorm(hidden_states))
+        residual = hidden_states
+        hidden_states = self.pre_feedforward_layernorm(hidden_states)
+        hidden_states = self.mlp(hidden_states)
+        hidden_states = residual + self.dropout(self.post_feedforward_layernorm(hidden_states))
+        return hidden_states
+
+
+class BreezeTTS2TextEncoder(nn.Module):
+    """Frozen T5Gemma2 encoder returning ``(B, S, hidden_size)`` states."""
+
+    def __init__(self, config: Any) -> None:
+        super().__init__()
+        self.config = config
+        self.embed_tokens = VocabParallelEmbedding(config.vocab_size, config.hidden_size)
+        self.embed_scale = float(config.hidden_size**0.5)
+        self.eoi_token_index = int(getattr(config, "eoi_token_index", 256000))
+        # T5Gemma2 stores this learned replacement vector under the input
+        # embedding module (``embed_tokens.eoi_embedding``), so keep the same
+        # parameter path for checkpoint loading and tied-weight inspection.
+        self.embed_tokens.eoi_embedding = nn.Parameter(torch.zeros(config.hidden_size))
+        self.layers = nn.ModuleList([_EncoderLayer(config, i) for i in range(config.num_hidden_layers)])
+        self.norm = _RMSNorm(config.hidden_size, config.rms_norm_eps)
+        self.rotary_emb = _RotaryEmbedding(config)
+        self.dropout = nn.Dropout(float(config.dropout_rate))
+
+    @property
+    def dtype(self) -> torch.dtype:
+        return next(self.parameters()).dtype
+
+    def forward(
+        self,
+        input_ids: torch.Tensor,
+        attention_mask: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        if input_ids.ndim != 2:
+            raise ValueError(f"Breeze text encoder expects 2D input_ids, got {tuple(input_ids.shape)}")
+        if attention_mask is not None and attention_mask.shape != input_ids.shape:
+            raise ValueError(
+                "Breeze text encoder attention_mask must match input_ids: "
+                f"{tuple(attention_mask.shape)} != {tuple(input_ids.shape)}"
+            )
+        hidden_states = self.embed_tokens(input_ids) * self.embed_scale
+        eoi_mask = input_ids == self.eoi_token_index
+        if bool(eoi_mask.any()):
+            hidden_states = torch.where(
+                eoi_mask.unsqueeze(-1),
+                self.embed_tokens.eoi_embedding.to(dtype=hidden_states.dtype),
+                hidden_states,
+            )
+        hidden_states = self.dropout(hidden_states)
+        positions = torch.arange(input_ids.shape[1], device=input_ids.device, dtype=torch.long).unsqueeze(0)
+        position_embeddings = {
+            layer_type: self.rotary_emb(hidden_states, positions, layer_type)
+            for layer_type in set(self.config.layer_types)
+        }
+        masks = {
+            layer_type: _attention_mask(
+                attention_mask,
+                batch_size=input_ids.shape[0],
+                seq_len=input_ids.shape[1],
+                layer_type=layer_type,
+                sliding_window=self.config.sliding_window,
+                dtype=hidden_states.dtype,
+                device=input_ids.device,
+            )
+            for layer_type in set(self.config.layer_types)
+        }
+        for layer in self.layers:
+            hidden_states = layer(
+                hidden_states,
+                position_embeddings[layer.attention_type],
+                masks[layer.attention_type],
+            )
+        return self.dropout(self.norm(hidden_states))
+
+    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
+        stacked_params_mapping = (
+            ("qkv_proj", "q_proj", "q"),
+            ("qkv_proj", "k_proj", "k"),
+            ("qkv_proj", "v_proj", "v"),
+            ("gate_up_proj", "gate_proj", 0),
+            ("gate_up_proj", "up_proj", 1),
+        )
+        params = dict(self.named_parameters())
+        loaded: set[str] = set()
+        for name, tensor in weights:
+            target = name
+            shard_id: str | int | None = None
+            for packed_name, source_name, source_id in stacked_params_mapping:
+                marker = f".{source_name}."
+                if marker in name:
+                    target = name.replace(marker, f".{packed_name}.")
+                    shard_id = source_id
+                    break
+            parameter = params.get(target)
+            if parameter is None:
+                continue
+            loader = getattr(parameter, "weight_loader", default_weight_loader)
+            if shard_id is None:
+                loader(parameter, tensor)
+            else:
+                loader(parameter, tensor, shard_id)
+            loaded.add(target)
+        return loaded
+
+
+__all__ = ["BreezeTTS2TextEncoder"]
diff --git a/vllm_omni/model_executor/models/breeze_tts_2/pipeline.py b/vllm_omni/model_executor/models/breeze_tts_2/pipeline.py
new file mode 100644
index 000000000..2b538df01
--- /dev/null
+++ b/vllm_omni/model_executor/models/breeze_tts_2/pipeline.py
@@ -0,0 +1,57 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Synchronous Breeze-TTS-2 pipeline: talker -> Mimi codec."""
+
+from vllm_omni.config.stage_config import (
+    PipelineConfig,
+    StageExecutionType,
+    StagePipelineConfig,
+)
+
+_PROC = "vllm_omni.model_executor.stage_input_processors.breeze_tts_2"
+
+BREEZE_TTS_2_PIPELINE = PipelineConfig(
+    model_type="breeze",
+    default_deploy_config_name="breeze_tts_2.yaml",
+    model_arch="BreezeForConditionalGeneration",
+    hf_architectures=("BreezeForConditionalGeneration",),
+    stages=(
+        StagePipelineConfig(
+            stage_id=0,
+            model_stage="breeze_tts_2",
+            execution_type=StageExecutionType.LLM_AR,
+            input_sources=(),
+            owns_tokenizer=True,
+            engine_output_type="latent",
+            async_chunk_process_next_stage_input_func=f"{_PROC}.talker2codec_async_chunk",
+            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],
+            },
+        ),
+        StagePipelineConfig(
+            stage_id=1,
+            model_stage="breeze_tts_2_codec",
+            execution_type=StageExecutionType.LLM_GENERATION,
+            input_sources=(0,),
+            final_output=True,
+            final_output_type="audio",
+            engine_output_type="audio",
+            model_arch="BreezeTTS2MimiCodec",
+            sync_process_input_func=f"{_PROC}.talker2codec",
+            sampling_constraints={"detokenize": True},
+            requires_full_payload_input=True,
+            retains_state_across_chunks=True,
+        ),
+    ),
+)
+
+__all__ = ["BREEZE_TTS_2_PIPELINE"]
diff --git a/vllm_omni/model_executor/models/breeze_tts_2/prompt_builder.py b/vllm_omni/model_executor/models/breeze_tts_2/prompt_builder.py
new file mode 100644
index 000000000..32c8145bb
--- /dev/null
+++ b/vllm_omni/model_executor/models/breeze_tts_2/prompt_builder.py
@@ -0,0 +1,336 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Breeze-TTS-2 request-to-prompt conversion.
+
+This module is intentionally limited to request preparation.  It creates the
+real prompt token ids needed by the scheduler and stores the text/audio masks
+and reference codes in ``additional_information``.  The stage-0 model later
+turns those values into embeddings; this keeps tokenization independent from
+the Qwen3/text-encoder implementation and avoids changing sequence length in
+the model ``preprocess`` hook.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+import torch
+from transformers import AutoTokenizer
+
+from vllm_omni.inputs.data import OmniTokensPrompt
+
+from .audio_tokenizer import BreezeReferenceAudioTokenizer
+
+AUDIO_TAG = "<|AUDIO|>"
+AUDIO_EOS = "<|audio_eos|>"
+INSTRUCTION_BOS = "<ins_bos>"
+INSTRUCTION_EOS = "<ins_eos>"
+
+
+@dataclass(frozen=True)
+class _TextSegment:
+    text: str
+
+
+@dataclass(frozen=True)
+class _AudioSegment:
+    source: Any
+    sample_rate: int | None
+
+
+class BreezeTTS2PromptBuilder:
+    """Build one Breeze prompt without depending on model modules.
+
+    ``tokenizer`` is a normal HuggingFace tokenizer.  ``reference_audio_encoder``
+    is injected so the builder can use the serving worker's cached audio
+    encoder and never reload it per request.  The returned ``OmniTokensPrompt``
+    contains scheduler token ids and compact CPU metadata for stage-0
+    ``preprocess``.
+    """
+
+    def __init__(
+        self,
+        tokenizer: Any,
+        config: Any,
+        reference_audio_encoder: BreezeReferenceAudioTokenizer | None = None,
+    ) -> None:
+        self.tokenizer = tokenizer
+        self.audio_encoder = reference_audio_encoder
+        self.audio_token_id = int(config.audio_token_id)
+        self.audio_eos_token_id = int(config.audio_eos_token_id)
+        # The Breeze tokenizer vocabulary is larger than the Qwen3 backbone
+        # vocabulary.  ``prompt_token_ids`` are scheduler bookkeeping only, so
+        # keep them in the backbone vocabulary and retain the real Breeze ids
+        # in ``additional_information['prompt_ids']`` for the talker.
+        self.scheduler_token_id = int(config.pad_token_id)
+        scheduler_vocab_size = int(config.backbone_config.vocab_size)
+        if self.scheduler_token_id >= scheduler_vocab_size:
+            raise ValueError(
+                "prompt_pad_token_id must be smaller than the backbone vocabulary: "
+                f"{self.scheduler_token_id} >= {scheduler_vocab_size}"
+            )
+        self.num_codebooks = int(config.num_codebooks)
+        codec_config = getattr(config, "codec_config", None)
+        if isinstance(codec_config, Mapping):
+            self.codebook_size = int(codec_config.get("codebook_size", 2048))
+        elif codec_config is not None:
+            self.codebook_size = int(getattr(codec_config, "codebook_size", 2048))
+        else:
+            # ``codec_config`` is optional in BreezeTTS2Config; a minimal
+            # checkpoint may omit it. Breeze's codec uses 2048-entry
+            # codebooks, the same fallback the talker and codec stages apply.
+            self.codebook_size = 2048
+        if self.num_codebooks <= 0 or self.codebook_size <= 0:
+            raise ValueError("num_codebooks and codec codebook_size must be positive")
+        self._validate_audio_special_tokens()
+
+    @classmethod
+    def from_pretrained(
+        cls,
+        model_path: str,
+        config: Any,
+        *,
+        reference_audio_encoder: BreezeReferenceAudioTokenizer | None = None,
+        tokenizer_kwargs: Mapping[str, Any] | None = None,
+    ) -> BreezeTTS2PromptBuilder:
+        """Load the text tokenizer once and construct a reusable builder."""
+        kwargs = dict(tokenizer_kwargs or {})
+        kwargs.setdefault("use_fast", True)
+        kwargs.setdefault("trust_remote_code", True)
+        tokenizer = AutoTokenizer.from_pretrained(model_path, **kwargs)
+        return cls(tokenizer, config, reference_audio_encoder)
+
+    def build(
+        self,
+        request: Mapping[str, Any],
+        *,
+        template: str | None = None,
+    ) -> OmniTokensPrompt:
+        """Convert one request to a vLLM-Omni token prompt.
+
+        Supported templates are ``tts_plain``, ``tts_instruction``,
+        ``ref_clone_tata`` and ``ref_edit_tata``.  When omitted, the template
+        is inferred from the presence of instruction/reference fields.
+        """
+        template_name = template or request.get("template")
+        if not isinstance(template_name, str) or not template_name:
+            template_name = _infer_template(request)
+        segments = self._build_segments(template_name, request)
+
+        # Breeze's reference implementation first adds tokenizer special
+        # tokens to every text segment, decodes those segments back to text,
+        # inserts the audio placeholders, and tokenizes the complete string
+        # once.  This matters at segment boundaries: tokenizing each raw text
+        # fragment independently can produce different boundary tokens.
+        rendered_segments: list[tuple[str, bool, int]] = []
+        reference_codes: list[torch.Tensor] = []
+
+        for segment in segments:
+            if isinstance(segment, _TextSegment):
+                ids = self._encode_one_text(segment.text, add_special_tokens=True)
+                if not ids:
+                    raise ValueError("Breeze text tokenizer returned an empty segment")
+                rendered = str(self.tokenizer.decode(ids, skip_special_tokens=False))
+                rendered_segments.append((rendered, True, 0))
+                continue
+
+            codes = self._resolve_reference_codes(segment)
+            reference_codes.append(codes)
+            audio_text = AUDIO_TAG * int(codes.shape[0]) + AUDIO_EOS
+            rendered_segments.append((audio_text, False, int(codes.shape[0]) + 1))
+
+        prompt_ids: list[int] = []
+        text_mask: list[bool] = []
+        text_lengths: list[int] = []
+        rendered_prompt = "".join(item[0] for item in rendered_segments)
+        prompt_ids = self._encode_one_text(rendered_prompt, add_special_tokens=False)
+        offset = 0
+        for rendered, is_text, expected_len in rendered_segments:
+            segment_ids = self._encode_one_text(rendered, add_special_tokens=False)
+            actual_len = len(segment_ids)
+            if not is_text and actual_len != expected_len:
+                raise ValueError(
+                    "Breeze audio placeholder token length changed after rendering: "
+                    f"expected {expected_len}, got {actual_len}"
+                )
+            if not is_text and segment_ids != [
+                *([self.audio_token_id] * (expected_len - 1)),
+                self.audio_eos_token_id,
+            ]:
+                raise ValueError("Breeze tokenizer did not preserve audio placeholder ids")
+            text_mask.extend([is_text] * actual_len)
+            if is_text:
+                text_lengths.append(actual_len)
+            offset += actual_len
+        if offset != len(prompt_ids) or len(text_mask) != len(prompt_ids):
+            raise RuntimeError("Breeze rendered prompt length accounting error")
+        if not prompt_ids:
+            raise ValueError("Breeze prompt is empty")
+
+        input_values = torch.cat(reference_codes, dim=0) if reference_codes else None
+        if input_values is not None and int(input_values.shape[0]) != prompt_ids.count(self.audio_token_id):
+            raise RuntimeError("reference code count does not match audio placeholder count")
+
+        additional_information: dict[str, Any] = {
+            # The model runner may invoke preprocess on a chunk of a long
+            # prompt. Keep one compact CPU copy so the talker can reconstruct
+            # the full embedding buffer before slicing that chunk.
+            "prompt_ids": torch.tensor(prompt_ids, dtype=torch.long),
+            "attention_mask": torch.ones(len(prompt_ids), dtype=torch.bool),
+            "text_ids_mask": torch.tensor(text_mask, dtype=torch.bool),
+            "text_ids_len": torch.tensor(text_lengths, dtype=torch.long),
+            "template": template_name,
+        }
+        if input_values is not None:
+            # ``input_values`` is the name used by the upstream Breeze model.
+            # Keep the tensor unbatched here: Omni transports one request at a
+            # time and the talker adds the batch dimension after collation.
+            additional_information["input_values"] = input_values
+            additional_information["ref_code_len"] = int(input_values.shape[0])
+
+        if self.scheduler_token_id < 0:
+            raise ValueError("prompt_pad_token_id must be non-negative")
+
+        return OmniTokensPrompt(
+            # Never expose Breeze's high text/audio ids to the Qwen3 scheduler
+            # or its token-range validation.  The real ids remain available in
+            # additional_information and are consumed by ``preprocess``.
+            prompt_token_ids=[self.scheduler_token_id] * len(prompt_ids),
+            additional_information=additional_information,
+        )
+
+    def _build_segments(self, template: str, request: Mapping[str, Any]) -> list[_TextSegment | _AudioSegment]:
+        speaker = _speaker_prefix(request.get("speaker", "S0"))
+        text = _required_text(request, "text")
+        instruction = request.get("instruction")
+        ref_text = request.get("ref_text")
+
+        if template == "tts_plain":
+            return [_TextSegment(f"{speaker}{text}")]
+        if template == "tts_instruction":
+            if not isinstance(instruction, str) or not instruction:
+                raise ValueError("tts_instruction requires a non-empty instruction")
+            return [_TextSegment(f"{speaker}{INSTRUCTION_BOS}{instruction}{INSTRUCTION_EOS}{text}")]
+        if template in ("ref_clone_tata", "ref_edit_tata"):
+            if not isinstance(ref_text, str) or not ref_text:
+                raise ValueError(f"{template} requires a non-empty ref_text")
+            audio = self._audio_segment(request)
+            if template == "ref_clone_tata":
+                return [_TextSegment(f"{speaker}{ref_text}"), audio, _TextSegment(f"{speaker}{text}")]
+            if not isinstance(instruction, str) or not instruction:
+                raise ValueError("ref_edit_tata requires a non-empty instruction")
+            return [
+                _TextSegment(f"{speaker}{ref_text}"),
+                audio,
+                _TextSegment(f"{speaker}{INSTRUCTION_BOS}{instruction}{INSTRUCTION_EOS}{text}"),
+            ]
+        raise ValueError(
+            f"unknown Breeze template {template!r}; expected tts_plain, tts_instruction, "
+            "ref_clone_tata or ref_edit_tata"
+        )
+
+    def _audio_segment(self, request: Mapping[str, Any]) -> _AudioSegment:
+        source = request.get("ref_audio")
+        if source is None:
+            source = request.get("ref_audio_codes")
+        if source is None:
+            raw_codes = request.get("codes")
+            source = raw_codes.get("ref") if isinstance(raw_codes, Mapping) else None
+        if source is None:
+            raise ValueError("reference template requires ref_audio or ref_audio_codes")
+        sample_rate = request.get("ref_audio_sample_rate")
+        return _AudioSegment(source, int(sample_rate) if sample_rate is not None else None)
+
+    def _resolve_reference_codes(self, segment: _AudioSegment) -> torch.Tensor:
+        source = segment.source
+        if _looks_like_codes(source, self.num_codebooks):
+            codes = torch.as_tensor(source)
+            return _normalize_codes(codes, self.num_codebooks, self.codebook_size)
+        if self.audio_encoder is None:
+            raise RuntimeError("reference audio was provided but no reference_audio_encoder is configured")
+        codes = self.audio_encoder.encode(source, segment.sample_rate)
+        return _normalize_codes(codes, self.num_codebooks, self.codebook_size)
+
+    def _encode_one_text(self, text: str, *, add_special_tokens: bool) -> list[int]:
+        encoded = self.tokenizer(text, add_special_tokens=add_special_tokens, padding=False)
+        ids = encoded["input_ids"] if isinstance(encoded, Mapping) else encoded.input_ids
+        if isinstance(ids, torch.Tensor):
+            ids = ids.tolist()
+        return _as_int_list(ids)
+
+    def _validate_audio_special_tokens(self) -> None:
+        convert = self.tokenizer.convert_tokens_to_ids
+        for token, expected in ((AUDIO_TAG, self.audio_token_id), (AUDIO_EOS, self.audio_eos_token_id)):
+            actual = convert(token)
+            unk = getattr(self.tokenizer, "unk_token_id", None)
+            if actual is None or (unk is not None and actual == unk) or int(actual) != expected:
+                raise ValueError(f"tokenizer id for {token!r} is {actual}, expected config value {expected}")
+
+
+def _infer_template(request: Mapping[str, Any]) -> str:
+    has_ref = (
+        request.get("ref_audio") is not None
+        or request.get("ref_audio_codes") is not None
+        or bool(request.get("ref_text"))
+    )
+    has_instruction = bool(request.get("instruction"))
+    if has_ref and has_instruction:
+        return "ref_edit_tata"
+    if has_ref:
+        return "ref_clone_tata"
+    return "tts_instruction" if has_instruction else "tts_plain"
+
+
+def _required_text(request: Mapping[str, Any], key: str) -> str:
+    value = request.get(key)
+    if not isinstance(value, str) or not value.strip():
+        raise ValueError(f"Breeze request requires non-empty {key}")
+    return value
+
+
+def _speaker_prefix(value: Any) -> str:
+    if value in (None, ""):
+        return ""
+    value = str(value)
+    return value if value.startswith("[") and value.endswith("]") else f"[{value}]"
+
+
+def _as_int_list(value: Any) -> list[int]:
+    if isinstance(value, torch.Tensor):
+        value = value.tolist()
+    elif isinstance(value, np.ndarray):
+        value = value.tolist()
+    if not isinstance(value, list):
+        raise ValueError("tokenizer input_ids must be a list")
+    if value and isinstance(value[0], (list, tuple, np.ndarray, torch.Tensor)):
+        if len(value) != 1:
+            raise ValueError("tokenizer input_ids contains multiple sequences")
+        return _as_int_list(value[0])
+    return [int(item) for item in value]
+
+
+def _looks_like_codes(value: Any, num_codebooks: int) -> bool:
+    if isinstance(value, (torch.Tensor, np.ndarray)):
+        return value.ndim == 2 and value.shape[-1] == num_codebooks
+    return False
+
+
+def _normalize_codes(codes: Any, num_codebooks: int, codebook_size: int) -> torch.Tensor:
+    codes = torch.as_tensor(codes)
+    if codes.ndim != 2:
+        raise ValueError(f"reference audio codes must be 2D, got {tuple(codes.shape)}")
+    if codes.shape[0] == 0:
+        raise ValueError("reference audio codes must contain at least one frame")
+    if codes.shape[-1] != num_codebooks:
+        raise ValueError(f"expected {num_codebooks} codebooks, got {tuple(codes.shape)}")
+    codes = codes.to(device="cpu", dtype=torch.long).contiguous()
+    if int(codes.min()) < 0 or int(codes.max()) >= codebook_size:
+        raise ValueError(f"reference code outside [0, {codebook_size})")
+    return codes.to(dtype=torch.int16)
+
+
+__all__ = ["BreezeTTS2PromptBuilder"]
diff --git a/vllm_omni/model_executor/models/common/ming/audio_dsp.py b/vllm_omni/model_executor/models/common/ming/audio_dsp.py
index be8cd489c..d32415352 100644
--- a/vllm_omni/model_executor/models/common/ming/audio_dsp.py
+++ b/vllm_omni/model_executor/models/common/ming/audio_dsp.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
 # Adopted from https://github.com/inclusionAI/Ming-omni-tts/blob/main/audio_tokenizer/istft.py
 
 import torch
@@ -66,6 +66,26 @@ class ISTFT(nn.Module):
         window_buffer: torch.Tensor | None = None,
         streaming: bool = False,
         last_chunk: bool = False,
+    ) -> torch.Tensor | tuple[torch.Tensor, torch.Tensor | None, torch.Tensor | None]:
+        if self.padding == "same" and spec.is_cuda and not torch.is_grad_enabled():
+            from .fused_istft import fused_istft, fused_istft_supported
+
+            if fused_istft_supported(
+                spec, self.window, self.n_fft, self.hop_length, audio_buffer, window_buffer, streaming
+            ):
+                frames = torch.fft.irfft(spec, self.n_fft, dim=1, norm="backward")
+                return fused_istft(
+                    frames, self.window, self.hop_length, audio_buffer, window_buffer, streaming, last_chunk
+                )
+        return self.forward_native(spec, audio_buffer, window_buffer, streaming, last_chunk)
+
+    def forward_native(
+        self,
+        spec: torch.Tensor,
+        audio_buffer: torch.Tensor | None = None,
+        window_buffer: torch.Tensor | None = None,
+        streaming: bool = False,
+        last_chunk: bool = False,
     ) -> torch.Tensor | tuple[torch.Tensor, torch.Tensor | None, torch.Tensor | None]:
         """
         Compute the Inverse Short Time Fourier Transform (ISTFT) of a complex spectrogram.
diff --git a/vllm_omni/model_executor/models/common/ming/fused_istft.py b/vllm_omni/model_executor/models/common/ming/fused_istft.py
new file mode 100644
index 000000000..95da3ff70
--- /dev/null
+++ b/vllm_omni/model_executor/models/common/ming/fused_istft.py
@@ -0,0 +1,177 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Post-FFT ISTFT fusion for Ming's four-way overlapping audio frames.
+
+Each lane owns one output sample and gathers its contributing frames. Audio
+and window tails remain unnormalized so the next streaming chunk can add them.
+The low-precision window rounding follows PyTorch's square, fold, and add
+boundaries; the inverse FFT and the envelope-underflow check remain unchanged.
+"""
+
+import torch
+from vllm.triton_utils import HAS_TRITON, tl, triton
+
+if HAS_TRITON:
+
+    @triton.jit
+    def _istft_kernel(
+        frames,
+        window,
+        previous_audio,
+        previous_window,
+        output,
+        envelope_output,
+        next_audio,
+        next_window,
+        frame_stride_b,
+        frame_stride_w,
+        frame_stride_t,
+        audio_stride_b,
+        audio_stride_t,
+        window_stride_t,
+        num_frames,
+        raw_size,
+        output_start,
+        output_size,
+        hop_size: tl.constexpr,
+        streaming: tl.constexpr,
+        has_buffer: tl.constexpr,
+        block_size: tl.constexpr,
+    ):
+        batch = tl.program_id(0)
+        sample = tl.program_id(1) * block_size + tl.arange(0, block_size)
+        valid = sample < raw_size
+        last_frame = sample // hop_size
+        audio = tl.full((block_size,), 0, tl.float32)
+        envelope = tl.full((block_size,), 0, tl.float32)
+        window_dtype = window.dtype.element_ty
+
+        # Match CUDA col2im's ascending frame order. Disable FMA at launch to
+        # preserve the separately rounded window multiplication.
+        for overlap in tl.static_range(3, -1, -1):
+            frame = last_frame - overlap
+            window_index = sample % hop_size + overlap * hop_size
+            mask = valid & (frame >= 0) & (frame < num_frames)
+            weight = tl.load(window + window_index, mask=mask, other=0).to(tl.float32)
+            value = tl.load(
+                frames + batch * frame_stride_b + window_index * frame_stride_w + frame * frame_stride_t,
+                mask=mask,
+                other=0,
+            )
+            audio += value * weight
+            envelope += (weight * weight).to(window_dtype).to(tl.float32)
+
+        # F.fold accumulates in FP32, then stores in the window's dtype.
+        envelope = envelope.to(window_dtype).to(tl.float32)
+        tail_size: tl.constexpr = 3 * hop_size
+        if has_buffer:
+            carry_mask = valid & (sample < tail_size)
+            carry_audio = tl.load(
+                previous_audio + batch * audio_stride_b + sample * audio_stride_t, mask=carry_mask, other=0
+            )
+            carry_window = tl.load(previous_window + sample * window_stride_t, mask=carry_mask, other=0)
+            audio += carry_audio
+            envelope = (envelope + carry_window.to(tl.float32)).to(window_dtype).to(tl.float32)
+
+        output_index = sample - output_start
+        emit = valid & (output_index >= 0) & (output_index < output_size)
+        tl.store(output + batch * output_size + output_index, audio / envelope, mask=emit)
+        if batch == 0:
+            tl.store(envelope_output + output_index, envelope, mask=emit)
+
+        if streaming:
+            tail_index = sample - (raw_size - tail_size)
+            tail_mask = valid & (tail_index >= 0)
+            tl.store(next_audio + batch * tail_size + tail_index, audio, mask=tail_mask)
+            if batch == 0:
+                tl.store(next_window + tail_index, envelope, mask=tail_mask)
+
+
+def fused_istft_supported(
+    spec: torch.Tensor,
+    window: torch.Tensor,
+    n_fft: int,
+    hop: int,
+    audio_buffer: torch.Tensor | None,
+    window_buffer: torch.Tensor | None,
+    streaming: bool,
+) -> bool:
+    if not (
+        HAS_TRITON
+        and spec.is_cuda
+        and torch.version.hip is None
+        and spec.dtype == torch.complex64
+        and spec.ndim == 3
+        and spec.shape[0] > 0
+        and spec.shape[1] == n_fft // 2 + 1
+        and spec.shape[2] >= 2
+        and hop > 0
+        and n_fft == 4 * hop
+        and window.shape == (n_fft,)
+        and window.is_contiguous()
+        and window.device == spec.device
+        and window.dtype in (torch.float32, torch.bfloat16, torch.float16)
+    ):
+        return False
+    if not streaming or (audio_buffer is None and window_buffer is None):
+        return True
+    return (
+        audio_buffer is not None
+        and window_buffer is not None
+        and audio_buffer.shape == (spec.shape[0], 3 * hop)
+        and window_buffer.shape == (1, 3 * hop)
+        and audio_buffer.device == window_buffer.device == spec.device
+        and audio_buffer.dtype == torch.float32
+        and window_buffer.dtype == window.dtype
+    )
+
+
+def fused_istft(
+    frames: torch.Tensor,
+    window: torch.Tensor,
+    hop: int,
+    audio_buffer: torch.Tensor | None,
+    window_buffer: torch.Tensor | None,
+    streaming: bool,
+    last_chunk: bool,
+) -> tuple[torch.Tensor, torch.Tensor | None, torch.Tensor | None]:
+    """Fuse supported post-FFT inputs; dispatch is checked by ``ISTFT``."""
+    batch, win_length, num_frames = frames.shape
+    tail_size = win_length - hop
+    pad = tail_size // 2
+    raw_size = (num_frames - 1) * hop + win_length
+    has_buffer = streaming and audio_buffer is not None
+    start = 0 if has_buffer else pad
+    end = raw_size - (tail_size if streaming and not last_chunk else pad)
+    output_size = end - start
+    output = frames.new_empty((batch, output_size))
+    envelope = window.new_empty((output_size,))
+    next_audio = frames.new_empty((batch, tail_size)) if streaming else audio_buffer
+    next_window = window.new_empty((1, tail_size)) if streaming else window_buffer
+
+    _istft_kernel[(batch, triton.cdiv(raw_size, 256))](
+        frames,
+        window,
+        audio_buffer,
+        window_buffer,
+        output,
+        envelope,
+        next_audio,
+        next_window,
+        *frames.stride(),
+        audio_buffer.stride(0) if streaming and audio_buffer is not None else 0,
+        audio_buffer.stride(1) if streaming and audio_buffer is not None else 0,
+        window_buffer.stride(1) if streaming and window_buffer is not None else 0,
+        num_frames,
+        raw_size,
+        start,
+        output_size,
+        hop_size=hop,
+        streaming=streaming,
+        has_buffer=has_buffer,
+        block_size=256,
+        enable_fp_fusion=False,
+    )
+    if not (envelope > 1e-11).all():
+        raise RuntimeError("ISTFT window envelope underflowed; invalid overlap-add state.")
+    return output, next_audio, next_window
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 60b4d4525..306301c94 100644
--- a/vllm_omni/model_executor/models/common/qwen3_code_predictor.py
+++ b/vllm_omni/model_executor/models/common/qwen3_code_predictor.py
@@ -439,10 +439,11 @@ class CodePredictorBaseModel(nn.Module):
         # native bf16 support (Turing, Volta).  The RMSNorm and RoPE
         # layers already upcast internally; this extends the same
         # treatment to attention and MLP.
-        # autocast to float32 is unsupported on CPU; skip fp32 upcast there
-        # (CPU uses full-precision intermediates internally).
+        # CPU autocast to float32 is unsupported, and Ascend fused operators
+        # require matching activation and weight dtypes. Preserve the existing
+        # stability fallback on the other accelerator backends.
         input_dtype = inputs_embeds.dtype
-        use_fp32 = input_dtype == torch.float16 and inputs_embeds.device.type != "cpu"
+        use_fp32 = input_dtype == torch.float16 and inputs_embeds.device.type not in ("cpu", "npu")
         if use_fp32:
             inputs_embeds = inputs_embeds.float()
         hidden_states = inputs_embeds
@@ -681,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(
@@ -697,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()
@@ -760,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()
@@ -769,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
@@ -831,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]:
@@ -849,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
@@ -865,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
@@ -904,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
@@ -913,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
@@ -1012,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
@@ -1035,6 +1119,9 @@ class CodePredictorWrapper(nn.Module):
         model_fwd = self._compiled_model_fwd
         lm_heads = self._lm_heads_list
         codec_embeds = self._codec_embeds_list
+        # torch-npu cannot replay an inner NPUGraph while the outer talker_mtp
+        # graph is being captured. Capture state is constant for this forward.
+        is_npu_capturing = current_omni_platform.is_npu() and torch.npu.is_current_stream_capturing()
 
         # Zero the padded region of the buffer
         proj_buf[:padded_bsz].zero_()
@@ -1068,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 = (
@@ -1085,7 +1177,9 @@ class CodePredictorWrapper(nn.Module):
             # Use captured device graph if available, otherwise call compiled fn.
             device_graph_entry = self._device_graphs.get(graph_key)
 
-            if device_graph_entry is not None:
+            # Let the outer graph record the regular forward during capture;
+            # normal inference still uses the inner graph replay fast path.
+            if device_graph_entry is not None and not is_npu_capturing:
                 device_graph_entry[0].replay()
                 hidden_out = device_graph_entry[1]
             else:
@@ -1117,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:
@@ -1125,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/tests/model_executor/models/dots_tts/__init__.py b/vllm_omni/model_executor/models/cosmos3/__init__.py
similarity index 100%
rename from tests/model_executor/models/dots_tts/__init__.py
rename to vllm_omni/model_executor/models/cosmos3/__init__.py
diff --git a/vllm_omni/model_executor/models/cosmos3/pipeline.py b/vllm_omni/model_executor/models/cosmos3/pipeline.py
new file mode 100644
index 000000000..d26b4f46c
--- /dev/null
+++ b/vllm_omni/model_executor/models/cosmos3/pipeline.py
@@ -0,0 +1,41 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Cosmos3 policy single-stage topology for online OpenPI serving.
+
+Cosmos3 policy checkpoints (e.g. ``nvidia/Cosmos3-Nano-Policy-DROID``) are one
+diffusion stage: robot observation -> action chunk. They are
+registered in ``OMNI_PIPELINES`` because online OpenPI serving
+(``/v1/realtime/robot/openpi``) requires a registered pipeline so the deploy
+yaml's ``model_config.policy_server_config`` reaches the websocket handshake.
+
+This pipeline declares neither ``hf_architectures`` nor
+``diffusers_class_name``: policy checkpoints share their HF metadata
+(``model_type=cosmos3_omni``, ``model_index.json`` ``_class_name=
+Cosmos3OmniDiffusersPipeline``) with the T2I/video Cosmos3 checkpoints, which
+must keep resolving through the default single-stage diffusion fallback.
+Select this pipeline explicitly via a deploy yaml ``pipeline:`` key, e.g.
+``vllm serve nvidia/Cosmos3-Nano-Policy-DROID --omni --deploy-config
+/absolute/path/to/vllm-omni/vllm_omni/deploy/cosmos3_policy_droid.yaml``.
+"""
+
+from vllm_omni.config.stage_config import (
+    PipelineConfig,
+    StageExecutionType,
+    StagePipelineConfig,
+)
+
+COSMOS3_POLICY_PIPELINE = PipelineConfig(
+    model_type="cosmos3_policy",
+    model_arch="Cosmos3OmniDiffusersPipeline",
+    stages=(
+        StagePipelineConfig(
+            stage_id=0,
+            model_stage="diffusion",
+            execution_type=StageExecutionType.DIFFUSION,
+            input_sources=(),
+            final_output=True,
+            final_output_type="action",
+            model_arch="Cosmos3OmniDiffusersPipeline",
+        ),
+    ),
+)
diff --git a/vllm_omni/model_executor/models/cosyvoice3/code2wav_core/cfm.py b/vllm_omni/model_executor/models/cosyvoice3/code2wav_core/cfm.py
index 2ec12a251..c86b4a305 100644
--- a/vllm_omni/model_executor/models/cosyvoice3/code2wav_core/cfm.py
+++ b/vllm_omni/model_executor/models/cosyvoice3/code2wav_core/cfm.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
 # Adopted from https://github.com/FunAudioLLM/CosyVoice/tree/main/cosyvoice/flow
 """Conditional Flow Matching (CFM) classes for audio generation."""
 
@@ -11,6 +11,7 @@ from omegaconf import DictConfig
 from torch.nn import functional as F
 from vllm.logger import init_logger
 
+from vllm_omni.model_executor.models.cosyvoice3.runtime import cosyvoice3_batch_flow_profile
 from vllm_omni.model_executor.models.cosyvoice3.utils import make_pad_mask
 
 logger = init_logger(__name__)
@@ -74,20 +75,23 @@ class ConditionalCFM(BASECFM):
                 shape: (batch_size, n_feats, mel_timesteps)
         """
 
-        z = torch.randn_like(mu).to(mu.device).to(mu.dtype) * temperature
-        cache_size = cache.shape[2]
-        # fix prompt and overlap part mu and z
-        if cache_size != 0:
-            z[:, :, :cache_size] = cache[:, :, :, 0]
-            mu[:, :, :cache_size] = cache[:, :, :, 1]
-        z_cache = torch.concat([z[:, :, :prompt_len], z[:, :, -34:]], dim=2)
-        mu_cache = torch.concat([mu[:, :, :prompt_len], mu[:, :, -34:]], dim=2)
-        cache = torch.stack([z_cache, mu_cache], dim=-1)
+        with cosyvoice3_batch_flow_profile("cosyvoice3_cfm_noise_cache"):
+            z = torch.randn_like(mu).to(mu.device).to(mu.dtype) * temperature
+            cache_size = cache.shape[2]
+            # fix prompt and overlap part mu and z
+            if cache_size != 0:
+                z[:, :, :cache_size] = cache[:, :, :, 0]
+                mu[:, :, :cache_size] = cache[:, :, :, 1]
+            z_cache = torch.concat([z[:, :, :prompt_len], z[:, :, -34:]], dim=2)
+            mu_cache = torch.concat([mu[:, :, :prompt_len], mu[:, :, -34:]], dim=2)
+            cache = torch.stack([z_cache, mu_cache], dim=-1)
 
-        t_span = torch.linspace(0, 1, n_timesteps + 1, device=mu.device, dtype=mu.dtype)
-        if self.t_scheduler == "cosine":
-            t_span = 1 - torch.cos(t_span * 0.5 * torch.pi)
-        return self.solve_euler(z, t_span=t_span, mu=mu, mask=mask, spks=spks, cond=cond), cache
+        with cosyvoice3_batch_flow_profile("cosyvoice3_cfm_t_span"):
+            t_span = torch.linspace(0, 1, n_timesteps + 1, device=mu.device, dtype=mu.dtype)
+            if self.t_scheduler == "cosine":
+                t_span = 1 - torch.cos(t_span * 0.5 * torch.pi)
+        with cosyvoice3_batch_flow_profile(f"cosyvoice3_cfm_euler_{max(1, int(n_timesteps))}_steps"):
+            return self.solve_euler(z, t_span=t_span, mu=mu, mask=mask, spks=spks, cond=cond), cache
 
     def solve_euler(self, x, t_span, mu, mask, spks, cond):
         """
@@ -111,26 +115,39 @@ class ConditionalCFM(BASECFM):
 
         # Do not use concat, it may cause memory format changed and trt infer with wrong results!
         # NOTE when flow run in amp mode, x.dtype is float32, which cause nan in trt fp16
-        # inference, so set dtype=spks.dtype
-        x_in = torch.zeros([2, 80, x.size(2)], device=x.device, dtype=spks.dtype)
-        mask_in = torch.zeros([2, 1, x.size(2)], device=x.device, dtype=spks.dtype)
-        mu_in = torch.zeros([2, 80, x.size(2)], device=x.device, dtype=spks.dtype)
-        t_in = torch.zeros([2], device=x.device, dtype=spks.dtype)
-        spks_in = torch.zeros([2, 80], device=x.device, dtype=spks.dtype)
-        cond_in = torch.zeros([2, 80, x.size(2)], device=x.device, dtype=spks.dtype)
+        # inference, so set dtype=spks.dtype.  The batch is doubled for CFG:
+        # first B rows are conditioned, second B rows are unconditional.
+        batch_size = int(x.size(0))
+        estimator_batch = 2 * batch_size
+        estimator_dtype = spks.dtype if spks is not None else x.dtype
+        with cosyvoice3_batch_flow_profile("cosyvoice3_cfm_cfg_allocate_2b"):
+            x_in = torch.zeros([estimator_batch, 80, x.size(2)], device=x.device, dtype=estimator_dtype)
+            mask_in = torch.zeros([estimator_batch, 1, x.size(2)], device=x.device, dtype=estimator_dtype)
+            mu_in = torch.zeros([estimator_batch, 80, x.size(2)], device=x.device, dtype=estimator_dtype)
+            t_in = torch.zeros([estimator_batch], device=x.device, dtype=estimator_dtype)
+            spks_in = torch.zeros([estimator_batch, 80], device=x.device, dtype=estimator_dtype)
+            cond_in = torch.zeros([estimator_batch, 80, x.size(2)], device=x.device, dtype=estimator_dtype)
         for step in range(1, len(t_span)):
             # Classifier-Free Guidance inference introduced in VoiceBox
-            x_in[:] = x
-            mask_in[:] = mask
-            mu_in[0] = mu
-            t_in[:] = t.unsqueeze(0)
-            spks_in[0] = spks
-            cond_in[0] = cond
-            dphi_dt = self.forward_estimator(x_in, mask_in, mu_in, t_in, spks_in, cond_in)
-            dphi_dt, cfg_dphi_dt = torch.split(dphi_dt, [x.size(0), x.size(0)], dim=0)
-            dphi_dt = (1.0 + self.inference_cfg_rate) * dphi_dt - self.inference_cfg_rate * cfg_dphi_dt
-            x = x + dt * dphi_dt
-            t = t + dt
+            with cosyvoice3_batch_flow_profile("cosyvoice3_cfm_cfg_prepare_2b"):
+                x_in[:batch_size] = x
+                x_in[batch_size:] = x
+                mask_in[:batch_size] = mask
+                mask_in[batch_size:] = mask
+                mu_in[:batch_size] = mu
+                t_in[:] = t
+                if spks is not None:
+                    spks_in[:batch_size] = spks
+                if cond is not None:
+                    cond_in[:batch_size] = cond
+            with cosyvoice3_batch_flow_profile("cosyvoice3_cfm_forward_estimator"):
+                dphi_dt = self.forward_estimator(x_in, mask_in, mu_in, t_in, spks_in, cond_in)
+            with cosyvoice3_batch_flow_profile("cosyvoice3_cfm_cfg_combine"):
+                dphi_dt, cfg_dphi_dt = torch.split(dphi_dt, [batch_size, batch_size], dim=0)
+                dphi_dt = (1.0 + self.inference_cfg_rate) * dphi_dt - self.inference_cfg_rate * cfg_dphi_dt
+            with cosyvoice3_batch_flow_profile("cosyvoice3_cfm_euler_update"):
+                x = x + dt * dphi_dt
+                t = t + dt
             sol.append(x)
             if step < len(t_span) - 1:
                 dt = t_span[step + 1] - t
@@ -158,12 +175,12 @@ class ConditionalCFM(BASECFM):
                 spks_e = spks.to(io_dtype).contiguous()
                 cond_e = cond.to(io_dtype).contiguous()
                 out_e = torch.empty_like(x_e)
-                estimator.set_input_shape("x", (2, 80, x_e.size(2)))
-                estimator.set_input_shape("mask", (2, 1, x_e.size(2)))
-                estimator.set_input_shape("mu", (2, 80, x_e.size(2)))
-                estimator.set_input_shape("t", (2,))
-                estimator.set_input_shape("spks", (2, 80))
-                estimator.set_input_shape("cond", (2, 80, x_e.size(2)))
+                estimator.set_input_shape("x", tuple(x_e.shape))
+                estimator.set_input_shape("mask", tuple(mask_e.shape))
+                estimator.set_input_shape("mu", tuple(mu_e.shape))
+                estimator.set_input_shape("t", tuple(t_e.shape))
+                estimator.set_input_shape("spks", tuple(spks_e.shape))
+                estimator.set_input_shape("cond", tuple(cond_e.shape))
                 data_ptrs = [
                     x_e.data_ptr(),
                     mask_e.data_ptr(),
@@ -211,22 +228,25 @@ class CausalConditionalCFM(ConditionalCFM):
                 shape: (batch_size, n_feats, mel_timesteps)
         """
 
-        z = (
-            torch.randn(
-                (mu.size(0), mu.size(1), mu.size(2)),
-                device=mu.device,
-                dtype=mu.dtype,
+        with cosyvoice3_batch_flow_profile("cosyvoice3_cfm_noise_cache"):
+            z = (
+                torch.randn(
+                    (mu.size(0), mu.size(1), mu.size(2)),
+                    device=mu.device,
+                    dtype=mu.dtype,
+                )
+                * temperature
             )
-            * temperature
-        )
 
         # fix prompt and overlap part mu and z
-        t_span = torch.linspace(0, 1, n_timesteps + 1, device=mu.device, dtype=mu.dtype)
+        with cosyvoice3_batch_flow_profile("cosyvoice3_cfm_t_span"):
+            t_span = torch.linspace(0, 1, n_timesteps + 1, device=mu.device, dtype=mu.dtype)
 
-        if self.t_scheduler == "cosine":
-            t_span = 1 - torch.cos(t_span * 0.5 * torch.pi)
+            if self.t_scheduler == "cosine":
+                t_span = 1 - torch.cos(t_span * 0.5 * torch.pi)
 
-        return self.solve_euler(z, t_span=t_span, mu=mu, mask=mask, spks=spks, cond=cond), None
+        with cosyvoice3_batch_flow_profile(f"cosyvoice3_cfm_euler_{max(1, int(n_timesteps))}_steps"):
+            return self.solve_euler(z, t_span=t_span, mu=mu, mask=mask, spks=spks, cond=cond), None
 
 
 class CausalMaskedDiffWithDiT(torch.nn.Module):
@@ -299,36 +319,41 @@ class CausalMaskedDiffWithDiT(torch.nn.Module):
         finalize: bool = False,
         n_timesteps: int = 10,
     ):
-        assert token.shape[0] == 1
-        # xvec projection
+        with cosyvoice3_batch_flow_profile("cosyvoice3_cfm_speaker_embedding"):
+            embedding = F.normalize(embedding, dim=1)
+            embedding = self.spk_embed_affine_layer(embedding)
 
-        embedding = F.normalize(embedding, dim=1)
+        with cosyvoice3_batch_flow_profile("cosyvoice3_cfm_token_embedding_lookahead"):
+            # concat text and prompt_text
+            codec_token_len = token_len
+            token, total_token_len = torch.concat([prompt_token, token], dim=1), prompt_token_len + codec_token_len
+            mask = (~make_pad_mask(total_token_len, max_len=token.shape[1])).unsqueeze(-1).to(embedding)
+            token = self.input_embedding(torch.clamp(token, min=0)) * mask
+            # text encode
+            if finalize is True:
+                h = self.pre_lookahead_layer(token)
+            else:
+                h = self.pre_lookahead_layer(
+                    token[:, : -self.pre_lookahead_len], context=token[:, -self.pre_lookahead_len :]
+                )
 
-        embedding = self.spk_embed_affine_layer(embedding)
+        with cosyvoice3_batch_flow_profile("cosyvoice3_cfm_repeat_to_mel_axis"):
+            h = h.repeat_interleave(self.token_mel_ratio, dim=1)
 
-        # concat text and prompt_text
-        token, token_len = torch.concat([prompt_token, token], dim=1), prompt_token_len + token_len
-        mask = (~make_pad_mask(token_len)).unsqueeze(-1).to(embedding)
-        token = self.input_embedding(torch.clamp(token, min=0)) * mask
-        # text encode
-        if finalize is True:
-            h = self.pre_lookahead_layer(token)
-        else:
-            h = self.pre_lookahead_layer(
-                token[:, : -self.pre_lookahead_len], context=token[:, -self.pre_lookahead_len :]
-            )
-        h = h.repeat_interleave(self.token_mel_ratio, dim=1)
+        batch_size = int(token.shape[0])
+        with cosyvoice3_batch_flow_profile("cosyvoice3_cfm_cond_prompt_mel"):
+            mel_len1, mel_len2 = prompt_feat.shape[1], h.shape[1] - prompt_feat.shape[1]
 
-        mel_len1, mel_len2 = prompt_feat.shape[1], h.shape[1] - prompt_feat.shape[1]
+            # get conditions
+            conds = torch.zeros([batch_size, mel_len1 + mel_len2, self.output_size], device=token.device).to(h.dtype)
+            conds[:, :mel_len1] = prompt_feat
+            conds = conds.transpose(1, 2)
 
-        # get conditions
-        conds = torch.zeros([1, mel_len1 + mel_len2, self.output_size], device=token.device).to(h.dtype)
+            lookahead = 0 if finalize else int(self.pre_lookahead_len)
+            valid_h_lens = torch.clamp(total_token_len.to(torch.long) - lookahead, min=0)
+            mel_lens = torch.clamp(valid_h_lens * int(self.token_mel_ratio), max=mel_len1 + mel_len2)
+            mask = (~make_pad_mask(mel_lens, max_len=mel_len1 + mel_len2)).to(h)
 
-        conds[:, :mel_len1] = prompt_feat
-
-        conds = conds.transpose(1, 2)
-
-        mask = (~make_pad_mask(torch.tensor([mel_len1 + mel_len2]))).to(h)
         feat, _ = self.decoder(
             mu=h.transpose(1, 2).contiguous(),
             mask=mask.unsqueeze(1),
@@ -338,6 +363,7 @@ class CausalMaskedDiffWithDiT(torch.nn.Module):
             streaming=streaming,
         )
 
-        feat = feat[:, :, mel_len1:]
-        assert feat.shape[2] == mel_len2
+        with cosyvoice3_batch_flow_profile("cosyvoice3_cfm_crop_prompt_mel"):
+            feat = feat[:, :, mel_len1:]
+            assert feat.shape[2] == mel_len2
         return feat.float(), None
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 2a5d472a0..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):
@@ -489,6 +584,9 @@ class HiFTGenerator(nn.Module):
             block.remove_weight_norm()
 
     def _stft(self, x):
+        if x.device.type == "npu":
+            return self._stft_on_cpu(x)
+
         spec = torch.stft(
             x,
             self.istft_params["n_fft"],
@@ -500,18 +598,49 @@ class HiFTGenerator(nn.Module):
         spec = torch.view_as_real(spec)  # [B, F, TT, 2]
         return spec[..., 0], spec[..., 1]
 
+    def _stft_on_cpu(self, x):
+        target_device = x.device
+        target_dtype = x.dtype
+        spec = torch.stft(
+            x.float().cpu(),
+            self.istft_params["n_fft"],
+            self.istft_params["hop_len"],
+            self.istft_params["n_fft"],
+            window=self.stft_window.float().cpu(),
+            return_complex=True,
+        )
+        spec = torch.view_as_real(spec).to(device=target_device, dtype=target_dtype)
+        return spec[..., 0], spec[..., 1]
+
     def _istft(self, magnitude, phase):
+        if magnitude.device.type == "npu":
+            return self._istft_on_cpu(magnitude, phase)
+
         magnitude = torch.clip(magnitude, max=1e2)
         real = magnitude * torch.cos(phase)
-        img = magnitude * torch.sin(phase)
-        inverse_transform = torch.istft(
-            torch.complex(real, img),
+        imag = magnitude * torch.sin(phase)
+        return torch.istft(
+            torch.complex(real, imag),
             self.istft_params["n_fft"],
             self.istft_params["hop_len"],
             self.istft_params["n_fft"],
             window=self._get_stft_window(magnitude),
         )
-        return inverse_transform
+
+    def _istft_on_cpu(self, magnitude, phase):
+        target_device = magnitude.device
+        target_dtype = magnitude.dtype
+        magnitude = torch.clip(magnitude, max=1e2)
+        real = magnitude * torch.cos(phase)
+        imag = magnitude * torch.sin(phase)
+        waveform = torch.istft(
+            torch.complex(real.float().cpu(), imag.float().cpu()),
+            self.istft_params["n_fft"],
+            self.istft_params["hop_len"],
+            self.istft_params["n_fft"],
+            window=self.stft_window.float().cpu(),
+        )
+        return waveform.to(device=target_device, dtype=target_dtype)
 
     def _get_stft_window(self, tensor: torch.Tensor) -> torch.Tensor:
         if self.stft_window.device != tensor.device:
@@ -572,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)
@@ -588,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:
@@ -751,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)
@@ -766,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):
@@ -920,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.py b/vllm_omni/model_executor/models/cosyvoice3/cosyvoice3.py
index 558e96b65..0ddc6dafa 100644
--- a/vllm_omni/model_executor/models/cosyvoice3/cosyvoice3.py
+++ b/vllm_omni/model_executor/models/cosyvoice3/cosyvoice3.py
@@ -39,6 +39,10 @@ from vllm.v1.sample.sampler import Sampler
 
 from vllm_omni.data_entry_keys import EmbeddingsStruct, OmniPayloadStruct, to_dict, to_struct
 from vllm_omni.inputs.mm_processor import OmniMultiModalProcessor
+from vllm_omni.model_executor.models.cosyvoice3.runtime import (
+    cosyvoice3_batch_flow_debug,
+    cosyvoice3_batch_flow_enabled,
+)
 from vllm_omni.model_executor.models.cosyvoice3.tokenizer import get_qwen_tokenizer
 from vllm_omni.model_executor.models.cosyvoice3.utils import (
     concat_text_with_prompt_ids,
@@ -1070,12 +1074,21 @@ class CosyVoice3Model(
             request_ids_list = self._split_request_ids(flat_ids, seq_token_counts)
 
             num_reqs = max(1, len(request_ids_list))
+            debug_batch_flow = cosyvoice3_batch_flow_debug()
+            if debug_batch_flow:
+                logger.info(
+                    "CosyVoice3 code2wav debug: forward num_reqs=%d seq_token_counts=%s flat_ids=%d",
+                    num_reqs,
+                    seq_token_counts,
+                    int(flat_ids.numel()),
+                )
             sample_rate = torch.tensor(int(self.config.sample_rate), dtype=torch.int32)
             empty_audio = torch.zeros((0,), dtype=torch.float32, device=input_ids.device)
             audios: list[torch.Tensor] = [empty_audio] * num_reqs
             srs: list[torch.Tensor] = [sample_rate] * num_reqs
             if not isinstance(runtime_info, list):
                 runtime_info = []
+            streaming_flow_items: list[dict[str, object]] = []
 
             for idx, req_ids in enumerate(request_ids_list):
                 raw = runtime_info[idx] if idx < len(runtime_info) and isinstance(runtime_info[idx], dict) else {}
@@ -1142,23 +1155,21 @@ class CosyVoice3Model(
                         with self._stream_audio_cache_lock:
                             cache_state = self._stream_vocoder_cache_by_req.get(req_id)
 
-                    tts_speech, new_cache_state = self.code2wav.forward_streaming(
-                        token=token.unsqueeze(0),
-                        prompt_token=speech_token[:1],
-                        prompt_feat=speech_feat[:1],
-                        embedding=embedding[:1],
-                        cache_state=cache_state,
-                        n_timesteps=10,
-                        token_offset_tokens=token_offset,
-                        finalize=stream_finished,
+                    streaming_flow_items.append(
+                        {
+                            "index": idx,
+                            "req_id": req_id,
+                            "stream_finished": stream_finished,
+                            "token": token.unsqueeze(0),
+                            "prompt_token": speech_token[:1],
+                            "prompt_feat": speech_feat[:1],
+                            "embedding": embedding[:1],
+                            "cache_state": cache_state,
+                            "token_offset_tokens": token_offset,
+                            "finalize": stream_finished,
+                        }
                     )
-
-                    if req_id is not None and hasattr(self, "_stream_vocoder_cache_by_req"):
-                        with self._stream_audio_cache_lock:
-                            if new_cache_state is None or stream_finished:
-                                self._stream_vocoder_cache_by_req.pop(req_id, None)
-                            else:
-                                self._stream_vocoder_cache_by_req[req_id] = new_cache_state
+                    continue
                 else:
                     token_offset = max(0, meta.talker_prefill_offset or 0) if meta else 0
                     tts_speech = self.code2wav.forward(
@@ -1174,6 +1185,60 @@ class CosyVoice3Model(
 
                 audios[idx] = self._stitch_stream_audio(req_id, audio, stream_finished)
 
+            if streaming_flow_items:
+                if debug_batch_flow:
+                    item_shapes = [
+                        (
+                            tuple(item["token"].shape),  # type: ignore[union-attr]
+                            tuple(item["prompt_token"].shape),  # type: ignore[union-attr]
+                            tuple(item["prompt_feat"].shape),  # type: ignore[union-attr]
+                            bool(item.get("finalize", False)),
+                        )
+                        for item in streaming_flow_items
+                    ]
+                    logger.info(
+                        "CosyVoice3 code2wav debug: streaming_items=%d item_shapes=%s",
+                        len(streaming_flow_items),
+                        item_shapes,
+                    )
+                if (
+                    len(streaming_flow_items) > 1
+                    and cosyvoice3_batch_flow_enabled()
+                    and hasattr(self.code2wav, "forward_streaming_batch")
+                ):
+                    streaming_results = self.code2wav.forward_streaming_batch(
+                        streaming_flow_items,
+                        n_timesteps=10,
+                    )
+                else:
+                    streaming_results = [
+                        self.code2wav.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]
+                            n_timesteps=10,
+                            token_offset_tokens=int(item.get("token_offset_tokens", 0)),
+                            finalize=bool(item.get("finalize", False)),
+                        )
+                        for item in streaming_flow_items
+                    ]
+
+                for item, (tts_speech, new_cache_state) in zip(streaming_flow_items, streaming_results):
+                    idx = int(item["index"])
+                    req_id = item.get("req_id")
+                    stream_finished = bool(item.get("stream_finished", False))
+                    if req_id is not None and hasattr(self, "_stream_vocoder_cache_by_req"):
+                        with self._stream_audio_cache_lock:
+                            if new_cache_state is None or stream_finished:
+                                self._stream_vocoder_cache_by_req.pop(req_id, None)
+                            else:
+                                self._stream_vocoder_cache_by_req[req_id] = new_cache_state
+
+                    audio = tts_speech.reshape(-1).to(dtype=torch.float32)
+                    audios[idx] = self._stitch_stream_audio(req_id, audio, stream_finished)
+
             return OmniOutput(text_hidden_states=None, multimodal_outputs={"audio": audios, "sr": srs})
         else:
             raise ValueError(f"Unsupported model_stage: {self.model_stage}")
diff --git a/vllm_omni/model_executor/models/cosyvoice3/cosyvoice3_code2wav.py b/vllm_omni/model_executor/models/cosyvoice3/cosyvoice3_code2wav.py
index 49e8e515b..1713467c8 100644
--- a/vllm_omni/model_executor/models/cosyvoice3/cosyvoice3_code2wav.py
+++ b/vllm_omni/model_executor/models/cosyvoice3/cosyvoice3_code2wav.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
 """
 CosyVoice3 Code2Wav Stage - Converts speech tokens to audio waveforms.
 
@@ -9,7 +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 TypedDict, cast
 
 import numpy as np
 import torch
@@ -27,11 +28,30 @@ from vllm_omni.model_executor.models.cosyvoice3.code2wav_core.hifigan import (
     CausalHiFTGenerator,
 )
 from vllm_omni.model_executor.models.cosyvoice3.code2wav_core.layers import PreLookaheadLayer
+from vllm_omni.model_executor.models.cosyvoice3.runtime import (
+    cosyvoice3_batch_flow_debug,
+    cosyvoice3_batch_flow_profile,
+)
 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.
 
@@ -112,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:
@@ -159,6 +183,9 @@ class CosyVoice3Code2Wav(nn.Module):
         token_offset_tokens: int = 0,
         streaming: bool = True,
         finalize: bool = False,
+        token_lens: torch.Tensor | None = None,
+        prompt_token_lens: torch.Tensor | None = None,
+        prompt_feat_lens: torch.Tensor | None = None,
     ) -> torch.Tensor:
         """Generate mel features via the upstream flow-model inference path."""
         flow_weight = next(self.flow_model.parameters())
@@ -169,9 +196,22 @@ class CosyVoice3Code2Wav(nn.Module):
         prompt_token = prompt_token.to(device=device, dtype=torch.int32)
         prompt_feat = prompt_feat.to(device=device, dtype=dtype)
         embedding = embedding.to(device=device, dtype=dtype)
-        token_len = torch.tensor([token.shape[1]], device=device, dtype=torch.int32)
-        prompt_token_len = torch.tensor([prompt_token.shape[1]], device=device, dtype=torch.int32)
-        prompt_feat_len = torch.tensor([prompt_feat.shape[1]], device=device, dtype=torch.int32)
+        batch_size = int(token.shape[0])
+        token_len = (
+            token_lens.to(device=device, dtype=torch.int32)
+            if token_lens is not None
+            else torch.full((batch_size,), token.shape[1], device=device, dtype=torch.int32)
+        )
+        prompt_token_len = (
+            prompt_token_lens.to(device=device, dtype=torch.int32)
+            if prompt_token_lens is not None
+            else torch.full((batch_size,), prompt_token.shape[1], device=device, dtype=torch.int32)
+        )
+        prompt_feat_len = (
+            prompt_feat_lens.to(device=device, dtype=torch.int32)
+            if prompt_feat_lens is not None
+            else torch.full((batch_size,), prompt_feat.shape[1], device=device, dtype=torch.int32)
+        )
 
         feat, _ = self.flow_model.inference(
             token=token,
@@ -192,6 +232,201 @@ class CosyVoice3Code2Wav(nn.Module):
 
         return feat
 
+    def _stream_hift_from_feat(
+        self,
+        feat: torch.Tensor,
+        *,
+        cache_state: dict[str, torch.Tensor] | None = None,
+        finalize: bool = False,
+    ) -> tuple[torch.Tensor, dict[str, torch.Tensor] | None]:
+        hift_weight = self.hift.m_source.l_linear.weight
+        chunk_mel = feat.to(device=hift_weight.device, dtype=hift_weight.dtype)
+
+        cached_mel = None if not cache_state else cache_state.get("mel")
+        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)
+            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:
+            window_mel = chunk_mel
+            f0_input_mel = chunk_mel
+            window_offset = 0
+            uv_offset = 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:
+            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)
+        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": 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[StreamingFlowItem],
+        *,
+        n_timesteps: int = 10,
+    ) -> list[tuple[torch.Tensor, dict[str, torch.Tensor] | None]]:
+        """Batch the flow-matching mel path, then run HiFT per request.
+
+        Items are grouped by prompt condition shape and finalization state.
+        Codec tokens may have different lengths; those are padded within the
+        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, StreamingFlowItem]]] = {}
+        for index, item in enumerate(items):
+            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(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))
+
+        if cosyvoice3_batch_flow_debug():
+            group_summary = {key: len(group) for key, group in groups.items()}
+            group_size_distribution = Counter(group_summary.values())
+            batchable_items = sum(size for size in group_summary.values() if size > 1)
+            logger.info(
+                "CosyVoice3 code2wav debug: forward_streaming_batch items=%d "
+                "groups=%s group_size_distribution=%s batchable_items=%d",
+                len(items),
+                group_summary,
+                dict(sorted(group_size_distribution.items())),
+                batchable_items,
+            )
+
+        for _key, group in groups.items():
+            if len(group) == 1:
+                index, item = group[0]
+                result = self.forward_streaming(
+                    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)),
+                )
+                results[index] = result
+                continue
+
+            token_tensors = [item["token"] for _, item in group]
+            token_lens = torch.tensor(
+                [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:
+                if int(token.shape[1]) == max_token_len:
+                    padded_tokens.append(token)
+                else:
+                    pad = torch.zeros(
+                        (token.shape[0], max_token_len - int(token.shape[1])),
+                        device=token.device,
+                        dtype=token.dtype,
+                    )
+                    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)
+            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))
+
+            with cosyvoice3_batch_flow_profile(f"cosyvoice3_flow_batch_b{len(group)}_t{tokens.shape[1]}"):
+                feat = self._forward_mel(
+                    token=tokens,
+                    prompt_token=prompt_tokens,
+                    prompt_feat=prompt_feats,
+                    embedding=embeddings,
+                    n_timesteps=n_timesteps,
+                    token_offset_tokens=0,
+                    streaming=True,
+                    finalize=finalize,
+                    token_lens=token_lens,
+                    prompt_token_lens=prompt_token_lens,
+                    prompt_feat_lens=prompt_feat_lens,
+                )
+
+            for row, (index, item) in enumerate(group):
+                trim_mel = max(0, int(item.get("token_offset_tokens", 0))) * int(self.token_mel_ratio)
+                valid_tokens = int(token_lens[row].item())
+                if not finalize:
+                    valid_tokens = max(0, valid_tokens - int(self.flow_model.pre_lookahead_len))
+                valid_mel = valid_tokens * int(self.token_mel_ratio)
+                row_feat = feat[row : row + 1, :, :valid_mel]
+                if trim_mel > 0:
+                    row_feat = row_feat[:, :, trim_mel:]
+                results[index] = self._stream_hift_from_feat(
+                    row_feat,
+                    cache_state=item.get("cache_state"),
+                    finalize=finalize,
+                )
+
+        assert all(result is not None for result in results), "every streaming item must produce exactly one result"
+        return cast(list[tuple[torch.Tensor, dict[str, torch.Tensor] | None]], results)
+
     @torch.inference_mode()
     def forward_streaming(
         self,
@@ -223,39 +458,7 @@ class CosyVoice3Code2Wav(nn.Module):
             streaming=True,
             finalize=finalize,
         )
-        hift_weight = self.hift.m_source.l_linear.weight
-        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
-
-        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
-        else:
-            tts_mel = chunk_mel
-
-        if tts_mel.shape[-1] == 0:
-            tts_speech = torch.zeros((chunk_mel.shape[0], 1, 0), device=chunk_mel.device, dtype=chunk_mel.dtype)
-        else:
-            tts_speech, _ = self.hift.inference(speech_feat=tts_mel, finalize=finalize)
-
-        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:]
-
-        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]),
-        }
-        return emitted_speech.reshape(emitted_speech.shape[0], 1, -1), new_state
+        return self._stream_hift_from_feat(feat, cache_state=cache_state, finalize=finalize)
 
     @torch.inference_mode()
     def forward(
@@ -290,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/cosyvoice3/runtime.py b/vllm_omni/model_executor/models/cosyvoice3/runtime.py
new file mode 100644
index 000000000..d94725148
--- /dev/null
+++ b/vllm_omni/model_executor/models/cosyvoice3/runtime.py
@@ -0,0 +1,31 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Runtime toggles shared by the CosyVoice3 stages."""
+
+import os
+from contextlib import nullcontext
+
+import torch
+
+_FALSE_ENV_VALUES = ("0", "false", "False", "")
+
+
+def _env_flag(name: str, default: str) -> bool:
+    return os.environ.get(name, default) not in _FALSE_ENV_VALUES
+
+
+def cosyvoice3_batch_flow_enabled() -> bool:
+    """Return whether cross-request Stage-1 flow batching is enabled."""
+    return _env_flag("COSYVOICE3_BATCH_FLOW", "0")
+
+
+def cosyvoice3_batch_flow_debug() -> bool:
+    """Return whether Stage-1 batching diagnostics are enabled."""
+    return _env_flag("COSYVOICE3_BATCH_FLOW_DEBUG", "0")
+
+
+def cosyvoice3_batch_flow_profile(name: str):
+    """Create a profiler scope only when batching diagnostics are enabled."""
+    if cosyvoice3_batch_flow_debug():
+        return torch.profiler.record_function(name)
+    return nullcontext()
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/fish_speech/prompt_utils.py b/vllm_omni/model_executor/models/fish_speech/prompt_utils.py
index 3918a6f94..61196f18f 100644
--- a/vllm_omni/model_executor/models/fish_speech/prompt_utils.py
+++ b/vllm_omni/model_executor/models/fish_speech/prompt_utils.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 """Shared Fish Speech prompt construction helpers."""
 
 from __future__ import annotations
@@ -11,6 +14,7 @@ FISH_CLONE_SYSTEM_PROMPT_SUFFIX = "\n\nSpeech:\n"
 
 _LEGACY_SPEAKER_TAG_PATTERN = re.compile(r"<speaker:(\d+)>")
 _CANONICAL_SPEAKER_TAG_PATTERN = re.compile(r"<\|speaker:\d+\|>")
+_PHONEME_TAG_PATTERN = re.compile(r"<\|phoneme_(?:start|end)\|>")
 _CONTROL_TOKEN_PATTERN = re.compile(r"<\|[^>]+\|>")
 
 
@@ -21,7 +25,7 @@ def normalize_fish_speech_text(text: str, *, add_default_speaker: bool = False)
     disallowed_tokens = [
         token
         for token in _CONTROL_TOKEN_PATTERN.findall(normalized)
-        if not _CANONICAL_SPEAKER_TAG_PATTERN.fullmatch(token)
+        if not (_CANONICAL_SPEAKER_TAG_PATTERN.fullmatch(token) or _PHONEME_TAG_PATTERN.fullmatch(token))
     ]
     if disallowed_tokens:
         disallowed_list = ", ".join(sorted(set(disallowed_tokens)))
diff --git a/vllm_omni/model_executor/models/higgs_audio_v3/higgs_audio_v3_talker.py b/vllm_omni/model_executor/models/higgs_audio_v3/higgs_audio_v3_talker.py
index 738e469f1..ba9c9eb2d 100644
--- a/vllm_omni/model_executor/models/higgs_audio_v3/higgs_audio_v3_talker.py
+++ b/vllm_omni/model_executor/models/higgs_audio_v3/higgs_audio_v3_talker.py
@@ -722,6 +722,13 @@ class HiggsAudioV3TalkerForConditionalGeneration(nn.Module):
 
             if isinstance(placeholder_positions, torch.Tensor):
                 if placeholder_positions.numel() == 0 or placeholder_positions.numel() != codes.shape[0]:
+                    logger.debug(
+                        "Skipping reference audio substitution for request %d: "
+                        "%d explicit placeholder positions do not match %d reference code rows",
+                        i,
+                        placeholder_positions.numel(),
+                        codes.shape[0],
+                    )
                     continue
                 request_positions = flat_positions[s:e]
                 ref_positions = placeholder_positions.to(
@@ -743,6 +750,13 @@ class HiggsAudioV3TalkerForConditionalGeneration(nn.Module):
                 placeholders = span_mask.nonzero(as_tuple=True)[0]
                 n_codes = int(codes.shape[0])
                 if int(placeholders.numel()) < n_codes:
+                    logger.debug(
+                        "Skipping reference audio substitution for request %d: "
+                        "legacy span contains %d placeholders for %d reference code rows",
+                        i,
+                        placeholders.numel(),
+                        n_codes,
+                    )
                     continue
                 target = placeholders[:n_codes] + s
 
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/mimo_audio/mimo_audio_llm.py b/vllm_omni/model_executor/models/mimo_audio/mimo_audio_llm.py
index bb01e522c..ec4faadb8 100644
--- a/vllm_omni/model_executor/models/mimo_audio/mimo_audio_llm.py
+++ b/vllm_omni/model_executor/models/mimo_audio/mimo_audio_llm.py
@@ -58,6 +58,12 @@ from vllm.sequence import IntermediateTensors
 from vllm.utils.tensor_schema import TensorSchema
 
 from vllm_omni.model_executor.models.mimo_audio.config_mimo_audio import MiMoAudioConfig
+from vllm_omni.model_executor.models.model_local_kv import (
+    ModelLocalKVScope,
+    ModelLocalKVSpec,
+    RowDriver,
+    spec_from_hf_config,
+)
 from vllm_omni.platforms import current_omni_platform
 
 logger = logging.getLogger(__name__)
@@ -744,6 +750,67 @@ class MiMoAudioLLMForConditionalGeneration(nn.Module, SupportsMultiModal, Suppor
     def get_language_model(self) -> torch.nn.Module:
         return self.model
 
+    def model_local_kv_specs(self) -> list[ModelLocalKVSpec]:
+        """Declare the local transformer's decode cache and its graph copies.
+
+        The cache is created per call inside ``base_local_forward`` and is
+        bounded by the decode loop, not by sequence length: the loop runs
+        ``group_size + max(delay_pattern)`` steps regardless of how long the
+        utterance is.
+
+        The second entry is the one that matters. ``base_local_forward`` runs
+        inside ``torch.cuda.graph`` during capture, so each captured bucket
+        leaves a cache's worth of tensors pinned in the graph pool for the
+        process lifetime. There is no Python object left to inspect -- the
+        cache is a local in the captured frame -- so the width comes from the
+        buckets that captured successfully, which is why it reads
+        ``local_forward_cg_by_bs`` rather than MIMO_CUDAGRAPH_BATCH_SIZES: a
+        bucket whose capture raised is logged and skipped.
+
+        Both entries are declared, and summing them over-states a single step:
+        a given call either replays a captured bucket or runs eagerly, never
+        both. The graph pool is resident regardless, so the sum is the right
+        ceiling for the process and the wrong number for one request.
+        """
+        delay_iters = self.group_size + max(self.delay_pattern)
+        dtype = next(self.local_transformer.parameters()).dtype
+        bound = f"group_size({self.group_size}) + max(delay_pattern)({max(self.delay_pattern)})"
+        specs = [
+            spec_from_hf_config(
+                self.local_config,
+                name="local_transformer",
+                dtype=dtype,
+                physical_capacity_positions=delay_iters,
+                capacity_source=bound,
+                scope=ModelLocalKVScope.INVOCATION,
+                # One cache, B rows wide -- not B caches. base_local_forward
+                # builds a single DynamicCache whose batch dimension is the
+                # number of requests in the group.
+                rows=RowDriver.MAX_NUM_SEQS,
+                allocation_note="one batched allocation per eager call; graph replay uses the pool entry instead",
+            )
+        ]
+        captured_rows = sum(self.local_forward_cg_by_bs)
+        if captured_rows:
+            specs.append(
+                spec_from_hf_config(
+                    self.local_config,
+                    name="local_transformer_graph_pool",
+                    dtype=dtype,
+                    physical_capacity_positions=delay_iters,
+                    capacity_source=bound,
+                    scope=ModelLocalKVScope.MODEL,
+                    rows=RowDriver.FIXED,
+                    rows_fixed=captured_rows,
+                    rows_reason=f"sum of captured buckets {sorted(self.local_forward_cg_by_bs)}",
+                    allocation_note=(
+                        "pinned in the CUDA graph pool; capture is gated only on cuda.is_available(), "
+                        "so this stays resident under enforce_eager too"
+                    ),
+                )
+            )
+        return specs
+
     def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:
         if kwargs.get("modality_preprocess") is None:
             mm_dummy_embeddings = []
diff --git a/vllm_omni/model_executor/models/ming_flash_omni/ming_flash_omni_talker.py b/vllm_omni/model_executor/models/ming_flash_omni/ming_flash_omni_talker.py
index d34cce465..f01e20688 100644
--- a/vllm_omni/model_executor/models/ming_flash_omni/ming_flash_omni_talker.py
+++ b/vllm_omni/model_executor/models/ming_flash_omni/ming_flash_omni_talker.py
@@ -158,6 +158,17 @@ class MingFlashOmniTalkerForConditionalGeneration(nn.Module, CustomProcessMixin)
             patch_size=self.patch_size,
         )
 
+    def model_local_kv_specs(self):
+        """Forward to the generator, which owns the talker's StaticCache.
+
+        ``MingAudioGenerator`` is a plain object rather than a submodule, so
+        the module-tree walk cannot reach it on its own.
+        """
+        generator = getattr(self, "audio_generator", None)
+        if generator is None:
+            return []
+        return generator.model_local_kv_specs()
+
     @property
     def device(self) -> torch.device:
         return next(self.model.parameters()).device
diff --git a/vllm_omni/model_executor/models/ming_flash_omni/talker_module.py b/vllm_omni/model_executor/models/ming_flash_omni/talker_module.py
index 8e3e55611..293ec2fb3 100644
--- a/vllm_omni/model_executor/models/ming_flash_omni/talker_module.py
+++ b/vllm_omni/model_executor/models/ming_flash_omni/talker_module.py
@@ -41,6 +41,12 @@ from vllm_omni.model_executor.models.common.ming.cfm_solver import (
     integrate_cfm_steps,
 )
 from vllm_omni.model_executor.models.common.ming.dit_blocks import CondEmbedder, DiTBlock, FinalLayer
+from vllm_omni.model_executor.models.model_local_kv import (
+    ModelLocalKVScope,
+    ModelLocalKVSpec,
+    RowDriver,
+    spec_from_hf_config,
+)
 
 logger = init_logger(__name__)
 
@@ -575,6 +581,13 @@ class MingAudioGenerator:
     for a single TTS request. The generator is stateless across requests.
     """
 
+    _STATIC_CACHE_LEN = 2048
+    """Positions the talker's StaticCache is preallocated for.
+
+    Read by both ``_init_kv_cache`` and ``model_local_kv_specs`` so the
+    declaration cannot drift from the allocation.
+    """
+
     def __init__(
         self,
         config,
@@ -609,6 +622,49 @@ class MingAudioGenerator:
         # trailing latent frames prepended on each decode call
         self._vae_decode_pad_frames = 32
 
+    def model_local_kv_specs(self) -> list[ModelLocalKVSpec]:
+        """Declare the talker's preallocated decode cache.
+
+        This is the case that a static table cannot hold. ``self._llm_config``
+        is a ``Qwen2Config`` resolved from the checkpoint at load time, so
+        layers, kv-heads and head-dim do not exist anywhere in this repo, and
+        the dtype is whatever the weights loaded as. Reading them off the same
+        objects ``_init_kv_cache`` builds from is the only way to get a real
+        number.
+
+        Unlike the other three this is not a ceiling that a short utterance
+        stays under. transformers v5 initializes ``StaticLayer`` lazily, but
+        the first write to a layer allocates all ``max_cache_len`` positions at
+        once rather than growing, so a prefill brings the full extent into
+        existence on step 0 of every generation.
+
+        Width is fixed at one row, not ``max_num_seqs``. ``forward`` takes only
+        ``runtime_additional_information[0]`` and runs the whole AR loop inline
+        before returning, so one worker holds one cache no matter how many
+        sequences the scheduler admits. Declaring this per-sequence -- which an
+        earlier revision did, by deriving the multiplier from scope -- reported
+        ``max_num_seqs`` times the real figure.
+
+        The caveat is that nothing enforces the serialization. ``StaticCache``
+        is built outside ``_sampler_pool``'s lock, so overlapping calls to
+        ``generate_latents`` would coexist. If this model ever gains a
+        concurrent entry point, this row count is the line to revisit.
+        """
+        return [
+            spec_from_hf_config(
+                self._llm_config,
+                name="talker_llm_static_cache",
+                dtype=next(self._model.parameters()).dtype,
+                physical_capacity_positions=self._STATIC_CACHE_LEN,
+                capacity_source=f"hardcoded max_cache_len={self._STATIC_CACHE_LEN} in _init_kv_cache",
+                scope=ModelLocalKVScope.INVOCATION,
+                rows=RowDriver.FIXED,
+                rows_fixed=1,
+                rows_reason="forward() handles one request and runs the AR loop inline",
+                allocation_note="full extent on first write per layer, not grown; rebuilt per text segment",
+            )
+        ]
+
     @cached_property
     def _sampler_pool(self) -> CFMGraphExecutorPool | None:
         device = next(self._model.parameters()).device
@@ -790,7 +846,7 @@ class MingAudioGenerator:
     def _init_kv_cache(
         self, use_static_cache: bool, device: torch.device, dtype: torch.dtype
     ) -> tuple[StaticCache | None, int]:
-        max_cache_len = 2048
+        max_cache_len = self._STATIC_CACHE_LEN
         if not use_static_cache:
             return None, max_cache_len
         cache = StaticCache(
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/batched_token2wav.py b/vllm_omni/model_executor/models/minicpmo_4_5/batched_token2wav.py
index 2bffeb49e..bec442282 100644
--- a/vllm_omni/model_executor/models/minicpmo_4_5/batched_token2wav.py
+++ b/vllm_omni/model_executor/models/minicpmo_4_5/batched_token2wav.py
@@ -46,6 +46,80 @@ def relpos_encode_token_budget(
     return max(lookahead + 1, min(int(cap), room))
 
 
+def _cfm_pad_frames(
+    *,
+    mel_frames: int,
+    offset: int,
+    noise_capacity: int,
+    bucket_frames: int,
+    disabled: bool,
+) -> int:
+    """Frame padding that aligns one CFM call onto the capture-shape grid.
+
+    Chunk lengths vary per request: the steady-state chunk is 50 mel frames,
+    but the first/last chunk and the ``plan_token2wav_encode_slices`` splits
+    land on arbitrary lengths, and every distinct length is its own CUDA-graph
+    capture shape. Padding the frame axis up to ``bucket_frames`` collapses
+    them onto one grid (the caller trims the output back). Measured on the
+    shipped config, 128 requests / concurrency 8: 61 captures and 1 cache
+    flush without bucketing versus 15 captures and 0 flushes with it, audio
+    RTF 1.317 -> 1.191 under otherwise identical conditions.
+
+    The attention and CNN caches also advance by the padded width so their
+    shapes stay on the same grid; in practice that is bounded by the trim in
+    ``_decode_batch_once`` (the cache width saturates at ``prompt_len +
+    100``) rather than by the decoder's ``rand_noise`` capacity.
+
+    Returns 0 when bucketing does not apply: the ragged valid-lengths path,
+    graphs unavailable or already disabled by ``CFMGraphWrapper._disable``,
+    or padding that would overflow the decoder's noise buffer.
+    """
+    if disabled or bucket_frames <= 1:
+        return 0
+    pad = (bucket_frames - mel_frames % bucket_frames) % bucket_frames
+    if offset + mel_frames + pad > noise_capacity:
+        return 0
+    return pad
+
+
+def _zero_padded_frames(tensor: torch.Tensor, valid_frames: int | None) -> None:
+    """Keep the padded columns of ``tensor`` at zero, in place.
+
+    Bucketing pads the frame axis so the capture shape stays fixed. The padded
+    columns carry no valid content: they are excluded from the attention by the
+    ``attn_mask`` built in ``_decode_batch_once``, and zeroing keeps them from
+    leaking back in. The integration step ``x = x + dt * velocity`` would
+    otherwise make the padded region non-zero again after the initial zeroing,
+    and the cross-chunk caches would read those values back.
+    """
+    if valid_frames is None or valid_frames >= int(tensor.shape[-1]):
+        return
+    tensor[..., valid_frames:] = 0.0
+
+
+def _zero_padded_cnn_cache(
+    cnn_cache: torch.Tensor,
+    estimator: nn.Module,
+    pad_frames: int,
+) -> None:
+    """Clear the cache positions that come from padded frames, in place.
+
+    Each block's CNN cache holds the tail of its convolution output
+    (``new_cnn_cache = x[..., -causal_padding[0]:]``, inside ``stepaudio2``),
+    so when the padding sits at the chunk tail those positions are
+    padding-derived and would otherwise become the next chunk's left context.
+    Padding is at most ``pad_frames`` wide, so only the trailing positions that
+    can come from it are cleared; the valid part of the window is kept.
+    """
+    for index, block in enumerate(estimator.blocks):
+        width = int(block.conv.block[1].causal_padding[0])
+        if width <= 0:
+            continue
+        zero_from = max(0, width - pad_frames)
+        if zero_from < width:
+            cnn_cache[index][..., zero_from:] = 0.0
+
+
 def plan_token2wav_encode_slices(
     num_frames: int,
     *,
@@ -249,6 +323,17 @@ class BatchedToken2Wav(nn.Module):
                     "CFM CUDA Graph is disabled on device type %s",
                     flow_parameter.device.type if flow_parameter is not None else "unknown",
                 )
+        # mel-frame bucket size for the CFM CUDA Graph path. Pad each decode
+        # chunk up to a multiple of this many frames so the graph cache key
+        # space stays small (0 disables bucketing, e.g. when graphs are off).
+        self._cfm_graph_bucket_frames = (
+            int(cfm_graph_cfg.get("bucket_frames", 0)) if self._cfm_graph_wrapper is not None else 0
+        )
+        if self._cfm_graph_bucket_frames > 1:
+            logger.info(
+                "CFM CUDA Graph bucketing enabled (bucket_frames=%d)",
+                self._cfm_graph_bucket_frames,
+            )
         self._prompt_features: dict[tuple[str, str], PromptFeatures] = {}
 
     def _hift_inference(
@@ -398,6 +483,7 @@ class BatchedToken2Wav(nn.Module):
         att_cache: torch.Tensor | None,
         attn_mask: torch.Tensor | None = None,
         valid_lengths: list[int] | None = None,
+        valid_frames: int | None = None,
     ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
         if self._trt_stepper is not None and valid_lengths is None:
             out, new_cnn, new_att = self._trt_stepper.step(
@@ -413,6 +499,13 @@ class BatchedToken2Wav(nn.Module):
         time_embedding = estimator.t_embedder(time).unsqueeze(1)
         width = int(x.shape[-1])
         speaker_features = speakers.unsqueeze(-1).expand(-1, -1, width)
+        if valid_frames is not None and valid_frames < width:
+            # Every frame gets the speaker vector, so the padded columns would
+            # stay non-zero even with x/mu/cond zeroed -- and the estimator
+            # would then emit non-zero features there, leaving the
+            # chunk-boundary attention/CNN caches padding-derived. Zero them.
+            speaker_features = speaker_features.clone()
+            _zero_padded_frames(speaker_features, valid_frames)
         estimator_input = torch.cat((x, mu, speaker_features, cond), dim=1)
         cnn_out, att_out = self._estimator_buffers(estimator, estimator_input, att_cache)
         old_cnn: Any = cnn_cache if cnn_cache is not None else [None] * len(estimator.blocks)
@@ -433,6 +526,7 @@ class BatchedToken2Wav(nn.Module):
                 graph_att,
                 cnn_out,
                 att_out,
+                attn_mask,
             )
         if valid_lengths is not None:
             if not hasattr(estimator, "in_proj"):
@@ -566,6 +660,26 @@ class BatchedToken2Wav(nn.Module):
         estimator = decoder.estimator
         batch_size = int(mu.shape[0])
         offset = int(att_cache.shape[4]) if att_cache is not None else 0
+        mel_frames = int(mu.shape[2])
+        pad_frames = _cfm_pad_frames(
+            mel_frames=mel_frames,
+            offset=offset,
+            noise_capacity=int(decoder.rand_noise.shape[2]),
+            bucket_frames=self._cfm_graph_bucket_frames,
+            disabled=(
+                valid_lengths is not None
+                or self._cfm_graph_wrapper is None
+                # `_disable` keeps the wrapper object alive, so check the flag
+                # too: padding under a disabled wrapper is pure overhead.
+                or not self._cfm_graph_wrapper.enabled
+            ),
+        )
+        if pad_frames:
+            # Replicate rather than zero: a repeated last frame is a closer
+            # continuation of the chunk than silence, so the padded positions
+            # carry less of a step change into the attention and CNN caches.
+            mu = torch.nn.functional.pad(mu, (0, pad_frames), mode="replicate")
+            cond = torch.nn.functional.pad(cond, (0, pad_frames), mode="replicate")
         end = offset + int(mu.shape[2])
         if end > int(decoder.rand_noise.shape[2]):
             raise RuntimeError(
@@ -574,6 +688,13 @@ class BatchedToken2Wav(nn.Module):
                 f'"available":{int(decoder.rand_noise.shape[2])}}}'
             )
         x = decoder.rand_noise[:, :, offset:end].expand(batch_size, -1, -1).clone()
+        if pad_frames:
+            # The padded columns would otherwise carry real noise values. They
+            # are excluded from this chunk's attention by ``attn_mask`` below
+            # and held at zero here, so the padded region stays inert. Masking
+            # is what removes them; zeroing alone would not, since a zero row
+            # still occupies part of the softmax denominator.
+            x[:, :, mel_frames:] = 0.0
         timeline = torch.linspace(
             0,
             1,
@@ -603,6 +724,20 @@ class BatchedToken2Wav(nn.Module):
                 device=mu.device,
             )
             attn_mask = valid_queries.unsqueeze(2) & torch.cat((current_keys, old_keys), dim=2)
+        elif pad_frames:
+            # Mask the padded keys instead of only zeroing their content: a
+            # zero-valued key/value pair still takes probability mass out of the
+            # softmax denominator, so the real frames keep attending to the
+            # padding unless it is explicitly excluded.
+            kv_len = int(mu.shape[2]) + offset
+            attn_mask = torch.ones(
+                2 * batch_size,
+                int(mu.shape[2]),
+                kv_len,
+                dtype=torch.bool,
+                device=mu.device,
+            )
+            attn_mask[:, :, mel_frames : mel_frames + pad_frames] = False
         next_cnn: list[torch.Tensor] = []
         next_att_cache: torch.Tensor | None = None
         ragged_att_cache: list[torch.Tensor] | None = None
@@ -622,10 +757,14 @@ class BatchedToken2Wav(nn.Module):
                     att_cache=old_att,
                     attn_mask=attn_mask,
                     valid_lengths=valid_lengths,
+                    valid_frames=mel_frames if pad_frames else None,
                 )
+                if pad_frames:
+                    _zero_padded_cnn_cache(step_cnn, estimator, pad_frames)
                 conditional, unconditional = estimate.split(batch_size, dim=0)
                 velocity = (1.0 + decoder.inference_cfg_rate) * conditional - decoder.inference_cfg_rate * unconditional
                 x = x + dt * velocity
+                _zero_padded_frames(x, mel_frames if pad_frames else None)
                 time = time + dt
                 if step + 1 < self.n_timesteps:
                     dt = timeline[step + 2] - time[0]
@@ -666,7 +805,15 @@ class BatchedToken2Wav(nn.Module):
                         dtype=self._estimator_att_cache_dtype,
                     )
                 next_att_cache[step].copy_(step_att)
+                if pad_frames:
+                    # The padded steps ran but hold no valid content, and each
+                    # cache entry becomes the next chunk's keys. Clear the
+                    # padded columns so the boundary the next chunk reads is
+                    # the valid one, in step with the mask built above.
+                    next_att_cache[step][..., mel_frames : mel_frames + pad_frames, :] = 0.0
                 del step_att
+        if pad_frames:
+            x = x[:, :, :mel_frames]
         if ragged_att_cache is not None:
             return x, torch.stack(next_cnn), ragged_att_cache
         assert next_att_cache is not None
diff --git a/vllm_omni/model_executor/models/minicpmo_4_5/cuda_graph_wrapper.py b/vllm_omni/model_executor/models/minicpmo_4_5/cuda_graph_wrapper.py
index d737905fd..4db0c39bf 100644
--- a/vllm_omni/model_executor/models/minicpmo_4_5/cuda_graph_wrapper.py
+++ b/vllm_omni/model_executor/models/minicpmo_4_5/cuda_graph_wrapper.py
@@ -135,11 +135,13 @@ class HiFTGraphWrapper:
         return speech, cache_source
 
 
-def _tensor_signature(value: torch.Tensor) -> tuple:
+def _tensor_signature(value: torch.Tensor | None) -> tuple:
+    if value is None:
+        return (None,)
     return tuple(value.shape), str(value.dtype), str(value.device)
 
 
-_DTYPE_MAP = {str(dtype): dtype for dtype in (torch.float32, torch.float16, torch.bfloat16, torch.float64)}
+_DTYPE_MAP = {str(dtype): dtype for dtype in (torch.float32, torch.float16, torch.bfloat16, torch.float64, torch.bool)}
 
 
 def _memory_snapshot(device: torch.device) -> tuple[int, int] | None:
@@ -231,7 +233,7 @@ class CFMGraphWrapper:
         return {**self._stats, "cache_size": len(self._cache)}
 
     def _call_graph_fn(self, args: tuple[torch.Tensor, ...]) -> torch.Tensor:
-        return self.graph_fn(args[0], args[1], None, args[2], args[3], args[4], args[5])
+        return self.graph_fn(args[0], args[1], args[6], args[2], args[3], args[4], args[5])
 
     def _eager(self, inputs: tuple[torch.Tensor, ...]) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
         self._stats["eager"] += 1
@@ -261,10 +263,21 @@ class CFMGraphWrapper:
         self.enabled = False
         self._flush()
 
-    def _capture(self, key: tuple) -> tuple | None:
-        """Capture a CUDA graph for the given key. Returns None on failure."""
+    def _capture(self, key: tuple, inputs: tuple | None = None) -> tuple | None:
+        """Capture a CUDA graph for the given key. Returns None on failure.
+
+        ``inputs`` should be the real tensors for this key whenever they are
+        available: the static buffers must be built from the values the graph
+        will actually run with. Zero-filled placeholders are only a fallback --
+        capturing with them bakes the placeholder branch into the graph (e.g. an
+        attention mask that looks like "nothing is masked").
+        """
         try:
-            static_inputs = _tensors_from_key(key)
+            static_inputs = (
+                tuple(None if tensor is None else tensor.detach().clone() for tensor in inputs)
+                if inputs is not None
+                else _tensors_from_key(key)
+            )
         except KeyError:
             # An unsupported dtype is a property of this shape alone, so run it
             # eager and keep the other shapes on graphs.
@@ -315,8 +328,9 @@ class CFMGraphWrapper:
         att_cache: torch.Tensor,
         cnn_out: torch.Tensor,
         att_out: torch.Tensor,
+        attn_mask: torch.Tensor | None = None,
     ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
-        inputs = (estimator_input, time_emb, cnn_cache, att_cache, cnn_out, att_out)
+        inputs = (estimator_input, time_emb, cnn_cache, att_cache, cnn_out, att_out, attn_mask)
         self._stats["calls"] += 1
 
         if not self.enabled or torch.cuda.is_current_stream_capturing() or estimator_input.device.type != "cuda":
@@ -330,7 +344,7 @@ class CFMGraphWrapper:
         if entry is None:
             if len(self._cache) >= self.max_graphs:
                 self._flush()
-            entry = self._capture(key)
+            entry = self._capture(key, inputs)
             if entry is None:
                 return self._eager(inputs)
             self._cache[key] = entry
@@ -339,7 +353,8 @@ class CFMGraphWrapper:
 
         static_inputs, static_output, graph = entry
         for static, current in zip(static_inputs, inputs, strict=True):
-            static.copy_(current)
+            if static is not None:
+                static.copy_(current)
         graph.replay()
         return (
             static_output.detach().clone(),
diff --git a/vllm_omni/model_executor/models/minicpmo_4_5/duplex/__init__.py b/vllm_omni/model_executor/models/minicpmo_4_5/duplex/__init__.py
index b681ad51e..e38cc12ef 100644
--- a/vllm_omni/model_executor/models/minicpmo_4_5/duplex/__init__.py
+++ b/vllm_omni/model_executor/models/minicpmo_4_5/duplex/__init__.py
@@ -1,15 +1,15 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 
-from .adapter import MiniCPMO45ClientRuntimeConfigError, MiniCPMO45NativeDuplexServingAdapter
 from .input import MiniCPMO45PcmAppendBuffer
+from .plugin import MiniCPMO45ClientRuntimeConfigError, MiniCPMO45DuplexPlugin
 from .policy import MiniCPMO45DuplexPolicy
 from .stage0 import MiniCPMO45Stage0DuplexRuntime
 
 __all__ = [
-    "MiniCPMO45DuplexPolicy",
-    "MiniCPMO45NativeDuplexServingAdapter",
     "MiniCPMO45ClientRuntimeConfigError",
+    "MiniCPMO45DuplexPlugin",
+    "MiniCPMO45DuplexPolicy",
     "MiniCPMO45PcmAppendBuffer",
     "MiniCPMO45Stage0DuplexRuntime",
 ]
diff --git a/vllm_omni/model_executor/models/minicpmo_4_5/duplex/adapter.py b/vllm_omni/model_executor/models/minicpmo_4_5/duplex/adapter.py
deleted file mode 100644
index 758beafc9..000000000
--- a/vllm_omni/model_executor/models/minicpmo_4_5/duplex/adapter.py
+++ /dev/null
@@ -1,335 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-from __future__ import annotations
-
-import base64
-from copy import deepcopy
-from typing import Any
-
-import numpy as np
-from vllm.multimodal.media import MediaConnector
-
-from vllm_omni.entrypoints.duplex.protocol import DuplexSessionConfig, native_duplex_opt_in
-from vllm_omni.entrypoints.duplex.runtime_adapter import (
-    ServingRuntimeConfigError,
-    reject_changed_runtime_value,
-)
-from vllm_omni.model_executor.models.minicpmo_4_5.duplex.policy import MiniCPMO45DuplexPolicy
-
-
-class MiniCPMO45ClientRuntimeConfigError(ServingRuntimeConfigError):
-    pass
-
-
-class MiniCPMO45NativeDuplexServingAdapter:
-    """Serving-side MiniCPM-o 4.5 native duplex session preparation.
-
-    The generic duplex WebSocket handler should not let client-supplied local
-    paths reach workers.  This adapter follows the existing media connector
-    boundary: serving resolves client media URIs, then workers receive only
-    normalized PCM payloads.  Server-owned model assets remain local paths here.
-    """
-
-    PRIVATE_RUNTIME_CONFIG_KEYS = frozenset(
-        {
-            "duplex_stage_sampling_params",
-            "duplex_stage_max_tokens",
-            "duplex_stage0_max_tokens",
-            "duplex_scheduler_token_id",
-            "duplex_first_append_context_tokens",
-            "ref_audio_data",
-            "ref_audio_format",
-            "ref_audio_sample_rate_hz",
-            "initial_user_text",
-        }
-    )
-
-    @classmethod
-    def is_enabled(cls, config: DuplexSessionConfig) -> bool:
-        return native_duplex_opt_in(config.extra_body) is True
-
-    @classmethod
-    def validate_client_config(cls, config: DuplexSessionConfig) -> None:
-        cls.validate_client_extra_body(config.extra_body)
-
-    @classmethod
-    def validate_client_extra_body(cls, extra_body: object) -> None:
-        if not isinstance(extra_body, dict):
-            return
-        private_keys = sorted(cls.PRIVATE_RUNTIME_CONFIG_KEYS.intersection(extra_body))
-        if private_keys:
-            raise MiniCPMO45ClientRuntimeConfigError(
-                "native duplex runtime configuration is server-owned: " + ", ".join(private_keys)
-            )
-
-    @classmethod
-    def runtime_config_for_update(
-        cls,
-        config: DuplexSessionConfig,
-        current: object,
-    ) -> dict[str, object]:
-        runtime_config = deepcopy(dict(current)) if isinstance(current, dict) else {}
-        reject_changed_runtime_value(
-            config.instructions,
-            runtime_config.get("instructions"),
-            message="instructions cannot be changed after the session is created",
-            code="instructions_update_unsupported",
-            error_cls=MiniCPMO45ClientRuntimeConfigError,
-        )
-        stage_max_tokens = runtime_config.get("duplex_stage_max_tokens")
-        stage_max_tokens = deepcopy(stage_max_tokens) if isinstance(stage_max_tokens, dict) else {}
-        stage_max_tokens["0"] = (
-            config.max_tokens if isinstance(config.max_tokens, int) and config.max_tokens > 0 else 20
-        )
-        stage_max_tokens.setdefault("1", 8192)
-        runtime_config["duplex_stage_max_tokens"] = stage_max_tokens
-
-        stage_sampling = runtime_config.get("duplex_stage_sampling_params")
-        stage_sampling = deepcopy(stage_sampling) if isinstance(stage_sampling, dict) else {}
-        stage0 = stage_sampling.get("0")
-        stage0 = deepcopy(stage0) if isinstance(stage0, dict) else {}
-        stage0["temperature"] = config.temperature if config.temperature is not None else 0.7
-        stage_sampling["0"] = stage0
-        runtime_config["duplex_stage_sampling_params"] = stage_sampling
-        return runtime_config
-
-    @classmethod
-    async def prepare_runtime_config(cls, config: DuplexSessionConfig, *, model_config: Any) -> dict[str, object]:
-        extra_body = dict(config.extra_body)
-        if any(key in extra_body for key in ("ref_audio_path", "tts_ref_audio_path")):
-            raise ValueError("ref_audio_path is not accepted by native duplex; use ref_audio URI instead")
-        cls.validate_client_config(config)
-        runtime_config: dict[str, object] = {"instructions": config.instructions}
-        initial_user_text = extra_body.pop("duplex_initial_user_text", None)
-        if isinstance(initial_user_text, str) and initial_user_text:
-            runtime_config["initial_user_text"] = initial_user_text
-        cls._apply_default_scheduler_policy(runtime_config, config=config, model_config=model_config)
-
-        ref_audio = config.ref_audio
-        extra_ref_audio = extra_body.get("ref_audio")
-        if ref_audio is None and isinstance(extra_ref_audio, str):
-            extra_body.pop("ref_audio")
-            ref_audio = extra_ref_audio
-        extra_tts_ref_audio = extra_body.get("tts_ref_audio")
-        if ref_audio is None and isinstance(extra_tts_ref_audio, str):
-            extra_body.pop("tts_ref_audio")
-            ref_audio = extra_tts_ref_audio
-
-        if ref_audio is None:
-            if any(str(modality).lower() == "audio" for modality in config.modalities):
-                raise MiniCPMO45ClientRuntimeConfigError(
-                    "MiniCPM-o native duplex audio output requires ref_audio",
-                    code="ref_audio_required",
-                )
-            cls._apply_first_append_context_tokens(
-                runtime_config,
-                model_config=model_config,
-                instructions=config.instructions,
-                initial_user_text=initial_user_text,
-                ref_sample_count=None,
-            )
-            config.extra_body = extra_body
-            return runtime_config
-        else:
-            wav_np, sr = await cls.resolve_ref_audio(ref_audio, model_config=model_config)
-
-        wav_np = cls.normalize_ref_audio(wav_np, int(sr), target_sr=16000)
-        # Trim to a whole number of pooled audio embeddings (100 ms frames) so
-        # the first-append scheduler reserve can count them exactly.
-        usable = (len(wav_np) // MiniCPMO45DuplexPolicy.SAMPLES_PER_AUDIO_TOKEN) * (
-            MiniCPMO45DuplexPolicy.SAMPLES_PER_AUDIO_TOKEN
-        )
-        wav_np = wav_np[:usable]
-        ref_audio_bytes = np.ascontiguousarray(wav_np, dtype=np.float32).tobytes()
-        runtime_config["ref_audio_data"] = base64.b64encode(ref_audio_bytes).decode("ascii")
-        runtime_config["ref_audio_format"] = "pcm_f32le"
-        runtime_config["ref_audio_sample_rate_hz"] = 16000
-        cls._apply_first_append_context_tokens(
-            runtime_config,
-            model_config=model_config,
-            instructions=config.instructions,
-            initial_user_text=initial_user_text,
-            ref_sample_count=len(wav_np),
-        )
-        config.extra_body = extra_body
-        config.ref_audio = None
-        return runtime_config
-
-    @classmethod
-    def _apply_default_scheduler_policy(
-        cls,
-        runtime_config: dict[str, object],
-        *,
-        config: DuplexSessionConfig,
-        model_config: Any,
-    ) -> 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}
-        stage0_params: dict[str, object] = {
-            "temperature": config.temperature if config.temperature is not None else 0.7,
-            "top_p": 0.8,
-            "top_k": 20,
-            "repetition_penalty": 1.05,
-        }
-        stop_token_ids = cls._native_stage0_stop_token_ids(model_config)
-        if stop_token_ids:
-            stage0_params["stop_token_ids"] = stop_token_ids
-        # Stage 1 keeps the deploy YAML's codec knobs, minus upstream's
-        # min_new_token=50: that floor is for whole-utterance chat TTS, while a
-        # duplex chunk is 26 codec samples, so check_stop would never release
-        # the Talker and Thinker would stall on the next model turn.
-        runtime_config["duplex_stage_sampling_params"] = {"0": stage0_params, "1": {"min_tokens": 0}}
-        scheduler_token_id = cls._native_scheduler_token_id(model_config)
-        if scheduler_token_id is not None:
-            runtime_config["duplex_scheduler_token_id"] = scheduler_token_id
-
-    @classmethod
-    def _apply_first_append_context_tokens(
-        cls,
-        runtime_config: dict[str, object],
-        *,
-        model_config: Any,
-        instructions: object,
-        initial_user_text: object,
-        ref_sample_count: int | None,
-    ) -> None:
-        """Precompute the exact session-context token count for the engine.
-
-        The first data-plane append carries the system template and optional
-        reference-audio embeddings ahead of the first unit. The engine
-        reserves scheduler slots from this count; an inexact count turns into
-        pad embeddings inside the model KV (surplus) or truncated context
-        (deficit), so it is computed with the same template and pooling math
-        the worker uses.
-        """
-        if "duplex_first_append_context_tokens" in runtime_config:
-            return
-        tokenizer = cls._load_native_tokenizer(model_config)
-        if tokenizer is None:
-            return
-        prefix, suffix = MiniCPMO45DuplexPolicy.session_context_texts(
-            instructions,
-            ref_sample_count is not None,
-            initial_user_text,
-        )
-        try:
-            prefix_ids = tokenizer.encode(prefix, add_special_tokens=False)
-            suffix_ids = tokenizer.encode(suffix, add_special_tokens=False)
-        except Exception:
-            return
-        ref_tokens = MiniCPMO45DuplexPolicy.audio_token_count(ref_sample_count or 0)
-        runtime_config["duplex_first_append_context_tokens"] = len(prefix_ids) + ref_tokens + len(suffix_ids)
-
-    @staticmethod
-    def _native_stage0_stop_token_ids(model_config: Any) -> list[int]:
-        tokenizer = MiniCPMO45NativeDuplexServingAdapter._load_native_tokenizer(model_config)
-        if tokenizer is None:
-            return []
-        out: list[int] = []
-        stop_token_fields = (
-            "chunk_eos_token_id",
-            "chunk_tts_eos_token_id",
-            "listen_token_id",
-            "turn_eos_token_id",
-        )
-        for field in stop_token_fields:
-            token = MiniCPMO45DuplexPolicy.SPECIAL_TOKEN_FIELDS[field]
-            token_id = MiniCPMO45NativeDuplexServingAdapter._convert_token_to_id(tokenizer, token)
-            if token_id is not None and token_id not in out:
-                out.append(token_id)
-        return out
-
-    @staticmethod
-    def _native_scheduler_token_id(model_config: Any) -> int | None:
-        tokenizer = MiniCPMO45NativeDuplexServingAdapter._load_native_tokenizer(model_config)
-        if tokenizer is None:
-            return None
-        scheduler_tokens = (
-            MiniCPMO45DuplexPolicy.SPECIAL_TOKEN_FIELDS["unit_token_id"],
-            MiniCPMO45DuplexPolicy.OPTIONAL_TOKEN_FIELDS["audio_placeholder_token_id"],
-        )
-        for token in scheduler_tokens:
-            token_id = MiniCPMO45NativeDuplexServingAdapter._convert_token_to_id(tokenizer, token)
-            if token_id is not None:
-                return token_id
-        eos_id = getattr(tokenizer, "eos_token_id", None)
-        if eos_id is None:
-            return None
-        try:
-            return int(eos_id)
-        except (TypeError, ValueError):
-            return None
-
-    @staticmethod
-    def _load_native_tokenizer(model_config: Any) -> Any | None:
-        model_path = getattr(model_config, "model", None)
-        if not isinstance(model_path, str) or not model_path:
-            return None
-        try:
-            from transformers import AutoTokenizer
-
-            return AutoTokenizer.from_pretrained(
-                model_path,
-                trust_remote_code=True,
-                local_files_only=True,
-            )
-        except Exception:
-            return None
-
-    @staticmethod
-    def _convert_token_to_id(tokenizer: Any, token: str) -> int | None:
-        convert = getattr(tokenizer, "convert_tokens_to_ids", None)
-        value = None
-        if callable(convert):
-            value = convert(token)
-            if isinstance(value, list):
-                value = value[0] if len(value) == 1 else None
-        if value is None:
-            token_id = -1
-        else:
-            try:
-                token_id = int(value)
-            except (TypeError, ValueError):
-                token_id = -1
-        unk_token_id = getattr(tokenizer, "unk_token_id", None)
-        if token_id >= 0 and token_id != unk_token_id:
-            return token_id
-        encode = getattr(tokenizer, "encode", None)
-        if callable(encode):
-            try:
-                ids = list(encode(token, add_special_tokens=False))
-            except TypeError:
-                ids = list(encode(token))
-            if len(ids) == 1:
-                try:
-                    token_id = int(ids[0])
-                except (TypeError, ValueError):
-                    token_id = -1
-                if token_id >= 0 and token_id != unk_token_id:
-                    return token_id
-        return None
-
-    @staticmethod
-    async def resolve_ref_audio(ref_audio: str, *, model_config: Any) -> tuple[np.ndarray, int]:
-        connector = MediaConnector(
-            allowed_local_media_path=getattr(model_config, "allowed_local_media_path", None),
-            allowed_media_domains=getattr(model_config, "allowed_media_domains", None),
-        )
-        wav_np, sr = await connector.fetch_audio_async(ref_audio)
-        return np.asarray(wav_np, dtype=np.float32), int(sr)
-
-    @staticmethod
-    def normalize_ref_audio(wav_np: np.ndarray, sample_rate: int, *, target_sr: int) -> np.ndarray:
-        wav_np = np.asarray(wav_np, dtype=np.float32)
-        if wav_np.ndim > 1:
-            wav_np = wav_np.mean(axis=-1)
-        wav_np = wav_np.reshape(-1)
-        if sample_rate <= 0 or sample_rate == target_sr or wav_np.size == 0:
-            return wav_np.astype(np.float32, copy=False)
-        import torch
-        import torchaudio
-
-        audio = torch.from_numpy(wav_np).to(dtype=torch.float32).unsqueeze(0)
-        resampled = torchaudio.functional.resample(audio, int(sample_rate), int(target_sr))
-        return resampled.squeeze(0).cpu().numpy().astype(np.float32, copy=False)
diff --git a/vllm_omni/model_executor/models/minicpmo_4_5/duplex/capabilities.py b/vllm_omni/model_executor/models/minicpmo_4_5/duplex/capabilities.py
index 668405892..d850f4c3c 100644
--- a/vllm_omni/model_executor/models/minicpmo_4_5/duplex/capabilities.py
+++ b/vllm_omni/model_executor/models/minicpmo_4_5/duplex/capabilities.py
@@ -3,7 +3,12 @@
 
 from __future__ import annotations
 
-from vllm_omni.entrypoints.duplex.protocol import DuplexCapabilities
+from vllm_omni.engine.duplex.config import DuplexCapabilities
+
+#: Silence units a text-seeded turn is given to generate on. The model speaks
+#: per audio unit, so a seeded turn still needs a clock; three units is what
+#: the benchmark harness uses for the same purpose.
+MINICPMO45_TEXT_TURN_PRIMING_UNITS = 3
 
 
 def minicpmo45_native_capabilities(*, max_sessions: int = 1) -> DuplexCapabilities:
@@ -31,11 +36,14 @@ def minicpmo45_native_capabilities(*, max_sessions: int = 1) -> DuplexCapabiliti
         supports_session_resume=True,
         session_admission_mode="engine_managed",
         supports_audio_truncate=True,
+        # The session template ends at the assistant turn, so seeded text puts
+        # the model in position to answer; it still generates per audio unit,
+        # hence the priming units.
+        supports_chat_completions=True,  # via initial_user_text
+        text_turn_priming_units=MINICPMO45_TEXT_TURN_PRIMING_UNITS,
         requires_model_runner_kv=True,
         requires_native_stage_role=True,
-        implementation_level="model_native_duplex",
         adapter_patterns=["scheduler_data_plane"],
-        input_modes=["append_audio_chunk"],
         signal_sources=["model_native", "client_event", "server_policy"],
         stage_handoff_transport="scheduler_data_plane",
         chunk_period_ms=1000,
diff --git a/vllm_omni/model_executor/models/minicpmo_4_5/duplex/compat.py b/vllm_omni/model_executor/models/minicpmo_4_5/duplex/compat.py
index 9a4bcf9b0..5b6b5c909 100644
--- a/vllm_omni/model_executor/models/minicpmo_4_5/duplex/compat.py
+++ b/vllm_omni/model_executor/models/minicpmo_4_5/duplex/compat.py
@@ -3,14 +3,12 @@
 
 from __future__ import annotations
 
-from typing import Any
 
-
-def patch_minicpmo_remote_config(config: Any) -> None:
+def patch_minicpmo_remote_config(config: object) -> None:
     """Fill config fields expected by the vLLM MiniCPM implementation."""
     seen: set[int] = set()
 
-    def patch_cfg(cfg: Any) -> None:
+    def patch_cfg(cfg: object) -> None:
         if cfg is None or id(cfg) in seen:
             return
         seen.add(id(cfg))
diff --git a/vllm_omni/model_executor/models/minicpmo_4_5/duplex/data_plane.py b/vllm_omni/model_executor/models/minicpmo_4_5/duplex/data_plane.py
index d4063ff3f..7bf51abfd 100644
--- a/vllm_omni/model_executor/models/minicpmo_4_5/duplex/data_plane.py
+++ b/vllm_omni/model_executor/models/minicpmo_4_5/duplex/data_plane.py
@@ -12,6 +12,7 @@ from vllm.logger import init_logger
 from vllm_omni.engine.duplex.contracts import (
     duplex_resource_request_belongs_to_session,
 )
+from vllm_omni.engine.duplex.plugin import DuplexDataPlane
 from vllm_omni.outputs.duplex import get_duplex_output_decision
 
 logger = init_logger(__name__)
@@ -44,6 +45,9 @@ class _TurnState:
 @dataclass(slots=True)
 class _RequestState:
     audio_offset: int = 0
+    #: A snapshot below ``audio_offset`` that has not been accepted as a restart
+    #: yet. See :meth:`MiniCPMO45DataPlaneSession.slice_cumulative_audio`.
+    audio_restart_candidate: int | None = None
     uses_segment_text_metadata: bool = False
     pending_audio_without_text: list[dict[str, object]] = field(default_factory=list)
     terminal: bool = False
@@ -53,7 +57,7 @@ class _RequestState:
         return self.turns.setdefault(turn_id, _TurnState())
 
 
-class MiniCPMO45DataPlaneSession:
+class MiniCPMO45DataPlaneSession(DuplexDataPlane):
     """MiniCPM output projector and request/turn cursor owner.
 
     The scheduler request owns cumulative Stage1 audio, while model turns own
@@ -487,13 +491,33 @@ class MiniCPMO45DataPlaneSession:
         prev_samples = state.audio_offset
         if prev_samples <= 0:
             state.audio_offset = num_samples
+            state.audio_restart_candidate = None
             return audio_data
         if num_samples == prev_samples:
             return None
         if num_samples < prev_samples:
+            # Below the cursor means one of two things, and they are not
+            # distinguishable from this snapshot alone: the producer restarted
+            # its buffer, or this is a unit that carries no cumulative audio at
+            # all (a continuation placeholder arrives as a single sample).
+            # Rewinding the cursor for the second case is expensive and silent:
+            # the next real snapshot is then sliced from ~0 and the whole
+            # session's audio goes out again as one delta. So defer the
+            # decision — hold the candidate and leave the cursor where it is.
+            candidate = state.audio_restart_candidate
+            if candidate is None or num_samples <= candidate:
+                state.audio_restart_candidate = num_samples
+                return audio_data
+            # A second below-cursor snapshot that grew from the first: the
+            # producer really did restart, and this is its delta.
+            state.audio_offset = num_samples
+            state.audio_restart_candidate = num_samples
+            prev_samples = candidate
+        else:
+            # Above the cursor: whatever the dip was, this stream never
+            # restarted, so it is sliced from the cursor as usual.
+            state.audio_restart_candidate = None
             state.audio_offset = num_samples
-            return audio_data
-        state.audio_offset = num_samples
         try:
             import torch
 
diff --git a/vllm_omni/model_executor/models/minicpmo_4_5/duplex/input.py b/vllm_omni/model_executor/models/minicpmo_4_5/duplex/input.py
index f7d86f1d7..4feb8cb97 100644
--- a/vllm_omni/model_executor/models/minicpmo_4_5/duplex/input.py
+++ b/vllm_omni/model_executor/models/minicpmo_4_5/duplex/input.py
@@ -6,9 +6,11 @@ from __future__ import annotations
 import base64
 import binascii
 from dataclasses import dataclass
-from typing import Any
 
 import numpy as np
+from numpy.typing import NDArray
+
+from vllm_omni.engine.duplex.plugin import PcmAppendBuffer, PcmAppendReservation
 
 
 @dataclass(frozen=True, slots=True)
@@ -18,7 +20,7 @@ class _PcmSpan:
     is_speech: bool
 
 
-class MiniCPMO45PcmAppendReservation:
+class MiniCPMO45PcmAppendReservation(PcmAppendReservation):
     __slots__ = (
         "_active",
         "_force_listen",
@@ -74,7 +76,7 @@ class MiniCPMO45PcmAppendReservation:
         self._owner._rollback_reservation(self)
 
 
-def validate_native_ref_audio_config(session_config: dict[str, Any]) -> None:
+def validate_native_ref_audio_config(session_config: dict[str, object]) -> None:
     extra_body = session_config.get("extra_body")
     if not isinstance(extra_body, dict):
         extra_body = {}
@@ -84,7 +86,7 @@ def validate_native_ref_audio_config(session_config: dict[str, Any]) -> None:
         raise ValueError("native duplex ref_audio_path is not accepted; resolve ref_audio in serving first")
 
 
-def decode_native_ref_audio_from_config(session_config: dict[str, Any]) -> np.ndarray | None:
+def decode_native_ref_audio_from_config(session_config: dict[str, object]) -> NDArray[np.float32] | None:
     validate_native_ref_audio_config(session_config)
     extra_body = session_config.get("extra_body")
     if not isinstance(extra_body, dict):
@@ -106,7 +108,7 @@ def decode_native_ref_audio_from_config(session_config: dict[str, Any]) -> np.nd
     return np.frombuffer(raw, dtype="<f4").astype(np.float32, copy=True)
 
 
-class MiniCPMO45PcmAppendBuffer:
+class MiniCPMO45PcmAppendBuffer(PcmAppendBuffer):
     """Accumulates short native-duplex PCM chunks into model-sized appends."""
 
     def __init__(self) -> None:
@@ -116,9 +118,12 @@ class MiniCPMO45PcmAppendBuffer:
         self._turn_had_speech = False
         self._reservation_seq = 0
         self._reservations: list[MiniCPMO45PcmAppendReservation] = []
-        # Omni duplex: queued camera frames (base64 JPEG), consumed FIFO at
-        # one frame per emitted model unit alongside the unit's audio.
-        self._frame_queue: list[str] = []
+        # Omni duplex: queued camera frames (base64 JPEG), grouped per client
+        # append and consumed FIFO at one group per emitted model unit. A
+        # group is the base frame plus its optional stacked composite (the
+        # wire contract allows at most 2 images per append); both must ride
+        # the same unit, mirroring official ``frame_list``.
+        self._frame_queue: list[list[str]] = []
 
     def clear(self) -> None:
         for reservation in self._reservations:
@@ -251,7 +256,9 @@ class MiniCPMO45PcmAppendBuffer:
         )
         frames_in = payload.get("video_frames")
         if isinstance(frames_in, list):
-            self._frame_queue.extend(frame for frame in frames_in if isinstance(frame, str) and frame)
+            frame_group = [frame for frame in frames_in if isinstance(frame, str) and frame]
+            if frame_group:
+                self._frame_queue.append(frame_group)
         self._turn_had_speech = self._turn_had_speech or bool(payload.get("is_speech", False))
         if not allow_emit:
             return None
@@ -284,16 +291,17 @@ class MiniCPMO45PcmAppendBuffer:
         out.pop("video_frames", None)
         out["audio"] = base64.b64encode(emit_raw).decode("ascii")
         out["sample_rate_hz"] = sample_rate_hz
-        # Omni duplex: attach at most one queued camera frame per emitted
-        # model unit (official cadence: one frame per 1 s chunk). The engine
-        # budgets 66 scheduler slots per attached frame from this payload.
-        # Official omni cadence is one frame per ~1 s chunk, and the first
-        # append consumes extra samples (1035 ms first window), so per-unit
-        # attachment could outrun the units Stage0 actually builds. Attach at
-        # most ONE frame per emitted payload; the rest stay queued.
+        # Omni duplex: attach at most one queued frame *group* per emitted
+        # model unit (official cadence: one ``frame_list`` per 1 s chunk). The
+        # engine budgets scheduler slots for every frame in this payload.
+        # The first append consumes extra samples (1035 ms first window), so
+        # per-unit attachment could outrun the units Stage0 actually builds.
+        # Attach ONE group per emitted payload; later groups stay queued. A
+        # group is what one client append carried (base frame + optional
+        # stacked composite), so the composite never lags its base frame.
         attached_frames: list[str] = []
         if emit_samples + pad_samples >= min_samples and self._frame_queue:
-            attached_frames = [self._frame_queue.pop(0)]
+            attached_frames = list(self._frame_queue.pop(0))
             out["video_frames"] = attached_frames
         out["force_listen"] = any(span.force_listen for span in reserved_spans)
         out["is_speech"] = any(span.is_speech for span in reserved_spans)
@@ -400,9 +408,9 @@ class MiniCPMO45PcmAppendBuffer:
         restored = b"".join(item._raw for item in rolled_back)
         self._buffer[:0] = restored
         self._prepend_spans([span for item in rolled_back for span in item._spans])
-        restored_frames = [frame for item in rolled_back for frame in item._video_frames]
-        if restored_frames:
-            self._frame_queue[:0] = restored_frames
+        restored_groups = [list(item._video_frames) for item in rolled_back if item._video_frames]
+        if restored_groups:
+            self._frame_queue[:0] = restored_groups
         self._sample_rate_hz = self._sample_rate_hz or reservation._sample_rate_hz
         self._turn_had_speech = self._turn_had_speech or any(item._turn_had_speech for item in rolled_back)
         for item in rolled_back:
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
new file mode 100644
index 000000000..e57377766
--- /dev/null
+++ b/vllm_omni/model_executor/models/minicpmo_4_5/duplex/plugin.py
@@ -0,0 +1,850 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""MiniCPM-o 4.5 full-duplex model plugin: engine policy and session policy in one class.
+
+Engine policy (scheduler token budget, resumable Stage0 prompt, listen
+decision) and session policy (client config validation, reference-audio
+resolution, per-stage sampling knobs) both run engine-side, so one class owns
+them. Client-supplied media URIs are resolved here through the media
+connector; workers only ever receive normalized PCM payloads.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import base64
+from base64 import b64decode
+from binascii import Error as BinasciiError
+from collections.abc import Mapping
+from copy import deepcopy
+from typing import TYPE_CHECKING, Any, cast
+
+import numpy as np
+from numpy.typing import NDArray
+from vllm.multimodal.media import MediaConnector
+from vllm.sampling_params import SamplingParams
+
+from vllm_omni.engine.duplex.config import DuplexCapabilities, DuplexSessionConfig
+from vllm_omni.engine.duplex.contracts import (
+    DuplexAppendPlan,
+    DuplexFence,
+    DuplexOutputAction,
+    DuplexOutputDecision,
+)
+from vllm_omni.engine.duplex.plugin import (
+    DuplexModelPlugin,
+    DuplexRuntimeConfigError,
+    EncodeAudio,
+    reject_changed_runtime_value,
+)
+from vllm_omni.model_executor.models.minicpmo_4_5.duplex.capabilities import (
+    minicpmo45_native_capabilities,
+)
+from vllm_omni.model_executor.models.minicpmo_4_5.duplex.data_plane import (
+    MiniCPMO45DataPlaneContext,
+    MiniCPMO45DataPlaneSession,
+)
+from vllm_omni.model_executor.models.minicpmo_4_5.duplex.policy import MiniCPMO45DuplexPolicy
+from vllm_omni.model_executor.models.minicpmo_4_5.duplex.session import (
+    MiniCPMO45ServingSessionState,
+)
+
+if TYPE_CHECKING:
+    import torch
+    from transformers import PreTrainedTokenizerBase
+    from vllm.config import ModelConfig
+
+_DUPLEX_CHUNK_SAMPLES = 16000
+_DUPLEX_SAMPLES_PER_AUDIO_TOKEN = 1600
+# <image> + 64 resampler embeddings + </image> per frame (max_slice_nums=1),
+# matching MiniCPMO45DuplexPolicy.VISION_TOKENS_PER_FRAME.
+_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(
+    {
+        "duplex_stage_sampling_params",
+        "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",
+        "ref_audio_sample_rate_hz",
+        "initial_user_text",
+    }
+)
+
+
+class MiniCPMO45ClientRuntimeConfigError(DuplexRuntimeConfigError):
+    pass
+
+
+# ---- engine policy helpers: scheduler token budget ----
+
+
+def _duplex_frames(payload: object) -> list[str]:
+    if not isinstance(payload, dict):
+        return []
+    frames = payload.get("video_frames")
+    if not isinstance(frames, list):
+        return []
+    return [frame for frame in frames if isinstance(frame, str) and frame]
+
+
+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 only the first frame is sliced and every other frame
+    reserves one 66-token block.
+    """
+    frames = _duplex_frames(payload)
+    if not frames:
+        return 0
+    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:
+    if not isinstance(payload, dict):
+        return None
+    audio = payload.get("audio") or payload.get("data")
+    if payload.get("format") != "pcm_f32le" or not isinstance(audio, str):
+        return None
+    try:
+        raw = b64decode(audio, validate=True)
+    except (BinasciiError, ValueError):
+        return None
+    return len(raw) // 4
+
+
+def duplex_payload_is_exact_chunks(payload: object) -> bool:
+    sample_count = _duplex_pcm_sample_count(payload)
+    return sample_count is not None and sample_count != 0 and sample_count % _DUPLEX_CHUNK_SAMPLES == 0
+
+
+def duplex_first_append_unit_count(payload: object) -> int | None:
+    sample_count = _duplex_pcm_sample_count(payload)
+    if not sample_count or sample_count % _DUPLEX_CHUNK_SAMPLES != 0:
+        return None
+    return max(1, sample_count // _DUPLEX_CHUNK_SAMPLES - 1)
+
+
+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
+    sample_count = max(1, sample_count)
+    if sample_count % _DUPLEX_CHUNK_SAMPLES == 0:
+        units = sample_count // _DUPLEX_CHUNK_SAMPLES
+        return units * (2 + _DUPLEX_CHUNK_SAMPLES // _DUPLEX_SAMPLES_PER_AUDIO_TOKEN) + vision_tokens
+    return max(16, min(768, sample_count // _DUPLEX_SAMPLES_PER_AUDIO_TOKEN + 8)) + vision_tokens
+
+
+def duplex_first_append_context_reserve(runtime_config: object) -> int:
+    if not isinstance(runtime_config, dict):
+        return 48
+    exact = runtime_config.get("duplex_first_append_context_tokens")
+    if isinstance(exact, int) and exact >= 0:
+        return exact
+    reserve = 48
+    ref = runtime_config.get("ref_audio_data")
+    if isinstance(ref, str) and ref:
+        try:
+            raw = b64decode(ref, validate=True)
+        except (BinasciiError, ValueError):
+            raw = b""
+        if raw:
+            reserve += max(0, (len(raw) // 4) // _DUPLEX_SAMPLES_PER_AUDIO_TOKEN + 8)
+    return reserve
+
+
+def _duplex_force_listen_count(extra_body: object) -> int:
+    raw = extra_body.get("force_listen_count") if isinstance(extra_body, dict) else None
+    try:
+        return 0 if raw is None else max(0, int(raw))
+    except (TypeError, ValueError):
+        return 0
+
+
+def build_duplex_data_plane_prompt(
+    *,
+    request_id: str,
+    fence: DuplexFence,
+    session_config: dict[str, object],
+    runtime_config: dict[str, object],
+    seq: int,
+    turn_seq: int,
+    payload: object,
+    final: bool,
+) -> dict[str, object]:
+    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:
+            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):
+        token_budget += 12
+    extra_body = session_config.get("extra_body")
+    raw_token_id = runtime_config.get("duplex_scheduler_token_id")
+    try:
+        token_id = 0 if raw_token_id is None else max(0, int(raw_token_id))
+    except (TypeError, ValueError):
+        token_id = 0
+    force_listen_count = _duplex_force_listen_count(extra_body)
+    if (
+        force_listen_count > 0
+        and turn_seq <= force_listen_count
+        and isinstance(payload, dict)
+        and payload.get("force_listen") is not True
+    ):
+        payload = {**payload, "force_listen": True}
+    return {
+        "prompt_token_ids": [token_id] * token_budget,
+        "model_intermediate_buffer": {
+            "request_id": request_id,
+            "global_request_id": [fence.session_id],
+            "duplex": {
+                "fence": fence,
+                "session_id": fence.session_id,
+                "epoch": fence.epoch,
+                "seq": seq,
+                "turn_id": fence.turn_id,
+                "turn_seq": turn_seq,
+                "mode": "append_audio_chunk",
+                "payload": payload,
+                "final": final,
+                "data_plane": True,
+                "session_config": dict(session_config),
+                "runtime_config": dict(runtime_config),
+                "scheduler_token_budget": token_budget,
+                "scheduler_token_id": token_id,
+            },
+        },
+    }
+
+
+# ---- engine policy helpers: listen decision ----
+
+
+def _coerce_int(value: object) -> int | None:
+    detach = getattr(value, "detach", None)
+    if callable(detach):
+        try:
+            flat: torch.Tensor = detach().cpu().reshape(-1)
+            if flat.numel() == 0:
+                return None
+            value = flat[0].item()
+        except Exception:
+            return None
+    try:
+        return int(cast(Any, value))  # Any: duck-typed scalar (int/float/str/tensor item)
+    except (TypeError, ValueError):
+        return None
+
+
+def _coerce_int_list(value: object) -> list[int]:
+    if value is None:
+        return []
+    if hasattr(value, "detach"):
+        try:
+            value = value.detach().cpu().reshape(-1).tolist()
+        except Exception:
+            return []
+    if not isinstance(value, (list, tuple)):
+        return []
+    return [token_id for item in value if (token_id := _coerce_int(item)) is not None]
+
+
+def _first_completion(output: object) -> object | None:
+    outputs = getattr(output, "outputs", None)
+    return outputs[0] if isinstance(outputs, list) and outputs else None
+
+
+def _multimodal_output(output: object, completion: object | None) -> dict[str, object]:
+    metadata = getattr(output, "multimodal_output", None)
+    if isinstance(metadata, dict):
+        return metadata
+    metadata = getattr(completion, "multimodal_output", None) if completion is not None else None
+    return metadata if isinstance(metadata, dict) else {}
+
+
+def _special_token_ids(metadata: dict[str, object]) -> dict[str, int]:
+    sources: list[object] = [metadata.get("special_token_ids"), metadata.get("meta")]
+    sources.append(
+        {
+            key.removeprefix("meta."): value
+            for key, value in metadata.items()
+            if isinstance(key, str) and key.startswith("meta.")
+        }
+    )
+    token_ids: dict[str, int] = {}
+    for source in sources:
+        if not isinstance(source, dict):
+            continue
+        for key, value in source.items():
+            token_id = _coerce_int(value)
+            if isinstance(key, str) and token_id is not None and token_id >= 0:
+                token_ids[key] = token_id
+    return token_ids
+
+
+def _completion_token_ids(completion: object | None) -> list[int]:
+    if completion is None:
+        return []
+    for attribute in ("token_ids", "cumulative_token_ids"):
+        token_ids = _coerce_int_list(getattr(completion, attribute, None))
+        if token_ids:
+            return token_ids
+    return []
+
+
+def _stage_config_value(runtime_config: dict[str, object], key: str, stage_id: int) -> object | None:
+    raw = runtime_config.get(key)
+    if isinstance(raw, dict):
+        value = raw.get(stage_id)
+        return raw.get(str(stage_id)) if value is None else value
+    if isinstance(raw, (list, tuple)) and stage_id < len(raw):
+        return raw[stage_id]
+    return None
+
+
+# ---- session policy helpers: tokenizer / reference audio ----
+
+
+def _load_tokenizer(model_config: ModelConfig | None) -> PreTrainedTokenizerBase | None:
+    model_path = getattr(model_config, "model", None)
+    if not isinstance(model_path, str) or not model_path:
+        return None
+    try:
+        from transformers import AutoTokenizer
+
+        return AutoTokenizer.from_pretrained(
+            model_path,
+            trust_remote_code=True,
+            local_files_only=True,
+        )
+    except Exception:
+        return None
+
+
+def _convert_token_to_id(tokenizer: PreTrainedTokenizerBase, token: str) -> int | None:
+    convert = getattr(tokenizer, "convert_tokens_to_ids", None)
+    value = None
+    if callable(convert):
+        value = convert(token)
+        if isinstance(value, list):
+            value = value[0] if len(value) == 1 else None
+    if value is None:
+        token_id = -1
+    else:
+        try:
+            token_id = int(value)
+        except (TypeError, ValueError):
+            token_id = -1
+    unk_token_id = getattr(tokenizer, "unk_token_id", None)
+    if token_id >= 0 and token_id != unk_token_id:
+        return token_id
+    encode = getattr(tokenizer, "encode", None)
+    if callable(encode):
+        try:
+            ids = list(encode(token, add_special_tokens=False))
+        except TypeError:
+            ids = list(encode(token))
+        if len(ids) == 1:
+            try:
+                token_id = int(ids[0])
+            except (TypeError, ValueError):
+                token_id = -1
+            if token_id >= 0 and token_id != unk_token_id:
+                return token_id
+    return None
+
+
+def _stage0_stop_token_ids(tokenizer: PreTrainedTokenizerBase | None) -> list[int]:
+    if tokenizer is None:
+        return []
+    out: list[int] = []
+    stop_token_fields = (
+        "chunk_eos_token_id",
+        "chunk_tts_eos_token_id",
+        "listen_token_id",
+        "turn_eos_token_id",
+    )
+    for field in stop_token_fields:
+        token = MiniCPMO45DuplexPolicy.SPECIAL_TOKEN_FIELDS[field]
+        token_id = _convert_token_to_id(tokenizer, token)
+        if token_id is not None and token_id not in out:
+            out.append(token_id)
+    return out
+
+
+def _scheduler_token_id(tokenizer: PreTrainedTokenizerBase | None) -> int | None:
+    if tokenizer is None:
+        return None
+    scheduler_tokens = (
+        MiniCPMO45DuplexPolicy.SPECIAL_TOKEN_FIELDS["unit_token_id"],
+        MiniCPMO45DuplexPolicy.OPTIONAL_TOKEN_FIELDS["audio_placeholder_token_id"],
+    )
+    for token in scheduler_tokens:
+        token_id = _convert_token_to_id(tokenizer, token)
+        if token_id is not None:
+            return token_id
+    eos_id = getattr(tokenizer, "eos_token_id", None)
+    if eos_id is None:
+        return None
+    try:
+        return int(eos_id)
+    except (TypeError, ValueError):
+        return None
+
+
+async def resolve_ref_audio(ref_audio: str, *, model_config: ModelConfig | None) -> tuple[NDArray[np.float32], int]:
+    connector = MediaConnector(
+        allowed_local_media_path=getattr(model_config, "allowed_local_media_path", None),
+        allowed_media_domains=getattr(model_config, "allowed_media_domains", None),
+    )
+    wav_np, sr = await connector.fetch_audio_async(ref_audio)
+    return np.asarray(wav_np, dtype=np.float32), int(sr)
+
+
+def normalize_ref_audio(wav_np: NDArray[np.float32], sample_rate: int, *, target_sr: int) -> NDArray[np.float32]:
+    wav_np = np.asarray(wav_np, dtype=np.float32)
+    if wav_np.ndim > 1:
+        wav_np = wav_np.mean(axis=-1)
+    wav_np = wav_np.reshape(-1)
+    if sample_rate <= 0 or sample_rate == target_sr or wav_np.size == 0:
+        return wav_np.astype(np.float32, copy=False)
+    import torch
+    import torchaudio
+
+    audio = torch.from_numpy(wav_np).to(dtype=torch.float32).unsqueeze(0)
+    resampled = torchaudio.functional.resample(audio, int(sample_rate), int(target_sr))
+    return resampled.squeeze(0).cpu().numpy().astype(np.float32, copy=False)
+
+
+def _apply_first_append_context_tokens(
+    runtime_config: dict[str, object],
+    *,
+    tokenizer: PreTrainedTokenizerBase | None,
+    instructions: object,
+    initial_user_text: object,
+    ref_sample_count: int | None,
+) -> None:
+    """Precompute the exact session-context token count for the engine.
+
+    The first data-plane append carries the system template and optional
+    reference-audio embeddings ahead of the first unit. The engine reserves
+    scheduler slots from this count; an inexact count turns into pad
+    embeddings inside the model KV (surplus) or truncated context (deficit),
+    so it is computed with the same template and pooling math the worker uses.
+    """
+    if "duplex_first_append_context_tokens" in runtime_config or tokenizer is None:
+        return
+    prefix, suffix = MiniCPMO45DuplexPolicy.session_context_texts(
+        instructions,
+        ref_sample_count is not None,
+        initial_user_text,
+    )
+    try:
+        prefix_ids = tokenizer.encode(prefix, add_special_tokens=False)
+        suffix_ids = tokenizer.encode(suffix, add_special_tokens=False)
+    except Exception:
+        return
+    ref_tokens = MiniCPMO45DuplexPolicy.audio_token_count(ref_sample_count or 0)
+    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}
+    stage0_params: dict[str, object] = {
+        "temperature": config.temperature if config.temperature is not None else 0.7,
+        "top_p": 0.8,
+        "top_k": 20,
+        "repetition_penalty": 1.05,
+    }
+    stop_token_ids = _stage0_stop_token_ids(tokenizer)
+    if stop_token_ids:
+        stage0_params["stop_token_ids"] = stop_token_ids
+    # Stage 1 keeps the deploy YAML's codec knobs, minus upstream's
+    # min_new_token=50: that floor is for whole-utterance chat TTS, while a
+    # duplex chunk is 26 codec samples, so check_stop would never release
+    # the Talker and Thinker would stall on the next model turn.
+    runtime_config["duplex_stage_sampling_params"] = {"0": stage0_params, "1": {"min_tokens": 0}}
+    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):
+    """MiniCPM-owned sampling policy, append planning, session state and output projection."""
+
+    plugin_id = "minicpmo45"
+    private_runtime_config_keys = PRIVATE_RUNTIME_CONFIG_KEYS
+    silence_continuation_samples = 16000
+
+    def __init__(self, encode_audio: EncodeAudio) -> None:
+        super().__init__(encode_audio)
+        self.data_plane = MiniCPMO45DataPlaneSession(encode_audio)
+        # The tokenizer is only needed for special-token ids and the session
+        # context token count; it is the same for every session, so load it
+        # once per model path, off the orchestrator loop.
+        self._tokenizers: dict[str, PreTrainedTokenizerBase | None] = {}
+        self._tokenizer_lock = asyncio.Lock()
+
+    async def _tokenizer_for(self, model_config: ModelConfig | None) -> PreTrainedTokenizerBase | None:
+        model_path = getattr(model_config, "model", None)
+        key = model_path if isinstance(model_path, str) else ""
+        if key in self._tokenizers:
+            return self._tokenizers[key]
+        async with self._tokenizer_lock:
+            if key not in self._tokenizers:
+                self._tokenizers[key] = await asyncio.to_thread(_load_tokenizer, model_config)
+        return self._tokenizers[key]
+
+    # ---- engine policy (the resumable Stage0 request) ----
+
+    def configure_sampling_params(
+        self,
+        *,
+        runtime_config: dict[str, object],
+        defaults: tuple[object, ...],
+    ) -> tuple[object, ...]:
+        configured: list[object] = []
+        for stage_id, default in enumerate(defaults):
+            max_tokens = _coerce_int(_stage_config_value(runtime_config, "duplex_stage_max_tokens", stage_id))
+            raw_overrides = _stage_config_value(runtime_config, "duplex_stage_sampling_params", stage_id)
+            overrides = dict(raw_overrides) if isinstance(raw_overrides, dict) else {}
+            if not isinstance(default, SamplingParams) or (not overrides and (max_tokens is None or max_tokens <= 0)):
+                configured.append(default)
+                continue
+            params = default.clone()
+            if max_tokens is not None and max_tokens > 0:
+                params.max_tokens = max_tokens
+            for name, value in overrides.items():
+                if not hasattr(params, name):
+                    continue
+                setattr(params, name, value)
+                if name == "stop_token_ids":
+                    all_stop_token_ids = getattr(params, "_all_stop_token_ids", None)
+                    if isinstance(all_stop_token_ids, set):
+                        all_stop_token_ids.update(int(token_id) for token_id in value)
+            configured.append(params)
+        return tuple(configured)
+
+    def plan_append(
+        self,
+        *,
+        request_id: str,
+        fence: DuplexFence,
+        session_config: dict[str, object],
+        runtime_config: dict[str, object],
+        seq: int,
+        turn_seq: int,
+        payload: object,
+        final: bool,
+        sampling_params: object,
+    ) -> DuplexAppendPlan:
+        del sampling_params
+        return DuplexAppendPlan(
+            prompt=build_duplex_data_plane_prompt(
+                request_id=request_id,
+                fence=fence,
+                session_config=session_config,
+                runtime_config=runtime_config,
+                seq=seq,
+                turn_seq=turn_seq,
+                payload=payload,
+                final=final,
+            )
+        )
+
+    def decide_output(
+        self,
+        *,
+        stage_id: int,
+        final_stage_id: int,
+        segment_finished: bool,
+        segment_token_ids: tuple[int, ...],
+        segment_output_metadata: dict[str, object],
+        output: object,
+    ) -> DuplexOutputDecision | None:
+        if stage_id >= final_stage_id or not segment_finished:
+            return None
+
+        completion = _first_completion(output)
+        output_metadata = _multimodal_output(output, completion)
+        special_token_ids = _special_token_ids(segment_output_metadata)
+        special_token_ids.update(_special_token_ids(output_metadata))
+        listen_id = special_token_ids.get("listen_token_id")
+        if listen_id is None:
+            return None
+
+        stop_reason = getattr(completion, "stop_reason", None) if completion is not None else None
+        token_ids = _completion_token_ids(completion) or list(segment_token_ids)
+        if _coerce_int(stop_reason) != listen_id and (not token_ids or token_ids[-1] != listen_id):
+            return None
+
+        metadata = dict(output_metadata)
+        for key, value in special_token_ids.items():
+            metadata.setdefault(f"meta.{key}", value)
+        metadata.update(
+            {
+                "duplex_direct_response": True,
+                "duplex_native_decision": "listen",
+                "model_listen": True,
+                "listen_source": "model_listen",
+            }
+        )
+        return DuplexOutputDecision(
+            action=DuplexOutputAction.DIRECT_RESPONSE,
+            metadata=metadata,
+        )
+
+    # ---- session policy ----
+
+    def create_session_state(self) -> MiniCPMO45ServingSessionState:
+        return MiniCPMO45ServingSessionState()
+
+    def capabilities(self, *, max_sessions: int) -> DuplexCapabilities:
+        return minicpmo45_native_capabilities(max_sessions=max_sessions)
+
+    def validate_client_extra_body(self, extra_body: object) -> None:
+        if not isinstance(extra_body, dict):
+            return
+        private_keys = sorted(PRIVATE_RUNTIME_CONFIG_KEYS.intersection(extra_body))
+        if private_keys:
+            raise MiniCPMO45ClientRuntimeConfigError(
+                "duplex runtime configuration is server-owned: " + ", ".join(private_keys)
+            )
+
+    async def prepare_runtime_config(
+        self, config: DuplexSessionConfig, *, model_config: ModelConfig | None
+    ) -> dict[str, object]:
+        extra_body = dict(config.extra_body)
+        if any(key in extra_body for key in ("ref_audio_path", "tts_ref_audio_path")):
+            raise MiniCPMO45ClientRuntimeConfigError(
+                "ref_audio_path is not accepted by duplex sessions; use ref_audio URI instead",
+                code="unsupported_ref_audio_path",
+            )
+        runtime_config: dict[str, object] = {"instructions": config.instructions}
+        # ``duplex_initial_user_text`` is the older extra_body spelling and
+        # still works; the session field is the framework-level one.
+        initial_user_text = extra_body.pop("duplex_initial_user_text", None)
+        if not (isinstance(initial_user_text, str) and initial_user_text):
+            initial_user_text = config.initial_user_text
+        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, model_config=model_config)
+
+        ref_audio = config.ref_audio
+        extra_ref_audio = extra_body.get("ref_audio")
+        if ref_audio is None and isinstance(extra_ref_audio, str):
+            extra_body.pop("ref_audio")
+            ref_audio = extra_ref_audio
+        extra_tts_ref_audio = extra_body.get("tts_ref_audio")
+        if ref_audio is None and isinstance(extra_tts_ref_audio, str):
+            extra_body.pop("tts_ref_audio")
+            ref_audio = extra_tts_ref_audio
+
+        if ref_audio is None:
+            if any(str(modality).lower() == "audio" for modality in config.modalities):
+                raise MiniCPMO45ClientRuntimeConfigError(
+                    "MiniCPM-o duplex audio output requires ref_audio",
+                    code="ref_audio_required",
+                )
+            _apply_first_append_context_tokens(
+                runtime_config,
+                tokenizer=tokenizer,
+                instructions=config.instructions,
+                initial_user_text=initial_user_text,
+                ref_sample_count=None,
+            )
+            config.extra_body = extra_body
+            return runtime_config
+
+        wav_np, sr = await resolve_ref_audio(ref_audio, model_config=model_config)
+        # torchaudio resampling is CPU work: keep it off the orchestrator loop.
+        wav_np = await asyncio.to_thread(normalize_ref_audio, wav_np, int(sr), target_sr=16000)
+        # Trim to a whole number of pooled audio embeddings (100 ms frames) so
+        # the first-append scheduler reserve can count them exactly.
+        usable = (len(wav_np) // MiniCPMO45DuplexPolicy.SAMPLES_PER_AUDIO_TOKEN) * (
+            MiniCPMO45DuplexPolicy.SAMPLES_PER_AUDIO_TOKEN
+        )
+        wav_np = wav_np[:usable]
+        ref_audio_bytes = np.ascontiguousarray(wav_np, dtype=np.float32).tobytes()
+        runtime_config["ref_audio_data"] = base64.b64encode(ref_audio_bytes).decode("ascii")
+        runtime_config["ref_audio_format"] = "pcm_f32le"
+        runtime_config["ref_audio_sample_rate_hz"] = 16000
+        _apply_first_append_context_tokens(
+            runtime_config,
+            tokenizer=tokenizer,
+            instructions=config.instructions,
+            initial_user_text=initial_user_text,
+            ref_sample_count=len(wav_np),
+        )
+        config.extra_body = extra_body
+        config.ref_audio = None
+        return runtime_config
+
+    def runtime_config_for_update(
+        self,
+        config: DuplexSessionConfig,
+        current: Mapping[str, object],
+    ) -> dict[str, object]:
+        runtime_config = deepcopy(dict(current))
+        reject_changed_runtime_value(
+            config.instructions,
+            runtime_config.get("instructions"),
+            message="instructions cannot be changed after the session is created",
+            code="instructions_update_unsupported",
+            error_cls=MiniCPMO45ClientRuntimeConfigError,
+        )
+        stage_max_tokens = runtime_config.get("duplex_stage_max_tokens")
+        stage_max_tokens = deepcopy(stage_max_tokens) if isinstance(stage_max_tokens, dict) else {}
+        stage_max_tokens["0"] = (
+            config.max_tokens if isinstance(config.max_tokens, int) and config.max_tokens > 0 else 20
+        )
+        stage_max_tokens.setdefault("1", 8192)
+        runtime_config["duplex_stage_max_tokens"] = stage_max_tokens
+
+        stage_sampling = runtime_config.get("duplex_stage_sampling_params")
+        stage_sampling = deepcopy(stage_sampling) if isinstance(stage_sampling, dict) else {}
+        stage0 = stage_sampling.get("0")
+        stage0 = deepcopy(stage0) if isinstance(stage0, dict) else {}
+        stage0["temperature"] = config.temperature if config.temperature is not None else 0.7
+        stage_sampling["0"] = stage0
+        runtime_config["duplex_stage_sampling_params"] = stage_sampling
+        return runtime_config
+
+    def data_plane_context(
+        self,
+        *,
+        epoch: int,
+        turn_id: int,
+        active_response_turn_id: int | None,
+        active_response_id: str | None,
+        auto_responds: bool,
+        response_format: str,
+        speed: float | None,
+        modalities: tuple[str, ...],
+    ) -> MiniCPMO45DataPlaneContext:
+        return MiniCPMO45DataPlaneContext(
+            epoch=epoch,
+            turn_id=turn_id,
+            active_response_turn_id=active_response_turn_id,
+            active_response_id=active_response_id,
+            auto_responds=auto_responds,
+            response_format=response_format,
+            speed=speed,
+            modalities=modalities,
+        )
+
+
+__all__ = [
+    "PRIVATE_RUNTIME_CONFIG_KEYS",
+    "MiniCPMO45ClientRuntimeConfigError",
+    "MiniCPMO45DuplexPlugin",
+    "build_duplex_data_plane_prompt",
+    "duplex_first_append_context_reserve",
+    "duplex_first_append_unit_count",
+    "duplex_payload_is_exact_chunks",
+    "duplex_scheduler_token_budget",
+    "normalize_ref_audio",
+    "resolve_ref_audio",
+]
diff --git a/vllm_omni/model_executor/models/minicpmo_4_5/duplex/policy.py b/vllm_omni/model_executor/models/minicpmo_4_5/duplex/policy.py
index 7a1779617..0332c81c0 100644
--- a/vllm_omni/model_executor/models/minicpmo_4_5/duplex/policy.py
+++ b/vllm_omni/model_executor/models/minicpmo_4_5/duplex/policy.py
@@ -3,7 +3,10 @@
 
 from __future__ import annotations
 
-from typing import Any
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from transformers import PreTrainedTokenizerBase
 
 
 class MiniCPMO45DuplexPolicy:
@@ -26,10 +29,12 @@ class MiniCPMO45DuplexPolicy:
     SAMPLES_PER_AUDIO_TOKEN = 1600
     # Vision framing contract (omni duplex). Official streaming_prefill feeds
     # each frame as <image> + 64 resampler embeddings + </image> inside the
-    # unit, ahead of the unit's audio embeddings (max_slice_nums=1 in
-    # streaming, so exactly one 64-token block per frame). A unit may carry
-    # its base frame plus an optional stacked composite of the sub-frames
-    # captured inside that unit (2 blocks).
+    # unit, ahead of the unit's audio embeddings. A lone frame is one block.
+    # A unit carrying its base frame plus the stacked composite of the
+    # sub-frames captured inside it is processed with the official HD
+    # suggestion (max_slice_nums=[2, 1]): the base frame adds the patches the
+    # processor cuts for its size (two for a 960x540 capture, none for a frame
+    # that fits one 448x448 tile) and the composite adds one block.
     VISION_EMBEDS_PER_FRAME = 64
     VISION_TOKENS_PER_FRAME = VISION_EMBEDS_PER_FRAME + 2  # <image> + embeds + </image>
     DEFAULT_MAX_NEW_SPEAK_TOKENS_PER_CHUNK = 20
@@ -87,7 +92,7 @@ class MiniCPMO45DuplexPolicy:
     }
 
     @classmethod
-    def token_ids_from_tokenizer(cls, tokenizer: Any) -> dict[str, int]:
+    def token_ids_from_tokenizer(cls, tokenizer: PreTrainedTokenizerBase) -> dict[str, int]:
         convert = getattr(tokenizer, "convert_tokens_to_ids", None)
 
         def token_id(token: str) -> int:
diff --git a/vllm_omni/model_executor/models/minicpmo_4_5/duplex/runtime.py b/vllm_omni/model_executor/models/minicpmo_4_5/duplex/runtime.py
deleted file mode 100644
index c8e746ce7..000000000
--- a/vllm_omni/model_executor/models/minicpmo_4_5/duplex/runtime.py
+++ /dev/null
@@ -1,372 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-from __future__ import annotations
-
-from base64 import b64decode
-from binascii import Error as BinasciiError
-from typing import Any, cast
-
-from vllm.sampling_params import SamplingParams
-
-from vllm_omni.engine.duplex.messages import DuplexFence
-from vllm_omni.engine.duplex.runtime import (
-    DuplexAppendPlan,
-    DuplexInputMode,
-    DuplexOutputAction,
-    DuplexOutputDecision,
-)
-
-_DUPLEX_CHUNK_SAMPLES = 16000
-_DUPLEX_SAMPLES_PER_AUDIO_TOKEN = 1600
-# <image> + 64 resampler embeddings + </image> per frame (max_slice_nums=1),
-# matching MiniCPMO45DuplexPolicy.VISION_TOKENS_PER_FRAME.
-_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
-
-
-def _duplex_frame_count(payload: object) -> int:
-    if not isinstance(payload, dict):
-        return 0
-    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)
-
-
-def _duplex_vision_tokens(payload: object) -> 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.
-    """
-    count = _duplex_frame_count(payload)
-    if count <= 0:
-        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
-
-
-def _duplex_pcm_sample_count(payload: object) -> int | None:
-    if not isinstance(payload, dict):
-        return None
-    audio = payload.get("audio") or payload.get("data")
-    if payload.get("format") != "pcm_f32le" or not isinstance(audio, str):
-        return None
-    try:
-        raw = b64decode(audio, validate=True)
-    except (BinasciiError, ValueError):
-        return None
-    return len(raw) // 4
-
-
-def duplex_payload_is_exact_chunks(payload: object) -> bool:
-    sample_count = _duplex_pcm_sample_count(payload)
-    return sample_count is not None and sample_count != 0 and sample_count % _DUPLEX_CHUNK_SAMPLES == 0
-
-
-def duplex_first_append_unit_count(payload: object) -> int | None:
-    sample_count = _duplex_pcm_sample_count(payload)
-    if not sample_count or sample_count % _DUPLEX_CHUNK_SAMPLES != 0:
-        return 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)
-    sample_count = _duplex_pcm_sample_count(payload)
-    if sample_count is None:
-        return max(1, int(default)) + vision_tokens
-    sample_count = max(1, sample_count)
-    if sample_count % _DUPLEX_CHUNK_SAMPLES == 0:
-        units = sample_count // _DUPLEX_CHUNK_SAMPLES
-        return units * (2 + _DUPLEX_CHUNK_SAMPLES // _DUPLEX_SAMPLES_PER_AUDIO_TOKEN) + vision_tokens
-    return max(16, min(768, sample_count // _DUPLEX_SAMPLES_PER_AUDIO_TOKEN + 8)) + vision_tokens
-
-
-def duplex_first_append_context_reserve(runtime_config: object) -> int:
-    if not isinstance(runtime_config, dict):
-        return 48
-    exact = runtime_config.get("duplex_first_append_context_tokens")
-    if isinstance(exact, int) and exact >= 0:
-        return exact
-    reserve = 48
-    ref = runtime_config.get("ref_audio_data")
-    if isinstance(ref, str) and ref:
-        try:
-            raw = b64decode(ref, validate=True)
-        except (BinasciiError, ValueError):
-            raw = b""
-        if raw:
-            reserve += max(0, (len(raw) // 4) // _DUPLEX_SAMPLES_PER_AUDIO_TOKEN + 8)
-    return reserve
-
-
-def _duplex_force_listen_count(extra_body: object) -> int:
-    raw = extra_body.get("force_listen_count") if isinstance(extra_body, dict) else None
-    try:
-        return 0 if raw is None else max(0, int(raw))
-    except (TypeError, ValueError):
-        return 0
-
-
-def build_duplex_data_plane_prompt(
-    *,
-    request_id: str,
-    fence: DuplexFence,
-    session_config: dict[str, Any],
-    runtime_config: dict[str, Any],
-    seq: int,
-    turn_seq: int,
-    mode: DuplexInputMode,
-    payload: object,
-    final: bool,
-) -> dict[str, Any]:
-    token_budget = duplex_scheduler_token_budget(payload)
-    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)
-    if seq > 1 and duplex_payload_is_exact_chunks(payload):
-        token_budget += 1
-    if final and duplex_payload_is_exact_chunks(payload):
-        token_budget += 12
-    extra_body = session_config.get("extra_body")
-    raw_token_id = runtime_config.get("duplex_scheduler_token_id")
-    try:
-        token_id = 0 if raw_token_id is None else max(0, int(raw_token_id))
-    except (TypeError, ValueError):
-        token_id = 0
-    force_listen_count = _duplex_force_listen_count(extra_body)
-    if (
-        force_listen_count > 0
-        and turn_seq <= force_listen_count
-        and isinstance(payload, dict)
-        and payload.get("force_listen") is not True
-    ):
-        payload = {**payload, "force_listen": True}
-    return {
-        "prompt_token_ids": [token_id] * token_budget,
-        "model_intermediate_buffer": {
-            "request_id": request_id,
-            "global_request_id": [fence.session_id],
-            "duplex": {
-                "fence": fence,
-                "session_id": fence.session_id,
-                "incarnation": fence.incarnation,
-                "epoch": fence.epoch,
-                "seq": seq,
-                "turn_id": fence.turn_id,
-                "response_seq": fence.response_seq,
-                "turn_seq": turn_seq,
-                "mode": mode.value,
-                "payload": payload,
-                "final": final,
-                "data_plane": True,
-                "session_config": dict(session_config),
-                "runtime_config": dict(runtime_config),
-                "scheduler_token_budget": token_budget,
-                "scheduler_token_id": token_id,
-            },
-        },
-    }
-
-
-def _coerce_int(value: object) -> int | None:
-    detach = getattr(value, "detach", None)
-    if callable(detach):
-        try:
-            flat: Any = detach().cpu().reshape(-1)
-            if flat.numel() == 0:
-                return None
-            value = flat[0].item()
-        except Exception:
-            return None
-    try:
-        return int(cast(Any, value))
-    except (TypeError, ValueError):
-        return None
-
-
-def _coerce_int_list(value: object) -> list[int]:
-    if value is None:
-        return []
-    if hasattr(value, "detach"):
-        try:
-            value = value.detach().cpu().reshape(-1).tolist()
-        except Exception:
-            return []
-    if not isinstance(value, (list, tuple)):
-        return []
-    return [token_id for item in value if (token_id := _coerce_int(item)) is not None]
-
-
-def _first_completion(output: object) -> object | None:
-    outputs = getattr(output, "outputs", None)
-    return outputs[0] if isinstance(outputs, list) and outputs else None
-
-
-def _multimodal_output(output: object, completion: object | None) -> dict[str, Any]:
-    metadata = getattr(output, "multimodal_output", None)
-    if isinstance(metadata, dict):
-        return metadata
-    metadata = getattr(completion, "multimodal_output", None) if completion is not None else None
-    return metadata if isinstance(metadata, dict) else {}
-
-
-def _special_token_ids(metadata: dict[str, Any]) -> dict[str, int]:
-    sources: list[object] = [metadata.get("special_token_ids"), metadata.get("meta")]
-    sources.append(
-        {
-            key.removeprefix("meta."): value
-            for key, value in metadata.items()
-            if isinstance(key, str) and key.startswith("meta.")
-        }
-    )
-    token_ids: dict[str, int] = {}
-    for source in sources:
-        if not isinstance(source, dict):
-            continue
-        for key, value in source.items():
-            token_id = _coerce_int(value)
-            if isinstance(key, str) and token_id is not None and token_id >= 0:
-                token_ids[key] = token_id
-    return token_ids
-
-
-def _completion_token_ids(completion: object | None) -> list[int]:
-    if completion is None:
-        return []
-    for attribute in ("token_ids", "cumulative_token_ids"):
-        token_ids = _coerce_int_list(getattr(completion, attribute, None))
-        if token_ids:
-            return token_ids
-    return []
-
-
-def _stage_config_value(runtime_config: dict[str, Any], key: str, stage_id: int) -> object | None:
-    raw = runtime_config.get(key)
-    if isinstance(raw, dict):
-        value = raw.get(stage_id)
-        return raw.get(str(stage_id)) if value is None else value
-    if isinstance(raw, (list, tuple)) and stage_id < len(raw):
-        return raw[stage_id]
-    return None
-
-
-class MiniCPMO45DuplexRuntimeExtension:
-    def configure_sampling_params(
-        self,
-        *,
-        runtime_config: dict[str, Any],
-        defaults: tuple[object, ...],
-    ) -> tuple[object, ...]:
-        configured: list[object] = []
-        for stage_id, default in enumerate(defaults):
-            max_tokens = _coerce_int(_stage_config_value(runtime_config, "duplex_stage_max_tokens", stage_id))
-            raw_overrides = _stage_config_value(runtime_config, "duplex_stage_sampling_params", stage_id)
-            overrides = dict(raw_overrides) if isinstance(raw_overrides, dict) else {}
-            if not isinstance(default, SamplingParams) or (not overrides and (max_tokens is None or max_tokens <= 0)):
-                configured.append(default)
-                continue
-            params = default.clone()
-            if max_tokens is not None and max_tokens > 0:
-                params.max_tokens = max_tokens
-            for name, value in overrides.items():
-                if not hasattr(params, name):
-                    continue
-                setattr(params, name, value)
-                if name == "stop_token_ids":
-                    all_stop_token_ids = getattr(params, "_all_stop_token_ids", None)
-                    if isinstance(all_stop_token_ids, set):
-                        all_stop_token_ids.update(int(token_id) for token_id in value)
-            configured.append(params)
-        return tuple(configured)
-
-    def plan_append(
-        self,
-        *,
-        request_id: str,
-        fence: DuplexFence,
-        session_config: dict[str, Any],
-        runtime_config: dict[str, Any],
-        seq: int,
-        turn_seq: int,
-        mode: DuplexInputMode,
-        payload: object,
-        final: bool,
-        sampling_params: object,
-    ) -> DuplexAppendPlan:
-        del sampling_params
-        return DuplexAppendPlan(
-            prompt=build_duplex_data_plane_prompt(
-                request_id=request_id,
-                fence=fence,
-                session_config=session_config,
-                runtime_config=runtime_config,
-                seq=seq,
-                turn_seq=turn_seq,
-                mode=mode,
-                payload=payload,
-                final=final,
-            )
-        )
-
-    def decide_output(
-        self,
-        *,
-        stage_id: int,
-        final_stage_id: int,
-        segment_finished: bool,
-        segment_token_ids: tuple[int, ...],
-        segment_output_metadata: dict[str, Any],
-        output: object,
-    ) -> DuplexOutputDecision | None:
-        if stage_id >= final_stage_id or not segment_finished:
-            return None
-
-        completion = _first_completion(output)
-        output_metadata = _multimodal_output(output, completion)
-        special_token_ids = _special_token_ids(segment_output_metadata)
-        special_token_ids.update(_special_token_ids(output_metadata))
-        listen_id = special_token_ids.get("listen_token_id")
-        if listen_id is None:
-            return None
-
-        stop_reason = getattr(completion, "stop_reason", None) if completion is not None else None
-        token_ids = _completion_token_ids(completion) or list(segment_token_ids)
-        if _coerce_int(stop_reason) != listen_id and (not token_ids or token_ids[-1] != listen_id):
-            return None
-
-        metadata = dict(output_metadata)
-        for key, value in special_token_ids.items():
-            metadata.setdefault(f"meta.{key}", value)
-        metadata.update(
-            {
-                "duplex_direct_response": True,
-                "duplex_native_decision": "listen",
-                "model_listen": True,
-                "listen_source": "model_listen",
-            }
-        )
-        return DuplexOutputDecision(
-            action=DuplexOutputAction.DIRECT_RESPONSE,
-            metadata=metadata,
-        )
-
-
-__all__ = [
-    "MiniCPMO45DuplexRuntimeExtension",
-    "build_duplex_data_plane_prompt",
-    "duplex_first_append_context_reserve",
-    "duplex_first_append_unit_count",
-    "duplex_payload_is_exact_chunks",
-    "duplex_scheduler_token_budget",
-]
diff --git a/vllm_omni/model_executor/models/minicpmo_4_5/duplex/serving_adapter.py b/vllm_omni/model_executor/models/minicpmo_4_5/duplex/serving_adapter.py
deleted file mode 100644
index ea51662a9..000000000
--- a/vllm_omni/model_executor/models/minicpmo_4_5/duplex/serving_adapter.py
+++ /dev/null
@@ -1,102 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-
-from __future__ import annotations
-
-from collections.abc import Callable, Mapping
-from typing import Any
-
-from vllm_omni.entrypoints.duplex.protocol import DuplexCapabilities
-from vllm_omni.model_executor.models.minicpmo_4_5.duplex.adapter import (
-    MiniCPMO45NativeDuplexServingAdapter,
-)
-from vllm_omni.model_executor.models.minicpmo_4_5.duplex.capabilities import (
-    minicpmo45_native_capabilities,
-)
-from vllm_omni.model_executor.models.minicpmo_4_5.duplex.data_plane import (
-    MiniCPMO45DataPlaneContext,
-    MiniCPMO45DataPlaneSession,
-)
-from vllm_omni.model_executor.models.minicpmo_4_5.duplex.session import (
-    MiniCPMO45ServingSessionState,
-)
-
-EncodeAudio = Callable[[object, int, str, float | None], str | None]
-
-
-class MiniCPMO45ServingRuntimeAdapter:
-    """MiniCPM-owned serving state, input packing, and output projection."""
-
-    adapter_id = "minicpmo45"
-    clean_response_done_prefix = ""
-    interrupted_tts_prefix = ""
-    private_runtime_config_keys = MiniCPMO45NativeDuplexServingAdapter.PRIVATE_RUNTIME_CONFIG_KEYS
-
-    def __init__(self, encode_audio: EncodeAudio) -> None:
-        self.session_states: dict[str, MiniCPMO45ServingSessionState] = {}
-        self.data_plane = MiniCPMO45DataPlaneSession(encode_audio)
-
-    def create_session_state(self) -> MiniCPMO45ServingSessionState:
-        return MiniCPMO45ServingSessionState()
-
-    def session_state(self, session_id: str) -> MiniCPMO45ServingSessionState:
-        state = self.session_states.get(session_id)
-        if state is None:
-            state = self.create_session_state()
-            self.session_states[session_id] = state
-        return state
-
-    def remove_session_state(self, session_id: str) -> None:
-        self.session_states.pop(session_id, None)
-
-    @staticmethod
-    def is_enabled(config: object) -> bool:
-        return MiniCPMO45NativeDuplexServingAdapter.is_enabled(config)  # type: ignore[arg-type]
-
-    @staticmethod
-    def capabilities(*, max_sessions: int) -> DuplexCapabilities:
-        return minicpmo45_native_capabilities(max_sessions=max_sessions)
-
-    @staticmethod
-    def validate_client_extra_body(extra_body: object) -> None:
-        MiniCPMO45NativeDuplexServingAdapter.validate_client_extra_body(extra_body)
-
-    @staticmethod
-    async def prepare_runtime_config(config: object, *, model_config: Any) -> dict[str, object]:
-        return await MiniCPMO45NativeDuplexServingAdapter.prepare_runtime_config(
-            config,  # type: ignore[arg-type]
-            model_config=model_config,
-        )
-
-    @staticmethod
-    def runtime_config_for_update(
-        config: object,
-        current: Mapping[str, object],
-    ) -> dict[str, object]:
-        return MiniCPMO45NativeDuplexServingAdapter.runtime_config_for_update(
-            config,  # type: ignore[arg-type]
-            dict(current),
-        )
-
-    @staticmethod
-    def data_plane_context(
-        *,
-        epoch: int,
-        turn_id: int,
-        active_response_turn_id: int | None,
-        active_response_id: str | None,
-        auto_responds: bool,
-        response_format: str,
-        speed: float | None,
-        modalities: tuple[str, ...],
-    ) -> MiniCPMO45DataPlaneContext:
-        return MiniCPMO45DataPlaneContext(
-            epoch=epoch,
-            turn_id=turn_id,
-            active_response_turn_id=active_response_turn_id,
-            active_response_id=active_response_id,
-            auto_responds=auto_responds,
-            response_format=response_format,
-            speed=speed,
-            modalities=modalities,
-        )
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 40c42cb81..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
@@ -4,34 +4,36 @@
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Awaitable, Callable
 from dataclasses import dataclass, field
 
+from vllm_omni.engine.duplex.plugin import DuplexModelSessionState
 from vllm_omni.model_executor.models.minicpmo_4_5.duplex.input import (
     MiniCPMO45PcmAppendBuffer,
 )
 
 
 @dataclass(slots=True)
-class MiniCPMO45ServingSessionState:
-    """Mutable serving state owned by one MiniCPM duplex session."""
+class MiniCPMO45ServingSessionState(DuplexModelSessionState):
+    """Mutable model-owned state of one MiniCPM duplex session (owned by the session runner)."""
 
     audio_buffer: MiniCPMO45PcmAppendBuffer = field(default_factory=MiniCPMO45PcmAppendBuffer)
     input_since_commit: bool = False
     speech_since_commit: bool = False
-    native_context_locked: 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
-    data_plane_task: asyncio.Task[None] | None = None
-    data_plane_restart_requested: 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
-    silence_continuation_scheduler: Callable[..., Awaitable[bool]] | 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,
@@ -58,3 +60,5 @@ class MiniCPMO45ServingSessionState:
         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/duplex/stage0.py b/vllm_omni/model_executor/models/minicpmo_4_5/duplex/stage0.py
index 6d9800025..bc13b58f2 100644
--- a/vllm_omni/model_executor/models/minicpmo_4_5/duplex/stage0.py
+++ b/vllm_omni/model_executor/models/minicpmo_4_5/duplex/stage0.py
@@ -6,15 +6,22 @@ from __future__ import annotations
 import base64
 import copy
 import time
+from collections.abc import Callable
 from contextlib import suppress
 from dataclasses import dataclass, field
 from threading import Lock
-from typing import Any
+from typing import TYPE_CHECKING, Any, cast
 
 import numpy as np
+from numpy.typing import NDArray
 
 from vllm_omni.model_executor.models.minicpmo_4_5.duplex.policy import MiniCPMO45DuplexPolicy
 
+if TYPE_CHECKING:
+    import torch
+    from PIL import Image
+    from torch import nn
+
 _MINICPMO45_SPECIAL_TOKEN_FIELDS = MiniCPMO45DuplexPolicy.SPECIAL_TOKEN_FIELDS
 _MINICPMO45_OPTIONAL_TOKEN_FIELDS = MiniCPMO45DuplexPolicy.OPTIONAL_TOKEN_FIELDS
 _MINICPMO45_PROCESSOR_LOAD_LOCK = Lock()
@@ -23,17 +30,19 @@ _MINICPMO45_PROCESSOR_LOAD_LOCK = Lock()
 @dataclass
 class _MiniCPMO45Stage0SessionState:
     session_id: str
+    #: Any: MiniCPM-o remote-code processor (transformers, no importable type).
     streaming_processor: Any | None = None
-    audio_buffer: np.ndarray = field(default_factory=lambda: np.array([], dtype=np.float32))
+    audio_buffer: NDArray[np.float32] = field(default_factory=lambda: np.array([], dtype=np.float32))
     audio_chunk_idx: int = 0
-    context_embeds: list[Any] = field(default_factory=list)
+    context_embeds: list[torch.Tensor] = field(default_factory=list)
     context_token_ids: list[int] = field(default_factory=list)
     current_turn_ended: bool = True
     prepared_append_identity: tuple[int | None, int] | None = None
-    prepared_inputs_embeds: Any | None = None
+    prepared_inputs_embeds: torch.Tensor | None = None
     prepared_input_token_ids: list[int] = field(default_factory=list)
-    prepared_result: dict[str, Any] = field(default_factory=dict)
-    audio_past_key_values: Any | None = None
+    prepared_result: dict[str, object] = field(default_factory=dict)
+    #: Opaque transformers cache, handed back to the model unchanged.
+    audio_past_key_values: object | None = None
     pending_terminator_token: int | None = None
     last_terminator_token: int | None = None
     pending_speech_context: bool = False
@@ -59,7 +68,7 @@ class MiniCPMO45Stage0DuplexRuntime:
     image_start_token_id: int = -1
     image_end_token_id: int = -1
 
-    def __init__(self, stage_model: Any, *, model_path: str | None = None, device: str = "cuda") -> None:
+    def __init__(self, stage_model: nn.Module, *, model_path: str | None = None, device: str = "cuda") -> None:
         self.stage_model = stage_model
         self.model_path = model_path
         self.device = device
@@ -85,7 +94,7 @@ class MiniCPMO45Stage0DuplexRuntime:
     def _configure_streaming_processor(
         self,
         state: _MiniCPMO45Stage0SessionState | None = None,
-    ) -> Any | None:
+    ) -> Any | None:  # Any: MiniCPM-o remote-code processor
         processor = self.processor
         if processor is None:
             return None
@@ -129,9 +138,9 @@ class MiniCPMO45Stage0DuplexRuntime:
     def _prepare_session_context(
         self,
         state: _MiniCPMO45Stage0SessionState,
-        session_config: dict[str, Any],
+        session_config: dict[str, object],
         *,
-        runtime_config: dict[str, Any] | None = None,
+        runtime_config: dict[str, object] | None = None,
     ) -> None:
         if not self._stage_runtime_ready():
             return
@@ -163,14 +172,14 @@ class MiniCPMO45Stage0DuplexRuntime:
     def _stage_prefill_embeddings_only(
         self,
         state: _MiniCPMO45Stage0SessionState,
-        audio_waveform: Any,
+        audio_waveform: NDArray[np.float32] | None,
         *,
-        video_frames: list[Any] | None = None,
+        video_frames: list[Image.Image] | None = None,
         epoch: int | None = None,
         seq: int | None = None,
         is_speech: bool = False,
         final: bool = False,
-    ) -> dict[str, Any]:
+    ) -> dict[str, object]:
         """Build scheduler-owned Stage0 input embeddings for one audio append.
 
         Unlike the legacy worker-control path, this method never calls an eager
@@ -217,7 +226,7 @@ class MiniCPMO45Stage0DuplexRuntime:
         # Omni duplex: encode this append's camera frames so the first unit can
         # carry them, mirroring official streaming_prefill (feed <unit>, then
         # every frame_list entry as its own <image> block, then the audio).
-        frame_blocks: list[Any] = []
+        frame_blocks: list[list[torch.Tensor]] = []
         if video_frames:
             self._require_vision_token_ids()
             encoded_frames = self._stage_vision_embeddings(video_frames)
@@ -227,7 +236,7 @@ class MiniCPMO45Stage0DuplexRuntime:
                 return self._stage_prefill_result(False, start_time, "streaming vision embedding failed")
             frame_blocks = encoded_frames
 
-        embed_parts: list[Any] = []
+        embed_parts: list[torch.Tensor] = []
         token_ids: list[int] = []
         if state.audio_chunk_idx == 0 and state.context_embeds:
             embed_parts.extend(state.context_embeds)
@@ -336,7 +345,7 @@ class MiniCPMO45Stage0DuplexRuntime:
         return result
 
     @staticmethod
-    def _stage_prefill_result(success: bool, start_time: float, reason: str = "") -> dict[str, Any]:
+    def _stage_prefill_result(success: bool, start_time: float, reason: str = "") -> dict[str, object]:
         return {
             "success": success,
             "prefill_success": success,
@@ -347,14 +356,14 @@ class MiniCPMO45Stage0DuplexRuntime:
         }
 
     @staticmethod
-    def _as_2d_tensor(value: Any) -> Any:
+    def _as_2d_tensor(value: torch.Tensor) -> torch.Tensor:
         if value.ndim == 1:
             return value.unsqueeze(0)
         if value.ndim == 3 and value.shape[0] == 1:
             return value.squeeze(0)
         return value
 
-    def _embed_token(self, token_id: int) -> Any:
+    def _embed_token(self, token_id: int) -> torch.Tensor:
         import torch
 
         token = torch.tensor([int(token_id)], dtype=torch.long, device=self._model_device())
@@ -362,7 +371,7 @@ class MiniCPMO45Stage0DuplexRuntime:
         embeds = embedder(token)
         return self._as_2d_tensor(embeds)
 
-    def _token_embedding_dtype(self) -> Any:
+    def _token_embedding_dtype(self) -> torch.dtype | None:
         """dtype of the decoder token embeddings, the unit's reference dtype.
 
         Official ``get_vllm_embedding`` casts vision hidden states to the token
@@ -376,7 +385,7 @@ class MiniCPMO45Stage0DuplexRuntime:
             return dtype
         return getattr(next(self.thinker.parameters()), "dtype", None)
 
-    def _token_embedder(self) -> Any:
+    def _token_embedder(self) -> Callable[[torch.Tensor], torch.Tensor]:
         nested_embed = getattr(getattr(getattr(self.thinker, "llm", None), "model", None), "embed_tokens", None)
         if callable(nested_embed):
             return nested_embed
@@ -391,7 +400,7 @@ class MiniCPMO45Stage0DuplexRuntime:
                     return embedder
         raise AttributeError("MiniCPM-o stage0 model does not expose token embeddings")
 
-    def _model_device(self) -> Any:
+    def _model_device(self) -> torch.device | str:
         try:
             return next(self.thinker.parameters()).device
         except Exception:
@@ -402,14 +411,14 @@ class MiniCPMO45Stage0DuplexRuntime:
             pass
         return self.device
 
-    def _streaming_chunk_size(self, processor: Any | None = None) -> int:
+    def _streaming_chunk_size(self, processor: Any | None = None) -> int:  # Any: remote-code processor
         processor = processor or self.processor
         get_chunk = getattr(processor, "get_streaming_chunk_size", None)
         if callable(get_chunk):
             return int(get_chunk())
         return 16000
 
-    def _sample_rate(self, processor: Any | None = None) -> int:
+    def _sample_rate(self, processor: Any | None = None) -> int:  # Any: remote-code processor
         processor = processor or self.processor
         return int(
             self._stage_param(
@@ -418,7 +427,7 @@ class MiniCPMO45Stage0DuplexRuntime:
             )
         )
 
-    def _first_chunk_samples(self, default_chunk_size: int, processor: Any | None = None) -> int:
+    def _first_chunk_samples(self, default_chunk_size: int, processor: Any | None = None) -> int:  # Any: processor
         processor = processor or self.processor
         if getattr(processor, "_streaming_mel_processor", None) is None:
             return default_chunk_size
@@ -427,7 +436,7 @@ class MiniCPMO45Stage0DuplexRuntime:
     def _pad_first_audio_chunk_if_needed(
         self,
         state: _MiniCPMO45Stage0SessionState,
-        processor: Any | None = None,
+        processor: Any | None = None,  # Any: remote-code processor
     ) -> None:
         if state.audio_chunk_idx != 0 or len(state.audio_buffer) == 0:
             return
@@ -440,7 +449,7 @@ class MiniCPMO45Stage0DuplexRuntime:
         padding: np.ndarray = np.zeros(first_chunk_samples - len(state.audio_buffer), dtype=np.float32)
         state.audio_buffer = np.concatenate([padding, state.audio_buffer])
 
-    def _stage_param(self, name: str, default: Any) -> Any:
+    def _stage_param(self, name: str, default: object) -> Any:  # Any: attribute read off the remote-code model
         for target in (self.stage_model, self.thinker, getattr(self.thinker, "llm", None)):
             value = getattr(target, name, None)
             if value is not None:
@@ -455,7 +464,7 @@ class MiniCPMO45Stage0DuplexRuntime:
         chunk_idx: int,
         default_chunk_size: int,
         *,
-        processor: Any | None = None,
+        processor: Any | None = None,  # Any: remote-code processor
     ) -> int:
         processor = processor or self.processor
         if chunk_idx != 0:
@@ -472,11 +481,11 @@ class MiniCPMO45Stage0DuplexRuntime:
 
     def _process_streaming_audio(
         self,
-        audio_chunk: Any,
+        audio_chunk: NDArray[np.float32],
         chunk_idx: int,
         *,
-        processor: Any | None = None,
-    ) -> Any:
+        processor: Any | None = None,  # Any: remote-code processor
+    ) -> Any:  # Any: transformers BatchFeature (or the dict fallback below)
         processor = processor or self.processor
         process = getattr(processor, "process_audio_streaming", None)
         if callable(process):
@@ -488,10 +497,10 @@ class MiniCPMO45Stage0DuplexRuntime:
 
     def _stage_audio_embeddings(
         self,
-        batch_feature: Any,
+        batch_feature: Any,  # Any: transformers BatchFeature
         *,
         state: _MiniCPMO45Stage0SessionState | None = None,
-    ) -> Any | None:
+    ) -> torch.Tensor | None:
         if hasattr(batch_feature, "to"):
             batch_feature = batch_feature.to(self.device)
         self._ensure_dynamic_cache_compat()
@@ -534,17 +543,17 @@ class MiniCPMO45Stage0DuplexRuntime:
                 self.thinker.audio_past_key_values = previous_audio_past_key_values
 
     @staticmethod
-    def _decode_ref_audio_from_session_config(session_config: dict[str, Any]) -> Any | None:
+    def _decode_ref_audio_from_session_config(session_config: dict[str, object]) -> NDArray[np.float32] | None:
         from vllm_omni.model_executor.models.minicpmo_4_5.duplex.input import decode_native_ref_audio_from_config
 
         return decode_native_ref_audio_from_config({"extra_body": session_config})
 
     def _stage_ref_audio_embeddings(
         self,
-        ref_audio: Any,
+        ref_audio: NDArray[np.float32],
         *,
         state: _MiniCPMO45Stage0SessionState | None = None,
-    ) -> Any | None:
+    ) -> torch.Tensor | None:
         process_audio = getattr(self.processor, "process_audio", None)
         if callable(process_audio):
             batch_feature = process_audio([ref_audio])
@@ -606,16 +615,16 @@ class MiniCPMO45Stage0DuplexRuntime:
         DynamicCache.get_usable_length = get_usable_length  # type: ignore[attr-defined]
 
     @staticmethod
-    def _cat_nested_tensors(value: Any) -> Any | None:
+    def _cat_nested_tensors(value: object) -> torch.Tensor | None:
         import torch
 
-        tensors = []
+        tensors: list[torch.Tensor] = []
 
-        def collect(item: Any) -> None:
+        def collect(item: object) -> None:
             if item is None:
                 return
             if hasattr(item, "detach"):
-                tensors.append(item)
+                tensors.append(cast("torch.Tensor", item))
                 return
             if isinstance(item, dict):
                 for child in item.values():
@@ -655,7 +664,7 @@ class MiniCPMO45Stage0DuplexRuntime:
         }
 
     @staticmethod
-    def _load_processor_from_path(model_path: str | None) -> Any | None:
+    def _load_processor_from_path(model_path: str | None) -> Any | None:  # Any: remote-code AutoProcessor
         if not model_path:
             return None
         try:
@@ -752,7 +761,7 @@ class MiniCPMO45Stage0DuplexRuntime:
         return self.stage_padding_token_id()
 
     @staticmethod
-    def _decode_audio_payload(payload: dict[str, Any]) -> Any:
+    def _decode_audio_payload(payload: dict[str, object]) -> NDArray[np.float32]:
         audio = payload.get("audio") or payload.get("data")
         if not isinstance(audio, str):
             raise ValueError("audio append payload requires base64 audio")
@@ -762,7 +771,7 @@ class MiniCPMO45Stage0DuplexRuntime:
         return np.frombuffer(base64.b64decode(audio), dtype=np.float32)
 
     @staticmethod
-    def _decode_video_frames_payload(payload: dict[str, Any]) -> list[Any]:
+    def _decode_video_frames_payload(payload: dict[str, object]) -> list[Image.Image]:
         """Decode omni-duplex camera frames (base64 JPEG/PNG) to PIL images."""
         frames = payload.get("video_frames")
         if not isinstance(frames, list) or not frames:
@@ -771,7 +780,7 @@ class MiniCPMO45Stage0DuplexRuntime:
 
         from PIL import Image
 
-        decoded: list[Any] = []
+        decoded: list[Image.Image] = []
         for frame_b64 in frames:
             if not isinstance(frame_b64, str) or not frame_b64:
                 continue
@@ -826,7 +835,7 @@ class MiniCPMO45Stage0DuplexRuntime:
             return [1]
         return [2] + [1] * (frame_count - 1)
 
-    def _encode_processed_vision(self, processed: Any) -> list[Any] | None:
+    def _encode_processed_vision(self, processed: Any) -> list[torch.Tensor] | None:  # Any: BatchFeature
         targets = (self.stage_model, self.thinker, getattr(self.stage_model, "model", None))
         for target in targets:
             if target is None:
@@ -842,8 +851,8 @@ class MiniCPMO45Stage0DuplexRuntime:
                 device, dtype = vpm_param.device, vpm_param.dtype
                 pixel_nested = processed["pixel_values"]
                 tgt_nested = processed["tgt_sizes"]
-                flat_pixels: list[Any] = []
-                flat_tgt: list[Any] = []
+                flat_pixels: list[torch.Tensor] = []
+                flat_tgt: list[torch.Tensor] = []
                 for image_slices, image_tgt in zip(pixel_nested, tgt_nested):
                     for slice_pixels in image_slices:
                         flat_pixels.append(slice_pixels.to(device=device, dtype=dtype))
@@ -858,7 +867,7 @@ class MiniCPMO45Stage0DuplexRuntime:
                 return None
             expected = MiniCPMO45DuplexPolicy.VISION_EMBEDS_PER_FRAME
             embed_dtype = self._token_embedding_dtype()
-            out: list[Any] = []
+            out: list[torch.Tensor] = []
             for block in hidden:
                 block_2d = self._as_2d_tensor(block)
                 if int(block_2d.shape[0]) != expected:
@@ -869,7 +878,7 @@ class MiniCPMO45Stage0DuplexRuntime:
             return out
         return None
 
-    def _stage_vision_embeddings(self, frames: list[Any]) -> list[list[Any]] | None:
+    def _stage_vision_embeddings(self, frames: list[Image.Image]) -> list[list[torch.Tensor]] | None:
         """Encode camera frames for omni duplex via the loaded vision tower.
 
         Official ``streaming_prefill`` encodes each ``frame_list`` entry as its
@@ -883,7 +892,7 @@ class MiniCPMO45Stage0DuplexRuntime:
         process_image = getattr(self.processor, "process_image", None)
         if not callable(process_image):
             return None
-        out: list[list[Any]] = []
+        out: list[list[torch.Tensor]] = []
         for frame, max_slices in zip(frames, self._official_max_slice_nums(len(frames))):
             try:
                 processed = process_image([frame], max_slice_nums=max_slices)
diff --git a/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_code2wav.py b/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_code2wav.py
index f701e8b26..da2c0eb72 100644
--- a/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_code2wav.py
+++ b/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_code2wav.py
@@ -9,6 +9,7 @@ import os
 import tempfile
 from collections.abc import Iterable, Mapping, Sequence
 from dataclasses import dataclass
+from functools import lru_cache
 from hashlib import sha256
 from pathlib import Path
 from typing import Any
@@ -57,6 +58,92 @@ def _scalar(value: Any, default: Any = None) -> Any:
     return default if value is None else value
 
 
+_REF_TARGET_SAMPLE_RATE = 24000
+# Overridable per deployment via ``ref_audio_max_seconds``.
+_REF_MAX_SECONDS = 6.0
+# Channel ceiling for the optional (channels, samples) downmix guard.
+_REF_MAX_CHANNELS = 8
+
+
+@lru_cache(maxsize=8)
+def _get_resampler(orig_freq: int, new_freq: int):
+    """Cached anti-aliased resampler matching token2wav's own loader.
+
+    ``torchaudio`` is imported lazily (it is not a hard runtime requirement of
+    this model on every platform) and the transform is built once per rate pair
+    instead of once per request, keeping it off the first-packet path.
+    """
+    import torchaudio
+
+    return torchaudio.transforms.Resample(orig_freq=orig_freq, new_freq=new_freq)
+
+
+def _read_reference_wav(path: str) -> tuple[Any, int]:
+    """Read a WAV file for :func:`_normalize_reference`.
+
+    ``soundfile`` returns ``(samples, channels)`` for multi-channel files
+    while the normalizer expects ``(channels, samples)``. Without the
+    transpose a stereo prompt looks like a huge channel count, the downmix
+    guard rejects it, and the caller silently falls back to the raw file --
+    a second L0 value for the same content.
+    """
+    waveform, sample_rate_hz = sf.read(path, dtype="float32", always_2d=False)
+    if getattr(waveform, "ndim", 1) > 1:
+        waveform = waveform.T
+    return waveform, int(sample_rate_hz)
+
+
+def _normalize_reference(
+    ref_audio: Any,
+    sample_rate_hz: int,
+    *,
+    max_seconds: float = _REF_MAX_SECONDS,
+) -> tuple[torch.Tensor, int]:
+    """Normalize a per-request reference waveform onto a shared grid.
+
+    MiniCPM-o streaming uses the reference-audio length as the CFM attention
+    cache origin (L0). Unnormalized references give every request a distinct
+    L0, which explodes the CFM CUDA-graph cache key space (see #6628). Fold
+    every reference onto the same sample rate and a fixed length (truncate
+    long ones, zero-pad short ones) so L0 becomes one constant value.
+
+    References longer than ``max_seconds`` are truncated with a warning;
+    the window is configurable via ``ref_audio_max_seconds``.
+    """
+    tensor = torch.as_tensor(ref_audio, dtype=torch.float32)
+    if tensor.dim() > 1:
+        # (channels, samples) -> mono; plain reshape(-1) would interleave.
+        # Upstream flattens request references to 1-D, so anything else is a
+        # non-standard caller: reject layouts we cannot downmix unambiguously
+        # instead of silently averaging the waveform away.
+        if tensor.shape[0] > _REF_MAX_CHANNELS:
+            raise ValueError(f"reference audio must be 1-D or (channels, samples); got shape {tuple(tensor.shape)}")
+        tensor = tensor.mean(dim=0)
+    waveform = tensor.reshape(-1).cpu().contiguous()
+    if waveform.numel() == 0:
+        # Keep the caller's "empty_ref_audio" error path intact: an empty
+        # waveform must not be zero-padded into a valid-length reference.
+        return waveform, _REF_TARGET_SAMPLE_RATE
+    if sample_rate_hz != _REF_TARGET_SAMPLE_RATE:
+        # Match token2wav's own loader (torchaudio, anti-aliased): it only
+        # resamples when the stored rate differs, so this output is what the
+        # model consumes.
+        waveform = _get_resampler(sample_rate_hz, _REF_TARGET_SAMPLE_RATE)(waveform.view(1, -1)).view(-1).contiguous()
+    max_samples = max(1, int(max_seconds * _REF_TARGET_SAMPLE_RATE))
+    if waveform.numel() > max_samples:
+        logger.warning(
+            "Reference audio is %.2fs, truncating to the %.2fs window (set ``ref_audio_max_seconds`` to keep more).",
+            waveform.numel() / _REF_TARGET_SAMPLE_RATE,
+            max_seconds,
+        )
+        waveform = waveform[:max_samples].contiguous()
+    elif waveform.numel() < max_samples:
+        # Zero-pad short references so every request shares one L0; trailing
+        # silence has minimal style impact (verified via E3 WER/SIM).
+        waveform = torch.nn.functional.pad(waveform, (0, max_samples - waveform.numel()))
+    return waveform, _REF_TARGET_SAMPLE_RATE
+
+
 def _codec_tensor(value: Any, fallback: torch.Tensor) -> torch.Tensor:
     if isinstance(value, torch.Tensor):
         return value.reshape(-1).to(device=fallback.device, dtype=torch.long)
@@ -181,7 +268,11 @@ class MiniCPMO45Code2Wav(nn.Module):
         self._cfm_graph_config = {
             "enabled": bool(extra.get("enable_cfm_graph", False)),
             "max_graphs": int(extra.get("cfm_max_graphs", 32)),
+            "bucket_frames": int(extra.get("cfm_graph_bucket_frames", 0)),
         }
+        self._ref_max_seconds = float(extra.get("ref_audio_max_seconds", _REF_MAX_SECONDS))
+        if self._ref_max_seconds <= 0:
+            raise ValueError("MiniCPM-o Code2Wav ref_audio_max_seconds must be > 0")
         self._min_batch_size = int(extra.get("code2wav_min_batch_size", 1))
         if self._min_batch_size < 1:
             raise ValueError("MiniCPM-o Code2Wav code2wav_min_batch_size must be >= 1")
@@ -192,6 +283,7 @@ class MiniCPMO45Code2Wav(nn.Module):
             raise ValueError("MiniCPM-o Code2Wav code2wav_initial_batch_size must be 0 or >= code2wav_min_batch_size")
         self._default_prompt_id = str(extra.get("prompt_cache_id", "HT_ref_audio"))
         self._prompt_wav_override = extra.get("prompt_wav")
+        self._default_prompt_normalized: tuple[str, str] | None = None
 
     @property
     def _default_prompt_wav(self) -> str:
@@ -199,6 +291,46 @@ class MiniCPMO45Code2Wav(nn.Module):
             return str(self._prompt_wav_override)
         return str(Path(self.model_path) / "assets" / "HT_ref_audio.wav")
 
+    def _normalized_default_prompt(self) -> tuple[str, str]:
+        """Fold the shipped default prompt onto the request-reference grid.
+
+        The shipped asset is 6.016 s and is loaded directly by token2wav, so a
+        request without a reference would otherwise keep a second L0 value a
+        couple of frames away from the normalized request references -- two
+        graph-key families instead of one (both use ``ref_audio_max_seconds``).
+        Returns ``(prompt_wav,
+        prompt_cache_id)``; if the asset cannot be read, the shipped path is
+        returned unchanged.
+        """
+        if self._default_prompt_normalized is not None:
+            return self._default_prompt_normalized
+        source = self._default_prompt_wav
+        fallback = (source, self._default_prompt_id)
+        try:
+            waveform, sample_rate_hz = _read_reference_wav(source)
+            normalized, target_sr = _normalize_reference(
+                waveform,
+                sample_rate_hz,
+                max_seconds=self._ref_max_seconds,
+            )
+        except Exception:
+            logger.warning("Could not normalize the default prompt %s; using it as-is", source)
+            self._default_prompt_normalized = fallback
+            return self._default_prompt_normalized
+        if normalized.numel() == 0:
+            self._default_prompt_normalized = fallback
+            return self._default_prompt_normalized
+        digest = sha256()
+        digest.update(normalized.numpy().tobytes())
+        digest.update(str(target_sr).encode())
+        cache_id = f"default-ref-{digest.hexdigest()[:24]}-{target_sr}"
+        path = Path(self._runtime_prompt_dir.name) / f"{cache_id}.wav"
+        if not path.is_file():
+            sf.write(path, normalized.numpy(), target_sr, format="WAV")
+        logger.info("Default prompt normalized onto the %.2fs window: %s", self._ref_max_seconds, path)
+        self._default_prompt_normalized = (str(path), cache_id)
+        return self._default_prompt_normalized
+
     def _extra_config(self) -> dict[str, Any]:
         model_config = getattr(self.vllm_config, "model_config", None)
         connector = getattr(model_config, "stage_connector_config", None)
@@ -220,9 +352,13 @@ class MiniCPMO45Code2Wav(nn.Module):
         sample_rate: Any,
     ) -> tuple[str, _RuntimePrompt]:
         sample_rate_hz = int(_scalar(sample_rate, 0))
-        waveform = torch.as_tensor(ref_audio, dtype=torch.float32).reshape(-1).cpu().contiguous()
         if sample_rate_hz <= 0:
             raise _batch_error("invalid_ref_audio_sample_rate", sample_rate=sample_rate_hz)
+        waveform, sample_rate_hz = _normalize_reference(
+            ref_audio,
+            sample_rate_hz,
+            max_seconds=self._ref_max_seconds,
+        )
         if waveform.numel() == 0:
             raise _batch_error("empty_ref_audio")
         if not bool(torch.isfinite(waveform).all().item()):
@@ -288,9 +424,10 @@ class MiniCPMO45Code2Wav(nn.Module):
         if entry is not None:
             return entry.cache_id, entry.path, cache_key
 
+        default_wav, default_cache_id = self._normalized_default_prompt()
         return (
-            str(_scalar(meta.get("prompt_cache_id"), self._default_prompt_id)),
-            str(_scalar(meta.get("prompt_wav"), self._default_prompt_wav)),
+            str(_scalar(meta.get("prompt_cache_id"), default_cache_id)),
+            str(_scalar(meta.get("prompt_wav"), default_wav)),
             None,
         )
 
diff --git a/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_omni.py b/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_omni.py
index e9ed05e75..b1c8db89c 100644
--- a/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_omni.py
+++ b/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_omni.py
@@ -157,15 +157,13 @@ class MiniCPMO45OmniForConditionalGeneration(nn.Module, SupportsMultiModal, Supp
         del sampling_metadata
         self._minicpmo45_active_duplex_rows = [row.row_idx for row in rows]
         self._minicpmo45_duplex_row_sessions = {
-            row.row_idx: (row.session_id, row.incarnation) for row in rows if row.session_id is not None
+            row.row_idx: row.session_id for row in rows if row.session_id is not None
         }
         request_sessions = getattr(self, "_minicpmo45_duplex_request_sessions", None)
         if not isinstance(request_sessions, dict):
             request_sessions = {}
             self._minicpmo45_duplex_request_sessions = request_sessions
-        request_sessions.update(
-            {row.request_id: (row.session_id, row.incarnation) for row in rows if row.session_id is not None}
-        )
+        request_sessions.update({row.request_id: row.session_id for row in rows if row.session_id is not None})
         self._minicpmo45_duplex_row_payloads = {row.row_idx: row.payload for row in rows if row.payload is not None}
         self._minicpmo45_duplex_row_max_tokens = {
             row.row_idx: row.max_tokens for row in rows if row.max_tokens is not None
@@ -199,7 +197,7 @@ class MiniCPMO45OmniForConditionalGeneration(nn.Module, SupportsMultiModal, Supp
             force_listen = payload.get("force_listen") is True
             is_speech = payload.get("is_speech")
             segment_key = (row.request_id, row.seq if row.seq is not None else -1)
-            session_key = (row.session_id, row.incarnation) if row.session_id is not None else None
+            session_key = row.session_id
             if turn_eos_id >= 0 and session_key is not None:
                 state = helper_sessions.get(session_key) if isinstance(helper_sessions, dict) else None
                 pending_speech_context = (
@@ -326,16 +324,12 @@ class MiniCPMO45OmniForConditionalGeneration(nn.Module, SupportsMultiModal, Supp
 
         helper = self._duplex_data_plane_helper()
         session_id = str(duplex.get("session_id") or "")
-        try:
-            incarnation = int(duplex.get("incarnation", 0))
-        except (TypeError, ValueError):
-            incarnation = 0
         payload = duplex.get("payload")
         if not session_id or not isinstance(payload, dict):
             embeds = input_embeds if input_embeds is not None else self.get_input_embeddings(input_ids)
             return input_ids, embeds, {"duplex": {"prefill_success": False, "reason": "bad_duplex_payload"}}
 
-        session_key = (session_id, incarnation)
+        session_key = session_id
         state = helper.sessions.get(session_key)
         if state is None:
             from vllm_omni.model_executor.models.minicpmo_4_5.duplex.stage0 import (
@@ -547,13 +541,13 @@ class MiniCPMO45OmniForConditionalGeneration(nn.Module, SupportsMultiModal, Supp
             )
 
             if isinstance(thinker_output, tuple):
-                embeds, text_hidden_states = thinker_output
+                _, text_hidden_states = thinker_output
             else:
                 text_hidden_states = thinker_output
 
             # Prepare hidden states for downstream stages
-            # Ensure correct shape: (batch_size, seq_len, hidden_dim)
-            if added_batch_dim:
+            # Ensure correct shape: (seq_len, hidden_dim)
+            if text_hidden_states.ndim == 3 and text_hidden_states.shape[0] == 1:
                 text_hidden_states = text_hidden_states.squeeze(0)
 
             # Return hidden states with latent in multimodal_outputs for stage_input_processors
diff --git a/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_omni_llm.py b/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_omni_llm.py
index 315ae159d..2781fcc30 100644
--- a/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_omni_llm.py
+++ b/vllm_omni/model_executor/models/minicpmo_4_5/minicpmo_4_5_omni_llm.py
@@ -136,6 +136,13 @@ def _encode_tokens(tokenizer: Any, prompt: str) -> list[int]:
 
 from vllm.utils.tensor_schema import TensorSchema, TensorShape
 
+from vllm_omni.model_executor.models.model_local_kv import (
+    ModelLocalKVScope,
+    ModelLocalKVSpec,
+    RowDriver,
+    spec_from_hf_config,
+)
+
 logger = init_logger(__name__)
 hf_logger = logging.get_logger(__name__)
 
@@ -2621,6 +2628,51 @@ class MiniCPMWhisperEncoder(WhisperEncoder):
             [MiniCPMWhisperEncoderLayer(config, layer_idx=i) for i in range(config.encoder_layers)]
         )
 
+    def model_local_kv_specs(self) -> list[ModelLocalKVSpec]:
+        """Declare the streaming encoder's self-attention cache.
+
+        Bounded by learned position embeddings, not by ``max_model_len``: the
+        cache cannot outgrow ``embed_positions``, and past that point the
+        forward pass repeats the last position rather than extending.
+
+        Whisper is encoder-only self-attention here, so kv-heads equal
+        attention heads. Layer count is read off the built ``self.layers``
+        rather than the config, so a partially built encoder reports what it
+        actually has.
+
+        Declared per session, not per sequence. Each streaming session state
+        owns its own ``audio_past_key_values`` and the encoder runs at batch
+        size one, so ``max_num_seqs`` is the wrong number here.
+
+        One session is the unit rather than the configured cap, because the cap
+        is not visible from the model and the setting that carries it cannot
+        distinguish "duplex off" from "one session" -- so a cap-scaled figure
+        would report a cache that a non-duplex deployment never allocates. An
+        earlier revision grew a capacity driver and an engine-side field to
+        carry that number for this one declarer; the arithmetic is a
+        multiplication the reader can do when they need the ceiling.
+        """
+        return [
+            spec_from_hf_config(
+                self.config,
+                name="whisper_encoder_self_attn",
+                dtype=self.conv1.weight.dtype,
+                layers=len(self.layers),
+                kv_heads=self.config.encoder_attention_heads,
+                head_dim=self.config.d_model // self.config.encoder_attention_heads,
+                physical_capacity_positions=int(self.embed_positions.weight.shape[0]),
+                capacity_source="embed_positions rows (max_source_positions)",
+                scope=ModelLocalKVScope.SESSION,
+                rows=RowDriver.FIXED,
+                rows_fixed=1,
+                rows_reason="one EncoderDecoderCache per streaming session, encoder runs at batch size 1",
+                allocation_note=(
+                    "only allocated on the streaming path, where use_cache is set; scales with the "
+                    "configured duplex session cap"
+                ),
+            )
+        ]
+
     def forward(
         self,
         input_features,
@@ -4528,6 +4580,10 @@ class MiniCPMO45OmniLLMForConditionalGeneration(nn.Module, SupportsMultiModal, S
                 multimodal_embeddings += tuple(audio_embeddings)
         return multimodal_embeddings
 
+    def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:
+        """vLLM V1 encoder profiling calls this; the inherited Protocol stub returns None."""
+        return self.get_multimodal_embeddings(**kwargs)
+
     def get_input_embeddings(
         self,
         input_ids: torch.Tensor,
@@ -4555,9 +4611,6 @@ class MiniCPMO45OmniLLMForConditionalGeneration(nn.Module, SupportsMultiModal, S
         inputs_embeds: torch.Tensor | None = None,
         **kwargs: object,
     ) -> torch.Tensor | IntermediateTensors:
-        """Forward pass through thinker model."""
-        text_inputs_embeds = None
-
         if intermediate_tensors is not None:
             inputs_embeds = None
 
@@ -4565,22 +4618,12 @@ class MiniCPMO45OmniLLMForConditionalGeneration(nn.Module, SupportsMultiModal, S
         elif inputs_embeds is None:
             multimodal_embeddings = self.get_multimodal_embeddings(**kwargs)
             inputs_embeds = self.get_input_embeddings(input_ids, multimodal_embeddings)
-            text_inputs_embeds = self.get_input_embeddings(
-                input_ids,
-                (
-                    [(torch.zeros_like(embeddings), "image") for embeddings in multimodal_embeddings]
-                    if multimodal_embeddings is not None
-                    else None
-                ),
-            )
             input_ids = None
-        else:
-            text_inputs_embeds = inputs_embeds
 
         # Forward through language model
         hidden_states = self.llm.model(input_ids, positions, intermediate_tensors, inputs_embeds=inputs_embeds)
 
-        return text_inputs_embeds, hidden_states.unsqueeze(0) if hidden_states.ndim == 2 else hidden_states
+        return hidden_states
 
     def compute_logits(self, hidden_states: torch.Tensor) -> torch.Tensor | None:
         """Compute logits from hidden states."""
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/minicpmo_4_5/pipeline.py b/vllm_omni/model_executor/models/minicpmo_4_5/pipeline.py
index 0ca61a346..e75393845 100644
--- a/vllm_omni/model_executor/models/minicpmo_4_5/pipeline.py
+++ b/vllm_omni/model_executor/models/minicpmo_4_5/pipeline.py
@@ -24,13 +24,7 @@ MINICPMO_4_5_PIPELINE = PipelineConfig(
     model_type="minicpmo_4_5",
     default_deploy_config_name="minicpmo_4_5.yaml",
     model_arch="MiniCPMO45OmniForConditionalGeneration",
-    duplex_runtime_extension=(
-        "vllm_omni.model_executor.models.minicpmo_4_5.duplex.runtime.MiniCPMO45DuplexRuntimeExtension"
-    ),
-    duplex_serving_adapter=(
-        "vllm_omni.model_executor.models.minicpmo_4_5.duplex.serving_adapter.MiniCPMO45ServingRuntimeAdapter"
-    ),
-    duplex_control_enabled=True,
+    duplex_plugin="vllm_omni.model_executor.models.minicpmo_4_5.duplex.plugin.MiniCPMO45DuplexPlugin",
     # MiniCPM-o 4.5's HF config.json reports `model_type="minicpmo"` and
     # `architectures=["MiniCPMO"]` — both shared verbatim with older MiniCPM-o
     # 1.0 / 2.6 checkpoints. The only field distinguishing the generations is
@@ -53,7 +47,13 @@ MINICPMO_4_5_PIPELINE = PipelineConfig(
             owns_tokenizer=True,
             requires_multimodal_data=True,
             engine_output_type="latent",
-            sampling_constraints={"detokenize": True},
+            sampling_constraints={
+                "detokenize": True,
+                # The llm2tts bridge discards this boundary and every row
+                # after it, so stop Stage 0 as soon as either valid
+                # MiniCPM-o 4.5 turn terminator is sampled.
+                "stop_token_ids": [151704, 151645],
+            },
         ),
         StagePipelineConfig(
             stage_id=1,
diff --git a/vllm_omni/model_executor/models/minimax_h3/checkpoint.py b/vllm_omni/model_executor/models/minimax_h3/checkpoint.py
index e8350f41a..b39af5cf8 100644
--- a/vllm_omni/model_executor/models/minimax_h3/checkpoint.py
+++ b/vllm_omni/model_executor/models/minimax_h3/checkpoint.py
@@ -1,16 +1,41 @@
 # 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,
 )
 
-MINIMAX_H3_TEXT_ENCODER_DOWNLOAD_PATTERNS = {
-    "fl2va": ["FL2VA/text_encoder/**"],
-    "ref2va": ["Ref2VA/text_encoder/**"],
+_FASTH3_MODULAR_MODEL_PREFIX = "FastVideo/"
+
+MINIMAX_H3_ENCODER_DOWNLOAD_PATTERNS = {
+    partition: [
+        f"{subdir}/text_encoder/**",
+        f"{subdir}/video_vae/**",
+        f"{subdir}/audio_vae/**",
+    ]
+    for partition, subdir in {"fl2va": "FL2VA", "ref2va": "Ref2VA"}.items()
 }
+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(
@@ -32,17 +57,20 @@ def resolve_minimax_h3_partition(
     return "ref2va" if task == "ref2va" else "fl2va"
 
 
-def resolve_minimax_h3_model_root(
+def resolve_minimax_h3_encoder_model_root(
     model: str,
     revision: str | None,
     task_type: str | None,
 ) -> 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"
@@ -50,13 +78,22 @@ def resolve_minimax_h3_model_root(
     snapshot = download_weights_from_hf_specific(
         model_name_or_path=model,
         cache_dir=None,
-        allow_patterns=MINIMAX_H3_TEXT_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")
 
 
-__all__ = ["resolve_minimax_h3_model_root", "resolve_minimax_h3_partition"]
+resolve_minimax_h3_model_root = resolve_minimax_h3_encoder_model_root
+
+
+__all__ = [
+    "resolve_minimax_h3_encoder_model_root",
+    "resolve_minimax_h3_model_root",
+    "resolve_minimax_h3_partition",
+]
diff --git a/vllm_omni/model_executor/models/minimax_h3/conditioning.py b/vllm_omni/model_executor/models/minimax_h3/conditioning.py
index efea25771..5d362f440 100644
--- a/vllm_omni/model_executor/models/minimax_h3/conditioning.py
+++ b/vllm_omni/model_executor/models/minimax_h3/conditioning.py
@@ -4,8 +4,9 @@
 
 from __future__ import annotations
 
-from collections.abc import Mapping
-from dataclasses import dataclass
+import math
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass, fields
 from typing import Any
 
 import torch
@@ -119,3 +120,785 @@ class MiniMaxH3TextConditioning:
             "hidden_states": self.hidden_states,
             "token_tags": self.token_tags,
         }
+
+
+MINIMAX_H3_ENCODER_REQUEST_KEY = "minimax_h3_encoder_request"
+MINIMAX_H3_ENCODER_LAYOUT_KEY = "minimax_h3_encoder_layout"
+STAGE_SCHEMA_VERSION = 2
+_ENCODER_WIRE_SCHEMA_ID = 1
+
+_TASK_TO_CODE = {"t2va": 1, "fl2va": 2, "ref2va": 3}
+_CODE_TO_TASK = {value: key for key, value in _TASK_TO_CODE.items()}
+_REF_KIND_TO_CODE = {"image": 1, "video": 2, "video_audio": 3, "audio": 4}
+_CODE_TO_REF_KIND = {value: key for key, value in _REF_KIND_TO_CODE.items()}
+_INTEGER_DTYPES = frozenset(
+    {
+        torch.int8,
+        torch.int16,
+        torch.int32,
+        torch.int64,
+        torch.uint8,
+    }
+)
+_VIDEO_CONDITION_WIDTH = 96
+_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):
+        raise ValueError("MiniMax H3 wire payload requires private layout metadata")
+    layout = private_metadata.get(MINIMAX_H3_ENCODER_LAYOUT_KEY)
+    if isinstance(layout, torch.Tensor):
+        return layout
+    raise ValueError("MiniMax H3 wire payload requires one packed encoder layout tensor")
+
+
+def _validate_condition_tensors(
+    visual: torch.Tensor | None,
+    visual_shapes: Sequence[Sequence[int]],
+    audio: torch.Tensor | None,
+    audio_lengths: Sequence[int],
+) -> None:
+    if (visual is None) != (not visual_shapes):
+        raise ValueError("MiniMax H3 visual condition and shapes must be present together")
+    if (audio is None) != (not audio_lengths):
+        raise ValueError("MiniMax H3 audio condition and lengths must be present together")
+
+    parsed_shapes = [tuple(int(item) for item in shape) for shape in visual_shapes]
+    if any(
+        len(shape) != 3 or any(item <= 0 for item in shape) or shape[1] % 2 or shape[2] % 2 for shape in parsed_shapes
+    ):
+        raise ValueError("MiniMax H3 visual condition shapes must be positive [T, H, W] triplets with even H/W")
+    if visual is not None:
+        expected_rows = sum(t * (h // 2) * (w // 2) for t, h, w in parsed_shapes)
+        if (
+            visual.dtype != torch.float32
+            or visual.ndim != 2
+            or tuple(visual.shape)
+            != (
+                expected_rows,
+                _VIDEO_CONDITION_WIDTH,
+            )
+        ):
+            raise ValueError(
+                "MiniMax H3 visual condition must be FP32 with shape "
+                f"[{expected_rows}, {_VIDEO_CONDITION_WIDTH}], got {visual.dtype} {tuple(visual.shape)}"
+            )
+
+    parsed_lengths = [int(length) for length in audio_lengths]
+    if any(length <= 0 for length in parsed_lengths):
+        raise ValueError("MiniMax H3 audio condition lengths must be positive")
+    if audio is not None:
+        expected_rows = _AUDIO_CONDITION_CHANNELS * sum(parsed_lengths)
+        if (
+            audio.dtype != torch.float32
+            or audio.ndim != 2
+            or tuple(audio.shape)
+            != (
+                expected_rows,
+                _AUDIO_CONDITION_WIDTH,
+            )
+        ):
+            raise ValueError(
+                "MiniMax H3 audio condition must be FP32 with shape "
+                f"[{expected_rows}, {_AUDIO_CONDITION_WIDTH}], got {audio.dtype} {tuple(audio.shape)}"
+            )
+
+
+def _ref_block_rows(ref_blocks: Sequence[Mapping[str, Any]]) -> list[list[int]]:
+    rows: list[list[int]] = []
+    for block in ref_blocks:
+        kind = str(block.get("kind") or "")
+        kind_code = _REF_KIND_TO_CODE.get(kind)
+        if kind_code is None:
+            raise ValueError(f"unsupported MiniMax H3 ref kind {kind!r}")
+        rows.append(
+            [
+                kind_code,
+                int(block.get("ref_audio_t", 0)),
+                int(block.get("latent_t", 0)),
+                int(block.get("latent_h", 0)),
+                int(block.get("latent_w", 0)),
+            ]
+        )
+    return rows
+
+
+def _decode_ref_blocks(value: torch.Tensor) -> tuple[dict[str, Any], ...]:
+    if value.ndim != 2 or value.shape[1] != 5:
+        raise ValueError("MiniMax H3 ref_blocks metadata must have shape [N, 5]")
+    blocks: list[dict[str, Any]] = []
+    for kind_code, ref_audio_t, ref_t, ref_h, ref_w in value.detach().cpu().tolist():
+        kind = _CODE_TO_REF_KIND.get(int(kind_code))
+        if kind is None:
+            raise ValueError(f"unsupported MiniMax H3 ref kind code {kind_code!r}")
+        block: dict[str, Any] = {"kind": kind}
+        for key, item in (
+            ("ref_audio_t", ref_audio_t),
+            ("latent_t", ref_t),
+            ("latent_h", ref_h),
+            ("latent_w", ref_w),
+        ):
+            if item:
+                block[key] = int(item)
+        blocks.append(block)
+    return tuple(blocks)
+
+
+@dataclass(frozen=True)
+class MiniMaxH3EncoderMediaInput:
+    task: str
+    height: int
+    width: int
+    num_frames: int
+    latent_t: int
+    audio_t: int
+    images: tuple[torch.Tensor, ...] = ()
+    videos: tuple[torch.Tensor, ...] = ()
+    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(
+        cls,
+        values: Sequence[torch.Tensor],
+        metadata: Mapping[str, Any],
+    ) -> MiniMaxH3EncoderMediaInput:
+        if not isinstance(values, Sequence) or isinstance(values, (str, bytes)):
+            raise ValueError("MiniMax H3 encoder media must be a tensor sequence")
+        tensors = list(values)
+        if any(not isinstance(item, torch.Tensor) for item in tensors):
+            raise ValueError("MiniMax H3 encoder media input must contain only tensors")
+        task = str(metadata["task"])
+        if task not in _TASK_TO_CODE:
+            raise ValueError(f"unsupported MiniMax H3 task {task!r}")
+        height = int(metadata["height"])
+        width = int(metadata["width"])
+        num_frames = int(metadata["num_frames"])
+        latent_t = int(metadata["latent_t"])
+        audio_t = int(metadata["audio_t"])
+        image_count = int(metadata.get("image_count", 0))
+        video_count = int(metadata.get("video_count", 0))
+        audio_count = int(metadata.get("audio_count", 0))
+        if min(height, width, num_frames, latent_t, audio_t) <= 0:
+            raise ValueError("MiniMax H3 encoder media dimensions must be positive")
+        if min(image_count, video_count, audio_count) < 0:
+            raise ValueError("MiniMax H3 encoder media counts must be non-negative")
+
+        audio_flags = tuple(bool(value) for value in metadata.get("video_audio_flags", ()))
+        video_audio_sample_rates = tuple(int(value) for value in metadata.get("video_audio_sample_rates", ()))
+        audio_sample_rates = tuple(int(value) for value in metadata.get("audio_sample_rates", ()))
+        if len(audio_flags) != video_count or len(video_audio_sample_rates) != video_count:
+            raise ValueError("MiniMax H3 video audio flags must align with videos")
+        if len(audio_sample_rates) != audio_count:
+            raise ValueError("MiniMax H3 audio sample rates must align with audio inputs")
+        if any((rate > 0) != has_audio for rate, has_audio in zip(video_audio_sample_rates, audio_flags, strict=True)):
+            raise ValueError("MiniMax H3 embedded audio sample rates must align with audio flags")
+        if any(rate <= 0 for rate in audio_sample_rates):
+            raise ValueError("MiniMax H3 audio sample rates must be positive")
+
+        cursor = 0
+        images = tuple(tensors[cursor : cursor + image_count])
+        cursor += image_count
+        videos = tuple(tensors[cursor : cursor + video_count])
+        cursor += video_count
+        if len(images) != image_count or any(image.ndim != 3 or image.shape[-1] != 3 for image in images):
+            raise ValueError("MiniMax H3 encoder images must have shape [H, W, 3]")
+        if len(videos) != video_count or any(video.ndim != 4 or video.shape[-1] != 3 for video in videos):
+            raise ValueError("MiniMax H3 encoder videos must have shape [T, H, W, 3]")
+
+        video_audios: list[tuple[torch.Tensor, int] | None] = []
+        for has_audio, sample_rate in zip(audio_flags, video_audio_sample_rates, strict=True):
+            if not has_audio:
+                video_audios.append(None)
+                continue
+            if cursor >= len(tensors):
+                raise ValueError("MiniMax H3 encoder media input is truncated")
+            waveform = tensors[cursor]
+            cursor += 1
+            if waveform.ndim not in (1, 2):
+                raise ValueError("MiniMax H3 embedded audio must have shape [samples] or [channels, samples]")
+            video_audios.append((waveform, sample_rate))
+
+        audios: list[tuple[torch.Tensor, int]] = []
+        for sample_rate in audio_sample_rates:
+            if cursor >= len(tensors):
+                raise ValueError("MiniMax H3 encoder media input is truncated")
+            waveform = tensors[cursor]
+            cursor += 1
+            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,
+            num_frames=num_frames,
+            latent_t=latent_t,
+            audio_t=audio_t,
+            images=images,
+            videos=videos,
+            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]:
+        task_code = _TASK_TO_CODE.get(self.task)
+        if task_code is None:
+            raise ValueError(f"unsupported MiniMax H3 task {self.task!r}")
+        if min(self.height, self.width, self.num_frames, self.latent_t, self.audio_t) <= 0:
+            raise ValueError("MiniMax H3 encoder media dimensions must be positive")
+        if len(self.video_audios) != len(self.videos):
+            raise ValueError("MiniMax H3 video audio slots must align with videos")
+        if any(image.ndim != 3 or image.shape[-1] != 3 for image in self.images):
+            raise ValueError("MiniMax H3 encoder images must have shape [H, W, 3]")
+        if any(video.ndim != 4 or video.shape[-1] != 3 for video in self.videos):
+            raise ValueError("MiniMax H3 encoder videos must have shape [T, H, W, 3]")
+        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:
+                continue
+            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]:
+        metadata = {
+            "audio_mode": self.audio_mode,
+            "task": self.task,
+            "height": self.height,
+            "width": self.width,
+            "num_frames": self.num_frames,
+            "latent_t": self.latent_t,
+            "audio_t": self.audio_t,
+            "image_count": len(self.images),
+            "video_count": len(self.videos),
+            "audio_count": len(self.audios),
+            "video_audio_flags": [item is not None for item in self.video_audios],
+            "video_audio_sample_rates": [item[1] if item is not None else 0 for item in self.video_audios],
+            "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)
+class MiniMaxH3EncoderMediaConditioning:
+    task: str
+    height: int
+    width: int
+    num_frames: int
+    latent_t: int
+    audio_t: int
+    visual_condition: torch.Tensor | None = None
+    visual_condition_shapes: tuple[tuple[int, int, int], ...] = ()
+    audio_condition: torch.Tensor | None = None
+    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,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        task_code = _TASK_TO_CODE.get(self.task)
+        if task_code is None:
+            raise ValueError(f"unsupported MiniMax H3 task {self.task!r}")
+        if min(self.height, self.width, self.num_frames, self.latent_t, self.audio_t) <= 0:
+            raise ValueError("MiniMax H3 encoder media dimensions must be positive")
+        _validate_condition_tensors(
+            self.visual_condition,
+            self.visual_condition_shapes,
+            self.audio_condition,
+            self.audio_condition_lengths,
+        )
+        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,
+            STAGE_SCHEMA_VERSION,
+            task_code,
+            self.height,
+            self.width,
+            self.num_frames,
+            self.latent_t,
+            self.audio_t,
+            len(self.visual_condition_shapes),
+            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 (
+            _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),
+        )
+
+
+@dataclass(frozen=True)
+class MiniMaxH3EncoderConditioning:
+    hidden_states: torch.Tensor
+    token_tags: torch.Tensor
+    task: str
+    height: int
+    width: int
+    num_frames: int
+    latent_t: int
+    audio_t: int
+    visual_condition: torch.Tensor | None = None
+    visual_condition_shapes: tuple[tuple[int, int, int], ...] = ()
+    audio_condition: torch.Tensor | None = None
+    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(
+        cls,
+        text: MiniMaxH3TextConditioning,
+        media: MiniMaxH3EncoderMediaConditioning,
+    ) -> MiniMaxH3EncoderConditioning:
+        """Combine local encoder results without a stage-wire round trip."""
+        text = MiniMaxH3TextConditioning.from_payload(text.to_payload())
+        _validate_condition_tensors(
+            media.visual_condition,
+            media.visual_condition_shapes,
+            media.audio_condition,
+            media.audio_condition_lengths,
+        )
+        return cls(
+            hidden_states=text.hidden_states,
+            token_tags=text.token_tags,
+            **{item.name: getattr(media, item.name) for item in fields(media)},
+        )
+
+    @classmethod
+    def from_omni_payload(cls, payload: Mapping[str, Any]) -> MiniMaxH3EncoderConditioning:
+        hidden_payload = payload.get("hidden_states")
+        embed_payload = payload.get("embed")
+        meta_payload = payload.get("meta")
+        hidden_states = hidden_payload.get("output") if isinstance(hidden_payload, Mapping) else None
+        token_tags = meta_payload.get("token_role_ids") if isinstance(meta_payload, Mapping) else None
+        visual = embed_payload.get("embedding") if isinstance(embed_payload, Mapping) else None
+        audio = embed_payload.get("speech_feat") if isinstance(embed_payload, Mapping) else None
+        if not all(isinstance(item, torch.Tensor) for item in (hidden_states, token_tags, visual, audio)):
+            raise ValueError("MiniMax H3 encoder wire requires text, visual and audio tensors")
+        assert isinstance(hidden_states, torch.Tensor)
+        assert isinstance(token_tags, torch.Tensor)
+        assert isinstance(visual, torch.Tensor)
+        assert isinstance(audio, torch.Tensor)
+        if token_tags.ndim == 2 and token_tags.shape[-1] == 1:
+            token_tags = token_tags.squeeze(-1)
+        text = MiniMaxH3TextConditioning.from_payload({"hidden_states": hidden_states, "token_tags": token_tags})
+        for name, value in (("visual", visual), ("audio", audio)):
+            if value.numel() == 0 and (value.dtype != torch.float32 or tuple(value.shape) != (0,)):
+                raise ValueError(f"MiniMax H3 empty {name} condition slot must be FP32 with shape [0]")
+        if not isinstance(meta_payload, Mapping):
+            raise ValueError("MiniMax H3 wire payload requires a meta mapping")
+        layout = _wire_layout(payload)
+        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) < 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,
+            task_code,
+            height,
+            width,
+            num_frames,
+            latent_t,
+            audio_t,
+            visual_count,
+            audio_count,
+            ref_count,
+            keyframe_count,
+            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}")
+        if min(height, width, num_frames, latent_t, audio_t) <= 0:
+            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")
+        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 = 15
+        visual_shapes = tuple(
+            tuple(values[cursor + 3 * index : cursor + 3 * (index + 1)]) for index in range(visual_count)
+        )
+        cursor += 3 * visual_count
+        audio_lengths = tuple(values[cursor : cursor + audio_count])
+        cursor += audio_count
+        ref_rows = values[cursor : cursor + 5 * ref_count]
+        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])
+        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,
+            task=task,
+            height=height,
+            width=width,
+            num_frames=num_frames,
+            latent_t=latent_t,
+            audio_t=audio_t,
+            visual_condition=visual_condition,
+            visual_condition_shapes=visual_shapes,
+            audio_condition=audio_condition,
+            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]:
+        text = MiniMaxH3TextConditioning.from_payload(
+            {
+                "hidden_states": self.hidden_states,
+                "token_tags": self.token_tags,
+            }
+        )
+        visual, audio, layout = MiniMaxH3EncoderMediaConditioning(
+            task=self.task,
+            height=self.height,
+            width=self.width,
+            num_frames=self.num_frames,
+            latent_t=self.latent_t,
+            audio_t=self.audio_t,
+            visual_condition=self.visual_condition,
+            visual_condition_shapes=self.visual_condition_shapes,
+            audio_condition=self.audio_condition,
+            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},
+            "embed": {
+                "embedding": visual,
+                "speech_feat": audio,
+            },
+            "meta": {"token_role_ids": text.token_tags},
+            "kv_metadata": {MINIMAX_H3_ENCODER_LAYOUT_KEY: layout},
+        }
+
+
+__all__ = [
+    "MINIMAX_H3_CONDITION_LABELS_KEY",
+    "MINIMAX_H3_ENCODER_LAYOUT_KEY",
+    "MINIMAX_H3_ENCODER_REQUEST_KEY",
+    "MINIMAX_H3_PRESENTATION_TASK_KEY",
+    "MINIMAX_H3_TEXT_CONDITIONING_SCHEMA",
+    "MINIMAX_H3_TEXT_HIDDEN_SIZE",
+    "STAGE_SCHEMA_VERSION",
+    "MiniMaxH3EncoderConditioning",
+    "MiniMaxH3EncoderMediaConditioning",
+    "MiniMaxH3EncoderMediaInput",
+    "MiniMaxH3TextConditioning",
+]
diff --git a/vllm_omni/model_executor/models/minimax_h3/encoder.py b/vllm_omni/model_executor/models/minimax_h3/encoder.py
new file mode 100644
index 000000000..44fefab91
--- /dev/null
+++ b/vllm_omni/model_executor/models/minimax_h3/encoder.py
@@ -0,0 +1,252 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import torch
+from vllm.config import VllmConfig
+from vllm.distributed.parallel_state import get_tp_group
+
+from vllm_omni.diffusion.distributed.utils import get_local_device
+from vllm_omni.diffusion.models.minimax_h3.vae import (
+    MiniMaxH3AudioVAE,
+    MiniMaxH3VideoVAE,
+)
+from vllm_omni.model_executor.models.minimax_h3.conditioning import (
+    MINIMAX_H3_ENCODER_LAYOUT_KEY,
+    MINIMAX_H3_ENCODER_REQUEST_KEY,
+    MiniMaxH3EncoderMediaConditioning,
+    MiniMaxH3EncoderMediaInput,
+)
+from vllm_omni.model_executor.models.minimax_h3.encoder_processing import encode_media
+from vllm_omni.model_executor.models.minimax_h3.text_encoder import (
+    MiniMaxH3TextEncoderBackbone,
+)
+from vllm_omni.model_executor.models.output_templates import OmniOutput
+
+_MEDIA_CONDITIONING_CACHE_KEY = "_minimax_h3_encoder_media_conditioning"
+_MEDIA_CACHE_KEY = "_minimax_h3_encoder_media"
+_COMPONENT_CONFIG_KEY = "minimax_h3_encoder_components"
+_COMPONENT_ROLES = frozenset({"text_encoder", "video_vae", "audio_vae"})
+
+
+def _partition_root(model_path: str) -> Path:
+    path = Path(model_path)
+    if path.name in {"text_encoder", "video_vae", "audio_vae"}:
+        return path.parent
+    return path
+
+
+@dataclass(frozen=True)
+class MiniMaxH3EncoderComponentConfig:
+    text_parallel_mode: str
+    video_parallel_mode: str
+    audio_parallel_mode: str
+
+    def __post_init__(self) -> None:
+        if self.text_parallel_mode != "tp":
+            raise ValueError("MiniMax H3 text encoder currently supports parallel_mode='tp' only")
+        if self.video_parallel_mode not in {"leader", "patch"}:
+            raise ValueError("MiniMax H3 video VAE parallel_mode must be 'leader' or 'patch'")
+        if self.audio_parallel_mode != "leader":
+            raise ValueError("MiniMax H3 audio VAE currently supports parallel_mode='leader' only")
+
+    @staticmethod
+    def _parallel_mode(raw: Mapping[str, Any], role: str) -> str:
+        value = raw[role]
+        if not isinstance(value, Mapping):
+            raise TypeError(f"MiniMax H3 encoder role {role!r} must be a mapping")
+        if set(value) != {"parallel_mode"}:
+            raise ValueError(f"MiniMax H3 encoder role {role!r} requires only parallel_mode")
+        return str(value["parallel_mode"])
+
+    @classmethod
+    def from_vllm_config(cls, vllm_config: VllmConfig) -> MiniMaxH3EncoderComponentConfig:
+        hf_config = vllm_config.model_config.hf_config
+        raw = getattr(hf_config, _COMPONENT_CONFIG_KEY, None)
+        if not isinstance(raw, Mapping):
+            raise ValueError(f"MiniMax H3 Encoder Stage requires explicit {_COMPONENT_CONFIG_KEY}")
+        roles = set(raw)
+        if roles != _COMPONENT_ROLES:
+            missing = sorted(_COMPONENT_ROLES - roles)
+            unknown = sorted(roles - _COMPONENT_ROLES)
+            raise ValueError(
+                f"{_COMPONENT_CONFIG_KEY} requires exactly {sorted(_COMPONENT_ROLES)}; "
+                f"missing={missing}, unknown={unknown}"
+            )
+        return cls(
+            text_parallel_mode=cls._parallel_mode(raw, "text_encoder"),
+            video_parallel_mode=cls._parallel_mode(raw, "video_vae"),
+            audio_parallel_mode=cls._parallel_mode(raw, "audio_vae"),
+        )
+
+
+class MiniMaxH3Encoder(MiniMaxH3TextEncoderBackbone):
+    requires_request_sample_eligibility = True
+    enable_update_additional_information = True
+    omni_payload_at_request_end = True
+
+    def __init__(self, *, vllm_config: VllmConfig, prefix: str = "model") -> None:
+        super().__init__(vllm_config=vllm_config, prefix=prefix)
+        try:
+            tp_group = get_tp_group()
+            tp_rank = int(tp_group.rank_in_group)
+        except (AssertionError, RuntimeError):
+            tp_group = None
+            tp_rank = 0
+        self._component_leader = tp_rank == 0
+        self.component_config = MiniMaxH3EncoderComponentConfig.from_vllm_config(vllm_config)
+        root = _partition_root(vllm_config.model_config.model)
+        missing = [name for name in ("text_encoder", "video_vae", "audio_vae") if not (root / name).is_dir()]
+        if missing:
+            raise RuntimeError(f"MiniMax H3 Encoder Stage requires all three encoders; missing {missing}")
+        device = get_local_device()
+        self.video_vae: MiniMaxH3VideoVAE | None = None
+        self.audio_vae: MiniMaxH3AudioVAE | None = None
+        if self._component_leader or self.component_config.video_parallel_mode == "patch":
+            self.video_vae = MiniMaxH3VideoVAE(
+                str(root / "video_vae"),
+                device=device,
+                encode_only=True,
+                trust_remote_code=vllm_config.model_config.trust_remote_code,
+            )
+            if self.component_config.video_parallel_mode == "patch":
+                if tp_group is None:
+                    raise RuntimeError("MiniMax H3 video VAE patch parallelism requires an initialized TP group")
+                self.video_vae.set_parallel_size(
+                    tp_group.world_size,
+                    process_group=tp_group.device_group,
+                )
+        if self._component_leader:
+            self.audio_vae = MiniMaxH3AudioVAE(
+                str(root / "audio_vae"),
+                device=device,
+                encode_only=True,
+                trust_remote_code=vllm_config.model_config.trust_remote_code,
+            )
+
+    @staticmethod
+    def _media_input(info: dict[str, Any]) -> MiniMaxH3EncoderMediaInput:
+        cached = info.get(_MEDIA_CACHE_KEY)
+        if isinstance(cached, MiniMaxH3EncoderMediaInput):
+            return cached
+        meta = info.get("meta")
+        metadata = meta.get(MINIMAX_H3_ENCODER_REQUEST_KEY) if isinstance(meta, Mapping) else None
+        if not isinstance(metadata, Mapping):
+            raise RuntimeError("MiniMax H3 unified encoder requires request metadata")
+
+        hidden_states = info.get("hidden_states")
+        raw_media = hidden_states.get("layers") if isinstance(hidden_states, Mapping) else None
+        if raw_media is None:
+            media_tensors: list[torch.Tensor] = []
+        elif isinstance(raw_media, Mapping):
+            try:
+                ordered_items = sorted(raw_media.items(), key=lambda item: int(item[0]))
+            except (TypeError, ValueError) as exc:
+                raise RuntimeError("MiniMax H3 encoder media keys must be integer indices") from exc
+            if [int(key) for key, _ in ordered_items] != list(range(len(ordered_items))):
+                raise RuntimeError("MiniMax H3 encoder media indices must be contiguous from zero")
+            media_tensors = [value for _, value in ordered_items]
+        else:
+            raise RuntimeError("MiniMax H3 encoder media must be a namespaced tensor mapping")
+        if any(not isinstance(value, torch.Tensor) for value in media_tensors):
+            raise RuntimeError("MiniMax H3 encoder media must contain only tensors")
+        media = MiniMaxH3EncoderMediaInput.from_mm_tensors(media_tensors, metadata)
+        if media.to_metadata() != dict(metadata):
+            raise RuntimeError("MiniMax H3 encoder media does not match request metadata")
+        info[_MEDIA_CACHE_KEY] = media
+        return media
+
+    def _encode_media(self, media: MiniMaxH3EncoderMediaInput) -> MiniMaxH3EncoderMediaConditioning | None:
+        if not self._component_leader and self.component_config.video_parallel_mode == "leader":
+            return None
+        return encode_media(
+            media,
+            video_vae=self.video_vae,
+            audio_vae=self.audio_vae,
+            emit_conditioning=self._component_leader,
+        )
+
+    @staticmethod
+    def _has_encoder_input(info: object) -> bool:
+        if not isinstance(info, Mapping):
+            return False
+        meta = info.get("meta")
+        return isinstance(meta, Mapping) and isinstance(meta.get(MINIMAX_H3_ENCODER_REQUEST_KEY), Mapping)
+
+    def make_omni_output(
+        self,
+        model_outputs: torch.Tensor | OmniOutput,
+        **kwargs: Any,
+    ) -> OmniOutput:
+        output = super().make_omni_output(model_outputs, **kwargs)
+        infos = kwargs.get("model_intermediate_buffer") or []
+        if not isinstance(infos, Sequence) or not infos:
+            return output
+        sample_eligible = kwargs.get("request_sample_eligible")
+        if sample_eligible is None:
+            sample_eligible = [True] * len(infos)
+        if len(sample_eligible) != len(infos):
+            raise RuntimeError(
+                f"MiniMax H3 unified encoder received {len(sample_eligible)} sampling flags for {len(infos)} requests"
+            )
+        per_request: list[tuple[torch.Tensor, torch.Tensor, torch.Tensor] | None] = []
+        release_workspace = False
+        for eligible, info in zip(sample_eligible, infos, strict=True):
+            if not eligible:
+                per_request.append(None)
+                continue
+            if not isinstance(info, dict) or not self._has_encoder_input(info):
+                raise RuntimeError("MiniMax H3 unified encoder request metadata is missing from the runner")
+            release_workspace = True
+            if _MEDIA_CONDITIONING_CACHE_KEY not in info:
+                info[_MEDIA_CONDITIONING_CACHE_KEY] = self._encode_media(self._media_input(info))
+            if not self._component_leader:
+                continue
+            cached = info.get(_MEDIA_CONDITIONING_CACHE_KEY)
+            if not isinstance(cached, MiniMaxH3EncoderMediaConditioning):
+                raise RuntimeError("MiniMax H3 encoder components did not produce conditioning")
+            per_request.append(cached.to_omni_components())
+
+        if release_workspace:
+            torch.accelerator.empty_cache()
+        if not self._component_leader:
+            return output
+
+        if not any(item is not None for item in per_request):
+            return output
+        empty = torch.empty((0,), dtype=torch.float32)
+        multimodal_outputs = dict(output.multimodal_outputs or {})
+        dotted_key = f"kv_metadata.{MINIMAX_H3_ENCODER_LAYOUT_KEY}"
+        multimodal_outputs[dotted_key] = [
+            item[2] if item is not None else torch.empty((0,), dtype=torch.int64) for item in per_request
+        ]
+
+        embed = dict(multimodal_outputs.get("embed") or {})
+        embed["embedding"] = [item[0] if item is not None else empty for item in per_request]
+        embed["speech_feat"] = [item[1] if item is not None else empty for item in per_request]
+        multimodal_outputs["embed"] = embed
+        return OmniOutput(
+            text_hidden_states=output.text_hidden_states,
+            multimodal_outputs=multimodal_outputs,
+            intermediate_tensors=output.intermediate_tensors,
+            next_token_id=output.next_token_id,
+        )
+
+    def load_weights(
+        self,
+        weights: Iterable[tuple[str, torch.Tensor]],
+    ) -> set[str]:
+        loaded = super().load_weights(weights)
+        for component_name in ("video_vae", "audio_vae"):
+            component = getattr(self, component_name)
+            if component is not None:
+                loaded.update(f"{component_name}.{name}" for name, _ in component.named_parameters())
+        return loaded
+
+
+__all__ = ["MiniMaxH3Encoder"]
diff --git a/vllm_omni/model_executor/models/minimax_h3/encoder_processing.py b/vllm_omni/model_executor/models/minimax_h3/encoder_processing.py
new file mode 100644
index 000000000..7ea4db459
--- /dev/null
+++ b/vllm_omni/model_executor/models/minimax_h3/encoder_processing.py
@@ -0,0 +1,810 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Shared request preparation and condition codec execution for MiniMax H3."""
+
+from __future__ import annotations
+
+import math
+import os
+import subprocess
+import tempfile
+from collections.abc import Callable, Mapping, Sequence
+from contextlib import AbstractContextManager, nullcontext
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+import torch
+from PIL import Image
+
+from vllm_omni.errors import OmniClientError
+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,
+    resolve_minimax_h3_aspect_ratio,
+    resolve_minimax_h3_output_canvas,
+    resolve_minimax_h3_reference_image_shape,
+)
+from vllm_omni.model_executor.models.minimax_h3.reference_video import (
+    MINIMAX_H3_QWEN_VIDEO_SAMPLE_FPS,
+    load_audio_file,
+    load_video_audio,
+    load_video_frames,
+    prepare_edit_video,
+    prepare_reference_videos,
+    sample_reference_video_frames,
+    validate_reference_audio_files,
+    validate_reference_audio_waveforms,
+)
+
+MINIMAX_H3_FPS = 24
+MINIMAX_H3_MIN_OUTPUT_SECONDS = 4.0
+MINIMAX_H3_MAX_OUTPUT_SECONDS = 15.0
+
+
+def _items(value: Any) -> list[Any]:
+    if value is None:
+        return []
+    if isinstance(value, list):
+        return value
+    if isinstance(value, tuple) and not (len(value) == 2 and isinstance(value[1], Mapping)):
+        return list(value)
+    return [value]
+
+
+def _audio_items(value: Any) -> list[Any]:
+    if value is None:
+        return []
+    if isinstance(value, (list, tuple)) and len(value) == 2 and isinstance(value[1], (int, np.integer)):
+        return [value]
+    return list(value) if isinstance(value, (list, tuple)) else [value]
+
+
+def _load_audio(value: Any) -> tuple[torch.Tensor, int]:
+    if isinstance(value, (list, tuple)) and not (len(value) == 2 and isinstance(value[1], (int, np.integer))):
+        audios = _load_audios(value)
+        if len(audios) != 1:
+            raise OmniClientError(f"MiniMax H3 expected one audio, got {len(audios)}")
+        return audios[0]
+    if isinstance(value, (str, os.PathLike)):
+        return load_audio_file(str(value))
+    if isinstance(value, (list, tuple)) and len(value) == 2:
+        waveform, sample_rate = value
+        return torch.as_tensor(waveform).float(), int(sample_rate)
+    if isinstance(value, dict):
+        waveform = value.get("waveform", value.get("array"))
+        sample_rate = value.get("sample_rate", value.get("sampling_rate"))
+        if waveform is not None and sample_rate is not None:
+            return torch.as_tensor(waveform).float(), int(sample_rate)
+    raise OmniClientError("MiniMax H3 audio input must be a path, (waveform, sample_rate), or a waveform mapping")
+
+
+def _load_audios(value: Any) -> list[tuple[torch.Tensor, int]]:
+    if isinstance(value, (list, tuple)) and not (len(value) == 2 and isinstance(value[1], (int, np.integer))):
+        if not value:
+            raise OmniClientError("MiniMax H3 audio input must not be empty")
+        return [_load_audio(item) for item in value]
+    return [_load_audio(value)]
+
+
+def _as_int_list(value: Any, *, name: str) -> list[int]:
+    if isinstance(value, bool):
+        raise OmniClientError(f"{name} must be an integer or a list of integers")
+    if isinstance(value, (int, np.integer)):
+        return [int(value)]
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
+        result = list(value)
+        if not result:
+            raise OmniClientError(f"{name} must not be empty")
+        if any(isinstance(item, bool) or not isinstance(item, (int, np.integer)) for item in result):
+            raise OmniClientError(f"{name} must contain only integers")
+        return [int(item) for item in result]
+    raise OmniClientError(f"{name} must be an integer or a list of integers")
+
+
+def _resolve_fl2va_keyframe_indices(extra: Mapping[str, Any], image_count: int) -> list[int]:
+    target = extra.get("target")
+    target = target if isinstance(target, Mapping) else {}
+    raw = extra.get("frame_indices", extra.get("frame_index"))
+    if raw is None:
+        raw = target.get("frame_indices", target.get("frame_index"))
+    raw_indices = ([0] if image_count == 1 else [0, -1]) if raw is None else _as_int_list(raw, name="frame_indices")
+    if len(raw_indices) != image_count:
+        raise OmniClientError(
+            f"MiniMax H3 FL2VA requires one frame index per image: got {raw_indices!r} for {image_count} image(s)"
+        )
+    if tuple(raw_indices) not in ((0,), (-1,), (0, -1)):
+        raise OmniClientError("MiniMax H3 FL2VA frame_indices must be [0], [-1], or [0, -1]")
+    return raw_indices
+
+
+def _validate_ref2va_reference_counts(image_count: int, video_count: int, audio_count: int) -> None:
+    if min(image_count, video_count, audio_count) < 0:
+        raise OmniClientError("MiniMax H3 reference counts must be non-negative")
+    if image_count + video_count == 0:
+        raise OmniClientError("ref2va requires at least one image or video reference")
+    if image_count > 9:
+        raise OmniClientError("ref2va accepts at most 9 image references")
+    if video_count > 3:
+        raise OmniClientError("ref2va accepts at most 3 video references")
+    if audio_count > 3:
+        raise OmniClientError("ref2va accepts at most 3 standalone audio references")
+    if image_count + video_count + audio_count > 12:
+        raise OmniClientError("ref2va accepts at most 12 total references")
+
+
+def _validate_reference_image(image: Image.Image) -> None:
+    resolve_minimax_h3_reference_image_shape(image)
+
+
+def resolve_minimax_h3_shape(
+    task: str,
+    sampling: Any,
+    image: Image.Image | None,
+) -> tuple[int, int, int, int, int]:
+    # The diffusion package exports a pipeline that imports this shared module.
+    from vllm_omni.diffusion.models.minimax_h3.time_request import (
+        MINIMAX_H3_SHAPE_PLANNER,
+        minimax_h3_align_frame_count,
+    )
+
+    fps = int(getattr(sampling, "fps", None) or MINIMAX_H3_FPS)
+    if fps != MINIMAX_H3_FPS:
+        raise OmniClientError(f"MiniMax H3 output fps is fixed at {MINIMAX_H3_FPS}")
+    extra = sampling.extra_args or {}
+    target = extra.get("target")
+    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 {duration_range}, got {duration!r}")
+        try:
+            duration = float(duration)
+        except (TypeError, ValueError) as exc:
+            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 <= 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)
+    width = getattr(sampling, "width", None)
+    aspect_ratio = resolve_minimax_h3_aspect_ratio(
+        task,
+        target.get("aspect_ratio", extra.get("aspect_ratio")),
+        image,
+    )
+    raw_short_edge = target.get("short_edge", extra.get("short_edge", MINIMAX_H3_OUTPUT_SHORT_EDGE))
+    if isinstance(raw_short_edge, bool) or not isinstance(raw_short_edge, (int, np.integer)):
+        raise OmniClientError(
+            f"MiniMax H3 target.short_edge must be {MINIMAX_H3_OUTPUT_SHORT_EDGE}, got {raw_short_edge!r}"
+        )
+    if height is None or width is None:
+        height, width = resolve_minimax_h3_output_canvas(aspect_ratio, int(raw_short_edge))
+    height = int(height) // 32 * 32
+    width = int(width) // 32 * 32
+    if min(height, width) <= 0:
+        raise OmniClientError(f"invalid MiniMax H3 canvas {width}x{height}")
+    if width > 4 * height or height > 4 * width:
+        raise OmniClientError("MiniMax H3 canvas aspect ratio must be in [1:4, 4:1]")
+    return (
+        height,
+        width,
+        num_frames,
+        MINIMAX_H3_SHAPE_PLANNER.video_latent_t(num_frames),
+        MINIMAX_H3_SHAPE_PLANNER.audio_latent_t(num_frames / fps),
+    )
+
+
+def _resolve_task(
+    extra_args: Mapping[str, Any],
+    multi_modal_data: Mapping[str, Any],
+) -> str:
+    requested = extra_args.get("task")
+    if requested is not None:
+        return str(requested).lower()
+    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"
+    return "t2va"
+
+
+def _prepare_encoder_images(
+    task: str,
+    images: list[Image.Image],
+    *,
+    height: int,
+    width: int,
+) -> list[Any]:
+    if not images:
+        return []
+    if task == "ref2va":
+        return [
+            image.resize(
+                resolve_minimax_h3_reference_image_shape(image),
+                Image.Resampling.LANCZOS,
+            )
+            for image in images
+        ]
+    if task != "fl2va":
+        return images
+    return [image.resize((width, height), Image.Resampling.LANCZOS) for image in images]
+
+
+def _image_to_tensor(image: Image.Image) -> torch.Tensor:
+    array = np.asarray(image.convert("RGB"), dtype=np.uint8)
+    return torch.from_numpy(np.array(array, copy=True)).contiguous()
+
+
+def _frames_to_tensor(frames: Sequence[Any]) -> torch.Tensor:
+    if len(frames) == 0:
+        raise ValueError("MiniMax H3 reference video must contain frames")
+    return torch.stack(
+        [
+            _image_to_tensor(frame if isinstance(frame, Image.Image) else Image.fromarray(np.asarray(frame)))
+            for frame in frames
+        ]
+    )
+
+
+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,
+    *,
+    expected_count: int,
+) -> list[dict[str, Any]] | None:
+    if prepared is None:
+        return None
+    if len(prepared) != expected_count:
+        raise OmniClientError("MiniMax H3 prepared-reference-video count does not match the request")
+    for item in prepared:
+        if not os.path.isfile(item["prepared_path"]):
+            raise OmniClientError(f"MiniMax H3 prepared reference video is unavailable: {item['prepared_path']}")
+    return prepared
+
+
+@dataclass(frozen=True)
+class PreparedEncoderInputs:
+    """CPU-owned media and Qwen presentation inputs, independent of a runner."""
+
+    prompt: str
+    media: MiniMaxH3EncoderMediaInput
+    images: list[Image.Image]
+    qwen_videos: list[tuple[np.ndarray, dict[str, Any]]]
+    video_timestamps: list[list[float]]
+    condition_labels: list[tuple[str, int]]
+
+
+def _effective_audio_inputs(
+    video_audios: Sequence[tuple[torch.Tensor, int] | None],
+    standalone_audios: Sequence[tuple[torch.Tensor, int]],
+    *,
+    max_standalone_seconds: float,
+) -> list[tuple[torch.Tensor, int]]:
+    """Return the waveforms exactly as the audio WVAE will consume them."""
+    audio_inputs = [item for item in video_audios if item is not None]
+    audio_inputs.extend(
+        (waveform[..., : int(round(max_standalone_seconds * sample_rate))], sample_rate)
+        for waveform, sample_rate in standalone_audios
+    )
+    return audio_inputs
+
+
+def prepare_encoder_inputs(
+    prompt: Any,
+    sampling: Any,
+    *,
+    task: str | None = None,
+    prepared_reference_videos: list[dict[str, Any]] | None = None,
+) -> PreparedEncoderInputs:
+    """Decode references once and prepare the shared text/codec presentation."""
+    if isinstance(prompt, str):
+        prompt = {"prompt": prompt}
+    if not isinstance(prompt, dict):
+        raise TypeError(f"MiniMax H3 expects a string or dict prompt, got {type(prompt)!r}")
+
+    text = str(prompt.get("prompt") or "")
+    if not text:
+        raise OmniClientError("MiniMax H3 requires a non-empty prompt")
+    multi_modal_data = prompt.get("multi_modal_data") or {}
+    if not isinstance(multi_modal_data, Mapping):
+        raise TypeError("multi_modal_data must be a mapping")
+
+    image_values = _items(multi_modal_data.get("image"))
+    videos = _items(multi_modal_data.get("video"))
+    raw_audio = multi_modal_data.get("audio")
+    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 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 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")
+        for image in raw_images:
+            _validate_reference_image(image)
+    elif task == "ref2va":
+        _validate_ref2va_reference_counts(len(raw_images), len(videos), len(audio_values))
+        if not raw_images and not videos:
+            raise OmniClientError("ref2va requires an image or video condition")
+    else:
+        raise OmniClientError(f"unsupported MiniMax H3 task {task!r}")
+
+    height, width, num_frames, latent_t, audio_t = resolve_minimax_h3_shape(
+        task,
+        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,
+        height=height,
+        width=width,
+    )
+    keyframe_indices = _resolve_fl2va_keyframe_indices(extra_args, len(images)) if task == "fl2va" else []
+    video_timestamps: list[list[float]] = []
+    qwen_video_inputs: list[tuple[np.ndarray, dict[str, Any]]] = []
+    condition_labels: list[tuple[str, int]] = []
+    encoded_video_inputs: list[torch.Tensor] = []
+    video_audio_inputs: list[tuple[torch.Tensor, int] | None] = []
+
+    if task == "fl2va":
+        condition_labels.extend(("image", index) for index in range(1, len(images) + 1))
+    elif task == "ref2va":
+        condition_labels.extend(("image", index) for index in range(1, len(images) + 1))
+        prepared_videos: list[dict[str, Any]] = []
+        if videos:
+            with tempfile.TemporaryDirectory(prefix="minimax_h3_encoder_") as workdir:
+                prepared_videos = _reuse_prepared_reference_videos(
+                    prepared_reference_videos, expected_count=len(videos)
+                )
+                if prepared_videos is None:
+                    prepared_videos = prepare_reference_videos(
+                        videos,
+                        target_frame_count=num_frames,
+                        workdir=workdir,
+                        start_time_seconds=extra_args.get("start_time_seconds"),
+                    )
+                for item in prepared_videos:
+                    full_frames = load_video_frames(item["prepared_path"])
+                    encoded_video_inputs.append(_frames_to_tensor(full_frames))
+                    sampled = sample_reference_video_frames(
+                        item["prepared_path"],
+                        decoded_frames=full_frames,
+                    )
+                    video_timestamps.append(sampled["block_timestamps"])
+                    frames = np.stack(sampled["frames"])
+                    frame_count = int(frames.shape[0])
+                    qwen_video_inputs.append(
+                        (
+                            frames,
+                            {
+                                "total_num_frames": frame_count,
+                                "fps": MINIMAX_H3_QWEN_VIDEO_SAMPLE_FPS,
+                                "duration": frame_count / MINIMAX_H3_QWEN_VIDEO_SAMPLE_FPS,
+                                "video_backend": "minimax_h3",
+                                "frames_indices": list(range(frame_count)),
+                                "do_sample_frames": False,
+                            },
+                        )
+                    )
+                    if item["input_has_audio"]:
+                        waveform, sample_rate = load_video_audio(
+                            item["original_path"],
+                            start_time_seconds=float(item.get("start_time_seconds", 0.0)),
+                            duration_seconds=item.get(
+                                "audio_duration_seconds",
+                                item.get("duration_seconds"),
+                            ),
+                        )
+                        video_audio_inputs.append((waveform.float().contiguous(), int(sample_rate)))
+                    else:
+                        video_audio_inputs.append(None)
+        audio_index = 0
+        for video_index, item in enumerate(prepared_videos, start=1):
+            if item["input_has_audio"]:
+                audio_index += 1
+                condition_labels.append(("audio", audio_index))
+            condition_labels.append(("video", video_index))
+        for _ in [] if lock_audio else audio_values:
+            audio_index += 1
+            condition_labels.append(("audio", audio_index))
+
+    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 []
+    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,
+        width=width,
+        num_frames=num_frames,
+        latent_t=latent_t,
+        audio_t=audio_t,
+        images=tuple(_image_to_tensor(image) for image in images),
+        videos=tuple(encoded_video_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,
+        media_input.audios,
+        max_standalone_seconds=float(media_input.num_frames) / MINIMAX_H3_FPS,
+    )
+    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])
+    if not lock_audio:
+        validate_reference_audio_waveforms(audio_inputs[embedded_audio_count:])
+
+    return PreparedEncoderInputs(
+        prompt=text,
+        media=media_input,
+        images=images,
+        qwen_videos=qwen_video_inputs,
+        video_timestamps=video_timestamps,
+        condition_labels=condition_labels,
+    )
+
+
+def _image_from_tensor(value: torch.Tensor) -> Image.Image:
+    if value.ndim != 3 or value.shape[-1] != 3:
+        raise ValueError(f"MiniMax H3 image tensor must have shape [H, W, 3], got {tuple(value.shape)}")
+    array = value.detach().cpu().to(torch.uint8).contiguous().numpy()
+    return Image.fromarray(array, mode="RGB")
+
+
+def encode_media(
+    media: MiniMaxH3EncoderMediaInput,
+    *,
+    video_vae: Any,
+    audio_vae: Any,
+    emit_conditioning: bool,
+    component_scope: Callable[[Any], AbstractContextManager[Any]] = nullcontext,
+) -> MiniMaxH3EncoderMediaConditioning | None:
+    """Run codecs on participating ranks; only the output rank runs audio.
+
+    The caller selects participating ranks and configures the VAE process group.
+    Every visual participant must call this function with the same references.
+    Component scopes allow the diffusion runner to stage one codec at a time.
+    """
+    visual_rows: list[torch.Tensor] = []
+    visual_shapes: list[tuple[int, int, int]] = []
+    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):
+            for value in media.images:
+                image = _image_from_tensor(value)
+                visual_rows.append(video_vae.encode_image(image))
+                visual_shapes.append((1, image.height // 16, image.width // 16))
+            for value in media.videos:
+                frames = np.asarray(value.detach().cpu().to(torch.uint8).contiguous().numpy())
+                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 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):
+            for waveform, sample_rate in audio_inputs:
+                rows, length = audio_vae.encode_waveform(waveform, sample_rate)
+                audio_rows.append(rows)
+                audio_lengths.append(int(length))
+            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(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]] = []
+    image_shapes = visual_shapes[: len(media.images)]
+    video_shapes = visual_shapes[len(media.images) :]
+    ref_blocks.extend({"kind": "image", "latent_h": shape[1], "latent_w": shape[2]} for shape in image_shapes)
+    embedded_lengths = iter(audio_lengths[:embedded_audio_count])
+    for shape, embedded in zip(video_shapes, media.video_audios, strict=True):
+        ref_audio_t = int(next(embedded_lengths)) if embedded is not None else 0
+        ref_blocks.append(
+            {
+                "kind": "video_audio" if ref_audio_t else "video",
+                "ref_audio_t": ref_audio_t,
+                "latent_t": shape[0],
+                "latent_h": shape[1],
+                "latent_w": shape[2],
+            }
+        )
+    ref_blocks.extend(
+        {
+            "kind": "audio",
+            "ref_audio_t": int(length),
+        }
+        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,
+        width=media.width,
+        num_frames=media.num_frames,
+        latent_t=media.latent_t,
+        audio_t=media.audio_t,
+        visual_condition=torch.cat(visual_rows) if visual_rows else None,
+        visual_condition_shapes=tuple(visual_shapes),
+        audio_condition=torch.cat(audio_rows) if audio_rows else None,
+        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/pipeline.py b/vllm_omni/model_executor/models/minimax_h3/pipeline.py
index 5ac94b5ee..085e2508a 100644
--- a/vllm_omni/model_executor/models/minimax_h3/pipeline.py
+++ b/vllm_omni/model_executor/models/minimax_h3/pipeline.py
@@ -16,18 +16,18 @@ MINIMAX_H3_PIPELINE = PipelineConfig(
     model_type="minimax_h3_disaggregated",
     default_deploy_config_name="minimax_h3_disaggregated.yaml",
     stage_cli_aliases={"text_encoder_tp_size": (0, "tensor_parallel_size")},
-    model_arch="MiniMaxH3TextEncoder",
+    model_arch="MiniMaxH3Encoder",
     stages=(
         StagePipelineConfig(
             stage_id=0,
-            model_stage="text_encoder",
+            model_stage="encoder",
             execution_type=StageExecutionType.LLM_AR,
             input_sources=(),
             owns_tokenizer=True,
             requires_multimodal_data=True,
-            model_arch="MiniMaxH3TextEncoder",
+            model_arch="MiniMaxH3Encoder",
             engine_output_type="latent",
-            prompt_transform_func=f"{_PROCESSOR}.prepare_text_encoder_prompt",
+            prompt_transform_func=f"{_PROCESSOR}.prepare_encoder_prompt",
             sampling_constraints={
                 "max_tokens": 1,
                 "temperature": 0.0,
@@ -42,9 +42,9 @@ MINIMAX_H3_PIPELINE = PipelineConfig(
             input_sources=(0,),
             final_output=True,
             final_output_type="video",
-            requires_multimodal_data=True,
+            requires_multimodal_data=False,
             model_arch="MiniMaxH3Pipeline",
-            custom_process_input_func=f"{_PROCESSOR}.text_encoder2diffusion",
+            custom_process_input_func=f"{_PROCESSOR}.encoder2diffusion",
             omni_kv_config={"need_recv_cache": False},
             model_path_resolver=f"{_DIFFUSION_PIPELINE}.resolve_minimax_h3_diffusion_model_path",
             inline_diffusion=True,
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 4f98d9e13..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,
     *,
@@ -531,14 +577,27 @@ def _decode_video_frames_ffmpeg(
     )
 
 
-def sample_reference_video_frames(prepared_path: str) -> dict[str, Any]:
-    meta = _probe_video(prepared_path)
+def sample_reference_video_frames(
+    prepared_path: str,
+    *,
+    decoded_frames: np.ndarray | None = None,
+) -> dict[str, Any]:
+    if decoded_frames is None:
+        meta = _probe_video(prepared_path)
+        frame_count = int(meta["frame_count"])
+    else:
+        decoded_frames = np.asarray(decoded_frames)
+        if decoded_frames.ndim != 4 or decoded_frames.shape[-1] != 3 or len(decoded_frames) <= 0:
+            raise OmniClientError(
+                f"decoded reference video frames must have shape [T, H, W, 3], got {decoded_frames.shape}"
+            )
+        frame_count = len(decoded_frames)
     ratio = MINIMAX_H3_FPS / MINIMAX_H3_QWEN_VIDEO_SAMPLE_FPS
     indices: list[int] = []
     cursor = 0.0
     while True:
         frame_index = int(round(cursor))
-        if frame_index >= meta["frame_count"]:
+        if frame_index >= frame_count:
             break
         if not indices or frame_index > indices[-1]:
             indices.append(frame_index)
@@ -546,16 +605,16 @@ def sample_reference_video_frames(prepared_path: str) -> dict[str, Any]:
     if not indices:
         raise OmniClientError(f"no frames sampled from {prepared_path}")
 
-    # The preparation step emits a lossless RGB stream. Decode only the sampled
-    # frames in one ffmpeg process so Qwen3VL sees the exact prepared pixels
-    # without decoding the entire high-bitrate stream into host memory.
-    decoded_frames = _decode_video_frames_ffmpeg(
-        prepared_path,
-        frame_count=int(meta["frame_count"]),
-        indices=indices,
-        width=meta["width"],
-        height=meta["height"],
-    )
+    if decoded_frames is None:
+        decoded_frames = _decode_video_frames_ffmpeg(
+            prepared_path,
+            frame_count=frame_count,
+            indices=indices,
+            width=meta["width"],
+            height=meta["height"],
+        )
+    else:
+        decoded_frames = decoded_frames[indices]
     frames = [np.asarray(frame) for frame in decoded_frames]
 
     timestamps = [index / MINIMAX_H3_QWEN_VIDEO_SAMPLE_FPS for index in range(len(indices))]
@@ -661,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/minimax_h3/text_encoder.py b/vllm_omni/model_executor/models/minimax_h3/text_encoder.py
index b1933af95..9ae74036e 100644
--- a/vllm_omni/model_executor/models/minimax_h3/text_encoder.py
+++ b/vllm_omni/model_executor/models/minimax_h3/text_encoder.py
@@ -176,7 +176,7 @@ class _ResidualMerge(nn.Module):
     info=Qwen3VLProcessingInfo,
     dummy_inputs=Qwen3VLDummyInputsBuilder,
 )
-class MiniMaxH3TextEncoder(Qwen3VLForConditionalGeneration):
+class MiniMaxH3TextEncoderBackbone(Qwen3VLForConditionalGeneration):
     """Qwen3-VL encoder used by MiniMax H3.
 
     MiniMax H3 consumes the residual stream after decoder layer 50.  The
@@ -305,3 +305,6 @@ class MiniMaxH3TextEncoder(Qwen3VLForConditionalGeneration):
             encoder_weights(),
             mapper=self.hf_to_vllm_mapper,
         )
+
+
+MiniMaxH3TextEncoder = MiniMaxH3TextEncoderBackbone
diff --git a/vllm_omni/model_executor/models/minimax_music3/dit.py b/vllm_omni/model_executor/models/minimax_music3/dit.py
index cf180ac52..1e7af63fc 100644
--- a/vllm_omni/model_executor/models/minimax_music3/dit.py
+++ b/vllm_omni/model_executor/models/minimax_music3/dit.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
 """Condition encoder and flow-matching transformer for MiniMax Music 3.
 
 Stage 1 turns the AR stage's conditioning frames into a DAC latent in two
@@ -16,13 +16,13 @@ a single ``to_qkv`` so each block runs one GEMM instead of three.
 :func:`remap_transformer_state` performs that fusion, and is the only place
 the checkpoint's layout is reinterpreted.
 
-Attention runs through the project's own diffusion attention layer, so this
-model picks up the same backend selection, sequence-parallel plumbing and
-KV-quant policy as every other transformer in the tree. That layer resolves
-its backend from the diffusion config, which an ``LLM_GENERATION`` stage such
-as this one does not set; it tolerates that and falls through to the platform
-default. If it cannot be built at all the block runs plain SDPA instead, a
-choice made once when the blocks are built and never inside ``forward``.
+Attention uses the project's diffusion attention layer when its selected
+backend supports the runtime dtype. This ``LLM_GENERATION`` stage does not set
+a diffusion backend and therefore gets the platform default. CUDA commonly
+resolves that default to FlashAttention, cuDNN, or FlashInfer, so the model
+routes its native float32 decode through SDPA while retaining the selected
+backend for supported lower-precision inputs. An explicitly selected backend
+remains authoritative.
 """
 
 from __future__ import annotations
@@ -75,6 +75,19 @@ _TRANSFORMER_IN_DIM = DIT_LATENT_CHANNELS * 2 + _CONDITION_DIM
 # reaches exactly zero, so the noise term never fully vanishes.
 _SIGMA_FLOOR = 1e-6
 
+# These backends reject float32 Q/K/V. MiniMax Music 3 decodes in float32, so
+# automatically selected incompatible backends must not receive its attention
+# tensors. This includes cuDNN and FlashInfer selected on Blackwell. Explicit
+# backend choices retain the shared layer's fail-fast contract instead of
+# being silently replaced here.
+_FLOAT32_UNSUPPORTED_BACKENDS = {
+    "FLASH_ATTN",
+    "FLASH_ATTN_HUB",
+    "FLASH_ATTN_3_HUB",
+    "CUDNN_ATTN",
+    "FLASHINFER_ATTN",
+}
+
 
 class FourierFeatures(nn.Module):
     """Random-Fourier timestep features: ``[B, 1] -> [B, out_features]``."""
@@ -149,10 +162,7 @@ def _build_native_attention(*, num_heads: int, head_size: int, softmax_scale: fl
     except Exception as exc:  # noqa: BLE001 - any failure means: use SDPA
         _NATIVE_ATTENTION_UNAVAILABLE = repr(exc)
         logger.warning(
-            "MiniMax Music 3 DiT could not build the diffusion attention layer "
-            "(%s); running torch SDPA instead. The stage decodes in float32, "
-            "for which the diffusion layer dispatches to SDPA anyway, so this "
-            "changes performance bookkeeping and not the audio.",
+            "MiniMax Music 3 DiT could not build the diffusion attention layer (%s); running torch SDPA instead.",
             exc,
         )
         return None
@@ -180,10 +190,19 @@ class Attention(nn.Module):
             softmax_scale=self.softmax_scale,
             prefix=prefix,
         )
-        self.backend_name = self.backend.attn_backend.get_name() if self.backend is not None else "TORCH_SDPA"
+        native_backend_name = self.backend.attn_backend.get_name() if self.backend is not None else None
+        self._auto_float32_sdpa = (
+            self.backend is not None
+            and not getattr(self.backend, "backend_explicit", False)
+            and native_backend_name in _FLOAT32_UNSUPPORTED_BACKENDS
+        )
+        if self._auto_float32_sdpa:
+            self.backend_name = f"TORCH_SDPA(float32)/{native_backend_name}(lower precision)"
+        else:
+            self.backend_name = native_backend_name or "TORCH_SDPA"
 
     def _attend(self, q: Tensor, k: Tensor, v: Tensor) -> Tensor:
-        if self.backend is not None:
+        if self.backend is not None and not (q.dtype == torch.float32 and self._auto_float32_sdpa):
             return self.backend(q, k, v)
         q, k, v = (t.transpose(1, 2) for t in (q, k, v))
         out = F.scaled_dot_product_attention(q, k, v, is_causal=False, scale=self.softmax_scale)
diff --git a/vllm_omni/model_executor/models/model_local_kv.py b/vllm_omni/model_executor/models/model_local_kv.py
new file mode 100644
index 000000000..7328e9967
--- /dev/null
+++ b/vllm_omni/model_executor/models/model_local_kv.py
@@ -0,0 +1,347 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Declaration protocol for attention KV kept outside the paged manager.
+
+Several models hold their own attention KV as HuggingFace ``transformers`` cache
+objects rather than using the engine's paged KV manager. That memory is
+allocated after the profiling run that decides how much KV the engine may claim,
+so no per-stage footprint number accounts for it, and nothing catches a cache
+that silently stops working.
+
+This module lets a model *declare* what it holds. It describes; it never
+allocates. Allocation for the diffusion path is owned by the DiT KV manager
+(RFC #5244 / PR #6094) and this protocol must not grow into a second allocator.
+
+Why a runtime query rather than a static table: geometry is frequently not
+knowable until weights are loaded. ``ming_flash_omni``'s talker builds its cache
+from a ``Qwen2Config`` that comes from the checkpoint, so layers, kv-heads,
+head-dim and dtype simply do not exist in this repo. A table would have a hole
+in it; a post-load query does not.
+
+Why capacity is a resolved number rather than a formula: the four known caches
+are each bounded by a different mechanism -- a sliding window, a decode-loop
+trip count, an encoder frame limit, a hardcoded constant -- and not one of them
+is ``max_model_len``. Only the model knows its own bound.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+from enum import Enum
+from typing import Protocol, runtime_checkable
+
+import torch
+from vllm.logger import init_logger
+
+logger = init_logger(__name__)
+
+__all__ = [
+    "HasModelLocalKV",
+    "ModelLocalKVScope",
+    "ModelLocalKVSpec",
+    "RowDriver",
+    "collect_model_local_kv_specs",
+    "spec_from_hf_config",
+]
+
+
+class ModelLocalKVScope(str, Enum):
+    """How long one allocation lives.
+
+    Diagnostic only. Lifetime and size are independent: a per-call cache can be
+    the widest thing a model owns, and a process-lifetime one can be a single
+    row. ``ModelLocalKVSpec.rows`` carries the size; this carries only the
+    reader's mental model of when the memory appears and goes.
+    """
+
+    INVOCATION = "invocation"
+    """Dies when the call returns (e.g. a per-step working copy)."""
+
+    REQUEST = "request"
+    """Retained across steps of one request, released when it finishes."""
+
+    SESSION = "session"
+    """Outlives a request; belongs to a duplex/streaming session."""
+
+    MODEL = "model"
+    """Lives as long as the model (e.g. captured into a CUDA-graph pool)."""
+
+
+class RowDriver(str, Enum):
+    """What sets how many rows of a cache are live at peak.
+
+    Two values, because two are all the known caches need. A third belongs
+    here only when a model actually has a cache the engine widens by some
+    other number -- adding one speculatively costs a branch everywhere and
+    buys nothing.
+    """
+
+    FIXED = "fixed"
+    """A count the model controls: a captured-bucket sum, a serialized call path."""
+
+    MAX_NUM_SEQS = "max_num_seqs"
+    """One row per in-flight sequence. Only the engine knows the value."""
+
+
+@dataclass(frozen=True)
+class ModelLocalKVSpec:
+    """One declared KV allocation.
+
+    A model returns one entry per *distinct lifetime*, not per cache object: if
+    the same geometry exists as both a retained per-request cache and a
+    short-lived working copy, that is two entries.
+    """
+
+    name: str
+    layers: int
+    kv_heads: int
+    head_dim: int
+    dtype: torch.dtype
+
+    physical_capacity_positions: int
+    """Positions the tensor can physically hold.
+
+    Not the logical sequence position. A sliding-window cache truncates on every
+    write, so a stream of thousands of tokens may only ever occupy
+    ``sliding_window - 1`` slots.
+    """
+
+    capacity_source: str
+    """Free-text note on where the bound comes from, for diagnostics only.
+
+    Never branch on this. It exists so a reader can tell "71 because sliding
+    window" from "2048 because someone typed 2048", which is otherwise
+    invisible.
+    """
+
+    scope: ModelLocalKVScope
+    """How long one allocation lives. Diagnostic only.
+
+    Deliberately not the multiplier. An earlier revision derived scaling from
+    scope, which made every non-``MODEL`` cache multiply by ``max_num_seqs``.
+    That over-reported ming by that factor (its calls are serialized) and used
+    the wrong driver entirely for MiniCPM-o (duplex sessions, not sequences).
+    Lifetime does not imply replication topology; ``rows`` says what does.
+    """
+
+    rows: RowDriver
+    """What sets how many rows of this shape are live at peak.
+
+    A row is one batch entry's worth of the geometry above. Deliberately does
+    not distinguish "one allocation N rows wide" from "N allocations of one
+    row": those cost the same, and an earlier revision that tried to carry both
+    got the object topology wrong in three of four declarers. Bytes are what
+    this protocol reports; describe the layout in ``allocation_note``.
+
+    Required, because defaulting it silently understates every cache whose
+    multiplicity is not 1.
+    """
+
+    rows_fixed: int = 1
+    """The count, when ``rows`` is ``FIXED``. Ignored otherwise."""
+
+    rows_reason: str = ""
+    """Why ``rows_fixed`` is that number. Required when ``rows`` is ``FIXED``.
+
+    A bare constant cannot be reviewed. ``rows_fixed=1`` on a cache that looks
+    per-request is exactly the claim a reader has to be able to check.
+    """
+
+    allocation_note: str | None = None
+    """Optional detail such as "rebuilt per text segment". Diagnostic only."""
+
+    def __post_init__(self) -> None:
+        if self.rows is RowDriver.FIXED:
+            if self.rows_fixed < 1:
+                raise ValueError(f"rows_fixed must be >= 1, got {self.rows_fixed}")
+            if not self.rows_reason.strip():
+                raise ValueError("a FIXED row count needs rows_reason; an unexplained constant cannot be reviewed")
+
+    @property
+    def bytes_per_row(self) -> int:
+        """Bytes for a single batch row of this cache."""
+        return (
+            2  # K and V
+            * self.layers
+            * self.kv_heads
+            * self.head_dim
+            * self.physical_capacity_positions
+            * torch.empty((), dtype=self.dtype).element_size()
+        )
+
+    def row_count(self, max_num_seqs: int = 1) -> int:
+        """Rows live at peak, given the engine's concurrency."""
+        if self.rows is RowDriver.FIXED:
+            return self.rows_fixed
+        return max(1, max_num_seqs)
+
+    def peak_bytes(self, max_num_seqs: int = 1) -> int:
+        """Peak bytes once the engine's concurrency is known.
+
+        The model supplies geometry and names the driver; only the engine knows
+        the number behind it.
+        """
+        return self.bytes_per_row * self.row_count(max_num_seqs)
+
+
+def _resolve(config: object, candidates: Sequence[str], what: str) -> int:
+    for attr in candidates:
+        value = getattr(config, attr, None)
+        if value is not None:
+            return int(value)
+    raise ValueError(
+        f"Cannot determine {what} from {type(config).__name__}: tried "
+        f"{', '.join(candidates)}. Pass it explicitly to spec_from_hf_config()."
+    )
+
+
+def spec_from_hf_config(
+    config: object,
+    *,
+    name: str,
+    physical_capacity_positions: int,
+    capacity_source: str,
+    scope: ModelLocalKVScope,
+    dtype: torch.dtype,
+    rows: RowDriver,
+    rows_fixed: int = 1,
+    rows_reason: str = "",
+    allocation_note: str | None = None,
+    layers: int | None = None,
+    kv_heads: int | None = None,
+    head_dim: int | None = None,
+) -> ModelLocalKVSpec:
+    """Build a spec from the same config object the cache is built from.
+
+    Every known model-local cache is constructed from an HF config, so the
+    geometry half of a declaration is the same three lookups each time. Pass
+    ``config`` and this derives them; pass ``layers``/``kv_heads``/``head_dim``
+    explicitly to override when the config uses encoder-decoder naming or when
+    the built module is a more truthful source than the config.
+
+    Raises rather than guessing when an attribute is absent: a silently wrong
+    geometry would under-report, which is the failure this protocol exists to
+    prevent. ``rows`` is keyword-required for the same reason -- an earlier
+    revision defaulted the batch extent to 1 here while documenting it as
+    required on the dataclass, so every declarer that used this helper got the
+    default and the guarantee was decorative.
+    """
+    if layers is None:
+        layers = _resolve(config, ("num_hidden_layers", "encoder_layers", "num_layers"), "layer count")
+    if kv_heads is None:
+        kv_heads = _resolve(
+            config,
+            ("num_key_value_heads", "num_attention_heads", "encoder_attention_heads"),
+            "kv head count",
+        )
+    if head_dim is None:
+        explicit = getattr(config, "head_dim", None)
+        if explicit is not None:
+            head_dim = int(explicit)
+        else:
+            hidden = _resolve(config, ("hidden_size", "d_model"), "hidden size")
+            heads = _resolve(config, ("num_attention_heads", "encoder_attention_heads"), "attention head count")
+            head_dim = hidden // heads
+
+    return ModelLocalKVSpec(
+        name=name,
+        layers=layers,
+        kv_heads=kv_heads,
+        head_dim=head_dim,
+        dtype=dtype,
+        physical_capacity_positions=physical_capacity_positions,
+        capacity_source=capacity_source,
+        scope=scope,
+        rows=rows,
+        rows_fixed=rows_fixed,
+        rows_reason=rows_reason,
+        allocation_note=allocation_note,
+    )
+
+
+@runtime_checkable
+class HasModelLocalKV(Protocol):
+    """Implemented by whichever object owns the cache.
+
+    Implement it on the owner, not on the registered model. The owner is
+    usually several levels down (a codec decoder, a talker backbone), and
+    ``collect_model_local_kv_specs`` finds it by walking the module tree, so
+    no intermediate class has to forward anything.
+    """
+
+    def model_local_kv_specs(self) -> Sequence[ModelLocalKVSpec]: ...
+
+
+def _unwrap_to_module(model: object) -> object:
+    """Unwrap runner-side wrappers down to the real module tree.
+
+    ``vllm.compilation.cuda_graph.CUDAGraphWrapper`` is a plain callable, not
+    an ``nn.Module``, but its ``__getattr__`` forwards anything the runnable
+    has -- including ``named_modules``. So a check for ``named_modules`` does
+    not detect the wrapper, and the wrapper and its runnable both answer to the
+    same attributes. That matters twice over: it means walking the wrapper
+    happens to work, and it means a naive walk can enter the tree as both the
+    wrapper and the root module and count a root-level declarer twice.
+
+    Prefer the supported ``unwrap()`` accessor, which returns the runnable
+    directly.
+    """
+    seen: set[int] = set()
+    current = model
+    while current is not None and id(current) not in seen:
+        seen.add(id(current))
+        unwrap = getattr(current, "unwrap", None)
+        if not callable(unwrap):
+            return current
+        try:
+            nxt = unwrap()
+        except Exception:
+            return current
+        if nxt is None or nxt is current:
+            return current
+        current = nxt
+    return model
+
+
+def collect_model_local_kv_specs(model: object) -> list[tuple[str, ModelLocalKVSpec]]:
+    """Collect every declaration in a loaded model, with the owner's path.
+
+    Walks ``named_modules()`` because the cache owner is an inner module in all
+    known cases. Requiring each registered model to forward the call would put
+    the burden on classes that do not own a cache and would silently report
+    zero the moment someone forgot -- exactly the failure mode this is meant to
+    surface.
+
+    A raising declaration is logged and skipped rather than propagated:
+    reporting memory must not be able to break model load.
+    """
+    root = _unwrap_to_module(model)
+
+    owners: list[tuple[str, object]] = []
+    seen_ids: set[int] = set()
+    if isinstance(root, HasModelLocalKV):
+        owners.append(("", root))
+        seen_ids.add(id(root))
+
+    named_modules = getattr(root, "named_modules", None)
+    if callable(named_modules):
+        for path, module in named_modules():
+            if id(module) in seen_ids or not isinstance(module, HasModelLocalKV):
+                continue
+            seen_ids.add(id(module))
+            owners.append((path, module))
+
+    collected: list[tuple[str, ModelLocalKVSpec]] = []
+    for path, owner in owners:
+        try:
+            specs = owner.model_local_kv_specs()
+        except Exception:
+            logger.warning(
+                "model_local_kv_specs() raised on %s; skipping its declaration",
+                type(owner).__name__,
+                exc_info=True,
+            )
+            continue
+        collected.extend((path, spec) for spec in specs)
+    return collected
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/moss_tts_nano/modeling_moss_tts_nano.py b/vllm_omni/model_executor/models/moss_tts_nano/modeling_moss_tts_nano.py
index a0b31bdf2..49c254deb 100644
--- a/vllm_omni/model_executor/models/moss_tts_nano/modeling_moss_tts_nano.py
+++ b/vllm_omni/model_executor/models/moss_tts_nano/modeling_moss_tts_nano.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
 """MOSS-TTS-Nano single-stage model for vLLM-Omni.
 
 Runs in a single AR worker stage.  The 0.1B AR LM and the
@@ -160,6 +160,33 @@ def _pick(info: dict, key: str, default):
     return val if val is not None else default
 
 
+def _configure_attention_implementation(lm: nn.Module, device: torch.device) -> None:
+    if device.type == "cuda":
+        try:
+            import flash_attn  # noqa: F401
+
+            lm._set_attention_implementation("flash_attention_2")
+            logger.info("MOSS-TTS-Nano using flash_attention_2")
+        except ImportError:
+            lm._set_attention_implementation("sdpa")
+            logger.info("MOSS-TTS-Nano using sdpa (flash_attn not installed)")
+    else:
+        # The checkpoint defaults to flash_attention_2, whose external
+        # flash_attn package is CUDA-only. PyTorch SDPA is dispatched to the
+        # native backend on non-CUDA accelerators such as Ascend NPU.
+        lm._set_attention_implementation("sdpa")
+        logger.info("MOSS-TTS-Nano using sdpa on %s", device.type)
+
+
+def _validate_max_num_seqs(max_num_seqs: int) -> None:
+    if max_num_seqs != 1:
+        raise ValueError(
+            "MOSS-TTS-Nano currently requires max_num_seqs=1 because its "
+            "remote model and audio tokenizer share RNG and streaming decode "
+            "state across requests. Higher values can corrupt generated audio."
+        )
+
+
 class MossTTSNanoForGeneration(nn.Module):
     """Single-stage MOSS-TTS-Nano model with streaming audio output.
 
@@ -179,6 +206,7 @@ class MossTTSNanoForGeneration(nn.Module):
         self.vllm_config = vllm_config
         self.config = vllm_config.model_config.hf_config
         self.model_path: str = vllm_config.model_config.model
+        _validate_max_num_seqs(vllm_config.scheduler_config.max_num_seqs)
 
         # Eager construction (not in load_weights) -- see module docstring.
         _patch_torchaudio_load()
@@ -209,15 +237,7 @@ class MossTTSNanoForGeneration(nn.Module):
                 trust_remote_code=True,
                 torch_dtype=tts_dtype,
             )
-        if device.type == "cuda":
-            try:
-                import flash_attn  # noqa: F401
-
-                lm._set_attention_implementation("flash_attention_2")
-                logger.info("MOSS-TTS-Nano using flash_attention_2")
-            except ImportError:
-                lm._set_attention_implementation("sdpa")
-                logger.info("MOSS-TTS-Nano using sdpa (flash_attn not installed)")
+        _configure_attention_implementation(lm, device)
         lm.to(device=device)
         lm.eval()
 
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 6bbefceab..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)
 
@@ -1326,14 +1330,12 @@ class Qwen2_5OmniThinkerForConditionalGeneration(
         if multimodal_embeddings is None or is_multimodal is None:
             return super().embed_input_ids(input_ids)
 
-        inputs_embeds = self._embed_text_input_ids(
-            input_ids,
-            self.get_language_model().embed_input_ids,
-            is_multimodal=is_multimodal,
-        )
-
         if len(multimodal_embeddings) == 0:
-            return inputs_embeds
+            return self._embed_text_input_ids(
+                input_ids,
+                self.get_language_model().embed_input_ids,
+                is_multimodal=is_multimodal,
+            )
 
         # Check for audio-in-video: interleaved video and audio tokens
         # in the multimodal region. Only use the interleaved path when
@@ -1341,6 +1343,8 @@ class Qwen2_5OmniThinkerForConditionalGeneration(
         video_token_id = self.config.video_token_index
         audio_token_id = self.config.audio_token_index
 
+        # The interleaving check reads scalar positions in a Python loop.
+        # Keep its masks on CPU to avoid repeated CUDA synchronization.
         input_ids_cpu = input_ids.cpu()
         is_video = is_multimodal & (input_ids_cpu == video_token_id)
         is_audio = is_multimodal & (input_ids_cpu == audio_token_id)
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 a5856718d..f7542d3e3 100644
--- a/vllm_omni/model_executor/models/qwen3_omni/qwen3_omni.py
+++ b/vllm_omni/model_executor/models/qwen3_omni/qwen3_omni.py
@@ -34,6 +34,7 @@ from vllm.model_executor.models.qwen3_omni_moe_thinker import (
 from vllm.model_executor.models.utils import (
     WeightsMapper,
     init_vllm_registered_model,
+    make_empty_intermediate_tensors_factory,
     maybe_prefix,
 )
 from vllm.multimodal import MULTIMODAL_REGISTRY
@@ -53,6 +54,7 @@ from vllm_omni.model_executor.models.qwen3_omni.quantization import (
     apply_outer_quant_config_mapping,
 )
 from vllm_omni.model_executor.models.qwen3_omni.qwen3_omni_moe_thinker import (
+    PP_CAPTURE_PREFIX,
     Qwen3OmniMoeThinkerDummyInputsBuilder,
     Qwen3OmniMoeThinkerForConditionalGeneration,
     Qwen3OmniMoeThinkerMultiModalProcessor,
@@ -169,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
@@ -274,6 +276,18 @@ class Qwen3OmniMoeForConditionalGeneration(
         self.make_empty_intermediate_tensors = (
             self.thinker.make_empty_intermediate_tensors if self.model_stage == "thinker" else lambda: None
         )
+        if self.model_stage == "thinker":
+            capture_indices = self._thinker_capture_layer_indices()
+            start_layer = self.thinker.language_model.model.start_layer
+            incoming_captures = [f"{PP_CAPTURE_PREFIX}{index}" for index in capture_indices if index < start_layer]
+            if incoming_captures:
+                self.make_empty_intermediate_tensors = make_empty_intermediate_tensors_factory(
+                    ["hidden_states", "residual", *incoming_captures], thinker_config.text_config.hidden_size
+                )
+
+    def _thinker_capture_layer_indices(self) -> list[int]:
+        accept_layer = getattr(self.talker_config, "accept_hidden_layer", None)
+        return [0, int(accept_layer)] if self.is_staged_run and accept_layer is not None else []
 
     @classmethod
     async def buffer_realtime_audio(
@@ -441,11 +455,11 @@ class Qwen3OmniMoeForConditionalGeneration(
             # Only staged runs have a talker stage to consume the capture; in a
             # plain vLLM run capturing would waste a clone per layer per step
             # and make the thinker return a tuple stock vLLM cannot handle.
-            accept_layer = getattr(self.talker_config, "accept_hidden_layer", None)
+            capture_indices = self._thinker_capture_layer_indices()
             capture_kwargs = {}
-            if accept_layer is not None and self.is_staged_run:
+            if capture_indices:
                 capture_kwargs = {
-                    "capture_layer_indices": [0, int(accept_layer)],
+                    "capture_layer_indices": capture_indices,
                     "return_hidden_states": True,
                 }
 
diff --git a/vllm_omni/model_executor/models/qwen3_omni/qwen3_omni_code2wav.py b/vllm_omni/model_executor/models/qwen3_omni/qwen3_omni_code2wav.py
index 67352eecb..bc8f6b3b4 100644
--- a/vllm_omni/model_executor/models/qwen3_omni/qwen3_omni_code2wav.py
+++ b/vllm_omni/model_executor/models/qwen3_omni/qwen3_omni_code2wav.py
@@ -316,21 +316,16 @@ class Qwen3OmniMoeCode2Wav(nn.Module, Qwen3OmniNestedSupportsQuant):
         else:
             # Fallback: assume all batch elements share the same sequence length.
             code_seq_lens = [codes.shape[-1]] * codes.shape[0]
+        # The decoder trims the same right-edge tail from every batch row.
+        # Infer it from the decoded window, not a shorter request's length:
+        # padding that request with codec zeros does not provide valid context.
+        tail = max(0, int(codes.shape[-1] * self.total_upsample) - batch_wav.shape[-1])
         for idx, code_seq_len in enumerate(code_seq_lens):
-            # The eager decoder (self(codes)) emits a fixed `tail` fewer samples than
-            # code_seq_len*total_upsample: the causal conv stack trims the sequence end
-            # because it lacks right context. The original slice assumed full length, so
-            # under async_chunk every streaming chunk silently dropped its last `tail`
-            # samples -> a ~23ms gap at every chunk boundary + cumulative ~1.2% time
-            # compression. Shift the start back by `tail` so this chunk refills the gap the
-            # previous chunk left (those frames are re-decoded here with proper context).
-            # `tail` is measured per call, so this is a no-op only when the decoder returns
-            # the nominal full length (tail==0, e.g. a C==0 decoder like Qwen3-TTS); for
-            # Qwen3-Omni Code2Wav both the eager forward AND the CUDA-graph wrapper
-            # (_trim_replay_output -> actual*upsample - 555) are short, so it applies to both.
-            tail = max(0, int(code_seq_len * self.total_upsample) - batch_wav.shape[-1])
+            # Refill the previous chunk's tail using the re-decoded left context,
+            # and exclude the current row's padded tail just as singleton decode does.
             start = max(0, left_context_size[idx] * self.total_upsample - tail)
-            wav_chunk = batch_wav[idx, :, start : code_seq_len * self.total_upsample]
+            end = max(0, code_seq_len * self.total_upsample - tail)
+            wav_chunk = batch_wav[idx, :, start:end]
             wavs.append(wav_chunk)
         return wavs
 
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 b2a7d7abe..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
@@ -118,6 +118,7 @@ from vllm.multimodal.utils import set_mm_embedding_modality
 from vllm.sequence import IntermediateTensors
 from vllm.transformers_utils.processor import cached_processor_from_config
 
+from vllm_omni.data_entry_keys import OmniPayload
 from vllm_omni.model_executor.models.qwen2_5_omni.qwen2_5_omni_thinker import (
     Qwen2_5OmniConditionalGenerationMixin,
     Qwen2_5OmniThinkerMultiModalDataParser,
@@ -140,6 +141,8 @@ except (ImportError, ModuleNotFoundError):
 
 logger = init_logger(__name__)
 
+PP_CAPTURE_PREFIX = "capture_"
+
 _THINKER_ARCHITECTURE = "Qwen3OmniMoeThinkerForConditionalGeneration"
 
 
@@ -568,7 +571,15 @@ class Qwen3MoeLLMModel(_Qwen3MoeLLMModel):
             hidden_states = intermediate_tensors["hidden_states"]
             residual = intermediate_tensors["residual"]
         capture_set = set(capture_layer_indices) if capture_layer_indices else None
-        captured_hidden_states: dict[str, torch.Tensor] | None = {} if return_hidden_states else None
+        captured_hidden_states: OmniPayload | None = {} if return_hidden_states else None
+
+        if captured_hidden_states is not None and capture_set and intermediate_tensors is not None:
+            for layer_idx in capture_set:
+                if layer_idx < self.start_layer:
+                    hs = captured_hidden_states.setdefault("hidden_states", {})
+                    layers = hs.setdefault("layers", {})
+                    # Receive buffers are reused on the next step; retain an independent snapshot.
+                    layers[layer_idx] = intermediate_tensors[f"{PP_CAPTURE_PREFIX}{layer_idx}"].clone()
 
         for layer_idx, layer in enumerate(self.layers[self.start_layer : self.end_layer]):
             layer_idx = layer_idx + self.start_layer
@@ -577,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,
@@ -589,7 +603,15 @@ class Qwen3MoeLLMModel(_Qwen3MoeLLMModel):
                 hidden_states = hidden_states + deepstack_input_embeds[f"deepstack_input_embeds_{layer_idx}"]
 
         if not get_pp_group().is_last_rank:
-            return IntermediateTensors({"hidden_states": hidden_states, "residual": residual})
+            tensors = {"hidden_states": hidden_states, "residual": residual}
+            if captured_hidden_states:
+                tensors.update(
+                    {
+                        f"{PP_CAPTURE_PREFIX}{index}": value
+                        for index, value in captured_hidden_states["hidden_states"]["layers"].items()
+                    }
+                )
+            return IntermediateTensors(tensors)
         hidden_states, _ = self.norm(hidden_states, residual)
         if captured_hidden_states is not None:
             return hidden_states, captured_hidden_states
@@ -1251,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.
@@ -1273,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 = []
 
@@ -1321,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)
             )
@@ -1336,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 6dfe8736d..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``.
@@ -10,9 +10,23 @@ from vllm_omni.config.stage_config import (
     StageExecutionType,
     StagePipelineConfig,
 )
+from vllm_omni.outputs.output_modality import (
+    TensorAccumulationStrategy,
+    register_key_accumulation_strategy,
+)
 
 _PROC = "vllm_omni.model_executor.stage_input_processors.qwen3_tts"
 
+# The talker's codec-frame keys are not waveform chunks, so they must not go
+# through the AUDIO modality's waveform-tuned default (CONCAT_LAST) whenever
+# a stage carrying them consolidates its output under that modality (e.g. an
+# AUDIO-typed final stage that forwards them directly instead of routing
+# through code2wav): ``codes.audio`` grows one row per decode step along
+# dim 0, and ``codes.ref`` re-emits the constant reference-context matrix
+# unchanged at every step.
+register_key_accumulation_strategy("codes.audio", TensorAccumulationStrategy.CONCAT_DIM0)
+register_key_accumulation_strategy("codes.ref", TensorAccumulationStrategy.REPLACE)
+
 QWEN3_TTS_PIPELINE = PipelineConfig(
     model_type="qwen3_tts",
     default_deploy_config_name="qwen3_tts.yaml",
@@ -27,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,
@@ -42,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 f1692f73d..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),
@@ -499,7 +513,7 @@ class Qwen3TTSCode2Wav(nn.Module):
             if wav.numel() == 0:
                 continue
             if wav.shape[0] > 0:
-                # Decoder already runs in fp32, so the .to(float32) is a redundant dispatch.
+                # Return FP32 audio regardless of the decoder compute dtype.
                 audios[idx] = (wav if wav.dtype == torch.float32 else wav.to(torch.float32)).reshape(-1)
 
         for req_id, finished, segment_finished in zip(
@@ -560,7 +574,7 @@ class Qwen3TTSCode2Wav(nn.Module):
         )
 
         device = self.vllm_config.device_config.device
-        self.decoder.to(device=device, dtype=torch.float32)
+        self.decoder.to(device=device, dtype=self.vllm_config.model_config.dtype)
 
         # Precompute SnakeBeta exp caches (benefits both Triton and eager paths)
         if hasattr(self.decoder, "precompute_snake_caches"):
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/segmented_graph_wrapper.py b/vllm_omni/model_executor/models/qwen3_tts/segmented_graph_wrapper.py
index a1eb071ee..3c73f5d13 100644
--- a/vllm_omni/model_executor/models/qwen3_tts/segmented_graph_wrapper.py
+++ b/vllm_omni/model_executor/models/qwen3_tts/segmented_graph_wrapper.py
@@ -17,6 +17,13 @@ from transformers.cache_utils import DynamicCache
 from vllm.logger import init_logger
 from vllm.platforms import current_platform
 
+from vllm_omni.model_executor.models.model_local_kv import (
+    ModelLocalKVScope,
+    ModelLocalKVSpec,
+    RowDriver,
+    spec_from_hf_config,
+)
+
 logger = init_logger(__name__)
 
 
@@ -166,6 +173,85 @@ class CUDAGraphDecoderWrapper:
         if self._stats_log_every > 0 and self._stats_total_requests % self._stats_log_every == 0:
             self.log_decode_stats()
 
+    @staticmethod
+    def _retained_kv_caches(states: dict) -> list[tuple[int, DynamicCache]]:
+        """Find the KV caches a capture kept alive, with their batch rows.
+
+        Walks the stored ``cache`` payload instead of assuming which capture
+        path populates it: ``_decode_icl_first_chunk`` fills its dict on the
+        decoder side, so the only reliable count is the one taken from the
+        objects themselves after warmup.
+        """
+        found: list[tuple[int, DynamicCache]] = []
+        for state in states.values():
+            payload = state.get("cache")
+            if not isinstance(payload, dict):
+                continue
+            for value in payload.values():
+                if not isinstance(value, DynamicCache):
+                    continue
+                layers = getattr(value, "layers", None)
+                keys = getattr(layers[0], "keys", None) if layers else None
+                if keys is None:
+                    continue
+                found.append((int(keys.shape[0]), value))
+        return found
+
+    def model_local_kv_specs(self) -> list[ModelLocalKVSpec]:
+        """Declare only the graph-resident copies this wrapper retains.
+
+        The per-decode cache is declared by the decoder itself, because it
+        exists whether or not graphs were captured. What is specific to this
+        wrapper is that every captured shape keeps its dummy ``DynamicCache``
+        alive for replay (``combined_states``, ``icl_prefix_states`` and
+        ``xvec_prefix_states`` all store ``cache``), for the process lifetime.
+
+        Rows come from the state dicts rather than the configured capture
+        lists: a capture that raised is logged and skipped, so the configured
+        shape count would over-report. The trade is that a capture whose
+        tensors transformers has not yet materialized contributes nothing, so
+        this is a floor rather than a contract.
+        """
+        config = self.decoder.config
+        try:
+            dtype = next(self.decoder.parameters()).dtype
+        except StopIteration:  # parameterless stub, only reachable in tests
+            return []
+
+        # Physical, not logical: the sliding window truncates on every write,
+        # so a stream of thousands of frames never occupies more than this.
+        physical = self.prefix_length - 1
+        retained = [
+            *self._retained_kv_caches(self.combined_states),
+            *self._retained_kv_caches(self.icl_prefix_states),
+            *self._retained_kv_caches(self.xvec_prefix_states),
+        ]
+        batched_captures = sum(rows for rows, _ in retained)
+
+        if not batched_captures:
+            return []
+        return [
+            spec_from_hf_config(
+                config,
+                name="codec_decoder_graph_pool",
+                dtype=dtype,
+                physical_capacity_positions=physical,
+                capacity_source=f"sliding_window({self.prefix_length}) - 1",
+                scope=ModelLocalKVScope.MODEL,
+                rows=RowDriver.FIXED,
+                rows_fixed=batched_captures,
+                rows_reason=(
+                    f"rows across {len(retained)} retained caches in "
+                    f"{len(self.combined_states)} suffix / {len(self.icl_prefix_states)} icl-prefix / "
+                    f"{len(self.xvec_prefix_states)} xvec-prefix captures"
+                ),
+                allocation_note=(
+                    "counted from caches transformers has materialized; captures whose tensors are still "
+                    "unallocated report nothing, so this is a floor for the xvec path"
+                ),
+            )
+        ]
+
     def log_decode_stats(self) -> None:
         if not getattr(self, "_stats_enabled", False) or self._stats_total_requests == 0:
             return
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 ea11e64a7..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,
@@ -854,6 +918,75 @@ class Qwen3TTSTokenizerV2Decoder(Qwen3TTSTokenizerV2DecoderPreTrainedModel):
         self._cudagraph_enabled = False
         self._cudagraph_wrapper = None
 
+    def model_local_kv_specs(self):
+        """Declare this decoder's attention KV.
+
+        Only the async-chunk path holds KV. In stateless mode the decoder runs
+        ``_forward_exact``, which calls ``pre_transformer`` without
+        ``use_cache`` and allocates no cache at all, so declaring a per-request
+        cache there invents memory that does not exist. The previous revision
+        did exactly that and reported over a gigabyte for stateless
+        deployments; the one before it hung the declaration off the CUDA-graph
+        wrapper and so reported zero under ``enforce_eager``, where the eager
+        async-chunk path does allocate. Both mistakes come from tying this to
+        the wrong condition.
+
+        Two entries when async-chunk is on: the retained per-request cache, and
+        the working copy ``_decode_icl_first_chunk`` deep-copies from it, which
+        is live at the same time.
+
+        The wrapper, when present, adds the graph-resident copies. It is a
+        plain object rather than a submodule, so the module-tree walk cannot
+        reach it; this is the hop it needs.
+        """
+        from vllm_omni.model_executor.models.model_local_kv import (
+            ModelLocalKVScope,
+            RowDriver,
+            spec_from_hf_config,
+        )
+
+        config = self.config
+        try:
+            dtype = next(self.parameters()).dtype
+        except StopIteration:  # parameterless stub, only reachable in tests
+            return []
+
+        window = int(getattr(config, "sliding_window", 0) or 0)
+        if window <= 1:
+            return []
+
+        specs = []
+        wrapper = getattr(self, "_cudagraph_wrapper", None)
+        # async_chunk is the wrapper's record of the mode; without a wrapper the
+        # decoder has not been told, and only the stateless path is reachable.
+        if wrapper is not None and getattr(wrapper, "async_chunk", False):
+            common = dict(
+                config=config,
+                dtype=dtype,
+                physical_capacity_positions=window - 1,
+                capacity_source=f"sliding_window({window}) - 1",
+                rows=RowDriver.MAX_NUM_SEQS,
+            )
+            specs.append(
+                spec_from_hf_config(
+                    name="codec_decoder_request",
+                    scope=ModelLocalKVScope.REQUEST,
+                    allocation_note="retained across chunks of one request",
+                    **common,
+                )
+            )
+            specs.append(
+                spec_from_hf_config(
+                    name="codec_decoder_working_copy",
+                    scope=ModelLocalKVScope.INVOCATION,
+                    allocation_note="deep-copied from the retained cache each chunk; live alongside it",
+                    **common,
+                )
+            )
+        if wrapper is not None:
+            specs.extend(wrapper.model_local_kv_specs())
+        return specs
+
     def precompute_snake_caches(self):
         """Precompute exp(alpha) and 1/(exp(beta)+eps) for all SnakeBeta modules."""
         count = 0
@@ -1331,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 b9373e5f2..468ed5302 100644
--- a/vllm_omni/model_executor/models/registry.py
+++ b/vllm_omni/model_executor/models/registry.py
@@ -87,6 +87,11 @@ _OMNI_MODELS = {
         "cosyvoice3",
         "CosyVoice3Model",
     ),
+    "AuKForConditionalGeneration": (
+        "auk",
+        "auk",
+        "AuKForConditionalGeneration",
+    ),
     "NemotronDenseForCausalLM": (
         "audex",
         "audex_thinker",
@@ -137,11 +142,6 @@ _OMNI_MODELS = {
         "mammoth_moda2",
         "MammothModa2Qwen3ForCausalLM",
     ),
-    "MammothModa2DiTPipeline": (
-        "mammoth_moda2",
-        "pipeline_mammothmoda2_dit",
-        "MammothModa2DiTPipeline",
-    ),
     "MammothModa2ForConditionalGeneration": (
         "mammoth_moda2",
         "mammoth_moda2",
@@ -321,12 +321,6 @@ _OMNI_MODELS = {
         "voxcpm2_talker",
         "VoxCPM2TalkerForConditionalGeneration",
     ),
-    ## dots.tts
-    "DotsTTSForConditionalGeneration": (
-        "dots_tts",
-        "dots_tts_talker",
-        "DotsTTSForConditionalGeneration",
-    ),
     ## Voxtral TTS
     "VoxtralTTSForConditionalGeneration": (
         "voxtral_tts",
@@ -396,11 +390,6 @@ _OMNI_MODELS = {
         "modeling_moss_tts_codec",
         "MossTTSCodecDecoder",
     ),
-    "DyninOmniForConditionalGeneration": (
-        "dynin_omni",
-        "dynin_omni",
-        "DyninOmniForConditionalGeneration",
-    ),
     ## IndexTTS2
     "IndexTTS2TalkerForConditionalGeneration": (
         "indextts2",
@@ -471,10 +460,10 @@ _OMNI_MODELS = {
         "qwen3_vl",
         "AuraQwen3VLForConditionalGeneration",
     ),
-    "MiniMaxH3TextEncoder": (
+    "MiniMaxH3Encoder": (
         "minimax_h3",
-        "text_encoder",
-        "MiniMaxH3TextEncoder",
+        "encoder",
+        "MiniMaxH3Encoder",
     ),
     ## MiniMax-Music3 (text-to-music; AR talker -> flow-matching acoustic decoder)
     "MiniMaxMusic3TalkerForConditionalGeneration": (
@@ -487,6 +476,16 @@ _OMNI_MODELS = {
         "acoustic",
         "MiniMaxMusic3AcousticForConditionalGeneration",
     ),
+    "BreezeForConditionalGeneration": (
+        "breeze_tts_2",
+        "modeling_breeze_tts_2_talker",
+        "BreezeTTS2TalkerForGeneration",
+    ),
+    "BreezeTTS2MimiCodec": (
+        "breeze_tts_2",
+        "modeling_breeze_tts_2_codec",
+        "BreezeTTS2MimiCodec",
+    ),
 }
 
 
diff --git a/vllm_omni/model_executor/models/utils.py b/vllm_omni/model_executor/models/utils.py
index fd9ddd41b..73e9d5572 100644
--- a/vllm_omni/model_executor/models/utils.py
+++ b/vllm_omni/model_executor/models/utils.py
@@ -1,10 +1,59 @@
-from collections.abc import Callable
+import math
+from collections.abc import Callable, Sequence
 from contextlib import contextmanager
 
+import numpy as np
 import torch
+from PIL import Image
 from vllm.model_executor.models.utils import maybe_prefix
 
 
+def normalize_decoded_video_frames(
+    video_input: Sequence[Image.Image],
+    *,
+    default_fps: float,
+) -> tuple[np.ndarray, float]:
+    """Convert decoded image frames to a contiguous THWC uint8 video array."""
+    if not video_input:
+        raise ValueError("video_edit received an empty decoded video frame sequence.")
+
+    frame_rate = float(default_fps)
+    for fps in (
+        getattr(video_input, "fps", None),
+        getattr(video_input, "frame_rate", None),
+    ):
+        try:
+            candidate = float(fps)
+        except (TypeError, ValueError):
+            continue
+        if math.isfinite(candidate) and candidate > 0:
+            frame_rate = candidate
+            break
+
+    frames = []
+    frame_size = None
+    for index, frame in enumerate(video_input):
+        if not isinstance(frame, Image.Image):
+            raise ValueError(
+                f"video_edit decoded video frame at index {index} must be a PIL.Image.Image, got {type(frame)}."
+            )
+        width, height = frame.size
+        if width <= 0 or height <= 0:
+            raise ValueError(
+                f"video_edit decoded video frame at index {index} must have positive dimensions, got {width}x{height}."
+            )
+        if frame_size is None:
+            frame_size = frame.size
+        elif frame.size != frame_size:
+            raise ValueError(
+                "video_edit decoded video frames must have identical dimensions; "
+                f"frame 0 is {frame_size}, frame {index} is {frame.size}."
+            )
+        frames.append(np.asarray(frame.convert("RGB"), dtype=np.uint8))
+
+    return np.ascontiguousarray(np.stack(frames)), frame_rate
+
+
 @contextmanager
 def transformers_keys_to_ignore_compat():
     """Make ``trust_remote_code`` weight loading robust to the transformers 5.9
diff --git a/vllm_omni/model_executor/models/voxcpm2/lora.py b/vllm_omni/model_executor/models/voxcpm2/lora.py
new file mode 100644
index 000000000..cc3640582
--- /dev/null
+++ b/vllm_omni/model_executor/models/voxcpm2/lora.py
@@ -0,0 +1,95 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Merge a native VoxCPM2 LoRA checkpoint at startup for all requests."""
+
+from __future__ import annotations
+
+import json
+import math
+from pathlib import Path
+
+import torch
+from safetensors.torch import load_file
+from torch import nn
+
+
+def merge_voxcpm2_lora(
+    adapter_path: str,
+    *,
+    base_lm: nn.Module,
+    residual_lm: nn.Module,
+    tts: nn.Module,
+) -> int:
+    """Validate and merge one local native safetensors adapter.
+
+    Call once after base weight loading and before fusion or graph capture.
+    Validate all checkpoint keys and tensors before changing weights.
+    """
+    path = Path(adapter_path)
+    with (path / "lora_config.json").open(encoding="utf-8") as f:
+        metadata = json.load(f)
+    config = metadata.get("lora_config") if isinstance(metadata, dict) else None
+    if not isinstance(config, dict):
+        raise ValueError("VoxCPM2 lora_config.json must contain a lora_config object")
+    rank, alpha = config.get("r"), config.get("alpha")
+    if type(rank) is not int or rank <= 0:
+        raise ValueError("VoxCPM2 LoRA r must be a positive integer")
+    if isinstance(alpha, bool) or not isinstance(alpha, (int, float)) or not math.isfinite(alpha):
+        raise ValueError("VoxCPM2 LoRA alpha must be finite")
+
+    targets: dict[str, nn.Linear] = {}
+    groups = (
+        ("lm", {"base_lm": base_lm, "residual_lm": residual_lm}, "target_modules_lm"),
+        ("dit", {"feat_decoder.estimator": tts.feat_decoder.estimator}, "target_modules_dit"),
+        ("proj", {"": tts}, "target_proj_modules"),
+    )
+    for group, roots, target_key in groups:
+        enabled = config.get(f"enable_{group}", False)
+        if type(enabled) is not bool:
+            raise ValueError(f"VoxCPM2 LoRA enable_{group} must be a boolean")
+        if not enabled:
+            continue
+        defaults = (
+            ["enc_to_lm_proj", "lm_to_dit_proj", "res_to_dit_proj", "fusion_concat_proj"]
+            if group == "proj"
+            else ["q_proj", "v_proj", "k_proj", "o_proj"]
+        )
+        names = config.get(target_key, defaults)
+        if not isinstance(names, list) or not names or any(not isinstance(n, str) or not n for n in names):
+            raise ValueError(f"VoxCPM2 LoRA {target_key} must be a non-empty list of names")
+        for prefix, root in roots.items():
+            matched = set()
+            for name, module in root.named_modules():
+                selector = name if group == "proj" else name.rsplit(".", 1)[-1]
+                if selector in names and isinstance(module, nn.Linear):
+                    targets[f"{prefix}.{name}" if prefix else name] = module
+                    matched.add(selector)
+            if missing := set(names) - matched:
+                raise ValueError(f"VoxCPM2 LoRA targets not found in {prefix or 'tts'}: {sorted(missing)}")
+    if not targets:
+        raise ValueError("VoxCPM2 LoRA config enables no target layers")
+
+    state = load_file(str(path / "lora_weights.safetensors"), device="cpu")
+    expected = {f"{name}.lora_{suffix}" for name in targets for suffix in ("A", "B")}
+    if set(state) != expected:
+        raise ValueError(
+            "VoxCPM2 LoRA checkpoint keys do not match the configured targets: "
+            f"missing={sorted(expected - set(state))}, unexpected={sorted(set(state) - expected)}"
+        )
+    for name, module in targets.items():
+        if not module.weight.is_floating_point() or module.weight.is_meta:
+            raise ValueError(f"VoxCPM2 LoRA requires materialized floating-point weights: {name}")
+        for suffix, shape in (("A", (rank, module.in_features)), ("B", (module.out_features, rank))):
+            key = f"{name}.lora_{suffix}"
+            tensor = state[key]
+            if tensor.shape != shape or not tensor.is_floating_point() or not torch.isfinite(tensor).all():
+                raise ValueError(f"Invalid VoxCPM2 LoRA tensor {key}: expected finite floating-point shape {shape}")
+
+    with torch.no_grad():
+        for name, module in targets.items():
+            # Merge one layer at a time in fp32, preserving the base Parameter.
+            a = state[f"{name}.lora_A"].to(device=module.weight.device, dtype=torch.float32)
+            b = state[f"{name}.lora_B"].to(device=module.weight.device, dtype=torch.float32)
+            merged = torch.addmm(module.weight.float(), b, a, alpha=alpha / rank)
+            module.weight.copy_(merged)
+    return len(targets)
diff --git a/vllm_omni/model_executor/models/voxcpm2/runtime_config.py b/vllm_omni/model_executor/models/voxcpm2/runtime_config.py
index 1446729e7..207be70f2 100644
--- a/vllm_omni/model_executor/models/voxcpm2/runtime_config.py
+++ b/vllm_omni/model_executor/models/voxcpm2/runtime_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 __future__ import annotations
 
@@ -13,6 +13,7 @@ logger = init_logger(__name__)
 
 @dataclasses.dataclass(frozen=True)
 class _VoxCPM2RuntimeConfig:
+    startup_lora_path: str | None = None
     enable_profiling: bool = False
     enable_nvtx_profile: bool = False
     enable_loc_dit_layer_nvtx: bool = False
@@ -105,6 +106,10 @@ class _VoxCPM2RuntimeConfig:
 
     @staticmethod
     def _coerce_value(key: str, value: Any, default: Any) -> Any:
+        if key == "startup_lora_path":
+            if value is not None and (not isinstance(value, str) or not value.strip()):
+                raise ValueError("VoxCPM2 startup_lora_path must be a non-empty local directory path or null")
+            return value
         if isinstance(default, bool):
             if isinstance(value, str):
                 return value.strip().lower() in ("1", "true", "yes", "on")
diff --git a/vllm_omni/model_executor/models/voxcpm2/voxcpm2_talker.py b/vllm_omni/model_executor/models/voxcpm2/voxcpm2_talker.py
index 5febb8912..47c6f1dd3 100644
--- a/vllm_omni/model_executor/models/voxcpm2/voxcpm2_talker.py
+++ b/vllm_omni/model_executor/models/voxcpm2/voxcpm2_talker.py
@@ -46,6 +46,7 @@ from vllm_omni.utils.speaker_cache import (
 )
 from vllm_omni.worker.runner_assisted_metadata import RunnerAssistedFullAttentionMetadataRequest
 
+from .lora import merge_voxcpm2_lora
 from .minicpm4_paged import MiniCPM4PagedForVoxCPM2, MiniCPM4PagedResidualLM
 from .runtime_config import _VoxCPM2RuntimeConfig
 from .voxcpm2_import_utils import import_voxcpm2_core
@@ -76,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
@@ -249,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
@@ -351,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
 
@@ -372,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))
 
@@ -381,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()
 
@@ -834,6 +876,9 @@ class VoxCPM2TalkerForConditionalGeneration(nn.Module):
         self.vllm_config = vllm_config
         self.config = vllm_config.model_config.hf_config
         self._runtime_config = _VoxCPM2RuntimeConfig.from_vllm_config(vllm_config)
+        self._startup_lora_applied = False
+        if self._runtime_config.startup_lora_path and vllm_config.load_config.load_format == "dummy":
+            raise ValueError("VoxCPM2 startup LoRA requires real base weights; load_format=dummy is unsupported")
         global _ENABLE_NVTX_PROFILE
         _ENABLE_NVTX_PROFILE = self._runtime_config.enable_nvtx_profile
 
@@ -1194,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
 
@@ -1221,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)
@@ -1651,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"):
@@ -1680,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()
 
@@ -1874,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")
@@ -2316,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"):
@@ -2331,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,
@@ -2365,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]
@@ -2387,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] = []
@@ -2409,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,
@@ -2473,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())
 
@@ -2550,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,
@@ -3100,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"):
@@ -3284,6 +3380,9 @@ class VoxCPM2TalkerForConditionalGeneration(nn.Module):
     hf_to_vllm_mapper = WeightsMapper(orig_to_new_prefix={"base_lm.": "model."})
 
     def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
+        if self._startup_lora_applied:
+            raise ValueError("Reloading VoxCPM2 weights with a startup LoRA is unsupported; restart the server")
+
         def _base_lm_only(ws):
             for name, tensor in ws:
                 if name.startswith("base_lm."):
@@ -3298,6 +3397,13 @@ class VoxCPM2TalkerForConditionalGeneration(nn.Module):
         # them as missing from the checkpoint.
         loaded |= {name for name, _ in self.named_parameters() if name.startswith(("_tts.", "residual_model."))}
 
+        if adapter_path := self._runtime_config.startup_lora_path:
+            merged = merge_voxcpm2_lora(
+                adapter_path, base_lm=self.model, residual_lm=self.residual_model, tts=self._tts
+            )
+            self._startup_lora_applied = True
+            logger.info("Merged VoxCPM2 startup LoRA from %s into %d linear layers", adapter_path, merged)
+
         logger.info(
             "Loaded VoxCPM2 (patch=%d, feat_dim=%d, dtype=%s)", self._patch_size, self._feat_dim, self._side_dtype
         )
diff --git a/vllm_omni/model_executor/models/voxtral_tts/voxtral_tts.py b/vllm_omni/model_executor/models/voxtral_tts/voxtral_tts.py
index c61aeaaad..de79c4cba 100644
--- a/vllm_omni/model_executor/models/voxtral_tts/voxtral_tts.py
+++ b/vllm_omni/model_executor/models/voxtral_tts/voxtral_tts.py
@@ -174,6 +174,11 @@ class VoxtralTTSForConditionalGeneration(
             return self.model.get_language_model()
         return self.model
 
+    def encoder_loaded(self):
+        if self.audio_tokenizer is not None:
+            return self.audio_tokenizer.encoder_loaded
+        return False
+
     def _enable_acoustic_transformer_cudagraph(self):
         """Initialize and capture CUDA graphs for compute_mm_logits."""
         if self.model_stage != "audio_generation" or not hasattr(self, "_vllm_config"):
diff --git a/vllm_omni/model_executor/models/voxtral_tts/voxtral_tts_audio_tokenizer.py b/vllm_omni/model_executor/models/voxtral_tts/voxtral_tts_audio_tokenizer.py
index 9be16c0f1..ac8e09625 100644
--- a/vllm_omni/model_executor/models/voxtral_tts/voxtral_tts_audio_tokenizer.py
+++ b/vllm_omni/model_executor/models/voxtral_tts/voxtral_tts_audio_tokenizer.py
@@ -900,6 +900,10 @@ class VoxtralTTSAudioTokenizer(nn.Module):
         """List of size of each codebook"""
         return self.quantizer.codebook_sizes
 
+    @property
+    def encoder_loaded(self) -> bool:
+        return self._encoder_loaded
+
     def load_weight(self, weight: tuple[str, torch.Tensor]) -> str:
         params_dict = dict(self.named_parameters())
         name, loaded_weight = weight
@@ -985,7 +989,7 @@ class VoxtralTTSAudioTokenizer(nn.Module):
 
     def encode_waveforms(self, x: list[torch.Tensor]) -> list[torch.Tensor]:
         if not self._encoder_loaded:
-            raise RuntimeError(
+            raise ValueError(
                 "encode_waveforms requires encoder weights which are not available in the open-source checkpoint."
             )
         audio_codes = []
diff --git a/vllm_omni/model_executor/stage_input_processors/auk.py b/vllm_omni/model_executor/stage_input_processors/auk.py
new file mode 100644
index 000000000..7c417aee1
--- /dev/null
+++ b/vllm_omni/model_executor/stage_input_processors/auk.py
@@ -0,0 +1,148 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Stage input processor for AuK: thinker encoder -> diffusion transition."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+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__)
+
+# The encoder emits the fused condition as
+# ``multimodal_outputs["hidden_states"]["output"]`` (``HiddenStatesStruct.output``,
+# the same stage-wire slot MiniMax H3 uses). The payload flattener may deliver
+# it under the dotted spelling instead, and a plain ``text_cond`` key is
+# accepted so an encoder that emits the condition directly still works.
+HIDDEN_STATES_KEY = "hidden_states"
+TEXT_COND_KEY = "output"
+_FALLBACK_KEYS = ("hidden_states.output", "text_cond")
+
+# Per-request knobs the prompt carries for stage 1. nfe/cfg/seed are not here:
+# they ride the stage-1 OmniDiffusionSamplingParams instead.
+_AUK_KNOBS = ("gen_seconds", "sway", "t_grid", "vae_sample")
+
+
+def _as_dict(prompt: Any) -> dict[str, Any]:
+    """Normalize the many prompt spellings the orchestrator may pass."""
+    if isinstance(prompt, list):
+        prompt = prompt[0] if prompt else {}
+    if prompt is None:
+        return {}
+    if isinstance(prompt, dict):
+        return prompt
+    if hasattr(prompt, "_asdict"):
+        return prompt._asdict()
+    if hasattr(prompt, "__dict__"):
+        return vars(prompt)
+    return {}
+
+
+def _has_audio(mm_data: Any) -> bool:
+    return isinstance(mm_data, Mapping) and mm_data.get("audio") is not None
+
+
+def _from_hidden_states(hidden: Any) -> Any:
+    """Read the fused condition out of the payload's hidden-states slot."""
+    if isinstance(hidden, Mapping):
+        return hidden.get(TEXT_COND_KEY)
+    # A deserialized payload arrives as a msgspec struct rather than a dict.
+    return getattr(hidden, TEXT_COND_KEY, None)
+
+
+def _extract_text_cond(ar_output: Any) -> Any:
+    """Read the fused text condition from the encoder output.
+
+    ``multimodal_output`` is attached to the RequestOutput; the CompletionOutput
+    is checked as a fallback for vLLM versions that attach it there.
+    """
+    for holder in (ar_output, *(getattr(ar_output, "outputs", None) or ())):
+        mm_output = getattr(holder, "multimodal_output", None)
+        if not isinstance(mm_output, Mapping):
+            continue
+        text_cond = _from_hidden_states(mm_output.get(HIDDEN_STATES_KEY))
+        if text_cond is not None:
+            return text_cond
+        for key in _FALLBACK_KEYS:
+            if mm_output.get(key) is not None:
+                return mm_output[key]
+    return None
+
+
+def _to_cpu_tensor(text_cond: Any) -> torch.Tensor:
+    """Coerce the emitted condition to a single 2-D CPU tensor."""
+    if isinstance(text_cond, list):
+        if not text_cond:
+            raise ValueError("AuK encoder emitted an empty text condition list")
+        parts = [_to_cpu_tensor(part) for part in text_cond]
+        return torch.cat(parts, dim=0) if len(parts) > 1 else parts[0]
+    if isinstance(text_cond, torch.Tensor):
+        tensor = text_cond
+    else:
+        # numpy array or any array-like the connector round-tripped.
+        tensor = torch.as_tensor(text_cond)
+    tensor = tensor.detach().cpu()
+    if tensor.ndim != 2:
+        raise ValueError(f"AuK text condition must be [tokens, hidden]; got shape {tuple(tensor.shape)}")
+    return tensor
+
+
+def encoder2dit(
+    source_outputs: list[Any],
+    prompt: OmniTokensPrompt | TextPrompt | list | None = None,
+    requires_multimodal_data: bool = False,
+    streaming_context: Any | None = None,
+) -> dict[str, Any] | None:
+    """Turn the AuK encoder stage's fused hidden states into a diffusion prompt.
+
+    The source clip is not decoded here: the original ``multi_modal_data`` is
+    forwarded so stage 1 resamples and VAE-encodes it itself. It is forwarded
+    unconditionally because the editing and enhancement tasks cannot run
+    without it; ``requires_multimodal_data`` only records the stage's
+    declaration.
+    """
+    del streaming_context, requires_multimodal_data
+    if not source_outputs:
+        return None
+
+    ar_output = source_outputs[0]
+    text_cond = _extract_text_cond(ar_output)
+    if text_cond is None:
+        raise ValueError(
+            "AuK encoder stage produced no hidden_states.output multimodal payload; "
+            "stage 1 cannot run without the fused thinker hidden states"
+        )
+    prompt_embeds = _to_cpu_tensor(text_cond)
+
+    original = _as_dict(prompt)
+    original_knobs = original.get("additional_information") or {}
+    if isinstance(original_knobs, Mapping):
+        original_knobs = original_knobs.get("auk") or {}
+    if not isinstance(original_knobs, Mapping):
+        original_knobs = {}
+
+    mm_data = original.get("multi_modal_data")
+    knobs: dict[str, Any] = {key: original_knobs.get(key) for key in _AUK_KNOBS}
+    declared_audio = original_knobs.get("has_audio")
+    knobs["has_audio"] = bool(declared_audio) if declared_audio is not None else _has_audio(mm_data)
+
+    logger.debug(
+        "[encoder2dit] text_cond=%s dtype=%s has_audio=%s gen_seconds=%s",
+        tuple(prompt_embeds.shape),
+        prompt_embeds.dtype,
+        knobs["has_audio"],
+        knobs["gen_seconds"],
+    )
+
+    return {
+        "prompt": "",
+        "prompt_embeds": prompt_embeds,
+        "multi_modal_data": mm_data,
+        "additional_information": {"auk": knobs},
+    }
diff --git a/vllm_omni/model_executor/stage_input_processors/breeze_tts_2.py b/vllm_omni/model_executor/stage_input_processors/breeze_tts_2.py
new file mode 100644
index 000000000..ae393948a
--- /dev/null
+++ b/vllm_omni/model_executor/stage_input_processors/breeze_tts_2.py
@@ -0,0 +1,244 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Stage-0 to stage-1 input conversion for Breeze-TTS-2.
+
+The prompt builder and the reference-audio tokenizer live under the Breeze
+model directory.  This module intentionally contains only the inter-stage
+contract: flatten the generated ``(T, Q)`` codec matrix into the codebook-major
+token sequence consumed by the stage-1 codec model.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+import torch
+from vllm.logger import init_logger
+
+from vllm_omni.data_entry_keys import CodesStruct, MetaStruct, OmniPayloadStruct
+from vllm_omni.inputs.data import OmniTokensPrompt
+
+logger = init_logger(__name__)
+
+# ``BreezeTTS2TalkerForGeneration`` emits the complete sequence accumulated
+# so far on every decode step.  The generic full-payload accumulator normally
+# concatenates rank-2 tensors, which would duplicate all earlier frames.
+# Replace the latest complete sequence instead.
+_FULL_PAYLOAD_REPLACE_KEYS: frozenset[str] = frozenset({"codes.audio"})
+_DEFAULT_CODEC_CHUNK_FRAMES = 8
+
+
+def _extract_audio_codes(output: Any) -> torch.Tensor | None:
+    """Extract ``codes.audio`` from the supported Omni output shapes."""
+    # Depending on the engine path, source_outputs contains either the
+    # per-request output itself or an EngineCoreOutput with ``outputs[0]``.
+    if isinstance(output, Mapping):
+        multimodal = output.get("multimodal_output", output.get("multimodal_outputs"))
+        if multimodal is None and "codes" in output:
+            multimodal = output
+        if multimodal is None and "codes.audio" in output:
+            audio = output["codes.audio"]
+            if isinstance(audio, (list, tuple)):
+                if len(audio) != 1:
+                    raise ValueError(f"expected one Breeze audio-code tensor, got {len(audio)}")
+                audio = audio[0]
+            audio = torch.as_tensor(audio)
+            if audio.ndim not in (1, 2):
+                raise ValueError(f"Breeze audio codes must be rank 1 or 2, got {tuple(audio.shape)}")
+            return audio.to(device="cpu", dtype=torch.long).contiguous()
+    else:
+        multimodal = getattr(output, "multimodal_output", None)
+        if multimodal is None:
+            multimodal = getattr(output, "multimodal_outputs", None)
+        if multimodal is None:
+            candidates = getattr(output, "outputs", None)
+            if isinstance(candidates, Sequence) and candidates:
+                return _extract_audio_codes(candidates[0])
+    if not isinstance(multimodal, Mapping):
+        return None
+    codes = multimodal.get("codes")
+    audio = codes.get("audio") if isinstance(codes, Mapping) else multimodal.get("codes.audio")
+    if audio is None:
+        return None
+    # ``OmniOutput`` stores one tensor per request under ``codes.audio``.
+    # ``process_engine_inputs`` invokes this function once per source output,
+    # so unwrap that single-item container before tensor conversion.
+    if isinstance(audio, (list, tuple)):
+        if len(audio) != 1:
+            raise ValueError(f"expected one Breeze audio-code tensor, got {len(audio)}")
+        audio = audio[0]
+    audio = torch.as_tensor(audio)
+    if audio.ndim == 3 and audio.shape[0] == 1:
+        audio = audio[0]
+    if audio.ndim not in (1, 2):
+        raise ValueError(
+            f"Breeze audio codes must have shape (T, Q) or codebook-major (Q*T,), got {tuple(audio.shape)}"
+        )
+    return audio.to(device="cpu", dtype=torch.long).contiguous()
+
+
+def talker2codec(
+    source_outputs: Sequence[Any],
+    prompt: Any = None,
+    _requires_multimodal_data: bool = False,
+) -> list[OmniTokensPrompt]:
+    """Build synchronous stage-1 prompts from completed stage-0 outputs.
+
+    Breeze's Mimi decoder receives one flat codebook-major sequence.  The
+    generated matrix is therefore transposed from ``(T, Q)`` to ``(Q, T)``
+    before flattening.  No audio decoding, text tokenization, or streaming
+    state is handled here.
+    """
+    del prompt, _requires_multimodal_data
+    results: list[OmniTokensPrompt] = []
+    for source_index, output in enumerate(source_outputs):
+        codes = _extract_audio_codes(output)
+        if codes is None or codes.numel() == 0:
+            logger.warning("Breeze stage output %d contains no audio codes", source_index)
+            results.append(OmniTokensPrompt(prompt_token_ids=[]))
+            continue
+        # Connector full-payload builders send a codebook-major flat tensor;
+        # direct in-process stage outputs carry frame-major ``(T, Q)``.
+        if codes.ndim == 1:
+            codebook_major_data = codes.contiguous()
+            codebook_major = codebook_major_data
+        else:
+            codebook_major_data = codes.transpose(0, 1).contiguous()
+            codebook_major = codebook_major_data.reshape(-1)
+        results.append(
+            OmniTokensPrompt(
+                prompt_token_ids=codebook_major.tolist(),
+                multi_modal_data={"codes": {"audio": codebook_major_data}},
+            )
+        )
+    return results
+
+
+def talker2codec_full_payload(
+    transfer_manager: Any = None,
+    pooling_output: Mapping[str, Any] | None = None,
+    request: Any = None,
+    is_finished: bool = False,
+) -> OmniPayloadStruct | None:
+    """Build the final Stage-1 payload from accumulated talker codes.
+
+    ``pooling_output`` is the AR runner's flattened per-request payload. Mimi
+    consumes codebook-major IDs, so the frame-major talker matrix is transposed
+    before flattening. A request that finishes without any codec frame still
+    gets an explicit empty payload with ``finished=True``: returning ``None``
+    would leave Stage 1 without a terminal marker, and the connector receiver
+    requeues marker-less empty chunks forever.
+    """
+    del transfer_manager, request
+    audio = None
+    if isinstance(pooling_output, Mapping):
+        audio = pooling_output.get("codes.audio")
+        if audio is None:
+            nested = pooling_output.get("codes")
+            if isinstance(nested, Mapping):
+                audio = nested.get("audio")
+
+    codes = torch.empty(0, dtype=torch.long) if audio is None else torch.as_tensor(audio, dtype=torch.long)
+    if codes.numel() == 0:
+        if not is_finished:
+            return None
+        return OmniPayloadStruct(
+            codes=CodesStruct(audio=torch.empty(0, dtype=torch.long)),
+            meta=MetaStruct(
+                code_flat_numel=0,
+                finished=torch.tensor(True, dtype=torch.bool),
+            ),
+        )
+    if codes.ndim == 2:
+        flat = codes.transpose(0, 1).contiguous().reshape(-1)
+    elif codes.ndim == 1:
+        flat = codes.contiguous()
+    else:
+        raise ValueError(f"Breeze audio codes must be rank 1 or 2, got {tuple(codes.shape)}")
+    return OmniPayloadStruct(
+        codes=CodesStruct(audio=flat),
+        meta=MetaStruct(
+            code_flat_numel=int(flat.numel()),
+            finished=torch.tensor(bool(is_finished), dtype=torch.bool),
+        ),
+    )
+
+
+def _extract_current_audio_frame(
+    multimodal_output: Mapping[str, Any] | None,
+) -> torch.Tensor | None:
+    """Extract the single ``(Q,)`` frame emitted by async Stage 0."""
+    if not isinstance(multimodal_output, Mapping):
+        return None
+    codes = multimodal_output.get("codes")
+    audio = codes.get("audio") if isinstance(codes, Mapping) else None
+    if audio is None:
+        return None
+    frame = torch.as_tensor(audio, dtype=torch.long).reshape(-1)
+    if frame.numel() == 0:
+        return None
+    return frame.cpu().contiguous()
+
+
+def _codec_chunk_frames(transfer_manager: Any) -> int:
+    connector = getattr(transfer_manager, "connector", None)
+    # SharedMemoryConnector stores its ConnectorSpec.extra directly in
+    # ``connector.config``; there is no second ``extra`` wrapper at runtime.
+    config = getattr(connector, "config", {}) or {}
+    value = config.get("breeze_codec_chunk_frames")
+    try:
+        chunk_frames = int(value) if value is not None else _DEFAULT_CODEC_CHUNK_FRAMES
+    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}")
+    return chunk_frames
+
+
+def talker2codec_async_chunk(
+    transfer_manager: Any,
+    multimodal_output: Mapping[str, Any] | None,
+    request: Any,
+    is_finished: bool = False,
+) -> OmniPayloadStruct | None:
+    """Batch Stage-0 frames and send only the un-emitted codebook-major tail."""
+    request_id = request.external_req_id
+    finished = bool(is_finished or request.is_finished())
+    frame = _extract_current_audio_frame(multimodal_output)
+    if frame is not None:
+        transfer_manager.code_prompt_token_ids[request_id].append(frame)
+
+    pending = transfer_manager.code_prompt_token_ids[request_id]
+    chunk_frames = _codec_chunk_frames(transfer_manager)
+    if not pending and not finished:
+        return None
+    if len(pending) < chunk_frames and not finished:
+        return None
+
+    if pending:
+        # Stage 0 supplies frame-major ``(T, Q)`` rows. The Qwen3-TTS decoder
+        # consumes ``(Q, T)``, so transpose before flattening the emitted tail.
+        tail = torch.stack(pending, dim=0)
+        flat = tail.transpose(0, 1).contiguous().reshape(-1)
+    else:
+        flat = torch.empty(0, dtype=torch.long)
+    pending.clear()
+
+    return OmniPayloadStruct(
+        codes=CodesStruct(audio=flat),
+        meta=MetaStruct(
+            request_id=request_id,
+            code_flat_numel=int(flat.numel()),
+            codec_streaming=True,
+            finished=torch.tensor(finished, dtype=torch.bool),
+            # The chunk adapter strips ``meta.finished`` before it reaches the
+            # stage-1 model; ``stream_finished`` survives and is what the
+            # codec uses to release per-request decoder state.
+            stream_finished=torch.tensor(finished, dtype=torch.bool),
+        ),
+    )
+
+
+__all__ = ["talker2codec", "talker2codec_async_chunk", "talker2codec_full_payload"]
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 7b23f8e49..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,19 +1,12 @@
-"""Stage input processor for MammothModa2 (AR -> DiT)."""
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""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"):
@@ -25,91 +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 = {
-            # float32 so the tensor crosses the stage boundary (the serializer uses
-            # numpy, which has no bf16); the DiT re-casts to the model dtype.
-            "full_hidden_states": full_hidden_states.float().contiguous(),
+    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 80995f92e..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__)
@@ -690,9 +693,6 @@ def _native_duplex_data_plane_metadata(streaming_context) -> dict[str, object] |
     session_id = duplex_state.get("session_id")
     if isinstance(session_id, str) and session_id:
         metadata["session_id"] = session_id
-    incarnation = duplex_state.get("incarnation")
-    if isinstance(incarnation, int):
-        metadata["incarnation"] = incarnation
     epoch = duplex_state.get("epoch")
     if isinstance(epoch, int):
         metadata["epoch"] = epoch
@@ -1013,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/minimax_h3.py b/vllm_omni/model_executor/stage_input_processors/minimax_h3.py
index 87808adc3..78fd0225f 100644
--- a/vllm_omni/model_executor/stage_input_processors/minimax_h3.py
+++ b/vllm_omni/model_executor/stage_input_processors/minimax_h3.py
@@ -1,73 +1,22 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
-"""MiniMax H3 text-encoder stage input and output adapters."""
+"""Adapters between MiniMax H3 conditioning and the Omni stage runner."""
 
 from __future__ import annotations
 
 import copy
-import shutil
-import tempfile
 from collections.abc import Mapping, Sequence
 from typing import Any
 
-import numpy as np
-from PIL import Image
-
-from vllm_omni.data_entry_keys import REQUEST_ARTIFACT_DIRS_KEY
-from vllm_omni.diffusion.models.minimax_h3.time_request import minimax_h3_align_frame_count
-from vllm_omni.errors import OmniClientError
+from vllm_omni.data_entry_keys import unflatten_payload
 from vllm_omni.inputs.data import OmniDiffusionSamplingParams
 from vllm_omni.model_executor.models.minimax_h3.conditioning import (
     MINIMAX_H3_CONDITION_LABELS_KEY,
+    MINIMAX_H3_ENCODER_REQUEST_KEY,
     MINIMAX_H3_PRESENTATION_TASK_KEY,
-    MiniMaxH3TextConditioning,
+    MiniMaxH3EncoderConditioning,
 )
-from vllm_omni.model_executor.models.minimax_h3.preprocessing import (
-    MINIMAX_H3_OUTPUT_SHORT_EDGE,
-    load_minimax_h3_images,
-    resolve_minimax_h3_aspect_ratio,
-    resolve_minimax_h3_output_canvas,
-    resolve_minimax_h3_reference_image_shape,
-)
-from vllm_omni.model_executor.models.minimax_h3.reference_video import (
-    MINIMAX_H3_PREPARED_REFERENCE_VIDEOS_KEY,
-    MINIMAX_H3_QWEN_VIDEO_SAMPLE_FPS,
-    prepare_reference_videos,
-    sample_reference_video_frames,
-    serialize_prepared_reference_videos,
-)
-
-
-def _items(value: Any) -> list[Any]:
-    if value is None:
-        return []
-    if isinstance(value, list):
-        return value
-    if isinstance(value, tuple) and not (len(value) == 2 and isinstance(value[1], Mapping)):
-        return list(value)
-    return [value]
-
-
-def _audio_items(value: Any) -> list[Any]:
-    if value is None:
-        return []
-    if isinstance(value, (list, tuple)) and len(value) == 2 and isinstance(value[1], (int, np.integer)):
-        return [value]
-    return list(value) if isinstance(value, (list, tuple)) else [value]
-
-
-def _resolve_task(
-    extra_args: Mapping[str, Any],
-    multi_modal_data: Mapping[str, Any],
-) -> str:
-    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:
-        return "ref2va"
-    if multi_modal_data.get("image") is not None:
-        return "fl2va"
-    return "t2va"
+from vllm_omni.model_executor.models.minimax_h3.encoder_processing import prepare_encoder_inputs
 
 
 def _diffusion_sampling_params(sampling_params_list: Sequence[Any]) -> Any:
@@ -78,190 +27,29 @@ def _diffusion_sampling_params(sampling_params_list: Sequence[Any]) -> Any:
     ]
     if len(diffusion_params) != 1:
         raise RuntimeError(
-            "MiniMax H3 text encoding requires exactly one OmniDiffusionSamplingParams stage parameter, "
+            "MiniMax H3 encoding requires exactly one OmniDiffusionSamplingParams stage parameter, "
             f"got {len(diffusion_params)}"
         )
     return diffusion_params[0]
 
 
-def _ref2va_target_frame_count(sampling_params_list: Sequence[Any]) -> int:
-    sampling = _diffusion_sampling_params(sampling_params_list)
-    extra_args = sampling.extra_args or {}
-    target = extra_args.get("target")
-    target = target if isinstance(target, Mapping) else {}
-    duration = target.get("duration_seconds", extra_args.get("duration_seconds", extra_args.get("duration")))
-    if duration is not None:
-        requested = int(round(float(duration) * 24))
-    elif int(getattr(sampling, "num_frames", None) or 1) > 1:
-        requested = int(sampling.num_frames)
-    else:
-        requested = 124
-    return minimax_h3_align_frame_count(requested)
-
-
-def _prepare_qwen_images(
-    task: str,
-    values: list[Any],
-    sampling_params_list: Sequence[Any],
-) -> list[Any]:
-    if not values:
-        return []
-    images = load_minimax_h3_images(values)
-    if task == "ref2va":
-        return [
-            image.resize(
-                resolve_minimax_h3_reference_image_shape(image),
-                Image.Resampling.LANCZOS,
-            )
-            for image in images
-        ]
-    if task != "fl2va":
-        return images
-
-    sampling = _diffusion_sampling_params(sampling_params_list)
-    extra_args = sampling.extra_args or {}
-    target = extra_args.get("target")
-    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 {}
-    aspect_ratio = resolve_minimax_h3_aspect_ratio(
-        task,
-        target.get("aspect_ratio", extra_args.get("aspect_ratio")),
-        images[0],
-    )
-    if not 0.25 <= aspect_ratio <= 4.0:
-        raise OmniClientError(f"MiniMax H3 canvas aspect ratio must be in [1:4, 4:1], got {aspect_ratio}")
-    height = sampling.height
-    width = sampling.width
-    if height is None or width is None:
-        short_edge = target.get(
-            "short_edge",
-            extra_args.get("short_edge", MINIMAX_H3_OUTPUT_SHORT_EDGE),
-        )
-        if isinstance(short_edge, bool) or not isinstance(short_edge, (int, np.integer)):
-            raise OmniClientError(
-                f"MiniMax H3 target.short_edge must be {MINIMAX_H3_OUTPUT_SHORT_EDGE}, got {short_edge!r}"
-            )
-        height, width = resolve_minimax_h3_output_canvas(aspect_ratio, int(short_edge))
-    height = int(height) // 32 * 32
-    width = int(width) // 32 * 32
-    if min(height, width) <= 0:
-        raise OmniClientError(f"invalid MiniMax H3 canvas {width}x{height}")
-    if width > 4 * height or height > 4 * width:
-        raise OmniClientError("MiniMax H3 canvas aspect ratio must be in [1:4, 4:1]")
-    return [image.resize((width, height), Image.Resampling.LANCZOS) for image in images]
-
-
-def prepare_text_encoder_prompt(
+def prepare_encoder_prompt(
     prompt: Any,
     sampling_params_list: Sequence[Any],
 ) -> Any:
-    """Build H3's labeled Qwen3-VL presentation for Stage 0.
-
-    The upstream Qwen3-VL multimodal processor expands each image/video
-    placeholder into the exact number of vision tokens and adds timestamped
-    video blocks.  Audio is represented only by its H3 text label and is not
-    sent to Qwen3-VL.
-    """
+    prepared = prepare_encoder_inputs(prompt, _diffusion_sampling_params(sampling_params_list))
     if isinstance(prompt, str):
-        return prompt
-    if not isinstance(prompt, dict):
-        raise TypeError(f"MiniMax H3 expects a string or dict prompt, got {type(prompt)!r}")
-
-    prompt = copy.copy(prompt)
-    additional_information = dict(prompt.get("additional_information") or {})
-    meta = dict(additional_information.get("meta") or {})
-    meta.pop(MINIMAX_H3_PREPARED_REFERENCE_VIDEOS_KEY, None)
-    additional_information["meta"] = meta
-    prompt["additional_information"] = additional_information
-
-    text = str(prompt.get("prompt") or "")
-    if not text:
-        raise OmniClientError("MiniMax H3 requires a non-empty prompt")
-    multi_modal_data = prompt.get("multi_modal_data") or {}
-    if not isinstance(multi_modal_data, Mapping):
-        raise TypeError("multi_modal_data must be a mapping")
-
-    image_values = _items(multi_modal_data.get("image"))
-    videos = _items(multi_modal_data.get("video"))
-    audios = _audio_items(multi_modal_data.get("audio"))
-    diffusion_sampling = _diffusion_sampling_params(sampling_params_list)
-    extra_args = diffusion_sampling.extra_args or {}
-    task = _resolve_task(extra_args, multi_modal_data)
-    images = _prepare_qwen_images(task, image_values, sampling_params_list)
-    qwen_video_inputs: list[tuple[np.ndarray, dict[str, Any]]] = []
-    condition_labels: list[tuple[str, int]] = []
-
-    if task == "t2va":
-        if images or videos or audios:
-            raise OmniClientError("t2va does not accept image, video, or audio conditions")
-    elif task == "fl2va":
-        if not images or videos or audios:
-            raise OmniClientError("fl2va requires image conditions only")
-        condition_labels.extend(("image", index) for index in range(1, len(images) + 1))
-    elif task == "ref2va":
-        if not images and not videos:
-            raise OmniClientError("ref2va requires an image or video condition")
-        condition_labels.extend(("image", index) for index in range(1, len(images) + 1))
-        prepared_videos: list[dict[str, Any]] = []
-        artifact_dir: str | None = None
-        if videos:
-            artifact_dir = tempfile.mkdtemp(prefix="minimax_h3_ref2va_")
-            try:
-                prepared_videos = prepare_reference_videos(
-                    videos,
-                    target_frame_count=_ref2va_target_frame_count(sampling_params_list),
-                    workdir=artifact_dir,
-                    start_time_seconds=extra_args.get("start_time_seconds"),
-                )
-                for item in prepared_videos:
-                    sampled = sample_reference_video_frames(item["prepared_path"])
-                    frames = np.stack(sampled["frames"])
-                    frame_count = int(frames.shape[0])
-                    qwen_video_inputs.append(
-                        (
-                            frames,
-                            {
-                                "total_num_frames": frame_count,
-                                "fps": MINIMAX_H3_QWEN_VIDEO_SAMPLE_FPS,
-                                "duration": frame_count / MINIMAX_H3_QWEN_VIDEO_SAMPLE_FPS,
-                                "video_backend": "minimax_h3",
-                                "frames_indices": list(range(frame_count)),
-                                "do_sample_frames": False,
-                            },
-                        )
-                    )
-            except BaseException:
-                shutil.rmtree(artifact_dir, ignore_errors=True)
-                raise
-        audio_index = 0
-        for video_index, item in enumerate(prepared_videos, start=1):
-            if item["input_has_audio"]:
-                audio_index += 1
-                condition_labels.append(("audio", audio_index))
-            condition_labels.append(("video", video_index))
-        for _ in audios:
-            audio_index += 1
-            condition_labels.append(("audio", audio_index))
-    else:
-        raise OmniClientError(f"unsupported MiniMax H3 task {task!r}")
-
+        prompt = {"prompt": prompt}
+    text = prepared.prompt
+    images = prepared.images
+    qwen_video_inputs = prepared.qwen_videos
+    condition_labels = prepared.condition_labels
+    media_input = prepared.media
+    task = media_input.task
     transformed = copy.copy(prompt)
-    if isinstance(prompt.get("additional_information"), Mapping):
-        transformed["additional_information"] = dict(prompt["additional_information"])
+    additional_information = dict(prompt.get("additional_information") or {})
     transformed["prompt"] = text
-    if task == "ref2va" and prepared_videos and artifact_dir is not None:
-        additional_information = dict(transformed.get("additional_information") or {})
-        meta = dict(additional_information.get("meta") or {})
-        meta[MINIMAX_H3_PREPARED_REFERENCE_VIDEOS_KEY] = serialize_prepared_reference_videos(
-            prepared_videos,
-            artifact_dir,
-        )
-        additional_information["meta"] = meta
-        transformed["additional_information"] = additional_information
-        transformed[REQUEST_ARTIFACT_DIRS_KEY] = [artifact_dir]
-    qwen_mm_data = dict(multi_modal_data)
-    qwen_mm_data.pop("audio", None)
+    qwen_mm_data: dict[str, Any] = {}
     if images:
         qwen_mm_data["image"] = images
     if qwen_video_inputs:
@@ -271,7 +59,16 @@ def prepare_text_encoder_prompt(
     mm_processor_kwargs = dict(prompt.get("mm_processor_kwargs") or {})
     mm_processor_kwargs[MINIMAX_H3_PRESENTATION_TASK_KEY] = task
     mm_processor_kwargs[MINIMAX_H3_CONDITION_LABELS_KEY] = condition_labels
+    media_tensors = media_input.to_mm_tensors()
     transformed["mm_processor_kwargs"] = mm_processor_kwargs
+
+    hidden_states = dict(additional_information.get("hidden_states") or {})
+    hidden_states["layers"] = dict(enumerate(media_tensors))
+    additional_information["hidden_states"] = hidden_states
+    meta = dict(additional_information.get("meta") or {})
+    meta[MINIMAX_H3_ENCODER_REQUEST_KEY] = media_input.to_metadata()
+    additional_information["meta"] = meta
+    transformed["additional_information"] = additional_information
     return transformed
 
 
@@ -295,18 +92,20 @@ def _global_request_id(prompt: Mapping[str, Any]) -> str | None:
     return str(value) if value is not None else None
 
 
-def text_encoder2diffusion(
+def encoder2diffusion(
     source_outputs: list[Any],
     prompt: Any = None,
     requires_multimodal_data: bool = False,
     streaming_context: Any | None = None,
 ) -> dict[str, Any] | None:
-    """Attach Stage 0 hidden states and token tags to the original request."""
+    """Reuse the encoder handoff for all three H3 encoder components."""
     del requires_multimodal_data, streaming_context
     if not source_outputs:
         return None
     if len(source_outputs) != 1:
-        raise RuntimeError(f"MiniMax H3 diffusion requires exactly one text-encoder source, got {len(source_outputs)}")
+        raise RuntimeError(f"MiniMax H3 DiT requires exactly one encoder source, got {len(source_outputs)}")
+    if not getattr(source_outputs[0], "finished", True):
+        return None
 
     diffusion_prompt = _original_prompt(prompt)
     source_output = source_outputs[0]
@@ -318,25 +117,32 @@ def text_encoder2diffusion(
         and str(source_request_id) != expected_request_id
     ):
         raise RuntimeError(
-            "MiniMax H3 text-encoder request ID does not match the diffusion request: "
+            "MiniMax H3 encoder request ID does not match the diffusion request: "
             f"source={source_request_id!r}, expected={expected_request_id!r}"
         )
 
     outputs = getattr(source_output, "outputs", None)
     if not isinstance(outputs, list) or len(outputs) != 1:
         output_count = len(outputs) if isinstance(outputs, list) else 0
-        raise RuntimeError(f"MiniMax H3 text encoder must return exactly one completion, got {output_count}")
-
-    completion = outputs[0]
-    payload = completion.multimodal_output
+        raise RuntimeError(f"MiniMax H3 encoder must return exactly one completion, got {output_count}")
+    payload = getattr(outputs[0], "multimodal_output", None)
     if not isinstance(payload, Mapping):
-        raise RuntimeError("MiniMax H3 text encoder returned no conditioning payload")
+        raise RuntimeError("MiniMax H3 encoder returned no conditioning payload")
     try:
-        conditioning = MiniMaxH3TextConditioning.from_omni_payload(payload)
+        conditioning = MiniMaxH3EncoderConditioning.from_omni_payload(unflatten_payload(dict(payload)))
     except ValueError as exc:
         raise RuntimeError(str(exc)) from exc
 
     additional_information = dict(diffusion_prompt.get("additional_information") or {})
-    additional_information["text_encoder_output"] = conditioning.to_payload()
+    additional_information.pop("hidden_states", None)
+    meta = dict(additional_information.get("meta") or {})
+    meta.pop(MINIMAX_H3_ENCODER_REQUEST_KEY, None)
+    if meta:
+        additional_information["meta"] = meta
+    else:
+        additional_information.pop("meta", None)
+    additional_information["encoder_output"] = conditioning.to_omni_payload()
     diffusion_prompt["additional_information"] = additional_information
+    diffusion_prompt["multi_modal_data"] = None
+    diffusion_prompt.pop("model_intermediate_buffer", None)
     return diffusion_prompt
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 423d288fe..79a6e782a 100644
--- a/vllm_omni/model_executor/stage_input_processors/qwen3_tts.py
+++ b/vllm_omni/model_executor/stage_input_processors/qwen3_tts.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 """Stage input processor for Qwen3-TTS: Talker -> Code2Wav."""
 
 import time
@@ -24,6 +27,7 @@ from vllm_omni.model_executor.stage_input_processors.chunk_size_utils import (
     parse_chunk_ramp,
 )
 from vllm_omni.model_executor.stage_input_processors.tts_utils import (
+    extract_full_utterance_decode_from_request,
     extract_language_from_prompt,
     extract_language_from_request,
     extract_speaker_from_prompt,
@@ -66,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:
@@ -74,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,
@@ -89,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
 
@@ -179,6 +207,26 @@ 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``:
+    # that flag is prompt construction only and VoiceDesign defaults it to True
+    # even for streaming responses (#4198, #6898 review). When True, defer
+    # connector chunks until the talker finishes so Code2Wav decodes once.
+    full_utterance_decode = extract_full_utterance_decode_from_request(request)
+    if full_utterance_decode is True and not finished:
+        return None
 
     if length <= 0:
         if finished:
@@ -192,7 +240,10 @@ def talker2code2wav_async_chunk(
             )
         return None
 
-    if adaptive_enabled:
+    if full_utterance_decode is True:
+        first_chunk = int(transfer_manager.put_req_chunk.get(request_id, 0)) <= 0
+        context_length = length
+    elif adaptive_enabled:
         _adaptive_states = getattr(transfer_manager, "_adaptive_states", None)
         if _adaptive_states is None:
             _adaptive_states = {}
@@ -289,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)
@@ -327,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]),
@@ -359,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,
@@ -367,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/model_executor/stage_input_processors/tts_utils.py b/vllm_omni/model_executor/stage_input_processors/tts_utils.py
index 1bc78b4a2..806f5dbcf 100644
--- a/vllm_omni/model_executor/stage_input_processors/tts_utils.py
+++ b/vllm_omni/model_executor/stage_input_processors/tts_utils.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
 # Copyright 2025 The Qwen team.
 """Shared TTS utility functions for speaker and language extraction.
 
@@ -103,6 +103,37 @@ def extract_speaker_from_prompt(
     return None
 
 
+# =============================================================================
+# Code2Wav emit-mode helpers (independent of prompt construction)
+# =============================================================================
+
+
+def extract_full_utterance_decode_from_request(request: Any) -> bool | None:
+    """Extract ``full_utterance_decode`` from a request's additional_information.
+
+    This is a *response / Code2Wav emit* intent flag. It must not be confused
+    with ``non_streaming_mode``, which only controls Qwen3-TTS prompt
+    construction and is independent of HTTP/WebSocket streaming (#4198).
+
+    Returns:
+        True/False when explicitly set, otherwise None.
+    """
+    additional_information = getattr(request, "additional_information", None)
+    if additional_information is None:
+        return None
+    entries = getattr(additional_information, "entries", None)
+    if not isinstance(entries, dict):
+        return None
+    entry = entries.get("full_utterance_decode")
+    if entry is None:
+        return None
+    list_data = getattr(entry, "list_data", None)
+    if isinstance(list_data, list) and list_data:
+        raw = list_data[0]
+        return raw if isinstance(raw, bool) else None
+    return None
+
+
 # =============================================================================
 # Language helpers
 # =============================================================================
diff --git a/vllm_omni/model_extras/__init__.py b/vllm_omni/model_extras/__init__.py
index 143a9b224..2e1146a82 100644
--- a/vllm_omni/model_extras/__init__.py
+++ b/vllm_omni/model_extras/__init__.py
@@ -6,6 +6,8 @@ from vllm_omni.model_extras.registry import (
     build_image_to_video_prompt,
     build_text_to_image_prompt,
     build_x_to_text_prompt,
+    get_ar_input_builder,
+    get_ar_tokenizer_validator,
     get_extra_body_params,
     get_extra_output_params,
     get_model_class_name,
@@ -22,6 +24,8 @@ __all__ = [
     "build_image_to_video_prompt",
     "build_text_to_image_prompt",
     "build_x_to_text_prompt",
+    "get_ar_input_builder",
+    "get_ar_tokenizer_validator",
     "get_extra_body_params",
     "get_extra_output_params",
     "get_model_class_name",
diff --git a/vllm_omni/model_extras/auk.py b/vllm_omni/model_extras/auk.py
new file mode 100644
index 000000000..16d6af52a
--- /dev/null
+++ b/vllm_omni/model_extras/auk.py
@@ -0,0 +1,145 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Request helpers for AuK: prompt rendering, sampling params, duration policy.
+
+AuK's contract is one instruction plus an optional reference clip in, audio
+out; the task (zero-shot TTS, instruct TTS, content or acoustic editing,
+enhancement, separation) is carried by the instruction text alone, so there is
+no per-task request surface.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import TYPE_CHECKING, Any
+
+from vllm import SamplingParams
+
+from vllm_omni.inputs.data import OmniDiffusionSamplingParams
+
+if TYPE_CHECKING:
+    import numpy as np
+    import torch
+
+# The upstream ChatML render of a single user turn through
+# ``Qwen2_5OmniProcessor.apply_chat_template(..., add_generation_prompt=True)``
+# with the template's default system turn.
+_CHATML = (
+    "<|im_start|>system\n"
+    "You are a helpful assistant.<|im_end|>\n"
+    "<|im_start|>user\n"
+    "{instruction}{audio_part}<|im_end|>\n"
+    "<|im_start|>assistant\n"
+)
+_AUDIO_PART = "<|audio_bos|><|AUDIO|><|audio_eos|>"
+
+# Literal marker the reference appends to the instruction when no reference
+# clip is supplied. The model was trained with it, so it is not decorative.
+NO_PROMPT_AUDIO = "|<no_prompt_audio>|"
+
+# Latent frame rate: 24 kHz waveform, VAE downsample 480 -> 50 frames/s.
+SAMPLE_RATE = 24000
+HOP = 480
+
+DEFAULT_NFE = 32
+DEFAULT_CFG = 2.0
+DEFAULT_SWAY = -1.0
+
+
+def auk_prompt(
+    instruction: str,
+    audio: tuple[np.ndarray | torch.Tensor, int] | None = None,
+    *,
+    gen_seconds: float | None = None,
+    sway: float = DEFAULT_SWAY,
+    t_grid: list[float] | None = None,
+    vae_sample: bool = False,
+) -> dict[str, Any]:
+    """Build the stage-0 prompt for one AuK request.
+
+    Args:
+        instruction: The task instruction; for text-only requests the
+            no-reference marker is appended if it is not already there.
+        audio: Reference or source clip as ``(waveform, sample_rate)``.
+            ``None`` selects the text-only (instruct TTS) path.
+        gen_seconds: Target duration. ``None`` reuses the source clip's
+            length and is an error for text-only requests.
+        sway: Sway coefficient for the Euler time grid.
+        t_grid: Explicit time grid, overriding ``sway``.
+        vae_sample: Draw the reference latent from the VAE posterior instead
+            of taking its mean.
+
+    Returns:
+        A prompt dict for ``Omni.generate``.
+    """
+    has_audio = audio is not None and not (isinstance(audio, (tuple, list)) and (len(audio) == 0 or audio[0] is None))
+    if not has_audio and not instruction.endswith(NO_PROMPT_AUDIO):
+        instruction = instruction + NO_PROMPT_AUDIO
+
+    prompt: dict[str, Any] = {
+        "prompt": _CHATML.format(
+            instruction=instruction,
+            audio_part=_AUDIO_PART if has_audio else "",
+        ),
+        "additional_information": {
+            "auk": {
+                "gen_seconds": gen_seconds,
+                "sway": sway,
+                "t_grid": list(t_grid) if t_grid is not None else None,
+                "vae_sample": vae_sample,
+                "has_audio": has_audio,
+            }
+        },
+    }
+    if has_audio:
+        prompt["multi_modal_data"] = {"audio": audio}
+    return prompt
+
+
+def auk_sampling_params(
+    *,
+    nfe: int = DEFAULT_NFE,
+    cfg: float = DEFAULT_CFG,
+    seed: int | None = 0,
+) -> list[SamplingParams | OmniDiffusionSamplingParams]:
+    """Build the per-stage sampling params for one AuK request.
+
+    Stage 0 is a prefill-only encoder, so its vLLM sampling is a no-op that
+    only has to satisfy the scheduler. Stage 1 carries the real knobs: ``nfe``
+    Euler steps and CFG strength. AuK-Flash ignores both and pins its
+    distilled recipe.
+    """
+    return [
+        SamplingParams(max_tokens=1, temperature=0.0, detokenize=False, seed=seed),
+        OmniDiffusionSamplingParams(num_inference_steps=nfe, guidance_scale=cfg, seed=seed),
+    ]
+
+
+def resolve_gen_frames(
+    gen_seconds: float | None,
+    ref_frames: int,
+    *,
+    sample_rate: int = SAMPLE_RATE,
+    hop: int = HOP,
+) -> int:
+    """Resolve the target latent length in frames.
+
+    An explicit duration wins; otherwise the target is as long as the source
+    clip. A text-only request with no duration has nothing to generate, which
+    is an error rather than a silent one-frame output.
+    """
+    if gen_seconds is not None:
+        if gen_seconds <= 0:
+            raise ValueError(f"gen_seconds must be positive; got {gen_seconds}")
+        return max(1, math.ceil(gen_seconds * sample_rate / hop))
+    if ref_frames > 0:
+        return ref_frames
+    raise ValueError("gen_seconds is required when the request carries no source audio")
+
+
+__all__ = [
+    "NO_PROMPT_AUDIO",
+    "auk_prompt",
+    "auk_sampling_params",
+    "resolve_gen_frames",
+]
diff --git a/vllm_omni/model_extras/cosmos3.py b/vllm_omni/model_extras/cosmos3.py
index 01cecf94f..452946b08 100644
--- a/vllm_omni/model_extras/cosmos3.py
+++ b/vllm_omni/model_extras/cosmos3.py
@@ -35,6 +35,7 @@ COSMOS3_EXTRA_BODY_PARAMS = frozenset(
         "resolution",
         "image_size",
         "use_state",
+        "format_prompt_as_json",
         "observation",
         "robot_obs",
         "deterministic_seed",
diff --git a/vllm_omni/model_extras/hunyuan_image3.py b/vllm_omni/model_extras/hunyuan_image3.py
index 8a53dfd54..46d48b513 100644
--- a/vllm_omni/model_extras/hunyuan_image3.py
+++ b/vllm_omni/model_extras/hunyuan_image3.py
@@ -3,6 +3,8 @@
 
 from __future__ import annotations
 
+from collections.abc import Mapping
+from dataclasses import dataclass, field
 from typing import Any
 
 
@@ -11,27 +13,162 @@ def build_x_to_text_prompt(
     prompt: str,
     has_image: bool,
 ) -> tuple[dict[str, Any], list[int] | None]:
-    """Build HunyuanImage-3 prompt tokens and stopping rules for T2T/I2T."""
+    """Build HunyuanImage-3 prompt tokens and stopping rules for T2T/I2T.
+
+    Routes through :func:`build_ar_stage_inputs`, the same declarative seam
+    the shared text_to_image / image_edit examples use, instead of
+    re-deriving the AR prefill and stop-token logic here. Unlike those
+    examples -- generic scripts that reach ``validate_ar_tokenizer`` only
+    indirectly via ``get_ar_tokenizer_validator`` -- this function is already
+    HunyuanImage3-specific, so it calls the validator directly rather than
+    requiring the (model-agnostic) ``x_to_text.py`` caller to know about it.
+    """
     from transformers import AutoTokenizer
 
-    from vllm_omni.diffusion.models.hunyuan_image3.prompt_utils import (
-        build_prompt_tokens,
-        resolve_stop_token_ids,
-        resolve_sys_type,
-    )
-
-    task = "i2t" if has_image else "t2t"
     tokenizer = AutoTokenizer.from_pretrained(model, trust_remote_code=True)
-    build_kwargs: dict[str, Any] = {"task": task, "bot_task": None}
-    if has_image:
-        build_kwargs["num_images"] = 1
-    built = build_prompt_tokens(prompt, tokenizer, **build_kwargs)
+    validate_ar_tokenizer(tokenizer)
+    ar_inputs = build_ar_stage_inputs(
+        prompt=prompt,
+        tokenizer=tokenizer,
+        extra_body=None,
+        num_images=1 if has_image else 0,
+        text_output=True,
+    )
     return (
         {
-            "prompt": prompt,
-            "prompt_token_ids": built.token_ids,
-            "modalities": ["text"],
-            "use_system_prompt": resolve_sys_type(None),
+            "prompt": ar_inputs.prompt,
+            "prompt_token_ids": ar_inputs.prompt_token_ids,
+            "modalities": ar_inputs.modalities,
+            "use_system_prompt": ar_inputs.use_system_prompt,
         },
-        resolve_stop_token_ids(task=task, bot_task=None, tokenizer=tokenizer, image_size="auto"),
+        ar_inputs.stop_token_ids,
     )
+
+
+@dataclass
+class ARStageInputs:
+    """AR-stage inputs the shared example applies to a HunyuanImage3 request.
+
+    ``prompt_token_ids`` (byte-for-byte HF parity) is preferred; ``prompt``
+    is the string fallback used when no tokenizer is available. ``modalities``
+    picks the AR output type (``["image"]`` for generation, ``["text"]`` for
+    comprehension). ``use_system_prompt`` feeds the DiT system-prompt prefix
+    and ``stop_token_ids`` terminate the AR decode.
+
+    ``stage_indices`` names which stage(s) in the request's
+    ``sampling_params_list`` these ``stop_token_ids`` belong to -- the shared
+    scripts apply them by explicit index, not by scanning for "whichever
+    stage isn't a diffusion stage." HunyuanImage-3.0's topology always puts
+    its single AR stage at index 0 (see
+    ``vllm_omni.model_executor.models.hunyuan_image3.pipeline``); a future
+    model with multiple AR/understanding stages would declare its own
+    indices here instead of relying on type-based inference.
+    """
+
+    prompt: str | None
+    prompt_token_ids: list[int] | None
+    modalities: list[str]
+    use_system_prompt: str
+    stop_token_ids: list[int]
+    stage_indices: list[int] = field(default_factory=lambda: [0])
+
+
+def build_ar_stage_inputs(
+    prompt: str,
+    tokenizer: Any | None,
+    extra_body: Mapping[str, Any] | None,
+    *,
+    num_images: int = 0,
+    height: int | None = None,
+    width: int | None = None,
+    text_output: bool = False,
+) -> ARStageInputs:
+    """Resolve HunyuanImage-3.0 AR-stage inputs declaratively.
+
+    Invoked generically by the shared task examples (``text_to_image`` /
+    ``image_to_image`` / ``x_to_text``) whenever the model declares an
+    ``ar_input_builder``. All model-specific knobs (``bot_task`` /
+    ``use_system_prompt`` / ``system_prompt``) arrive via ``extra_body``, so
+    the example itself stays model-agnostic. The heavy lifting is delegated to
+    :func:`build_ar_prompt_inputs`. The OpenAI server's ``serving_chat.py``
+    does not go through this seam -- it independently calls the same
+    underlying ``build_prompt``/``build_prompt_tokens``/``resolve_stop_token_ids``
+    primitives (see that function's docstring for the resulting divergence risk).
+    """
+    from vllm_omni.diffusion.models.hunyuan_image3.prompt_utils import (
+        build_ar_prompt_inputs,
+    )
+
+    extra_body = extra_body or {}
+    has_image = num_images > 0
+    if text_output:
+        task = "i2t" if has_image else "t2t"
+    else:
+        task = "it2i" if has_image else "t2i"
+
+    # ar_image_size: None -> AR predicts aspect ratio; explicit "{w}x{h}" ->
+    # AR stops at the terminator. Comprehension (text) tasks always auto-size.
+    ar_image_size: str | None = None
+    if not text_output and height is not None and width is not None:
+        ar_image_size = f"{width}x{height}"
+
+    kwargs: dict[str, Any] = {
+        "task": task,
+        "sys_type": extra_body.get("use_system_prompt"),
+        "custom_system_prompt": extra_body.get("system_prompt"),
+        "num_images": max(num_images, 1) if has_image else 1,
+        "tokenizer": tokenizer,
+        "image_size": ar_image_size,
+    }
+    # Only forward bot_task when the caller set it: present (incl. explicit
+    # ``None`` -> plain mode) overrides; absent lets each task pick its default
+    # trigger via build_ar_prompt_inputs' own sentinel default.
+    if "bot_task" in extra_body:
+        kwargs["bot_task"] = extra_body["bot_task"]
+
+    resolved = build_ar_prompt_inputs(prompt, **kwargs)
+    return ARStageInputs(
+        prompt=resolved.prompt,
+        prompt_token_ids=resolved.prompt_token_ids,
+        modalities=["text"] if text_output else ["image"],
+        use_system_prompt=resolved.system_prompt_type,
+        stop_token_ids=resolved.stop_token_ids,
+        # HunyuanImage-3.0's AR stage is always stage 0 (see pipeline.py's
+        # HUNYUAN_IMAGE3_PIPELINE / _AR_PIPELINE topologies).
+        stage_indices=[0],
+    )
+
+
+def validate_ar_tokenizer(tokenizer: Any) -> None:
+    """Registry-declared ``ar_tokenizer_validator`` hook for HunyuanImage3.
+
+    Called by the shared task examples right after they load a *real*
+    tokenizer for the AR stage, so a model/tokenizer revision bump that
+    silently shifts special-token ids fails loudly instead of producing a
+    request that completes with the wrong stop tokens.
+    """
+    from vllm_omni.diffusion.models.hunyuan_image3.prompt_utils import (
+        validate_special_token_ids,
+    )
+
+    validate_special_token_ids(tokenizer)
+
+
+# Per-request, model-specific knobs (non-standard sampling-param fields).
+# Standard knobs (guidance_scale / num_inference_steps / seed / height / width)
+# stay on OmniDiffusionSamplingParams; engine-level knobs
+# (diffusion_kv_cache_* / vae_use_tiling) stay as Omni() init args.
+HUNYUAN_IMAGE3_EXTRA_BODY_PARAMS = frozenset(
+    {
+        "bot_task",
+        "use_system_prompt",
+        "system_prompt",
+        "negative_prompt",
+    }
+)
+# Text outputs for i2t/t2t are surfaced through the standard AR text path;
+# no diffusion custom-output params are declared.
+HUNYUAN_IMAGE3_EXTRA_OUTPUT_PARAMS = frozenset()
+# HunyuanImage3 runs an AR stage before DiT; its extra_args must be initialised
+# so bot_task / use_system_prompt reach the AR input path.
+HUNYUAN_IMAGE3_INIT_EXTRA_ARGS_FOR_NON_DIFFUSION_STAGES = True
diff --git a/vllm_omni/model_extras/registry.py b/vllm_omni/model_extras/registry.py
index 4d2ad010a..9c4a6eed6 100644
--- a/vllm_omni/model_extras/registry.py
+++ b/vllm_omni/model_extras/registry.py
@@ -28,7 +28,18 @@ from vllm_omni.model_extras.helios import (
     HELIOS_EXTRA_BODY_PARAMS,
     HELIOS_EXTRA_OUTPUT_PARAMS,
 )
+from vllm_omni.model_extras.hunyuan_image3 import (
+    HUNYUAN_IMAGE3_EXTRA_BODY_PARAMS,
+    HUNYUAN_IMAGE3_EXTRA_OUTPUT_PARAMS,
+    HUNYUAN_IMAGE3_INIT_EXTRA_ARGS_FOR_NON_DIFFUSION_STAGES,
+)
+from vllm_omni.model_extras.hunyuan_image3 import (
+    build_ar_stage_inputs as build_hunyuan_image3_ar_stage_inputs,
+)
 from vllm_omni.model_extras.hunyuan_image3 import build_x_to_text_prompt as build_hunyuan_x_to_text_prompt
+from vllm_omni.model_extras.hunyuan_image3 import (
+    validate_ar_tokenizer as validate_hunyuan_image3_ar_tokenizer,
+)
 from vllm_omni.model_extras.lingbot_video import LINGBOT_VIDEO_EXTRA_BODY_PARAMS
 from vllm_omni.model_extras.ltx2 import (
     LTX_EXTRA_BODY_PARAMS,
@@ -178,6 +189,16 @@ def default_image_to_image_prompt(
     return result
 
 
+def _always_preserve_reference_image_size(
+    *,
+    model: str | None,
+    revision: str | None = None,
+) -> bool:
+    """Declare that a pipeline owns reference-image geometry."""
+    del model, revision
+    return True
+
+
 _EXTRA_SPECS: dict[str, dict[str, Any]] = {
     "BagelPipeline": {
         "extra_body_params": BAGEL_EXTRA_BODY_PARAMS,
@@ -219,6 +240,15 @@ _EXTRA_SPECS: dict[str, dict[str, Any]] = {
         # Shared T2I/I2V envelopes select the output modality. LingBot's
         # pipeline owns model-specific validation and normalization.
     },
+    **{
+        model_class_name: {
+            "reference_image_size_resolver": _always_preserve_reference_image_size,
+        }
+        for model_class_name in (
+            "MiniMaxH3Pipeline",
+            "MiniMaxH3ModularPipeline",
+        )
+    },
     **{
         model_class_name: {
             "extra_body_params": LTX_EXTRA_BODY_PARAMS,
@@ -233,6 +263,18 @@ _EXTRA_SPECS: dict[str, dict[str, Any]] = {
             "LTX2DistilledTwoStagePipeline",
         )
     },
+    # HunyuanImage3 keys on the model architecture name that ``get_model_class_name``
+    # reports at runtime for its AR+DiT / AR-only / DiT-only deploys
+    # (``od_config.model_class_name`` == the diffusion registry arch key). The
+    # "HunyuanImage3Pipeline" alias is kept for any path that surfaces the
+    # pipeline class name instead.
+    "HunyuanImage3ForCausalMM": {
+        "extra_body_params": HUNYUAN_IMAGE3_EXTRA_BODY_PARAMS,
+        "extra_output_params": HUNYUAN_IMAGE3_EXTRA_OUTPUT_PARAMS,
+        "init_extra_args_for_non_diffusion_stages": HUNYUAN_IMAGE3_INIT_EXTRA_ARGS_FOR_NON_DIFFUSION_STAGES,
+        "ar_input_builder": build_hunyuan_image3_ar_stage_inputs,
+        "ar_tokenizer_validator": validate_hunyuan_image3_ar_tokenizer,
+    },
     "SanaVideoPipeline": {
         "extra_body_params": SANA_VIDEO_EXTRA_BODY_PARAMS,
     },
@@ -263,6 +305,10 @@ for model_class_name in ("LTX2Pipeline", "LTX2TwoStagePipeline"):
     _EXTRA_SPECS[model_class_name]["transformer_config_subfolder_resolver"] = ltx_transformer_config_subfolder
 
 
+# Alias: some code paths surface HunyuanImage3's pipeline class name rather than
+# the architecture name; point both at the same spec.
+_EXTRA_SPECS["HunyuanImage3Pipeline"] = _EXTRA_SPECS["HunyuanImage3ForCausalMM"]
+
 # Multi-stage discovery reports the top-level wrapper rather than its DiT
 # submodule, so both names must resolve to the same request builders.
 _EXTRA_SPECS["MammothModa2ForConditionalGeneration"] = _EXTRA_SPECS["MammothModa2DiTPipeline"]
@@ -358,6 +404,32 @@ def should_init_extra_args_for_non_diffusion_stages(model_class_name: str | None
     return bool(spec and spec.get("init_extra_args_for_non_diffusion_stages", False))
 
 
+def get_ar_input_builder(model_class_name: str | None) -> Callable[..., Any] | None:
+    """Return a model's AR-stage input builder, or ``None`` if undeclared.
+
+    Models with a text/AR stage that needs template-formatted prompt tokens
+    and AR stop tokens (e.g. HunyuanImage3) declare an ``ar_input_builder``.
+    The shared task examples call it generically when present, so the example
+    scripts stay model-agnostic; models without one are unaffected.
+    """
+    spec = _get_spec(model_class_name)
+    return spec.get("ar_input_builder") if spec is not None else None
+
+
+def get_ar_tokenizer_validator(model_class_name: str | None) -> Callable[[Any], None] | None:
+    """Return a model's AR-tokenizer validator, or ``None`` if undeclared.
+
+    Models whose AR prompt/stop-token logic depends on hardcoded special
+    token ids (e.g. HunyuanImage3) declare an ``ar_tokenizer_validator`` to
+    check those ids against whatever tokenizer actually loads at runtime.
+    The shared task examples call it generically, right after loading a real
+    tokenizer, so model/tokenizer revision drift fails loudly instead of
+    silently producing a request with the wrong stop tokens.
+    """
+    spec = _get_spec(model_class_name)
+    return spec.get("ar_tokenizer_validator") if spec is not None else None
+
+
 def build_text_to_image_prompt(
     model_class_name: str | None,
     prompt: dict[str, Any],
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/mm_outputs.py b/vllm_omni/outputs/mm_outputs.py
index 8c5fe6442..45d1fc6fc 100644
--- a/vllm_omni/outputs/mm_outputs.py
+++ b/vllm_omni/outputs/mm_outputs.py
@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 """Multimodal output data structures for vLLM-Omni.
 
 This module defines structured types for multimodal outputs.
@@ -14,7 +16,11 @@ import torch
 from vllm.logger import init_logger
 from vllm.outputs import CompletionOutput
 
-from vllm_omni.outputs.output_modality import TensorAccumulationStrategy
+from vllm_omni.outputs.output_modality import (
+    OutputModality,
+    TensorAccumulationStrategy,
+    get_accumulation_strategy,
+)
 from vllm_omni.outputs.utils import _is_tensor_list, _to_cpu
 
 logger = init_logger(__name__)
@@ -44,21 +50,24 @@ def _consolidate_tensor_list(
     tensor_list: list[torch.Tensor],
     strategy: TensorAccumulationStrategy,
 ) -> torch.Tensor:
-    """Concatenate a deferred tensor list, with fallbacks on shape mismatch."""
+    """Concatenate a deferred tensor list, with a fallback for CONCAT_LAST only.
+
+    A shape mismatch under CONCAT_LAST is expected for genuine audio waveform
+    chunks (their non-last dims can vary between async-chunk steps), so that
+    case falls back to flattening each chunk before concatenating. Any other
+    strategy failing to concatenate means the tensors are not shaped the way
+    that strategy assumes (e.g. a key was assigned the wrong strategy), so it
+    is surfaced instead of silently keeping only the last chunk.
+    """
     try:
         return _cat_tensors(tensor_list, strategy)
-    except RuntimeError:
-        # [TODO: this part is for async chunk, not for audio only. can we come up with a design
-        # that identify this by whether using async chunk instead of modality?]
-        if key != "audio":
-            logger.warning("Error concatenating tensor for key %s; keeping last tensor", key)
-            return tensor_list[-1]
-        # Audio chunks may have mismatched shapes; retry along the last dim,
-        # then fall back to flattening each chunk.
-        try:
-            return torch.cat(tensor_list, dim=-1)
-        except RuntimeError:
-            return torch.cat([chunk.reshape(-1) for chunk in tensor_list], dim=0)
+    except RuntimeError as exc:
+        if strategy is not TensorAccumulationStrategy.CONCAT_LAST:
+            raise RuntimeError(
+                f"Error concatenating tensor list for key {key!r} under strategy {strategy}: {exc}"
+            ) from exc
+        logger.warning("CONCAT_LAST failed for key %s; flattening each chunk before concatenating", key)
+        return torch.cat([chunk.reshape(-1) for chunk in tensor_list], dim=0)
 
 
 def _append_entries(store: dict[str, Any], incoming: dict[str, Any]) -> None:
@@ -113,7 +122,7 @@ class MultimodalPayload(Mapping):
             return self.tensors[key]
         return self.metadata.get(key, default)
 
-    def __contains__(self, key: str) -> bool:
+    def __contains__(self, key: object) -> bool:
         return key in self.tensors or key in self.metadata
 
     def __getitem__(self, key: str) -> Any:
@@ -145,23 +154,37 @@ class MultimodalPayload(Mapping):
     def merged_with(self, incoming: MultimodalPayload) -> MultimodalPayload:
         """Merge *incoming* onto this payload and return the result.
 
-        Tensor values accumulate into lists for deferred concatenation;
-        non-tensor values are replaced with the latest. When this payload
+        Content tensors accumulate into lists for deferred concatenation;
+        known sample-rate keys are snapshots replaced immediately, including
+        in DELTA streams that do not consolidate each emission. Missing keys
+        retain their previous value. Other values keep the existing merge
+        behavior. When this payload
         is empty, *incoming* is returned as-is, so callers should use the
         return value: ``accumulated = accumulated.merged_with(incoming)``.
         """
         if self.is_empty:
             return incoming
+        # Capture before merging: incoming may be this payload. Store these
+        # snapshots in only one partition even if their representation changes.
+        snapshots = {key: incoming[key] for key in _METADATA_TENSOR_KEYS if key in incoming}
         _append_entries(self.tensors, incoming.tensors)
         _append_entries(self.metadata, incoming.metadata)
+        for key, value in snapshots.items():
+            self.tensors.pop(key, None)
+            self.metadata[key] = value
         return self
 
-    def consolidate_tensors(self, strategy: TensorAccumulationStrategy) -> None:
+    def consolidate_tensors(self, modality: OutputModality) -> None:
         """Concatenate deferred tensor lists into single tensors.
 
-        Tensors are generated content accumulated as chunks, so lists are
-        concatenated according to *strategy* (e.g. audio chunks along the
-        time dimension, latent frames along the batch dimension).
+        Tensors are generated content accumulated as chunks, so each key's
+        list is concatenated according to the strategy
+        ``get_accumulation_strategy(modality, key)`` resolves for it (e.g.
+        audio waveform chunks along the time dimension, latent frames along
+        the batch dimension). Most keys share *modality*'s default, but a
+        key can be registered for a different strategy -- e.g. a codec-frame
+        matrix that grows along dim 0 rather than the waveform-tuned default
+        for its modality -- via ``register_key_accumulation_strategy``.
         """
         # Relocate scalar metadata tensors (e.g. sample rate) that from_dict
         # routed into .tensors, so they take the REPLACE path via .metadata
@@ -174,6 +197,7 @@ class MultimodalPayload(Mapping):
 
         for key, value in list(self.tensors.items()):
             if _is_tensor_list(value):
+                strategy = get_accumulation_strategy(modality, key)
                 self.tensors[key] = _consolidate_tensor_list(key, value, strategy)
 
     def consolidate_metadata(self) -> None:
diff --git a/vllm_omni/outputs/output_modality.py b/vllm_omni/outputs/output_modality.py
index 7cdbc1f19..412e61619 100644
--- a/vllm_omni/outputs/output_modality.py
+++ b/vllm_omni/outputs/output_modality.py
@@ -115,8 +115,43 @@ class TensorAccumulationStrategy(Enum):
     """Replace previous tensor entirely with the latest one."""
 
 
-def get_accumulation_strategy(modality: OutputModality) -> TensorAccumulationStrategy:
-    """Determine tensor merge strategy from the multimodal flags."""
+# Per-tensor-key overrides for the modality-wide default below. A modality
+# is a coarse hint (e.g. AUDIO tensors are usually waveform chunks that grow
+# along the last dimension), but some models emit tensors under that same
+# modality whose accumulation semantics differ -- e.g. discrete codec-frame
+# matrices that grow along dim 0, or a constant reference/context tensor
+# re-emitted unchanged at every step. Pipelines that produce such keys
+# register the correct strategy here via ``register_key_accumulation_strategy``
+# instead of forcing every tensor of the modality through one default.
+_KEY_ACCUMULATION_OVERRIDES: dict[str, TensorAccumulationStrategy] = {}
+
+
+def register_key_accumulation_strategy(key: str, strategy: TensorAccumulationStrategy) -> None:
+    """Register a per-key override for ``get_accumulation_strategy``.
+
+    Args:
+        key: The flattened multimodal output key this override applies to,
+            e.g. ``"codes.audio"`` as produced by
+            ``vllm_omni.data_entry_keys.flatten_payload`` from a nested
+            ``{"codes": {"audio": tensor}}`` payload.
+        strategy: The accumulation strategy to use for this key, regardless
+            of the modality its request is otherwise associated with.
+    """
+    _KEY_ACCUMULATION_OVERRIDES[key] = strategy
+
+
+def get_accumulation_strategy(
+    modality: OutputModality,
+    key: str | None = None,
+) -> TensorAccumulationStrategy:
+    """Determine the tensor merge strategy for one output key.
+
+    A registered per-key override (see ``register_key_accumulation_strategy``)
+    always wins; otherwise the strategy falls back to the modality-wide
+    default.
+    """
+    if key is not None and key in _KEY_ACCUMULATION_OVERRIDES:
+        return _KEY_ACCUMULATION_OVERRIDES[key]
     if OutputModality.AUDIO in modality:
         return TensorAccumulationStrategy.CONCAT_LAST
     if OutputModality.IMAGE in modality or OutputModality.LATENT in modality:
diff --git a/vllm_omni/outputs/output_processor.py b/vllm_omni/outputs/output_processor.py
index 13844518e..cac8d9990 100644
--- a/vllm_omni/outputs/output_processor.py
+++ b/vllm_omni/outputs/output_processor.py
@@ -28,7 +28,7 @@ from vllm_omni.outputs.multimodal_accumulation import (
     is_non_final_delta_audio_chunk,
     replace_snapshot_keys,
 )
-from vllm_omni.outputs.output_modality import OutputModality, get_accumulation_strategy
+from vllm_omni.outputs.output_modality import OutputModality
 
 logger = init_logger(__name__)
 
@@ -59,6 +59,10 @@ def _modality_to_type_string(modality: OutputModality) -> str:
     return "text"
 
 
+_TPOT_ELAPSED_MS = "_tpot_elapsed_ms"
+_TPOT_INTERVALS = "_tpot_intervals"
+
+
 def _mean_time_per_output_token_ms(stats: RequestStateStats) -> float:
     output_intervals = stats.num_generation_tokens - 1
     if output_intervals <= 0:
@@ -67,6 +71,17 @@ def _mean_time_per_output_token_ms(stats: RequestStateStats) -> float:
     return decode_time_s * 1000.0 / float(output_intervals)
 
 
+def _accumulate_segment_tpot(record: dict[str, object], *, elapsed_ms: float, new_tokens: int) -> None:
+    """Weight one decode step by its token count. ITL stays one sample per step."""
+    if new_tokens <= 0:
+        return
+    total_elapsed_ms = float(record.get(_TPOT_ELAPSED_MS) or 0.0) + elapsed_ms
+    total_intervals = int(record.get(_TPOT_INTERVALS) or 0) + new_tokens
+    record[_TPOT_ELAPSED_MS] = total_elapsed_ms
+    record[_TPOT_INTERVALS] = total_intervals
+    record["vllm_tpot_ms"] = total_elapsed_ms / float(total_intervals)
+
+
 class OmniRequestState(RequestState):
     """Request state for omni models, tracking multimodal outputs.
 
@@ -125,8 +140,8 @@ class OmniRequestState(RequestState):
         """Consolidate accumulated tensor lists into single tensors.
 
         Uses TensorAccumulationStrategy derived from the output modality
-        to determine concatenation behavior. Metadata values always use
-        REPLACE (keep latest).
+        (with any per-key override applied) to determine concatenation
+        behavior. Metadata values always use REPLACE (keep latest).
         """
         if self.mm_accumulated.is_empty:
             return
@@ -135,10 +150,9 @@ class OmniRequestState(RequestState):
             modality = OutputModality.from_string(self.mm_type)
         except (ValueError, KeyError):
             modality = OutputModality.TEXT
-        strategy = get_accumulation_strategy(modality)
 
         try:
-            self.mm_accumulated.consolidate_tensors(strategy)
+            self.mm_accumulated.consolidate_tensors(modality)
             self.mm_accumulated.consolidate_metadata()
         except (RuntimeError, TypeError, KeyError):
             logger.exception("Error consolidating multimodal tensors")
@@ -430,7 +444,10 @@ class MultimodalOutputProcessor(VLLMOutputProcessor):
         )
 
     def pop_native_text_metrics(self, request_id: str) -> dict[str, Any]:
-        return self._native_text_metrics_by_request.pop(request_id, {})
+        record = self._native_text_metrics_by_request.pop(request_id, {})
+        record.pop(_TPOT_ELAPSED_MS, None)
+        record.pop(_TPOT_INTERVALS, None)
+        return record
 
     def abort_requests(self, request_ids, internal: bool) -> list[str]:
         aborted_ids, _outputs = self.abort_requests_collecting_outputs(request_ids, internal=internal)
@@ -667,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:
@@ -680,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,
@@ -701,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
@@ -753,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,
@@ -770,6 +804,7 @@ class MultimodalOutputProcessor(VLLMOutputProcessor):
         was_prefilling = req_state.is_prefilling
         native_stats = req_state.native_text_stats if isinstance(req_state, OmniRequestState) else None
         previous_last_token_ts = native_stats.last_token_ts if native_stats is not None else 0.0
+        previous_num_generation_tokens = int(native_stats.num_generation_tokens) if native_stats is not None else 0
 
         # NOTE: We pass ``None`` for  *iteration_stats* to the parent so that
         # the upstream's ``_update_stats_from_output`` logs stats via its own
@@ -786,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
 
@@ -798,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
@@ -808,7 +851,13 @@ class MultimodalOutputProcessor(VLLMOutputProcessor):
             itls_ms = record.setdefault("vllm_itls_ms", [])
             itls_ms.append(itl_ms)
             record["vllm_itl_ms"] = sum(itls_ms) / float(len(itls_ms))
-        record["vllm_tpot_ms"] = _mean_time_per_output_token_ms(native_stats)
+            _accumulate_segment_tpot(
+                record,
+                elapsed_ms=itl_ms,
+                new_tokens=max(int(native_stats.num_generation_tokens) - previous_num_generation_tokens, 0),
+            )
+        elif not record["vllm_itls_ms"]:
+            record["vllm_tpot_ms"] = _mean_time_per_output_token_ms(native_stats)
 
     def _update_stats_from_finished(
         self,
@@ -836,6 +885,7 @@ class MultimodalOutputProcessor(VLLMOutputProcessor):
         finished_request = iteration_stats.finished_requests[-1]
         if finished_request.request_id != req_state.external_req_id:
             return
-        self._native_text_metric_record(req_state.external_req_id)["vllm_tpot_ms"] = (
-            float(finished_request.mean_time_per_output_token) * 1000.0
-        )
+        finished_tpot_ms = float(finished_request.mean_time_per_output_token) * 1000.0
+        record = self._native_text_metric_record(req_state.external_req_id)
+        if finished_tpot_ms > 0 and not record.get("vllm_itls_ms"):
+            record["vllm_tpot_ms"] = finished_tpot_ms
diff --git a/vllm_omni/platforms/npu/models/minicpmo_4_5_code2wav.py b/vllm_omni/platforms/npu/models/minicpmo_4_5_code2wav.py
index 0d34c93a5..4346e83b6 100644
--- a/vllm_omni/platforms/npu/models/minicpmo_4_5_code2wav.py
+++ b/vllm_omni/platforms/npu/models/minicpmo_4_5_code2wav.py
@@ -75,10 +75,15 @@ def _graphable_estimator_step(
     cond,
     cnn_cache,
     att_cache,
+    valid_frames=None,
 ):
     """Run the CFM estimator body after host-backed timestep embedding."""
     width = int(x.shape[-1])
     speaker_features = speakers.unsqueeze(-1).expand(-1, -1, width)
+    if valid_frames is not None and valid_frames < width:
+        # Match the CUDA path: padded columns must not carry the speaker vector.
+        speaker_features = speaker_features.clone()
+        speaker_features[:, :, valid_frames:] = 0.0
     estimator_input = torch.cat((x, mu, speaker_features, cond), dim=1)
     cnn_out, att_out = backend._estimator_buffers(estimator, estimator_input, att_cache)
     old_cnn = cnn_cache if cnn_cache is not None else [None] * len(estimator.blocks)
@@ -108,6 +113,7 @@ def _patched_estimator_step(
     att_cache,
     attn_mask=None,
     valid_lengths=None,
+    valid_frames=None,
 ):
     assert _original_estimator_step is not None
     graph_runner = _backend_graph_runners.get(self)
@@ -130,10 +136,16 @@ def _patched_estimator_step(
             att_cache=att_cache,
             attn_mask=attn_mask,
             valid_lengths=valid_lengths,
+            valid_frames=valid_frames,
         )
     if (cnn_cache is None) != (att_cache is None):
         raise ValueError("estimator CNN and attention caches must both be present or absent")
 
+    # valid_frames only matters for padded inputs; skip forwarding it for
+    # unpadded calls so platform-owned graphable bodies that predate the
+    # padding feature keep working with the old signature.
+    graphable_kwargs = {"valid_frames": valid_frames} if valid_frames is not None else {}
+
     # The upstream embedder creates a frequency tensor on the host. Keep it
     # outside capture while retaining the tensor-only estimator body in graph.
     time_embedding = estimator.t_embedder(time).unsqueeze(1)
@@ -152,6 +164,7 @@ def _patched_estimator_step(
                 cond=step_cond,
                 cnn_cache=None,
                 att_cache=None,
+                **graphable_kwargs,
             ),
         )
 
@@ -169,6 +182,7 @@ def _patched_estimator_step(
             cond=step_cond,
             cnn_cache=step_cnn,
             att_cache=step_att,
+            **graphable_kwargs,
         ),
     )
 
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/models/qwen3_tts.py b/vllm_omni/platforms/npu/models/qwen3_tts.py
index a91d2cf80..124e60624 100644
--- a/vllm_omni/platforms/npu/models/qwen3_tts.py
+++ b/vllm_omni/platforms/npu/models/qwen3_tts.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
 
 """Patch Qwen3-TTS NPU runtime setup and weights.
 
@@ -68,11 +68,16 @@ def _patched_load_weights(self, weights):
     assert _original_load_weights is not None
     loaded = _original_load_weights(self, weights)
     device = self.vllm_config.device_config.device
-    runtime_dtype = getattr(self, "_npu_decoder_runtime_dtype", lambda _: torch.float32)(device)
-    self.decoder.to(device=device, dtype=runtime_dtype)
+    platform_dtype_override = getattr(self, "_npu_decoder_runtime_dtype", None)
+    if platform_dtype_override is not None:
+        # 310P requires FP16 and deliberately overrides the stage dtype.
+        runtime_dtype = platform_dtype_override(device)
+        self.decoder.to(device=device, dtype=runtime_dtype)
+        if hasattr(self.decoder, "precompute_snake_caches"):
+            self.decoder.precompute_snake_caches()
     _prepare_npu_decoder_weights(self.decoder)
-    if runtime_dtype != torch.float32 and hasattr(self.decoder, "precompute_snake_caches"):
-        self.decoder.precompute_snake_caches()
+    actual_dtype = next(self.decoder.parameters()).dtype
+    logger.info("Prepared NPU Code2Wav decoder with runtime dtype %s", actual_dtype)
     return loaded
 
 
@@ -108,8 +113,8 @@ def _apply_a5_prompt_embeds_builder_patch() -> None:
 
     # The talker imports the builder by name at module scope, so its reference
     # must be swapped as well (same as the 310P patch).
-    prompt_embeds_builder.Qwen3TTSPromptEmbedsBuilder = _Qwen3TTSPromptEmbedsBuilderA5
-    qwen3_tts_talker.Qwen3TTSPromptEmbedsBuilder = _Qwen3TTSPromptEmbedsBuilderA5
+    setattr(prompt_embeds_builder, "Qwen3TTSPromptEmbedsBuilder", _Qwen3TTSPromptEmbedsBuilderA5)
+    setattr(qwen3_tts_talker, "Qwen3TTSPromptEmbedsBuilder", _Qwen3TTSPromptEmbedsBuilderA5)
     _A5_PATCHED = True
     logger.debug("Applied A5 prompt-embeds builder patch for Qwen3-TTS")
 
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 734178e01..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,
@@ -334,6 +256,8 @@ class NPUARModelRunner(OmniNPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
         if not isinstance(info, dict):
             return None
         val = info.get("omni_final_stage_id")
+        if val is None:
+            return None
         try:
             return int(val)
         except (TypeError, ValueError):
@@ -449,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():
@@ -512,7 +433,7 @@ class NPUARModelRunner(OmniNPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
                         # returns True. before returning early here we call
                         # dummy run to ensure coordinate_batch_across_dp
                         # is called into to avoid out of sync issues.
-                        self._dummy_run(1)
+                        self._dummy_run(1, skip_gdn_state_update=True)
 
                     kv_ids = self.kv_extracted_req_ids
                     self.kv_extracted_req_ids = None
@@ -779,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,
             )
@@ -861,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
 
@@ -896,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(
@@ -953,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
@@ -1035,6 +965,8 @@ class NPUARModelRunner(OmniNPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
                     propose_draft_token_ids(sampler_output.sampled_token_ids)
 
         (
+            num_nans_in_logits,
+            num_nans_device,
             logprobs_lists,
             valid_sampled_token_ids,
             prompt_logprobs_dict,
@@ -1101,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),
@@ -1126,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
                 )
@@ -1278,6 +1206,7 @@ class NPUARModelRunner(OmniNPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
             kv_connector_output=kv_connector_output,
             ec_connector_output=ec_connector_output if self.supports_mm_inputs else None,
             cudagraph_stats=cudagraph_stats,
+            num_nans_in_logits=num_nans_in_logits,
         )
         model_runner_output.kv_extracted_req_ids = kv_extracted_req_ids
         model_runner_output.routed_experts = routed_experts_lists
@@ -1318,6 +1247,7 @@ class NPUARModelRunner(OmniNPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
             invalid_req_indices=invalid_req_indices,
             async_output_copy_stream=self.async_output_copy_stream,
             vocab_size=self.input_batch.vocab_size,
+            num_nans=num_nans_device,
         )
         self.input_batch.set_async_sampled_token_ids(
             async_output.sampled_token_ids_cpu,
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 fc26882cd..d796dec8e 100644
--- a/vllm_omni/platforms/npu/worker/npu_generation_model_runner.py
+++ b/vllm_omni/platforms/npu/worker/npu_generation_model_runner.py
@@ -166,7 +166,7 @@ class NPUGenerationModelRunner(OmniNPUModelRunner, OmniConnectorModelRunnerMixin
                         # returns True. before returning early here we call
                         # dummy run to ensure coordinate_batch_across_dp
                         # is called into to avoid out of sync issues.
-                        self._dummy_run(1)
+                        self._dummy_run(1, skip_gdn_state_update=True)
                     if not has_kv_transfer_group():
                         # Return empty ModelRunnerOutput if no work to do.
                         return self.attach_omni_connector_output(EMPTY_MODEL_RUNNER_OUTPUT)
@@ -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
@@ -636,6 +637,7 @@ class NPUGenerationModelRunner(OmniNPUModelRunner, OmniConnectorModelRunnerMixin
         profile_seq_lens: int | None = None,
         profile_cpp: bool = False,
         randomize_inputs: bool = False,
+        skip_gdn_state_update: bool = False,
     ) -> tuple[torch.Tensor, torch.Tensor]:
         # only support eager mode and piecewise graph now
         assert cudagraph_runtime_mode is None or cudagraph_runtime_mode.is_valid_runtime_mode()
@@ -768,7 +770,10 @@ class NPUGenerationModelRunner(OmniNPUModelRunner, OmniConnectorModelRunnerMixin
                 self.query_start_loc.np[1 : num_reqs_padded + 1] = cum_num_tokens
                 self.query_start_loc.copy_to_gpu()
                 if self._has_gdn:
-                    self.gdn_query_start_loc.np[1 : num_reqs_padded + 1] = cum_num_tokens
+                    if skip_gdn_state_update:
+                        self.gdn_query_start_loc.np.fill(0)
+                    else:
+                        self.gdn_query_start_loc.np[1 : num_reqs_padded + 1] = cum_num_tokens
                     self.gdn_query_start_loc.copy_to_gpu()
 
                 if not profile_cpp:
@@ -786,6 +791,12 @@ class NPUGenerationModelRunner(OmniNPUModelRunner, OmniConnectorModelRunnerMixin
                 # rows as well so device-side metadata does not see stale block ids.
                 self.input_batch.block_table.commit_block_table(num_reqs_padded)
 
+                # Invalidate slots before backends copy metadata for dummy execution.
+                if not is_graph_capturing:
+                    for kv_cache_gid in range(len(self.kv_cache_config.kv_cache_groups)):
+                        blk_table = self.input_batch.block_table[kv_cache_gid]
+                        blk_table.slot_mapping.gpu.fill_(-1)
+
                 pad_attn = cudagraph_runtime_mode == CUDAGraphMode.FULL
                 attn_metadata, _ = self._build_attention_metadata(
                     num_tokens=num_tokens_unpadded,
@@ -796,11 +807,10 @@ class NPUGenerationModelRunner(OmniNPUModelRunner, OmniConnectorModelRunnerMixin
                     ubatch_slices=ubatch_slices_padded if pad_attn else ubatch_slices,
                     for_cudagraph_capture=is_graph_capturing,
                     num_scheduled_tokens_np=num_scheduled_tokens,
+                    cudagraph_runtime_mode=cudagraph_runtime_mode,
+                    batch_descriptor=batch_desc,
+                    skip_gdn_state_update=skip_gdn_state_update,
                 )
-                if not is_graph_capturing:
-                    for kv_cache_gid in range(len(self.kv_cache_config.kv_cache_groups)):
-                        blk_table = self.input_batch.block_table[kv_cache_gid]
-                        blk_table.slot_mapping.gpu.fill_(-1)
 
         with self.maybe_dummy_run_with_lora(
             self.lora_config,
diff --git a/vllm_omni/platforms/npu/worker/npu_model_runner.py b/vllm_omni/platforms/npu/worker/npu_model_runner.py
index 8f0369808..d8e352d48 100644
--- a/vllm_omni/platforms/npu/worker/npu_model_runner.py
+++ b/vllm_omni/platforms/npu/worker/npu_model_runner.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 functools import partial
 from typing import Any
@@ -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()
@@ -126,6 +125,7 @@ class OmniNPUModelRunner(OmniGPUModelRunner, NPUModelRunner):
         profile_seq_lens: int | None = None,
         profile_cpp: bool = False,
         randomize_inputs: bool = False,
+        skip_gdn_state_update: bool = False,
     ) -> tuple[torch.Tensor, torch.Tensor]:
         # only support eager mode and piecewise graph now
         assert cudagraph_runtime_mode is None or cudagraph_runtime_mode.is_valid_runtime_mode()
@@ -257,7 +257,10 @@ class OmniNPUModelRunner(OmniGPUModelRunner, NPUModelRunner):
                 self.query_start_loc.np[1 : num_reqs_padded + 1] = cum_num_tokens
                 self.query_start_loc.copy_to_gpu()
                 if self._has_gdn:
-                    self.gdn_query_start_loc.np[1 : num_reqs_padded + 1] = cum_num_tokens
+                    if skip_gdn_state_update:
+                        self.gdn_query_start_loc.np.fill(0)
+                    else:
+                        self.gdn_query_start_loc.np[1 : num_reqs_padded + 1] = cum_num_tokens
                     self.gdn_query_start_loc.copy_to_gpu()
 
                 if not profile_cpp:
@@ -275,6 +278,12 @@ class OmniNPUModelRunner(OmniGPUModelRunner, NPUModelRunner):
                 # rows as well so device-side metadata does not see stale block ids.
                 self.input_batch.block_table.commit_block_table(num_reqs_padded)
 
+                # Invalidate slots before backends copy metadata for dummy execution.
+                if not is_graph_capturing:
+                    for kv_cache_gid in range(len(self.kv_cache_config.kv_cache_groups)):
+                        blk_table = self.input_batch.block_table[kv_cache_gid]
+                        blk_table.slot_mapping.gpu.fill_(-1)
+
                 pad_attn = cudagraph_runtime_mode == CUDAGraphMode.FULL
                 attn_metadata, _ = self._build_attention_metadata(
                     num_tokens=num_tokens_unpadded,
@@ -285,11 +294,10 @@ class OmniNPUModelRunner(OmniGPUModelRunner, NPUModelRunner):
                     ubatch_slices=ubatch_slices_padded if pad_attn else ubatch_slices,
                     for_cudagraph_capture=is_graph_capturing,
                     num_scheduled_tokens_np=num_scheduled_tokens,
+                    cudagraph_runtime_mode=cudagraph_runtime_mode,
+                    batch_descriptor=batch_desc,
+                    skip_gdn_state_update=skip_gdn_state_update,
                 )
-                if not is_graph_capturing:
-                    for kv_cache_gid in range(len(self.kv_cache_config.kv_cache_groups)):
-                        blk_table = self.input_batch.block_table[kv_cache_gid]
-                        blk_table.slot_mapping.gpu.fill_(-1)
 
         with self.maybe_dummy_run_with_lora(
             self.lora_config,
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/entrypoints/duplex/audio.py b/vllm_omni/protocol/realtime/audio.py
similarity index 96%
rename from vllm_omni/entrypoints/duplex/audio.py
rename to vllm_omni/protocol/realtime/audio.py
index 747293a1a..5f163826a 100644
--- a/vllm_omni/entrypoints/duplex/audio.py
+++ b/vllm_omni/protocol/realtime/audio.py
@@ -11,6 +11,8 @@ 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.
@@ -39,14 +41,10 @@ def validate_input_sample_rate_hz(sample_rate_hz: object) -> int:
 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
-    # Import lazily so the generic Duplex audio module does not pull in the
-    # OpenAI API server while the Duplex stack itself is being imported.
-    from vllm_omni.entrypoints.openai.audio_utils_mixin import StreamingAudioResampler
-
     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:
+    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:
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 6beb91018..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",
@@ -34,11 +33,13 @@ _CLASS_TO_MODULE: dict[str, str] = {
     "MingFlashOmniConfig": "vllm_omni.transformers_utils.configs.ming_flash_omni",
     "Qwen3VLMoeVisionConfig": "vllm_omni.transformers_utils.configs.ming_flash_omni",
     "WhisperEncoderConfig": "vllm_omni.transformers_utils.configs.ming_flash_omni",
+    "AuKConfig": "vllm_omni.transformers_utils.configs.auk",
     "SenseNovaU1Config": "vllm_omni.transformers_utils.configs.sensenova_u1",
 }
 
 __all__ = [
     "Audio8TTSConfig",
+    "AuKConfig",
     "Audio8TTSFastARConfig",
     "Audio8TTSSlowARConfig",
     "HiggsAudioV3Config",
@@ -51,7 +52,6 @@ __all__ = [
     "FishSpeechFastARConfig",
     "GLMTTSConfig",
     "VoxCPM2Config",
-    "DotsTTSConfig",
     "VoxtralTTSConfig",
     "CosyVoice3Config",
     "MiniMaxMusic3Config",
@@ -82,8 +82,8 @@ def __dir__():
 # Eagerly import all config modules so their AutoConfig.register() side-effects
 # run as soon as `vllm_omni.transformers_utils.configs` is imported.
 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/auk.py b/vllm_omni/transformers_utils/configs/auk.py
new file mode 100644
index 000000000..d1e8fa805
--- /dev/null
+++ b/vllm_omni/transformers_utils/configs/auk.py
@@ -0,0 +1,130 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+"""Config for the AuK instruction-driven audio generation model.
+
+The upstream checkpoint ships ``config.yaml`` plus loose safetensors, so an
+assembled directory is produced by ``tools/prepare_auk_checkpoint.py``: the
+Qwen2.5-Omni-3B ``config.json`` with this ``model_type``, AuK's architecture,
+and the five sections below added at the top level.
+
+Subclassing ``Qwen2_5OmniConfig`` is load-bearing, not stylistic. The encoder
+stage reuses the in-tree Qwen2.5-Omni thinker processor, whose
+``get_hf_config`` resolves ``self.ctx.get_hf_config(Qwen2_5OmniConfig)`` and
+asserts the type, so a bare ``PretrainedConfig`` subclass would fail before
+the first request. Inheriting also leaves the parent's nested
+``thinker_config`` / ``talker_config`` / ``token2wav_config`` handling and its
+``get_text_config`` in place, which is what the encoder stage reads.
+"""
+
+from typing import Any
+
+from transformers import AutoConfig
+from transformers.models.qwen2_5_omni.configuration_qwen2_5_omni import Qwen2_5OmniConfig
+
+# The distilled AuK-Flash checkpoint pins a 4-step time grid recorded in its
+# metadata. The values are exact and must never be rounded: the student was
+# trained on them, and a rounded grid changes the output amplitude.
+AUK_FLASH_T_GRID: tuple[float, ...] = (
+    0.0,
+    0.07612049579620361,
+    0.2928932309150696,
+    0.6173166036605835,
+    1.0,
+)
+
+DEFAULT_DIT: dict[str, Any] = {
+    "dim": 1536,
+    "heads": 24,
+    "dim_head": 64,
+    "ff_mult": 2,
+    "text_hidden_dim": 2048,
+    "num_layers": 10,
+    "num_single_layers": 20,
+    "attn_mask_enabled": True,
+}
+
+DEFAULT_VAE: dict[str, Any] = {
+    "latent_dim": 64,
+    "downsample_rate": 480,
+    "target_sample_rate": 24000,
+    "model_init_kwargs": {
+        "upsample_rates": [5, 4, 3, 2, 2, 2],
+        "upsample_kernel_sizes": [10, 8, 6, 4, 4, 4],
+        "upsample_initial_channel": 1536,
+        "resblock_kernel_sizes": [3, 7, 11],
+        "resblock_dilation_sizes": [[1, 3, 5], [1, 3, 5], [1, 3, 5]],
+        "downsample_rates": [2, 2, 2, 3, 4, 5],
+        "downsample_channels": [12, 24, 48, 96, 192, 384, 768],
+        "snake_logscale": True,
+        "latent_dim": 64,
+        "use_vae": True,
+        "causal": True,
+        "flow_hidden_channels": 256,
+        "act_causal": True,
+    },
+}
+
+# Base AuK sampling recipe; AuK-Flash replaces nfe and cfg with its own.
+DEFAULT_SAMPLING: dict[str, Any] = {"nfe": 32, "cfg": 2.0, "sway": -1.0}
+
+VARIANTS = ("base", "flash")
+
+
+class AuKConfig(Qwen2_5OmniConfig):
+    """Assembled AuK checkpoint config: a Qwen2.5-Omni config plus DiT and VAE."""
+
+    model_type = "auk"
+
+    def __init__(
+        self,
+        dit: dict[str, Any] | None = None,
+        vae: dict[str, Any] | None = None,
+        variant: str = "base",
+        flash_t_grid: list[float] | None = None,
+        defaults: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        if variant not in VARIANTS:
+            raise ValueError(f"AuK variant must be one of {VARIANTS}; got {variant!r}")
+
+        # Assigned before the parent's init so nothing it runs during
+        # validation sees a half-built config.
+        self.dit = {**DEFAULT_DIT, **(dit or {})}
+        self.vae = {**DEFAULT_VAE, **(vae or {})}
+        self.variant = variant
+        self.flash_t_grid = list(flash_t_grid) if flash_t_grid is not None else list(AUK_FLASH_T_GRID)
+        self.defaults = {**DEFAULT_SAMPLING, **(defaults or {})}
+
+        kwargs.setdefault("architectures", ["AuKForConditionalGeneration"])
+        # The parent owns thinker_config / talker_config / token2wav_config and
+        # get_text_config; nothing here overrides them.
+        super().__init__(**kwargs)
+
+    @property
+    def is_flash(self) -> bool:
+        """Whether this checkpoint is the distilled 4-step student."""
+        return getattr(self, "variant", "base") == "flash"
+
+    @property
+    def latent_dim(self) -> int:
+        return int(self.vae["latent_dim"])
+
+    @property
+    def downsample_rate(self) -> int:
+        return int(self.vae["downsample_rate"])
+
+    @property
+    def target_sample_rate(self) -> int:
+        return int(self.vae["target_sample_rate"])
+
+
+AutoConfig.register("auk", AuKConfig)
+
+__all__ = [
+    "AUK_FLASH_T_GRID",
+    "DEFAULT_DIT",
+    "DEFAULT_SAMPLING",
+    "DEFAULT_VAE",
+    "VARIANTS",
+    "AuKConfig",
+]
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/audio_resample.py b/vllm_omni/utils/audio_resample.py
new file mode 100644
index 000000000..fc6230f6e
--- /dev/null
+++ b/vllm_omni/utils/audio_resample.py
@@ -0,0 +1,167 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Streaming resampling, shared by the engine and the entrypoints.
+
+Lives here rather than beside the OpenAI audio mixin because the duplex
+engine needs it too, and engine code must not import the entrypoints layer.
+Pure numpy on purpose: importing this must not pull in torch or the API
+server.
+"""
+
+from __future__ import annotations
+
+import math
+
+import numpy as np
+
+__all__ = ["StreamingAudioResampler"]
+
+
+class StreamingAudioResampler:
+    """Stateful polyphase resampler for streaming mono float audio.
+
+    Retains filter state so output is invariant to input chunk boundaries.
+    """
+
+    _half_filter_width = 10
+    _kaiser_beta = 5.0
+    max_polyphase_factor = 2_048
+
+    def __init__(self, source_rate: int, target_rate: int):
+        if source_rate <= 0 or target_rate <= 0:
+            raise ValueError("Audio sample rates must be positive")
+        self.source_rate = source_rate
+        self.target_rate = target_rate
+        rate_gcd = math.gcd(source_rate, target_rate)
+        self._up = target_rate // rate_gcd
+        self._down = source_rate // rate_gcd
+        if max(self._up, self._down) > self.max_polyphase_factor:
+            raise ValueError("source and target sample rates have an unsupported resampling ratio")
+        self._half_len, self._phase_kernels = self._design_polyphase_filter()
+        self._history_samples = self._phase_kernels.shape[1] - 1
+        self.reset()
+
+    def _design_polyphase_filter(self) -> tuple[int, np.ndarray]:
+        if self._up == self._down:
+            return 0, np.ones((1, 1), dtype=np.float32)
+
+        max_rate = max(self._up, self._down)
+        half_len = self._half_filter_width * max_rate
+        offsets = np.arange(-half_len, half_len + 1, dtype=np.float64)
+        cutoff = 1.0 / max_rate
+        taps = cutoff * np.sinc(cutoff * offsets)
+        taps *= np.kaiser(taps.size, self._kaiser_beta)
+        taps /= np.sum(taps)
+        taps *= self._up
+        taps = np.ascontiguousarray(taps, dtype=np.float32)
+
+        phases = [taps[phase :: self._up] for phase in range(self._up)]
+        phase_width = max(phase.size for phase in phases)
+        kernels = np.zeros((self._up, phase_width), dtype=np.float32)
+        for phase_index, phase in enumerate(phases):
+            kernels[phase_index, -phase.size :] = phase[::-1]
+        return half_len, kernels
+
+    @property
+    def scratch_bytes(self) -> int:
+        pending_samples = self._ceil_div(self._input_samples * self._up, self._down) - self._output_samples
+        return max(0, pending_samples) * np.dtype(np.float32).itemsize
+
+    @staticmethod
+    def _ceil_div(numerator: int, denominator: int) -> int:
+        return -(-numerator // denominator)
+
+    def _render_outputs(
+        self,
+        combined: np.ndarray,
+        *,
+        first_output: int,
+        output_count: int,
+        input_start: int,
+    ) -> np.ndarray:
+        if output_count <= 0:
+            return np.empty(0, dtype=np.float32)
+
+        output_indexes = np.arange(first_output, first_output + output_count, dtype=np.int64)
+        filter_indexes = output_indexes * self._down + self._half_len
+        source_indexes = filter_indexes // self._up
+        phases = filter_indexes % self._up
+        windows = np.lib.stride_tricks.sliding_window_view(
+            combined,
+            self._phase_kernels.shape[1],
+        )
+        selected_windows = windows[source_indexes - input_start]
+        return np.sum(
+            selected_windows * self._phase_kernels[phases],
+            axis=1,
+            dtype=np.float32,
+        )
+
+    def _push(self, chunk: np.ndarray) -> np.ndarray:
+        if chunk.size == 0:
+            return np.empty(0, dtype=np.float32)
+        if self._flushed:
+            raise RuntimeError("cannot process audio after the resampler has been finalized; call reset first")
+
+        combined = np.concatenate((self._history, chunk))
+        next_input_samples = self._input_samples + chunk.size
+        stable_output_samples = max(
+            0,
+            self._ceil_div(next_input_samples * self._up - self._half_len, self._down),
+        )
+        output = self._render_outputs(
+            combined,
+            first_output=self._output_samples,
+            output_count=stable_output_samples - self._output_samples,
+            input_start=self._input_samples,
+        )
+        if self._history_samples:
+            self._history = combined[-self._history_samples :].copy()
+        self._input_samples = next_input_samples
+        self._output_samples = stable_output_samples
+        return output
+
+    def _flush(self) -> np.ndarray:
+        if self._flushed:
+            return np.empty(0, dtype=np.float32)
+
+        total_output_samples = self._ceil_div(self._input_samples * self._up, self._down)
+        output_count = total_output_samples - self._output_samples
+        if output_count:
+            last_output = total_output_samples - 1
+            last_source_index = (last_output * self._down + self._half_len) // self._up
+            right_padding = max(0, last_source_index - self._input_samples + 1)
+            combined = np.concatenate((self._history, np.zeros(right_padding, dtype=np.float32)))
+            output = self._render_outputs(
+                combined,
+                first_output=self._output_samples,
+                output_count=output_count,
+                input_start=self._input_samples,
+            )
+        else:
+            output = np.empty(0, dtype=np.float32)
+        self._output_samples = total_output_samples
+        self._flushed = True
+        return output
+
+    def process(self, audio: np.ndarray, *, final: bool = False) -> np.ndarray:
+        chunk = np.asarray(audio, dtype=np.float32)
+        if chunk.ndim != 1:
+            raise ValueError(f"Streaming audio resampling only supports mono audio, got shape {chunk.shape}")
+        chunk = np.ascontiguousarray(chunk, dtype=np.float32)
+        output = self._push(chunk)
+        if not final:
+            return output
+        tail = self._flush()
+        if not output.size:
+            return tail
+        if not tail.size:
+            return output
+        return np.concatenate((output, tail))
+
+    def reset(self) -> None:
+        self._history = np.zeros(self._history_samples, dtype=np.float32)
+        self._input_samples = 0
+        self._output_samples = 0
+        self._flushed = False
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/base.py b/vllm_omni/worker/base.py
index 2a7e9c876..1d0fcd5dc 100644
--- a/vllm_omni/worker/base.py
+++ b/vllm_omni/worker/base.py
@@ -1,3 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
 """Base worker class for vLLM-Omni with device-level GPU memory profiling."""
 
 from __future__ import annotations
@@ -308,3 +311,16 @@ class OmniGPUWorkerBase(GPUWorker):
                     pass
             tid = task.task_id if hasattr(task, "task_id") else "unknown"
             return OmniACK(task_id=tid, status="ERROR", error_msg=str(e))
+
+    def encoder_loaded(self) -> bool:
+        """Check if encoder weights are loaded in the model.
+
+        This method is exposed via collective_rpc to check encoder availability
+        for models that support voice cloning with reference audio.
+
+        Returns:
+            bool: True if encoder weights are available, False otherwise.
+        """
+        if hasattr(self.model_runner, "model") and hasattr(self.model_runner.model, "encoder_loaded"):
+            return self.model_runner.model.encoder_loaded()
+        return False
diff --git a/vllm_omni/worker/gpu_ar_model_runner.py b/vllm_omni/worker/gpu_ar_model_runner.py
index 6625effe8..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
 
@@ -2088,6 +1978,16 @@ class GPUARModelRunner(OmniGPUModelRunner, OmniConnectorModelRunnerMixin, Duplex
             sampler_output = self._sample(logits, spec_decode_metadata)
 
         self._update_states_after_model_execute(sampler_output.sampled_token_ids, scheduler_output)
+        if self.use_async_scheduling:
+            pp = get_pp_group()
+            # Earlier PP ranks posted the matching async receive in the
+            # connector-only branch above (inherited from vLLM). Without this
+            # send their next `_prepare_input_ids` waits forever.
+            # For torchrun external_launcher PP mode with broadcast_pp_output=True,
+            # PP outputs have been broadcast to all ranks at logits computation,
+            # so the sampled token ids must not be sent again.
+            if not self.broadcast_pp_output and pp.world_size > 1 and pp.is_last_rank:
+                self._pp_broadcast_prev_sampled_token_ids(sampler_output.sampled_token_ids)
 
         self._draft_token_ids = None
         self._draft_token_req_ids = None
@@ -2249,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 80d55020f..1664df24b 100644
--- a/vllm_omni/worker/gpu_model_runner.py
+++ b/vllm_omni/worker/gpu_model_runner.py
@@ -33,9 +33,12 @@ 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
+from vllm_omni.model_executor.models.model_local_kv import collect_model_local_kv_specs
 from vllm_omni.model_executor.models.output_templates import OmniOutput
 from vllm_omni.platforms import current_omni_platform
 
@@ -77,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):
@@ -85,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
@@ -170,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:
@@ -190,10 +203,58 @@ 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()
         self._prewarm_attention_capture_workspaces()
+        self._report_model_local_kv()
+
+    def _report_model_local_kv(self) -> None:
+        """Log attention KV this model holds outside the paged manager.
+
+        Reporting only. Two of these caches are captured into CUDA graphs
+        during ``load_model``, so NVML already charges them to the process
+        before ``determine_available_memory()`` samples it; subtracting the
+        declared total from the KV budget would double-count them. What is not
+        charged is the per-request half, which appears after profiling and
+        scales with ``max_num_seqs``.
+
+        Wrapped whole: a memory report has no business breaking model load,
+        and this runs on platforms these declarations have never been
+        exercised on.
+        """
+        try:
+            self._log_model_local_kv()
+        except Exception:
+            logger.warning("Model-local KV reporting failed; continuing", exc_info=True)
+
+    def _log_model_local_kv(self) -> None:
+        specs = collect_model_local_kv_specs(getattr(self, "model", None))
+        if not specs:
+            return
+        max_num_seqs = max(1, int(self.scheduler_config.max_num_seqs))
+        total = sum(spec.peak_bytes(max_num_seqs) for _, spec in specs)
+        logger.info(
+            "Model-local KV (outside the paged manager): %.2f MiB across %d declaration(s) at max_num_seqs=%d",
+            total / (1 << 20),
+            len(specs),
+            max_num_seqs,
+        )
+        for path, spec in specs:
+            logger.info(
+                "  %s.%s: %.2f MiB (%d rows from %s x %.2f MiB/row, scope=%s, %d positions from %s)",
+                path or type(self.model).__name__,
+                spec.name,
+                spec.peak_bytes(max_num_seqs) / (1 << 20),
+                spec.row_count(max_num_seqs),
+                spec.rows.value if spec.rows.value != "fixed" else f"fixed({spec.rows_fixed}; {spec.rows_reason})",
+                spec.bytes_per_row / (1 << 20),
+                spec.scope.value,
+                spec.physical_capacity_positions,
+                spec.capacity_source,
+            )
 
     def _maybe_enable_output_token_ids_for_model_sampler(self) -> None:
         if getattr(self.model, "logitsprocs_need_output_token_ids", False):
@@ -467,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
@@ -487,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"):
@@ -552,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
 
@@ -642,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])
@@ -845,8 +893,8 @@ class OmniGPUModelRunner(GPUModelRunner):
 
     @torch.inference_mode()
     def extract_multimodal_outputs(
-        self, hidden_states: torch.Tensor | list[torch.Tensor] | OmniOutput
-    ) -> tuple[Any, Any]:
+        self, hidden_states: torch.Tensor | list[torch.Tensor] | OmniOutput | IntermediateTensors
+    ) -> tuple[torch.Tensor | IntermediateTensors, OmniPayload | None]:
         if (
             hasattr(self.model, "have_multimodal_outputs")
             and self.model.have_multimodal_outputs
@@ -855,7 +903,7 @@ class OmniGPUModelRunner(GPUModelRunner):
             text_hidden_states = hidden_states.text_hidden_states
             multimodal_outputs = hidden_states.multimodal_outputs
 
-        elif isinstance(hidden_states, torch.Tensor):
+        elif isinstance(hidden_states, (torch.Tensor, IntermediateTensors)):
             text_hidden_states = hidden_states
             multimodal_outputs = {}
         elif isinstance(hidden_states, list) or isinstance(hidden_states, tuple):
@@ -1116,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]
@@ -1178,6 +1226,9 @@ class OmniGPUModelRunner(GPUModelRunner):
             else:
                 hidden_states = outputs
             hidden_states, multimodal_outputs = self.extract_multimodal_outputs(hidden_states)
+            if isinstance(hidden_states, IntermediateTensors):
+                # Profiling/graph capture needs a tensor to select dummy sampler rows.
+                hidden_states = hidden_states["hidden_states"]
             if self.speculative_config and (
                 self.speculative_config.use_eagle()
                 or self.speculative_config.uses_draft_model()
@@ -1650,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]
@@ -1991,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(
@@ -2025,7 +2086,7 @@ class OmniGPUModelRunner(GPUModelRunner):
             **model_kwargs,
             **model_kwargs_extra,
         )
-        if not isinstance(model_output, OmniOutput) and hasattr(self.model, "make_omni_output"):
+        if not isinstance(model_output, (OmniOutput, IntermediateTensors)) and hasattr(self.model, "make_omni_output"):
             model_output = self.model.make_omni_output(model_output, **model_kwargs, **model_kwargs_extra)
         # Cache model output so later sample_tokens can consume multimodal results.
         self._omni_last_model_output = model_output
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)