fix(#1528): two comments name RetakePipeline as the caller that sets force_uncond_pass, and none of upstream's seven construction sites sets it

.agents/issue-index.md

@@ -660,3 +660,4 @@ rather than merged. `scripts/check-agent-record.py` gates both.
 | [#1765](https://github.com/mudler/vllm.cpp/issues/1765) | `GATE-METAL-MLX-COMPILE` | **[#1692](https://github.com/mudler/vllm.cpp/issues/1692) says `src/vt/metal/metal_mlx_provider.mm` is "compiled by NO job in this repository". MEASURED, and that is wrong in a way that changes what is owed:** `.github/workflows/release.yml:347` `mlx_arm64` builds it on `macos-15` against the real `mlx==0.32.0` wheel. The defect is the TRIGGER -- `release.yml` fires on a `v*` tag or a manual dispatch, never on a pull request and never on a push to `main`, and `ci.yml` has no Apple runner (all 17 `runs-on` lines are ubuntu-latest x14, ubuntu-24.04-arm x1, windows-2022 x2; its single `macos` string is `test_release_macos_metadata.py` at `:199`, which compiles nothing). So the only build of the file happens AFTER a change lands, and a break presents as a BLOCKED RELEASE rather than a red check; #1584's edit to `MlxFallback` is the case that proved it. On a configured CPU tree the file has **0** occurrences in `build.ninja` and **0** in `compile_commands.json` -- as does every other `.mm` -- against 3 for `src/vt/op_provider.cpp` as a control. **Closed by a never-linked OBJECT library** (`vllm_metal_mlx_provider_syntax_check`, the `vllm_rocm_platform_syntax_check` idiom) that compiles the file on Linux: it is the ONLY Metal TU that can be, carrying 0 Objective-C constructs against 10/5/19 for `metal_ops.mm`/`metal_backend.mm`/`metal_context.mm`, because `metal_context.h:22` hands it every Metal handle as a `void*` on purpose. `LANGUAGE CXX` for `-x c++`; `-Wno-deprecated` for `#import`, MEASURED narrow (a `[[deprecated]]` call still fails as `-Werror=deprecated-declarations`); guarded `NOT VLLM_CPP_MLX` (the LANGUAGE property is directory-scoped and must not reach the shipping build) and `NOT MSVC` (`#import` there means a type library). **The limit is stated rather than glossed:** the stubs under `src/vt/metal/stubs` are written from this file's call sites, so the gate proves it compiles against the REAL `vt::` seam -- the #1584 defect class exactly -- and is blind to every MLX API change, which `mlx_arm64` alone can see. Red-before/green-after and the `## Owed` residue in [gate-metal-mlx-compile.md](specs/gate-metal-mlx-compile.md) | bug |
 | [#1777](https://github.com/mudler/vllm.cpp/issues/1777) | `GATE-FP8-NUMERIC-BOUND` | **Layer 2 of [#1189](https://github.com/mudler/vllm.cpp/issues/1189)'s `## Gate design` had no implementation, and nothing in the tree could see a per-tensor scale collapse.** Layer 1 passed on 2026-08-23 (`rc` job `2911ed39`, `TOKEN_VERDICT=PASS`), and the header of `tests/parity/test_qwen27n_fp8_tower_paged_engine.cpp` records why that is not enough: a x1.02 AND a x1.10 perturbation of every FP8 weight scale were demonstrably REACHED on the dgx production build and both still produced 16/16 IDENTICAL tokens, with only x2.00 failing. So a wrong-but-close scale and a silent dequant -- which is numerically BETTER than the quantized path -- are invisible to every token comparison here. The audit corrects the brief in one place rather than re-implementing what exists: the SHAPE ASSERTION at the GEMM boundary is already DONE in two places, `src/vt/ops.cpp::MatmulFp8BlockScaled` asserting `b_scale == [cdiv(N,block_n), cdiv(K,block_k)]` (pinned by `test_ops_matmul_fp8_block_cpu.cpp` G5) and `Fp8BlockScaledRefusalFor` refusing `N % 128` / `K % 128` BY NAME before CUTLASS can answer `Invalid status` (#1453, pinned by G4/G6), and the CUDA TU's own comment at the refusal site says so. FIXED IN FLOW: `tests/vllm/model_executor/models/test_fp8_block_numeric_bound.cpp` bounds every projection against the fixture's independent `double` reference through the production `Fp8BlockLinearMethod::Apply`, TWO-SIDED in the same case -- clean UNDER the bound and x1.10 OVER it, per shape per dtype, plus a 4x margin over the grid -- because a one-directional bound stops biting the moment somebody widens it and nothing would say so. Measured over six shapes: bf16 clean 3.82e-3 against x1.10 1.034e-1 at `kBoundBf16 = 2e-2` (5.2x each way), f32 clean 6.20e-6 against 1.000e-1 at `kBoundF32 = 1e-4`. The statistic floors its denominator at 1% of the projection's own maximum, and that was MEASURED rather than assumed: unfloored, the clean f32 reading moves 835x on one shape because a single output element cancels to near zero, which is a number that cannot carry a bound. `dense_fp8_block::Fp8BlockScaleSpread` is the scale-variance probe #1189 asks for, a max/min RATIO because the issue pins the degenerate reading at exactly 1.0 where a variance reads 0.0, carried with the GEMM counter in one `Fp8BlockStats` snapshot; single-cell grids are counted APART from collapsed ones because 11 of the model fixture's 13 grids hold one cell and a probe that reads 11 on a healthy model is one nobody believes. The split arm also gained the two GEMM-boundary operand assertions the merged arm has carried since M6 -- without the packed one, a short buffer is read PAST ITS END by the first GEMM and the call returns a value. Seven mutations in both directions, tar-snapshotted and `sha256sum -c` verified after each: x1.10 RED 14 assertions, x1.02 RED 14, the same 14 (not predicted: the bf16 readings come in at 2.32e-2 to 2.39e-2 against the 2e-2 bound because the truncating store compounds ON TOP of the scale error, so the bf16 half is caught by only 1.16x and the f32 half by 200x), the bound widened to 1.0 RED 6, a collapsing load path RED 14 across 2 cases, the probe's accounting RED 2, and each new operand assertion RED when defanged. CPU tier throughout, so `build-test-cpu` and `sanitize-cpu` run all of it on every pull request; `cuda-fat-build` runs no `ctest` and nothing here rests on it. **#1189 is NOT closed**: its gate design is now covered but its six milestones' `## Owed` sections are live, and no closing keyword appears in this change. Spec [`gate-fp8-numeric-bound.md`](specs/gate-fp8-numeric-bound.md) | gap |
 | [#1779](https://github.com/mudler/vllm.cpp/issues/1779) | `GATE-PREPUSH-FAIL-LOUD` | **`.githooks/pre-push` named six checkers and three of them had no file, and its file-test guard skipped each missing one in silence while the hook still exited 0** -- so it presented as six gates and ran three, and `core.hooksPath` is set to `.githooks` here, so it runs on every push. `check-policy.py` and `check-state-record.py` went with `0f3e44eee`, `check-public-doc-tables.py` with #1714; all three are deleted, not renamed. PART 1 FIXED IN FLOW: the loop now refuses a name it cannot find, the three dead names are pruned, the dead `--base` case arm goes with them, and `.githooks/README.md` stops listing the retired table gate. A red-first suite executes the hook against a scratch repository and pins both directions. PART 2 IS NOT FIXED AND STAYS OWED under `## Owed` in `.agents/specs/gate-prepush-fail-loud.md`: 65 specs still name a deleted checker, which needs its own row | bug |
+| [#1528](https://github.com/mudler/vllm.cpp/issues/1528) | `LTX25-GUIDED-VIDEO` | **Two comments in the LTX-2.5 guided denoiser named `RetakePipeline` as the one upstream caller that sets `force_uncond_pass`, and NO upstream caller sets it at `fd4ded7f`.** `include/vllm/model_executor/models/ltx2_denoisers.h:144-145` and `src/vllm/model_executor/models/ltx2_denoisers.cpp:111-113`, both from `daeff67f2` (row `LTX25-GUIDED-VIDEO`, [#1092](https://github.com/mudler/vllm.cpp/issues/1092), PR [#1102](https://github.com/mudler/vllm.cpp/pull/1102)). Re-derived at the local `Lightricks/LTX-2` checkout whose `git rev-parse HEAD` is `fd4ded7f2d88d3da713abcdd4ad41ecc4a9314ca`, the revision `.agents/specs/ltx25-guided-video.md:6` pins. `git grep -n force_uncond_pass` over the WHOLE tree, not only `*.py`, returns 11 LINES and not one is an assignment by a caller (the filing counted 10 because it restricted the grep to `*.py`; the two counts agree and name different populations): `utils/denoisers.py:74` declares the `_guided_denoise` keyword, `:102-103` are the two reads, `:267,273,297` are `GuidedDenoiser` storing and forwarding it, `:313,319,357` are `FactoryGuidedDenoiser` doing the same, `utils/samplers.py:692` is the substring `force_uncond_pass=True` inside a raised ERROR MESSAGE, and `packages/ltx-pipelines/CLAUDE.md:76` documents it. `git grep -n 'GuidedDenoiser('` finds SEVEN construction sites, three `GuidedDenoiser` and four `FactoryGuidedDenoiser`, which is a stronger statement than the filing's retake-only check: `a2vid_two_stage.py:230`, `keyframe_interpolation.py:232`, `retake.py:305`, `t2a_one_stage.py:155`, `ti2vid_one_stage.py:221`, `ti2vid_two_stages.py:248`, `ti2vid_two_stages_hq.py:271`. None passes the keyword, so all seven take the `force_uncond_pass: bool = False` default. The flag is a CFG++ affordance per `CLAUDE.md:76`: run the uncond pass even when `cfg_scale=1.0`, because CFG++ still needs the uncond prediction for the ordinary differential equation derivative. Upstream ships the plumbing and turns it on nowhere. TWO SMALLER ERRORS RIDE ALONG: the header cited the declaration as `:76`, which is the DOCSTRING and not the declaration at `:74`; and both comments cited `retake.py:305-311`, whose last line is BLANK, the construction being `:305-310`. THE CODE WAS ALREADY RIGHT and nothing about behavior changed: `Ltx2GuidedDenoiseInputs::force_uncond_pass` defaults to `false`, `grep -rn force_uncond_pass src/ include/ tests/` finds two reads and no assignment, and the condition at `ltx2_denoisers.cpp` mirrors `denoisers.py:102-103` operand for operand. This is a documentation defect ONLY, and no wider scope was taken. THE ANCHOR WAS LOAD-BEARING, which is why it is a bug and not a typo: a reader who trusts it concludes retake is missing a flag upstream sets and sets it, and `force_uncond_pass` adds an uncond pass per PRESENT modality, doubling retake's DiT forward count from 8 to 16 and changing its output. The comment invited the exact divergence it appeared to describe. A comment-only change CANNOT be red-first tested, and this row does not pretend otherwise: the evidence is the upstream re-derivation above, cited by `file:line` at the pin, and an independent reviewer re-derived it rather than reading it. FIXED IN FLOW, comment text only. Two specs were checked and deliberately NOT edited: `ltx25-retake.md` never mentions the field, and `ltx25-guided-video.md:198` states the CONDITION without claiming a caller, which is true at the pin | bug |

include/vllm/model_executor/models/ltx2_denoisers.h

@@ -141,8 +141,16 @@ struct Ltx2GuidedDenoiseInputs {
   int64_t num_blocks = 0;
 
   int64_t step_index = 0;
-  // `force_uncond_pass` (`:76`, read at `:102-103`). `RetakePipeline` is the one
-  // upstream caller that sets it (retake.py:305-311).
+  // `force_uncond_pass` (declared at denoisers.py:74, read at `:102-103`). NO
+  // upstream caller enables it at `fd4ded7f`. It is a CFG++ affordance that runs
+  // the uncond pass when `cfg_scale` is 1.0 and the uncond prediction is still
+  // needed for the ordinary differential equation derivative, described at
+  // `packages/ltx-pipelines/CLAUDE.md:76`. Upstream declares the flag and
+  // threads it through `GuidedDenoiser` (`:267`, stored at `:273`, forwarded at
+  // `:297`) and `FactoryGuidedDenoiser` (`:313`, `:319`, `:357`), and all seven
+  // construction sites in the upstream tree take the `False` default,
+  // `RetakePipeline` (retake.py:305-310) included. This field mirrors that
+  // unused plumbing, so nothing in this tree assigns it either.
   bool force_uncond_pass = false;
 
   // `_last_denoised_video` / `_last_denoised_audio` (denoisers.py:274-275). Null

src/vllm/model_executor/models/ltx2_denoisers.cpp

@@ -109,8 +109,11 @@ Ltx2GuidedDenoiseResult Ltx2GuidedDenoise(const Ltx2X0Model& transformer,
   passes.push_back({Ltx2DenoisePass::kCond, v_context, a_context, Ltx2PerturbationConfig{}});
 
   // `:102-109`. `force_uncond_pass` adds the pass for a modality that is PRESENT
-  // even when its own guider does not ask (retake.py:305-311 is the one upstream
-  // caller that sets it).
+  // even when its own guider does not ask. NO upstream caller enables it at
+  // `fd4ded7f`. It is CFG++ plumbing, declared at `:74` and described at
+  // `packages/ltx-pipelines/CLAUDE.md:76`, that all seven upstream construction
+  // sites leave at its `False` default, `RetakePipeline` (retake.py:305-310)
+  // included. This arm therefore mirrors a path upstream ships and never takes.
   const bool v_needs_neg = video_guider.DoUnconditionalGeneration() ||
                            (in.force_uncond_pass && in.video != nullptr);
   const bool a_needs_neg = audio_guider.DoUnconditionalGeneration() ||