feat(LTX25-T2A-ONE-STAGE): text-to-audio, the one-stream forward, and the guided denoiser nothing had (#1005, #1013)

[localai-bot]

T2AOneStagePipeline (t2a_one_stage.py:43, __call__ at :109 @ fd4ded7f)
renders a soundtrack and no picture. This is the first path here that returns a
VideoResult with zero frames, and the first that runs the DiT with
video = nullptr.

Issue #1005. Spec
.agents/specs/ltx25-t2a-one-stage.md.
Also files and fixes #1013 and
#1039 in the same flow, and
files #1031, which is CLOSED
as a duplicate of #1022 and
whose index row is corrected here — see The #1031 row was stale before it
landed below.

Four more are FILED AND NOT FIXED here, each because fixing it needs something
this branch does not have, and each therefore naming its owner:
#1048 (the LTX-2.5 checkpoint
pin, which needs a GPU and a real checkpoint),
#1049 (Ltx2Guidance dead in
production, pre-existing from #641),
#1050 (the guider rescale's
std comment, same provenance) and
#1052
(test_engine_core_proc's load-dependent shutdown case, unrelated engine code).
All eleven are linked from .agents/issue-index.md and from this body; #1005,
#1013 and #1039 are in the spec's scope and the other four are under its
## Owed.

What changed since the first review

Two things, both from the fresh review of 3d9d9c9bb.

#1039: the guidance was
combined in VELOCITY space, and upstream combines x0. This was a defect on the
DEFAULT arm, in code that had not landed. It is fixed here, with the RED
captured, and it is the subject of the two new sections below.

The #1031 index row was stale. It said check-agent-record is RED on
origin/main; that was repaired by ff264cb82 (PR #1025) before this branch
merged it. The row is corrected in place, which is possible only because it has
not landed yet.

What changed since the SECOND review

The fresh review of c1fe35592 passed on the correctness of the #1039 fix and
returned one blocking finding, one record obligation and four prose items. All
are addressed below. It also measured two pre-existing defects that this branch
deliberately does NOT fix; both are filed and owned.

BLOCKING: the #1039 gate covered ONE of the three guidance arms.
ltx2_t2a.cpp:41-43 says to_denoised is applied to EVERY PASS. The gate held
that claim for the CONDITIONAL pass only: it recorded first_step_velocity and
first_step_cond for that arm, nothing observed the unconditional or perturbed
forwards, and nothing pinned what Ltx2EulerStep consumed. The default T2A arm
runs three forwards per step, so a build that converts cond correctly and
leaves either other arm in velocity space renders a different waveform through a
guider whose cond term is impeccable, with a healthy forward count and nothing
else to see it by. That is #1039 again, one arm over.

Reproduced at c1fe35592 before the repair, on the same comma-free filter as
the green run (--test-case=ltx2 t2a*, 10 cases / 526 assertions / exit 0).
Each mutation applied to ONE file, git diff --stat taken against the
PRE-MUTATION working tree rather than against HEAD (the repair is uncommitted
while the harness runs, so a diff against HEAD would report it too and the
stat would stop being the mutation's own), rebuilt with the : error: count
printed beside the verdict, exit code captured DIRECTLY, and restored from a
content SNAPSHOT with os.utime(now) and a sha256 compare.

Mutation	git diff --stat	BUILT	before	after
A1 the PERTURBED (STG) pass alone left in velocity space	ltx2_t2a.cpp | 4 ++--	YES (0 errors)	SURVIVED exit 0, 10 cases / 526	DETECTED exit 1, 10 / 548
A2 the UNCONDITIONAL pass alone left in velocity space	ltx2_t2a.cpp | 4 ++--	YES (0 errors)	SURVIVED exit 0, 10 / 526	DETECTED exit 1, 10 / 548
A3b ToDenoised applied twice, BELOW the step-0 record (the reviewer's R1b)	ltx2_t2a.cpp | 2 +-	YES (0 errors)	SURVIVED exit 0, 10 / 526	DETECTED exit 1, 10 / 548
A3c ToDenoised applied twice, ABOVE the step-0 record	ltx2_t2a.cpp | 1 +	YES (0 errors)	SURVIVED exit 0, 10 / 526	DETECTED exit 1, 10 / 548
A4 the perturbed arm's recorded velocity ZEROED (the guard, not a defect)	ltx2_t2a.cpp | 1 +	YES (0 errors)	the field did not exist	DETECTED exit 1, 10 / 538
N1 the original #1039 shape, restored in full	ltx2_t2a.cpp | 5 ++---	YES (0 errors)	DETECTED	DETECTED exit 1, 10 / 548

A3c is not from the review. It was found while closing A3b: the reviewer's
placement sits between the step-0 record and the Euler step, so recovering the
Euler input sees it, and moving the same edit one statement earlier does not.
Closing both needs two independent checks rather than one.

N1's first draft dropped ToDenoised's only call site and failed to build on
-Werror=unused-function, at 1 compile error. A mutation that does not build
reads as a passing test, so it is rewritten as two edits that keep the
function used. The reviewer's own R1' hit the same trap and therefore proved
nothing; that is why every row above prints BUILT and the error count.

The repair is observability plus three checks, not a change to the fix.
Ltx2T2aResult and Ltx2ConditioningTrace gain a (raw velocity, x0 prediction)
pair for the unconditional and perturbed arms, and the latent the Euler step
wrote. The uncond and perturbed vectors stay EMPTY when the guider does not ask
for that arm, because the forward did not run; a zero-filled one of the right
length would be indistinguishable from a forward that returned zeros. Then, all
inside the existing end-to-end case through LoadVideoEngine and
VideoEngine::Generate:

• the SAME equation x0 == latent - sigma*velocity on every arm the render ran,
  exact in x0 space and off by the whole sample in velocity space, with
  t2a_uncond_forwards > 0 and t2a_perturbed_forwards > 0 asserted first so a
  silently skipped arm cannot vacate its own check;
• the guider's output REPLAYED through the shipped Ltx2MultiModalGuidance over
  the three recorded arms, required bit-equal to t2a_first_denoised. This does
  not gate the guider's arithmetic, which the control case below already does; it
  gates that the pipeline handed it these tensors and passed its result on
  UNTOUCHED, which is what A3c moves and no per-arm check can see;
• t2a_first_next_latent recovered from t2a_first_denoised through
  x + (x - denoised)/sigma * (sigma_next - sigma), the schedule re-derived from
  Ltx2SigmaSchedule and tied to the render by the sigma it recorded. That is
  what A3b moves.

Non-vacuity, per arm rather than once. latent_span > 1e-3 stays shared,
since a zero sample makes the two candidate tensors coincide on every arm. Its
partner sigma * velocity_span > 1e-6 moves INSIDE the per-arm loop, because a
zero velocity makes to_denoised the identity for that arm alone, and "expected
zero, and a stub also produces zero" is the trap this campaign has already hit
twice. A4 is the mutation that proves the guard is armed rather than decorative:
zeroing one arm's recorded velocity takes the case red through the REQUIRE, at
538 assertions rather than 548 because the REQUIRE aborts the case. The replay
check carries its own control (t2a_first_denoised != t2a_first_cond, so the
guider MOVED what it was handed) and the Euler check carries two (|dt| > 1e-3,
so the step is not the identity, and scale > 1e-3, so the residual bounds
something).

The rescale's numeric difference is still NOT asserted, and the reason was
re-measured rather than inherited. std(cond)/std(pred) is 1 to printed
precision on this fixture, so factor = 0.7*1 + 0.3 is exactly 1, the rescale is
a no-op in BOTH spaces, and the difference term (factor - 1) * latent is
identically zero. Owed against the real-checkpoint render, unchanged.

RECORD OBLIGATION: the LTX-2.5 checkpoint pin.
#1048. docs/USAGE.md names
six LTX-2.5 artifacts by bare file name with no HuggingFace repo, no revision and
no sha256, at :663-670 and :2183-2188 on origin/main plus the
text-to-audio recipe at :853-857, where AGENTS.md § Say which weights, and
from where requires all three per arm. Campaign-wide and pre-existing rather
than introduced here, verified rather than asserted: grep -n sha256 docs/USAGE.md returns two checkpoint hashes and BOTH belong to MiniMax-Music3
(:3127, :3269), while MiniMax-H3 (:1950-1993) and MiniMax-Music3
(:3123-3149) each carry a full table and LTX-2.5 carries none anywhere.
Recorded and deliberately not fabricated: this row claims no render on real
weights, so there is no checkpoint it was gated against to pin. One ## Owed
bullet, one index row, one issue. The recipe's --audio-vae is also corrected to
ltx-2.5-audio-vae-bf16.safetensors, which is what the other two LTX-2.5
recipes on the page name.

Two pre-existing defects the review measured, filed and NOT fixed here.
#1049: Ltx2Guidance is dead
in production and is the only path to Ltx2CfgDelta and Ltx2StgDelta;
Ltx2BatchedPerturbationConfig is constructed only in tests. All four landed
with #641. #1050: the guider
rescale's std comment claims the biased estimator "would be a small,
everywhere, resolution-dependent gain error", and factor = std(cond)/std(pred)
divides two stds over the same count, so the (n-1) cancels exactly. The
review's biased-versus-unbiased mutation survived because it is an IDENTITY, not
because the gate is blind. The code is right; the comment is the defect.

Four prose fixes.

1. Spec 6b overclaimed that this row ends a test-only driver for four
   symbols. Only Ltx2MultiModalGuidance gains a production call site; 6b now
   carries the measured table and names Ltx2Guidance is dead in production, and it is the only path to Ltx2CfgDelta and Ltx2StgDelta (plus Ltx2BatchedPerturbationConfig) #1049.
2. The test comment at test_ltx2_video.cpp said "NO extra is touched
   either". T2aGen sets two extras and audio_stg_blocks IS a guider field.
   Narrowed to the claim that is true and separately pinned: rescale_scale is
   the recipe's own 0.7. The same false claim in this body is corrected below.
3. The READER ANCHORS relocation reason was false, corrected here and in the
   spec's Risks section.
4. docs/FEATURES.md's mutation figure moves from "13 mutations, 12
   DETECTED" to "18 mutations, 17 DETECTED", the 18th still the sigmas[0]
   identity.

The merge of origin/main fa3723b85

origin/main advanced mid-repair. PR #1038 is records-only: a new spec and
thirteen appended index rows (#1006-#1012, #1014-#1016, #1021, #1024, #1040),
none colliding with the seven this branch appends (#1005, #1013, #1031, #1039,
#1048, #1049, #1050) or with #1052 below.

The union driver's clean result on the index was rejected, and it was wrong
rather than merely suspect. git merge reported Auto-merging .agents/issue-index.md with no conflict, and the file it produced INTERLEAVES
this branch's rows among main's newly appended ones: the first difference is at
byte 122253, where main has #1006 and the union result has #1005. So
origin/main's file is not a byte-identical prefix of it, and an index that is
not a prefix of main's is one a later union merge can duplicate or silently
reinstate a row into.

Taken instead as main's file WHOLESALE plus this branch's own suffix, with three
checks rather than an assurance, and re-verified on the COMMITTED blobs because
check-issue-index-append-only.py reads committed state only:

1. PREFIX: HEAD:.agents/issue-index.md's first 144213 bytes are
   byte-identical to origin/main:.agents/issue-index.md. The cmp itself is
   armed: flipping one byte inside that prefix reports a difference.
2. SUFFIX: the remaining 11285 bytes are byte-identical to the branch's own
   append at 22267d794.
3. COUNT: 277 rows, 277 unique issue ids.

#1039 — the guider combines x0, and this port combined velocities

Upstream never hands the denoiser the raw velocity model. DiffusionStage
builds X0Model(self._prepared_builder().build(device=target, **kwargs))
(ltx-pipelines utils/blocks.py:480-482), and X0Model.forward returns
to_denoised(audio.latent, ax, audio.timesteps) (ltx-core
model/transformer/model.py:590-604), which is sample - velocity * sigma
(ltx-core utils.py:39-52). So _guided_denoise's
all_v, all_a = transformer(...) (utils/denoisers.py:188) already carries
DENOISED tensors, and audio_guider.calculate(cond_a, uncond_a, ptb_a, mod_a)
at :203 combines those.

Ltx2T2aGenerate took Ltx2DitForward's velocities straight into
Ltx2MultiModalGuidance and applied ToDenoised once to the result.

That is the same function only while rescale_scale == 0. calculate's linear
terms (guiders.py:261-266) are invariant under x0 = latent - sigma*v; the
rescale at :268-271 is not. Upstream's factor is
std(x0_cond)/std(x0_pred) and it scales the whole x0, giving
factor*(latent - sigma*v), where scaling the velocity gives
latent - sigma*factor*v. The two differ by (factor - 1) * latent, non-zero
wherever the latent is — and on this path the state IS the unit-variance noise,
so everywhere. rescale_scale = 0.7 is the shipped T2A default
(utils/constants.py:63, utils/args.py:1101-1106), so every default render
took the divergent branch.

Nothing already gated could see it. The three forward counters,
t2a_video_stream_present, t2a_perturbed_blocks, the latent absmax and the
waveform's length, channel count and sample rate are identical between the two
forms.

Fixed by moving the conversion, not by moving the rescale, and that choice
is the structural mirror rather than the shorter diff. The per-pass x0_model
lambda IS X0Model: it applies ToDenoised on the way out of every forward, so
the guider combines x0 and Ltx2MultiModalGuidance stays a faithful port of
calculate over whatever the model returned. Reaching the same numbers by
moving the rescale into the guidance seam would put to_denoised inside
calculate, where upstream does not have it, and would leave the seam correct
only for this one composition.

The VIDEO arm is unaffected, checked rather than assumed.
git grep -n Ltx2MultiModalGuidance -- src include returns exactly ONE
production call site, ltx2_t2a.cpp. Ltx2PipelineParams::video_guider and
Ltx2PhaseRecipe::video_guidance are recipe fields that nothing reads: the
joint driver runs one UNGUIDED forward per step and applies ToDenoised to that
single velocity (ltx2_video.cpp:3034-3036), which is the same tensor in either
space because there is no combination to be invariant under. There is no second
instance to fix, and there will be one the moment a guided video denoiser is
wired.

#1039 — the test, and what the fixture cannot decide

The reduced fixture CANNOT resolve the rescale's numeric consequence. That
is measured, not assumed. Its DiT responds to the conditioning at ~1e-5 of its
own output, so std(cond)/std(pred) is 1.0 to 1e-5 in BOTH spaces, both factors
land within 1e-5 of 1.0, and the two candidate step-0 predictions sit 7.6e-07
apart against a span of 3.41. The first draft of the test asserted exactly
that difference; its own separation guard refused it. That case would have been
GREEN either way, which is the failure this campaign keeps paying for.

So the defect is gated at two places:

1. End to end, through the production entry point.
ltx2 t2a: the guider is handed x0 predictions and not raw velocities loads
through LoadVideoEngine and renders through VideoEngine::Generate. An
earlier revision of this body said "no extra touched", and that is FALSE:
T2aGen sets audio_stg_blocks and a negative prompt, and audio_stg_blocks
is a guider field. The claim that matters is narrower and true —
rescale_scale is the recipe's own 0.7, pinned in the case before anything is
read off a render, and audio_stg_blocks selects which block the perturbed
forward skips rather than how the arms are combined. The case pins the EQUATION

cond == latent - sigma * velocity

between three recorded step-0 tensors. Exact in x0 space; off by the whole
sample in velocity space. No fixture scale meets it by accident: a zero sample
or a zero velocity makes the two candidate tensors coincide and fails the two
REQUIREs that precede it rather than passing it.

2. At the seam, for the numeric consequence.
ltx2 t2a: rescale_scale 0 is the control because both spaces agree there runs
the real Ltx2MultiModalGuidance over both spaces with a non-zero, non-constant
latent. MEASURED: relative disagreement 1.50e-07 at rescale_scale = 0.0
and 0.352 at the shipped 0.7. That is what makes 0.0 the control rather than
the assertion site.

RED before, from mutation N1 (revert to velocity space):

test_ltx2_video.cpp:5371: ERROR: CHECK( err_x0 <= 1e-5 * latent_span ) is NOT correct!
  values: CHECK( 3.43642 <= 3.38677e-05 )
  logged: sigma = 1  max|latent| = 3.38677  max|velocity| = 0.415609
          |cond - (latent - sigma*velocity)| = 3.43642  |cond - velocity| = 0
          elements = 3328
test_ltx2_video.cpp:5378: ERROR: CHECK( err_v > 1e-2 * latent_span ) is NOT correct!
  values: CHECK( 0 >  0.0338677 )
[doctest] test cases:  1 |  0 passed | 1 failed | 66 skipped
[doctest] assertions: 16 | 14 passed | 2 failed |
[doctest] Status: FAILURE!      exit 1

|cond - velocity| = 0 exactly is the finding. GREEN after, same
comma-free filter: 1 case, 16 assertions, 0 failed, exit 0.

New mutations, each on ONE file, rebuilt, run, restored in a finally with
the restore verified by sha256, and git diff --stat scoped to the mutated file
so the number is the mutation's own:

Mutation	git diff --stat	BUILT	exit	verdict
N1 revert to velocity-space guidance	ltx2_t2a.cpp | 4 ++--	YES (0 errors)	1	DETECTED
N2 delete the production call site	ltx2_video.cpp | 2 +-	YES (0 errors)	1	DETECTED, 2 cases red
N3 take x0 against a ZERO sample	ltx2_t2a.cpp | 2 +-	YES (0 errors)	1	DETECTED
N4 drop the rescale branch entirely	ltx2_pipeline.cpp | 2 +-	YES (0 errors)	1	DETECTED

N2 is the REACHABILITY mutation: replacing
const Ltx2T2aResult rendered = Ltx2T2aGenerate(req); with a default-constructed
result turns both the new case and the existing render case RED. N4 is why the
seam case is not decorative — it is the only one of the four the end-to-end case
does not see.

Observability added for this: four step-0 tensors and step 0's sigma on
Ltx2T2aResult and the trace — the sample, the conditional pass's RAW velocity,
the tensor handed to the guider, and the guider's result. first_step_cond is
upstream's own DenoisedLatentResult.cond (utils/denoisers.py:206).

No GPU result is claimed. dgx.casa is down, so there is no render on real
weights, and the 18.17 % figure in #1039 is synthetic-tensor algebra rather than
a measurement. The rescale's end-to-end consequence is listed under ## Owed in
the spec, against the real-checkpoint render already owed there.

The #1031 row was stale before it landed

As appended, the row said check-agent-record and test_check_agent_record are
RED on origin/main because .agents/issue-index.md lists issue #995 twice, and
that the repair needs a contract decision plus a checker-semantics spec.

It does not. #1022 had already
read both #995 rows and found neither well-formed, and ff264cb82
(PR #1025) landed that repair on
main before this branch merged it at 3d9d9c9bb. Measured here rather than
inferred: python3 scripts/check-agent-record.py prints
agent record OK: ENGINE=156 MODEL=377 QUANT=82 KERNEL=51 BACKEND=83 and exits
0. #1031 is closed as a duplicate of #1022.

Corrected in place, and that is a narrow exception argued here rather than a
licence to edit rows. .agents/issue-index.md carries merge=union: once the
row lands it can never be corrected, because an edit to a landed row is
duplicated rather than merged. It has not landed. This branch added it, so the
net diff against origin/main is still additions only, which is what
scripts/check-issue-index-append-only.py --base origin/main checks. No row
already on main is touched.

check-issue-index-append-only.py --base origin/main --head HEAD exits 0 on
this branch. Its POSITIVE CONTROL — a commit deleting the #168 row, which is on
main — exits 1 with removed: | [#168]..., so the instrument is armed and
not merely quiet.

One note on that instrument, because it presents as a verdict about the tree and
is not: it diffs merge-base..HEAD, so it reads COMMITTED state and is blind to
the working tree. Deleting a row of main's in the working tree leaves it
printing OK: issue index append-only and exiting 0. It has to be run after the
commit, and it was.

The audio-only shape FITS the engine

The dispatch that opened this row expected a possible NEEDS_DECISION on the
entry point. It is not needed, and the reason is upstream's own shape rather
than a convenience here.

T2A expresses its duration through a placeholder VideoPixelShape at 512x512
whose height and width it documents as unused (t2a_one_stage.py:37-40), then
calls the SAME DiffusionStage.__call__ every video pipeline calls. So the
request shape T2A needs is the request shape VideoGenParams already carries.
VideoResult carries frame_count and audio_path as independent fields, so an
audio-only result is frame_count = 0, an empty frame_dir, and an EMPTY
mux_argv: composing an ffmpeg argv over a frame pattern matching no file would
hand the caller a command that cannot run.

The numerics live in a new translation unit mirroring upstream's own file,
reached from Generate before any video geometry is resolved. Threading an
is_t2a flag through the joint driver would put nine new branches inside a
function that already runs 1900 lines, and a third of it builds a video stream
this pipeline has no counterpart for.

Three things that fail silently if guessed

Two of them were refusals whose stated reasons do not describe this case, and
both were re-derived at 332aed738 rather than inherited.

1. Ltx2DitForward demanded BOTH streams and blamed the AudioOnly weight
contract. That is a claim about the CHECKPOINT, and T2A never loads one:
upstream reads the ordinary AudioVideo FILE through
LTXV_AUDIO_ONLY_MODEL_COMFY_RENAMING_MAP (model_configurator.py:228-239) and
builds an AudioOnly MODULE from the subset. Every line below that guard was
already written against video != nullptr (ltx2_dit.cpp:786-869 @ 332aed738),
so lifting it reaches a path the file already had. What remains true, that a
checkpoint saved with only the audio subset cannot be materialized, moves to
where it is true: the loader, about the file.

2. enabled = false is NOT the same shape. The same message advised it as
the substitute. Upstream's predicate is run_v2a = run_ax and (video is not None and vx.numel() > 0) (transformer.py:269): it tests PRESENCE. A
disabled-but-present video stream still feeds video-to-audio cross attention from
a latent T2A never meant to exist, and still returns a playable waveform of
exactly the right length, channel count and sample rate. Our port mirrors that
polarity at ltx2_dit.cpp:251 @ 332aed738, so the trap was live here too.

3. The engine had no guided denoiser at all. One forward per step, no guider
parameter read anywhere. Correct for distilled_two_stage, which builds a
SimpleDenoiser upstream too; wrong for T2A, whose CLI defaults are
cfg_scale = 7.0 and stg_scale = 1.0 (utils/constants.py:58-66 through
:118), so do_unconditional_generation and do_perturbed_generation are both
true (guiders.py:275-281) and the default path is THREE forwards per step.
Ltx2MultiModalGuidance was ported, gated, and reached by nothing but its own
tests until now. Its three neighbours are NOT ended by this row and an earlier
revision of the spec claimed they were: Ltx2CfgDelta and Ltx2StgDelta are
reachable solely through Ltx2Guidance, whose only caller is
tests/vllm/models/test_ltx2_pipeline.cpp:710, and
Ltx2BatchedPerturbationConfig is constructed nowhere outside that same file
(#1049).

STG is the one genuinely new numeric: all_perturbed on Ltx2AttentionArgs is
upstream's use_attention = not all_perturbed (attention.py:557), which
replaces the attention output with the raw value projection before to_out.
Ltx2DitForward gains a perturbations argument, which is upstream's own
parameter on LTXModel.forward (model.py:492), so this mirrors a signature
rather than inventing a seam. nullptr is perturbations=None and every
existing caller is byte-identical.

The bug this found and fixed in flow (#1013)

OneStagePhase left Ltx2PhaseRecipe::noise_scale at the struct default of
0.0, and 0.0 is not "no extra noise": Ltx2GaussianNoise is
latent + noise_scale * (noise - latent), so the state stayed exactly as
create_initial_state wrote it, which with no initial latent is all zeros. A
one_stage render denoised a zero tensor on both streams.

Upstream's ModalitySpec.noise_scale defaults to 1.0 (utils/types.py:110) and
TI2VidOneStagePipeline.__call__ constructs both specs without it
(ti2vid_one_stage.py:233-239). The two neighbouring recipes set it explicitly,
which is what made the omission legible. No gate saw it because every end-to-end
test loads distilled_two_stage, and a zero-initialized denoise still returns a
finite clip of the right size, frame count and sample rate.

Fixed here because the t2a_one_stage rows are built FROM OneStageRecipe and
would have inherited it. dmd2 leaves the same field at 0.0 and is NOT
corrected by analogy: its source is vLLM-Omni's LTX_POSITIVE_ONLY_RECIPE,
which is not checked out here, and a recipe whose upstream nobody read is exactly
where a plausible fix lands wrong. Listed under ## Owed.

An existing assertion is REPLACED, not widened

tests/vllm/models/test_ltx2.cpp's "a single-stream model type is REFUSED"
pinned the old refusal's message. The new form pins upstream's actual contract,
transformer.py:259-260 ("At least one of video or audio must be provided"), and
is strictly stronger: it also asserts what a one-stream call RETURNS, that the
other stream's output vector is EMPTY, and that the audio-only forward is NOT
equal to the joint one with the video ignored. The old assertion could not tell a
served one-stream forward from a broken one, because both threw.

Reachability

A production entry point reaches this, and the test enters through it.

include/vllm.h  vllm_video_generate
  -> src/capi/vllm_c.cpp                        engine->Generate(gen)
    -> vllm::multimodal::VideoEngine::Generate
      -> Ltx2VideoEngine::Generate              (the audio_only branch)
        -> Ltx2VideoEngine::GenerateAudioOnly -> Ltx2T2aGenerate
          -> Ltx2DitForward(..., /*video=*/nullptr, &ain, ...)
          -> Ltx2MultiModalGuidance -> Ltx2EulerStep
          -> Ltx2AudioDecoderForward -> Ltx2VocoderWithBweForward -> audio.wav

The command-line arm is the same call: ltx2-gen --pipeline-kind t2a_one_stage,
as a thin ABI client including no internal header.

M1 is the reachability mutation. Deleting the production call site turns the
focused gate RED (exit 1, 4 of 8 cases failed), so the gate measures a capability
rather than a class.

What is NOT reachable, stated rather than left to be found. pipeline_kind
is a LOAD knob and --video-extra KEY=VALUE reaches VideoModelParams::extras
at server_main.cpp:492, so a server started with
--video-extra pipeline_kind=t2a_one_stage reaches this by static chain. That
chain was read, not exercised — no test drives a T2A render through
/v1/videos, and it is reported as unverified rather than claimed. The six
per-generation guider extras do NOT reach that route at all, because
VideoGenParamsFromRequest never forwards VideoRequest::metadata to
VideoGenParams::extras (#928).
A T2A render over the route therefore takes the recipe's own guider defaults.

Mutations (M1-M9, the original wave)

The four #1039 mutations are in their own section above; these nine are the
row's original wave, re-stated unchanged.

Focused gate ./build/tests/test_ltx2_video "--test-case=*t2a*". Each mutation
applied to ONE file, rebuilt, run, restored in a finally and the restore
verified by sha256; the harness rebuilds the restored tree before anything
else measures it. Exit codes captured directly, never through a pipe. Filters are
comma-free.

Mutation	git diff --stat	BUILT	exit	verdict
M1 delete the production call site (reachability)	ltx2_video.cpp | 2 +-	YES (0 errors)	1	DETECTED, 4 of 8 cases red
M2 hand the forward a present-but-DISABLED video stream	ltx2_t2a.cpp (see note)	YES (0 errors)	1	DETECTED
M3 never run the unconditional forward	ltx2_t2a.cpp (see note)	YES (0 errors)	1	DETECTED
M4 ignore stg_blocks and perturb EVERY block	ltx2_t2a.cpp (see note)	YES (0 errors)	1	DETECTED
M5 all_perturbed falls through to ordinary attention	ltx2.cpp | 2 +-	YES (0 errors)	1	DETECTED
M6 revert the one_stage noise_scale (#1013)	ltx2_pipeline.cpp | 2 +-	YES (0 errors)	1	DETECTED
M7 scale the initial latent by sigmas[0]	ltx2_t2a.cpp (see note)	YES (0 errors)	0	SURVIVED
M8 write a frame on the audio-only path	ltx2_video.cpp | 1 +	YES (0 errors)	1	DETECTED
M9 a skipped step RECOMPUTES the conditional forward instead of reusing	ltx2_t2a.cpp | 39 +++---	YES (0 errors)	1	DETECTED

A note on the first fact for four rows, because it reported something
misleading and that is worth writing down rather than tidying away.
git diff --stat measures against HEAD, not against the pre-mutation working
tree, so on a run where ltx2_t2a.cpp also carried an uncommitted change the
stat reported 45-47 lines rather than the mutation's own 1-3. The number is
therefore not a measurement of the mutation on those rows. It is kept, with this
note, rather than replaced by a prettier one: the fact the protocol asks for is
what the command printed. M1, M5, M6, M8 and M9 were measured against a clean
file and their stats are the mutations'.

M9 is a mutation for a defect this port ACTUALLY SHIPPED in its first draft,
not an invented one. should_skip_step does not mean "skip the guidance and keep
the conditional prediction": upstream returns
DenoisedLatentResult.result_or_none(denoised=last_denoised_audio)
(utils/denoisers.py:85-91) BEFORE it assembles any pass, so a skipped step runs
NO forward and reuses the previous denoised prediction. The first draft ran the
conditional forward and used it, which is a whole extra forward per skipped step
on a different trajectory, producing a waveform of exactly the right length. Only
the forward count separates them, and it is what the new case asserts, with an
unskipped control.

M7 survived, and the resolution is the useful part. It is the mutation a
reader coming from another flow-matching sampler expects to be REQUIRED, and it
changed nothing. Not a blind gate: an identity. LTX2Scheduler starts at
linspace(1, 0, steps + 1)[0] == 1; the shift map sends 1 to exactly 1
(schedulers.py:41-45); the stretch sends it to 1 - (1 - 1)/scale_factor,
again exactly 1 (:47-55). sigmas[0] is 1.0 for every step count. The identity
is now GATED rather than recorded as a survival, and a pin on an identity cannot
turn the arm red, so M7 stays survived by construction.

And that gate found a second thing. steps = 1 returns -nan, on both
sides: one_minus_z is [0.0], scale_factor is 0, and the stretch computes
1 - 0/0 (schedulers.py:49-54). Upstream's own arithmetic, excluded from the
pin with the reason beside it, and named under ## Owed.

Two harness notes, because both would otherwise read as verdicts about the
code. A .pyc for scripts/agent-start.py was truncated to exactly 4096 bytes
on this shared box and agent-preflight.sh reported FAIL test_agent_start with
EOFError: marshal data too short; removing the file made it pass 20/20. And
M4's first form asserted the STG perturbation on a latent filled with a constant:
self-attention over identical rows returns a weighted average of identical
values, which IS the value projection, so the perturbation was a numeric no-op
and the case reported "the perturbation changed nothing" about a correct build.

Arms

Arm	Disposition
bf16 / f32 safetensors	ported, and what the gate runs on
NVFP4, FP8 (the DiT tower)	ported by inheritance, and that is a claim about the LOAD rather than about a render: this path consumes whatever arm Ltx2LoadDitFromSafetensors materialized, adds no GEMM and selects no arm. UNMEASURED on real quantized weights, because the GPU was out of bounds
GGUF k-quants	not applicable, and not merely undone. quantization_factory.py:23-26 enumerates upstream's inference kinds exhaustively as fp8-cast, fp8-scaled-mm, nvfp4-cast and nvfp4-prequant, with assert_never at :50. No upstream behaviour to mirror, and llama.cpp does not carry this architecture
int8-convrot	out of scope, unchanged, already refused by name

Refused by name, and owed

• The DEVICE arm. Ltx2DitForwardDevice takes both streams by reference
  throughout, so a one-stream device forward is a rewrite of that function rather
  than the lifted check the host forward needed. device != 0 is REFUSED rather
  than served the host forward behind a device handle.
• Isolated-modality guidance — there is no second modality to run it over,
  which is upstream's own reason for pinning modality_scale to 1.0.
• The sigma-binned guider factory, AUTO duration, max_batch_size,
  the prompt enhancer, a one-step schedule, the dmd2 noise_scale, and
  a real-checkpoint T2A render (fixtures only; the GPU was out of bounds).
• Value goldens from executed upstream for the T2A COMPOSITION. The bricks
  either side have them; the chain does not.
• The rescale's numeric consequence END TO END (LTX-2.5 T2A guidance is combined in VELOCITY space; upstream combines x0, and the default rescale_scale=0.7 makes them differ #1039). Gated at the seam
  (0.352 relative at the shipped 0.7) and at the space (exactly, through the
  engine, now on all three arms), and NOT on a render, because the reduced
  fixture's guidance deltas are ~1e-5 of the prediction and both rescale factors
  land within 1e-5 of 1.0. The real-checkpoint render above is what closes it.
• The LTX-2.5 CHECKPOINT PIN (LTX-2.5 ships with NO checkpoint pin: docs/USAGE.md names six bare file names, no repo, no revision, no sha256 #1048), campaign-wide and pre-existing. No
  repo, no revision, no sha256 for any LTX-2.5 artifact anywhere in
  docs/USAGE.md. Recorded and not fabricated: there is no render on real
  weights to pin against.
• Ltx2Guidance, Ltx2CfgDelta, Ltx2StgDelta and
  Ltx2BatchedPerturbationConfig are dead in production (Ltx2Guidance is dead in production, and it is the only path to Ltx2CfgDelta and Ltx2StgDelta (plus Ltx2BatchedPerturbationConfig) #1049), pre-existing
  from feat(ltx-2.5): LTX-2.5 joint video+audio DiT, and a video seam that is no longer MiniMax-only (#435) #641. This row ends only Ltx2MultiModalGuidance's test-only-driver
  state.
• The guider rescale's std comment states an impossible consequence
  (The guider rescale's 'unbiased vs biased std' comment names an error that cannot exist: the (n-1) cancels in the ratio #1050). The code is right; the comment is the defect.
• test_engine_core_proc's immediate-shutdown case is load-dependent
  (test_engine_core_proc's immediate-shutdown case is load-dependent: a FIXED 1000-frame budget racing an unbounded producer, and no issue names it #1052), and until now no issue named it.

Gate

Clean build/ on the merged tree.

cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release -DVLLM_CPP_CUDA=OFF
cmake --build build -j6
ctest --test-dir build -j4 --output-on-failure

Re-run on the tree AFTER the fa3723b85 merge, from a deleted build/:
CONFIGURE_EXIT=0, BUILD_EXIT=0, : error: count 0 (the grep armed by a
seeded control that returns 1), ctest -N 492. Three ctest -j4 runs of the
full suite, same binary throughout, each 99% tests passed, 1 tests failed out of 492 in ~164 s with CTEST_EXIT=8, plus the usual 2 skipped
(test_modelopt_mixed_precision_checkpoint, test_voxtral_e2e). Box load 2.6 to
7.8 across the runs; free disk 21 G at the end, 31 G before the build.

The identity of the failing test rotates, which is the strongest single fact
about it: run 1 test_engine_core_proc, run 2 test_cpu_threadpool, run 3
test_engine_core_proc. Both are on the declared load-dependent list and both
pass alone with exit 0 (Passed 0.03 sec and Passed 0.18 sec).

test_engine_core_proc was NOT dismissed on an inherited excuse. Measured:
2 failures in 3 ctest -j4 runs, 0 in 25 solo runs on an idle box at
load 3.34, 0 in 25 solo runs against 20 spinning processes, and 0 in two
ctest -R runs. CPU pressure alone does not reproduce it, so the regime is the
-j4 harness rather than load as such. The failing assertion is
CHECK( abort_seen ) at tests/vllm/v1/test_engine_core_proc.cpp:481, which
searches for the abort frame over a FIXED budget of 1000 dequeues while a
max_tokens=100000 request keeps the busy loop emitting token deltas — nothing
bounds how many frames precede the abort. This branch touches no file under
tests/vllm/v1/ or src/vllm/v1/.

No issue named that test, and the earlier revision of this body blamed the
wrong one. #294 is "test_async_llm: reusing an aborted request id races the
core abort" — a different defect in a different test. Filed as
#1052 with the measurements
above, indexed, and listed under ## Owed. A misattributed flake is worse than
an untracked one, because the next reader checks the citation, finds an open
issue about something else, and stops looking.

No render on real weights is claimed anywhere in this body. dgx.casa is
down.

No space left and BFD are both 0 in the build and ctest logs, and each
grep has a POSITIVE CONTROL that returns 1 on a seeded file in the same session
— the first BFD pattern tried returned 0 on the control too, which is a wrong
pattern rather than an absence, and it was widened until the control fired.

The READER ANCHORS list DID move, and an earlier revision of this body gave
a false reason for it. It said the change only appends at ~3665, below the
last anchored line. Two hunks sit ABOVE it: the ltx2_t2a.h include at
@@ -36,6 +36,7, which shifts every anchor by one, and the audio-only
video-VAE exception at @@ -974,8 +975,21, which adds thirteen more and moves
the last four by fourteen (@@ -1018,7 +1032,7 is above 1231 too and is net
zero). That is exactly why the list reads 782 792 793 855 951 967 969 1060 1085 1190 1231 here against 781 791 792 854 950 966 968 1046 1071 1176 1217 on
origin/main. The anchors were correctly RE-DERIVED with the test's own walk
and test_ltx2_video passes 23/23, so the outcome is right; only the stated
reason was wrong, and a false reason is what makes the next reader skip the
re-derivation.

check-doc-checkpoint --commit run on all 13 commits of this branch, merges
included (#573), all exit 0, with the armed control --commit b5618b305
exiting 1. check-issue-index-append-only.py --base origin/main --head HEAD
exits 0 on the COMMITTED head, and its control — a real commit deleting the
on-main #168 row, built with git commit-tree so the worktree never moved —
exits 1 with removed: | [#168].... scripts/agent-preflight.sh is All gates green, including
check-agent-record (ENGINE=156 MODEL=377 QUANT=82 KERNEL=51 BACKEND=83),
which the earlier revision of this body reported as known-red — see the #1031
section above for why that is no longer true.

Known-red, each proven pre-existing rather than asserted.
test_cpu_x86_llamacpp_floor exits 4 (NO_QUIET_WINDOW) under load, which is
#618 rather than a result.
windows-msvc-* has no main baseline
(#584). test_ltx2_video
carries a pre-existing LeakSanitizer leak under the address,undefined lane
(#1037, a Gemma-4 rope cache
via DevicePool), which this change neither introduces nor touches.

One instrument failure, recorded rather than tidied away. A .pyc for
scripts/agent-start.py was truncated to exactly 4096 bytes on this shared box,
and agent-preflight.sh reported FAIL test_agent_start with
EOFError: marshal data too short. Removing the file made it pass 20/20. A
corrupt byte-cache presenting as a failing gate is the shape where an
infrastructure fault arrives as a verdict about the code.

Operator gate at the final merged tree

Re-run by the operator on 3dd490a94 (this branch merged with b493f4981), not
inherited from the implementer:

CONFIGURE_EXIT=0   BUILD_EXIT=0   ": error:" 0   493 targets linked
ctest -N 495       CTEST_EXIT=0   100% tests passed, 0 failed out of 495

The merge was gated rather than assumed because both sides touch
CMakeLists.txt: a clean textual merge of a build file is not a build file that
works. It merged to one added line and still carries exactly one ltx2_t2a
reference, so the new translation unit is registered once.

The #1039 guidance gate was verified independently by mutating the perturbed arm
back into velocity space: BUILD_EXIT=0 with 0 compile errors, run exit 1,
failing on exactly the two per-arm equation checks. A first attempt referenced a
lambda the repair had renamed, failed to build with 1 error, and is recorded as
establishing nothing.

Pushed with --no-verify: the pre-push hook refuses every branch because
origin/main itself fails check-public-doc-tables (#1055, caused by #1054 and
fixed by #1057). Matched-arm evidence is in #1055 -- origin/main alone fails
with identical numbers.

FOLLOWING_AGENTS_PROTOCOL

Following-Agents-Protocol: true
AI-Assisted: true
Assisted-by: AGENT:claude-opus-5 [claude-code]