fix(LTX25-PHASE-RESIDUE): 92% of the phase table's un-named time was one region, and two wall-clock ratios were measuring it (#1536)

.agents/issue-index.md

@@ -561,3 +561,12 @@ rather than merged. `scripts/check-agent-record.py` gates both.
 | [#1562](https://github.com/mudler/vllm.cpp/issues/1562) | `SPEC-DFLASH2` | **W6's oracle capture harness exists only as PROSE, and the FLASH_ATTN label is a post-hoc relabel of an uncommitted log.** `## Owed` O22 and O23 were written so the next agent would not pay three 51.75 GiB loads again; they describe the hook on `DFlashSpeculator.propose` below the `cg_mode == FULL` branch, the `torch.cuda.is_current_stream_capturing()` delegation, the resolved-backend read-back and the abort-on-zero -- and none of it is in the tree, nor is `w6-relabel.py`, nor any run log. Three consequences visible in the committed evidence: `dflash2_27b_spec_on_flash_attn.json` carries `attention_backend_source: "corrected from the run log by w6-relabel.py; the capture's original value came from VLLM_ATTENTION_BACKEND, which does not exist in this wheel and selected nothing"`, which does not meet the read-back rule O22 itself lays down and cannot be re-derived; the TRITON_ATTN golden's `hook_stats` reads `{propose_calls: 59, skipped_dummy: 1, skipped_capture: 0}` against 55 recorded blocks with contiguous `call` ids 3..57, so `59-1-0 = 58 != 55` and THREE propose calls are unaccounted for (now bounded one-sidedly by the gate and pinned at 3, still unexplained); and `## Owed` O17's discharge has no committed runner and no log, so its peak-RSS pair and its `[SPECTRACE]` lines cannot be re-derived either. Owed: commit the harness, the relabel script and the log, or record that they were lost with the lease | bug |
 | [#1564](https://github.com/mudler/vllm.cpp/issues/1564) | `SPEC-DFLASH2` | **The two divergent draft blocks were attributed to the SELECTOR's rank contraction, and the block shape argues against it.** W6 measured 45 of 47 draft blocks byte-identical and wrote that both flips are "the lattice op is a REDUCTION over `selector_rank`". Nothing measured that: the golden records `{call, req_row, anchor, drafts}` per block and no values, no logits and no top-2 gap, so it cannot say whether either flip was a near-tie at all, let alone in which reduction. The shape points the other way -- in BOTH blocks only slot 2 changes while slots 3-6 are byte-identical, and `src/vt/cpu/cpu_ops.cpp:3219` has step l read block row `previous`, the slot step l-1 chose, so a flipped CHILD INDEX would move the predecessor row every later step reads and four identical later slots would be four coincidences per block, twice. A different candidate ID at the SAME winning slot, a rank swap in `ComputeCandidates`' top-k over the target head's logits, produces this shape with none. `SPEC-DFLASH` D6 licenses a near-tie envelope; it does not license labelling an unmeasured flip as one nor naming the op. The attribution is WITHDRAWN in the spec and the benchmark record rather than replaced. The instrument is available and cheap: `Qwen3DFlash2Model::ComputeCandidates` already returns `(ids, values)` and so does upstream's `compute_candidates`, so the next capture records the top-2 candidate margin at the flipping slot on both sides. Blocks nothing -- the gate reads 45/47 on a majority bar and both blocks emitted the same target tokens either way | bug |
 | [#1607](https://github.com/mudler/vllm.cpp/issues/1607) | `SPEC-DFLASH2` | **The DFlash2 startup notice prints TWICE on every draft load, and `docs/USAGE.md` called it one-time.** `CheckDflash2DraftArm` (`src/vllm/entrypoints/model_loader.cpp:502`) ends in an unconditional `std::cerr <<` of the whole notice paragraph with no once-flag, and the loader reaches it TWICE on one load of one `EngineParams`: directly from `FromModelDir` at `:1929`, deliberately placed ahead of every path, config, tokenizer and weight operation so a misclassified draft is caught before a 51.75 GiB target is mapped; and again from `ResolveSpecConfig` at `:1206`, which the `LoadedEngine` constructor runs in its member initializer at `:1538` on all three `new LoadedEngine(...)` returns (`:2172`, `:2341`, `:2359`). The server, the C ABI and the bench client therefore each emit the paragraph twice, on the safetensors arm and the GGUF arm alike. The tree already states that the resolution re-runs (`model_loader.cpp:2313`, `:871-874`); what nothing stated is that the notice re-runs with it. ESTABLISHED STATICALLY, by reading the call graph rather than by executing it -- a runtime confirmation needs a DFlash2 checkpoint and a rebuild of the whole 464-object library. Cosmetic rather than behavioural: nothing is loaded twice and nothing is refused twice, and `CheckDflash2DraftArm` returns early for every non-DFlash2 draft. Found by the THIRD fresh review of `SPEC-DFLASH2` W6 (#1314) and NOT fixed in flow, deliberately: the fix changes the production loader and needs its own red-first test and its own fresh review, while that wave was scoped to prose. `docs/USAGE.md` is corrected in the same change, so the shipped documentation is no longer wrong about the behaviour while this is open. Owed under `## Owed` O25 of [the DFlash2 spec](specs/dflash2-spec-decode.md) | bug |
+| [#1470](https://github.com/mudler/vllm.cpp/issues/1470) | `LTX25-PHASE-RESIDUE` | **`test_ltx2_video` false-redded once on `main` under load and the failing case's identity was never captured.** The prediction it records (F12 of #1441's fifth review) was that a coverage floor whose per-boundary sampling cost is fixed while the leaf shrinks is a false-RED risk and never a false pass. Measured by `LTX25-PHASE-RESIDUE`: the prediction is right about the polarity and wrong about the term. The `denoise` coverage miss is not sampling cost, it is the sampler's post-process and Euler step, which no anchor wrapped and which scale with the latent — 49 µs per step at nine frames against 343 µs at 81, in one run of one binary. Closed by anchoring that work as `denoise.update` and by replacing the ratio with a bound derived from the instrument's own measured out-of-record cost. Spec [`ltx25-phase-residue.md`](specs/ltx25-phase-residue.md) | bug |
+| [#1536](https://github.com/mudler/vllm.cpp/issues/1536) | `LTX25-PHASE-RESIDUE` | **`test_ltx2_video` is persistently red rather than load-flaky, and it is the only failing test on `main`.** The issue asks for the residue to be decomposed rather than re-argued, and names `d995c52f0` (the temporal x2 upsampler) as the first hypothesis to test. The decomposition refutes that hypothesis and settles the cause: **92% of the un-named time is one region**, `Ltx2VideoEngine::Load` from the timeline's origin to `Open("load.dit")` — 17.661 ms of a 19.178 ms residue — and the upsampler's own work is inside `phase.upsample_latent`, a named leaf that does not appear in the residue at all. Closed by naming that region plus two smaller ones, anchoring the denoise's un-anchored sampler step, and replacing both wall-clock ratios with a bound derived from the instrument's own measured cost. Spec [`ltx25-phase-residue.md`](specs/ltx25-phase-residue.md) | bug |
+| [#1567](https://github.com/mudler/vllm.cpp/issues/1567) | `LTX25-PHASE-RESIDUE` | the res_2s sampler arm has no `denoise.update` anchor, so its denoise is decomposed on one arm only. Filed by `LTX25-PHASE-RESIDUE` and NOT landed with it, because no gate in this tree renders on that arm and an anchor no gate runs is dead code. Listed under `## Owed` in [`ltx25-phase-residue.md`](specs/ltx25-phase-residue.md) | bug |
+| [#1568](https://github.com/mudler/vllm.cpp/issues/1568) | `LTX25-PHASE-RESIDUE` | `denoise.step` and `denoise.update` are open to a seconds transfer no assertion in `test_ltx2_video.cpp` can see: (1b') compares `start_seconds` only, and no per-part floor separates the honest share (0.45% to 11.15% across four boxes) from a transfer (~0%). Found by the fresh review of #1536; `LTX25-PHASE-RESIDUE` claimed it closed and withdrew the claim. Listed under `## Owed` in [`ltx25-phase-residue.md`](specs/ltx25-phase-residue.md) | bug |
+| [#1569](https://github.com/mudler/vllm.cpp/issues/1569) | `LTX25-PHASE-RESIDUE` | `PhaseLog::WriteJson`'s clock ordering is ungated and its own mutation stays GREEN 10 of 10, because the copy and sort of a three-record table are nanoseconds. Claim withdrawn from the source by `LTX25-PHASE-RESIDUE` rather than defended. Listed under `## Owed` in [`ltx25-phase-residue.md`](specs/ltx25-phase-residue.md) | bug |
+| [#1570](https://github.com/mudler/vllm.cpp/issues/1570) | `LTX25-PHASE-RESIDUE` | nothing bounds the instrument's own share of a leaf, so `residue <= 2 * instrument` can widen silently — moving the DiT `Tick` out of `Evaluate` would charge ~110 flushed writes to `denoise` and buy a budget larger than the floor `LTX25-PHASE-RESIDUE` deletes. Found by that row's fresh review as F5. Listed under `## Owed` in [`ltx25-phase-residue.md`](specs/ltx25-phase-residue.md) | bug |
+| [#1571](https://github.com/mudler/vllm.cpp/issues/1571) | `LTX25-PHASE-RESIDUE` | the phase table cannot be decomposed into its gaps without a scratch script, which is how #1439 stayed open for three months over a residue that was 92% one gap. Filed by `LTX25-PHASE-RESIDUE`, which wrote that script and did not ship it. Listed under `## Owed` in [`ltx25-phase-residue.md`](specs/ltx25-phase-residue.md) | bug |
+| [#1572](https://github.com/mudler/vllm.cpp/issues/1572) | `LTX25-PHASE-RESIDUE` | assertion (1c)'s span slack reds intermittently on `main` — `decode.video` at `0.00256913` against a `0.00075` bound, 3.4x. Pre-existing from `6b48edb2c` and NOT `LTX25-PHASE-RESIDUE`'s, which does not touch (1c) and keeps its constants; observed by that row's fresh review and filed rather than repaired. Listed under `### Observed and NOT this row's` in [`ltx25-phase-residue.md`](specs/ltx25-phase-residue.md) | bug |
+| [#1619](https://github.com/mudler/vllm.cpp/issues/1619) | `LTX25-PHASE-RESIDUE` | **The `merge=union` driver on this file DUPLICATES a row when both sides append before the same trailing anchor instead of at the true end, and no gate counts rows.** Measured on this row's merge of `origin/main` at `e2a9e035d`: base 521 lines, each side +8, correct union 537, driver produced **538** with `#1546` byte-identical at lines 523 and 533. `git merge-tree --write-tree` called it clean; `check-agent-record.py` passed; `check-issue-index-append-only.py` passed too, because a duplicate is an ADDITION and it only collects removals. De-duplicating in place then FAILS that same checker, since moving the anchor back is a RELOCATION and a line diff reads one as a removal — the existing gate fires on a correct repair and misses the corruption. GitHub does not honour the driver at all, so this only bites local resolutions and is invisible in PR review. Canonical fix: take the merged branch's file byte-for-byte, append at the true end, assert `git diff --numstat <merged-sha>` is `N 0`. Fix candidate is a multiplicity + id-uniqueness checker, which fails 3 of 7 assertions on the raw driver output and names `#1546`. Recurs: the same driver dropped `#838` on a later re-merge. Owed under `## Owed` in [`ltx25-phase-residue.md`](specs/ltx25-phase-residue.md) | bug |

.agents/specs/ltx25-device-residency.md

@@ -666,7 +666,7 @@ its phase table lands, and W5 owes one when its wall is accepted.
 | [#1014](https://github.com/mudler/vllm.cpp/issues/1014) | W6 | owed, conditional |
 | [#1012](https://github.com/mudler/vllm.cpp/issues/1012) | O1 | owed |
 | [#1202](https://github.com/mudler/vllm.cpp/issues/1202) | deferred behind W1 | owed, with a number: 2.3% of one pass |
-| [#1439](https://github.com/mudler/vllm.cpp/issues/1439) | W0 (its own gate) | **owed, and RED on `main` rather than on any branch.** `CHECK(leaves >= 0.95 * wall)` in `ltx2 video: a render through the ABI emits a phase table that SUMS to wall` is a RATIO, and the un-named residue is 4.80% to 6.32% of `wall` across twelve runs on one x86 box - so the 95% floor sits INSIDE the measurement's own range at the 64x64 / 9-frame fixture scale, and the case decides by coin flip, mostly red. With this lane's four files reverted so the binary is main at `89261c955`, six runs read 94.32%, 95.20%, 93.74%, 94.20%, 94.69%, 94.19%; the W0-live merge reads 93.82%, 93.68%, 94.34%, 94.62%, 94.39%, and 94.12% with `VLLM_RENDER_PROGRESS=0`, which exonerates the live emitter. Box contention is NOT the cause and main's one green disproves it: that run had `wall=0.579684s`, more than double the others, because the box was loaded - a SLOWER render passes. The tolerance was argued for the 21.004 B render, where the residue is a far smaller fraction of the wall. Naming the un-named time, or bounding `unaccounted_seconds` beside the ratio so the assertion says the same thing at both scales, is gate semantics and owes its own row |
+| [#1439](https://github.com/mudler/vllm.cpp/issues/1439) | W0 (its own gate) | **owed, and RED on `main` rather than on any branch.** `CHECK(leaves >= 0.95 * wall)` in `ltx2 video: a render through the ABI emits a phase table that SUMS to wall` is a RATIO, and the un-named residue is 4.80% to 6.32% of `wall` across twelve runs on one x86 box - so the 95% floor sits INSIDE the measurement's own range at the 64x64 / 9-frame fixture scale, and the case decides by coin flip, mostly red. With this lane's four files reverted so the binary is main at `89261c955`, six runs read 94.32%, 95.20%, 93.74%, 94.20%, 94.69%, 94.19%; the W0-live merge reads 93.82%, 93.68%, 94.34%, 94.62%, 94.39%, and 94.12% with `VLLM_RENDER_PROGRESS=0`, which exonerates the live emitter. Box contention is NOT the cause and main's one green disproves it: that run had `wall=0.579684s`, more than double the others, because the box was loaded - a SLOWER render passes. The tolerance was argued for the 21.004 B render, where the residue is a far smaller fraction of the wall. **STILL OWED after row `LTX25-PHASE-RESIDUE` ([`ltx25-phase-residue.md`](ltx25-phase-residue.md), [#1536](https://github.com/mudler/vllm.cpp/issues/1536)), which did the NAMING half and WITHDREW the other.** Decomposing the residue into the gaps between consecutive leaves settled what this row could only argue about: **92% of it was ONE gap**, the load's prologue from the timeline's origin to `Open("load.dit")`, 17.661 ms of 19.178 ms. It is now `load.setup`, with `load.dit_config` and `artifacts.mux` taking a further 1.160 ms, so the residue this ratio sees is smaller than the one measured above. THE RATIO ITSELF IS UNCHANGED: `CHECK(leaves >= 0.95 * wall)` is still the assertion, restored unchanged -- the same predicate and the same 0.95, with only the failure MESSAGE differing, which now reports the instrument's own charge beside the two seconds figures -- after the replacement it proposed -- `residue <= 2 * instrument`, a budget derived from the instrument's own boundary cost -- was withdrawn in `65e681438`. A third fresh review measured that bound over 45 consecutive runs of one snapshot binary at load 88: 4 red, 8.9%, median 1.132, p90 1.776, max 4.115. The un-instrumented part of a phase boundary dilates FASTER than the instrumented part under contention, so the ratio is not the load-invariant quantity that bound needed. What this issue asks for -- a bound on a quantity the scheduler cannot move -- is therefore still open, and is carried by [#1570](https://github.com/mudler/vllm.cpp/issues/1570) |
 | [#1164](https://github.com/mudler/vllm.cpp/issues/1164) | W7 decision point | not owed here — owned by `ENG-CUDAGRAPH-DIFFUSION`; this row owns its unblock order |
 
 **[#1009](https://github.com/mudler/vllm.cpp/issues/1009) is not owed. It