[tunamitom]

Two decode-graph reductions, each exact by construction, each with its
own measured node delta (two separate deltas that happen to be equal —
not one number counted twice):

• retained-buffer compaction (always on): selected_local_records
  takes out=/count_out= so the compaction kernel writes the DSA
  stage's retained physical/counts buffers directly (one write per
  element instead of two; the per-stage copy disappears). Its own delta:
  −48 graph nodes per decode round = the two per-stage copy nodes
  removed × 24 decode stages. Default None allocates exactly as before.
  Bytes beyond each row's count are -1 and don't care.
• fused pack (--decode-fusion, default off): one compiled Triton
  kernel replaces the 8-kernel decode score/ID pack, writing pairs
  straight into the existing cursor buffer (select/copy/integer-only,
  exact by construction, allocates nothing). Its own delta: a separate
  −48 graph nodes per decode round = the shipped Inductor-fused pack
  chain's 3 graph nodes per call fused to 1, × 24 decode stages.

Together the two deltas remove 96 nodes/round (0.100–0.112 ms/round at a
measured 1.042–1.163 µs dispatch cost per removed node; see Evidence).

Design notes

• No environment channel: the gate is the plan setting
  --decode-fusion -> Plan.decode_fusion (recorded in plan settings)
  -> PreparationConfig -> PreparedDecoder/PreparedMLA/PreparedDSA
  -> the PreparedDistributedTopK constructor argument. The component
  never reads the environment in any form and no preparation stamps a
  variable; a regression test pins the source free of environment reads.
  (That regression is a source-text check; its docstring and assert
  messages now say exactly what it checks and that it is not a
  behavioural proof.)
• Aliasing guard fixed: it compared untyped_storage().data_ptr(),
  so disjoint GraphBufferPool cursor buffers (one shared chunk, disjoint
  byte ranges) raised ValueError on every eager pool caller. The guard
  now checks byte ranges (strided bounding box) and rejects only real
  overlap of out=/count_out= with the kernel's inputs; it stays out
  of Dynamo traces (torch.compiler.is_compiling() skip, as before).
  Tests cover true overlap (raises), disjoint shared-chunk pool buffers
  (pass), and GPU equality of the retained write vs the allocating path.
  Design origin, disclosed for the AGENTS.md authorship rule: the
  byte-range guard design (data_ptr() + strided bounding-box extent)
  came from an external design-review comment (Claude Opus 5.5's
  first-pass review of this work), not from the original implementation
  pass. The guard is input validation around the kernel — not kernel
  code and not the aliasing mechanism itself — and is stated neutrally so
  the maintainer can judge.
• Bit-exactness GPU-verified: 5-case GPU matrix (rows 1-8, widths
  48-2048, worlds 8/16, tied / NaN / -inf scores, dead entries, ids whose
  int32 narrowing wraps) — fused pack vs shipped pack bit-equal 5/5 on
  an idle GPU; the test rides with the branch.

Follow-up

• rebuild_manifest.from_plan does not record decode_fusion, so a
  fused package's rebuild manifest describes the 8-kernel pack. Suggest
  recording it when set (absent ⇒ false), the same treatment as the
  block-verification manifest key. The output is bit-exact either way,
  so this is a manifest-accuracy follow-up, not a correctness fix.

Numerics class

BIT-EXACT — select/copy/integer-only paths; GPU-verified as above. The
compaction writes the bytes the previous copy produced.

Evidence, stated honestly

The shipped pack chain is already Inductor-fused, so the fused pack's
saving is its own node reduction (3 nodes/call → 1, × 24 stages = −48/round),
not eight sequential launches; the compaction's −48/round is separate
(its two per-stage copy nodes × 24). Node counts come from the exported
package's captured decode-round graphs; the per-node dispatch cost
(1.042–1.163 µs) and the resulting 0.100–0.112 ms/round for the two
combined (−96 nodes/round) are from captured-chain replays of those
graph shapes. None of it was re-measured on this tree; no before/after
decode round time or tok/s is claimed. The maintainer may drop the gated
fused pack and keep the compaction alone (the commits are split
accordingly), or ask for a serving-level measurement first. The new
Triton kernel is offered for kernel-level review. Authorship: written by
Hermes Agent (hermes-agent); no restricted model authored the kernel
code.

Tests

• tests/components/test_distributed_topk_pack.py — 11 passed
  (3 compaction/guard incl. 1 GPU, 2 CPU pack parity, 5 GPU bit-equality
  cases, 1 environment-read source-text check). Re-run on the final tip: CPU-only
  5 passed / 6 skipped (CUDA cases skip without a GPU); with one idle GPU the full
  suite re-ran on the final tip: 11 passed (CUDA matrix included).
• tests/recipes/test_kimi31.py + tests/recipes/test_kimi3_preparation.py
  — 49 passed (identical to base; the preparation test plan stub now
  carries decode_fusion). Final-tip re-run (all three suites, CPU):
  54 passed, 6 skipped; base-failure parity re-run: base's 49 passed,
  zero failures at base and none new at the tip.
• Full run (tests/cli + tests/recipes + tests/components): exactly
  the 13 pre-existing failures of the intake-lane base — no new
  failures (base-failure parity).
• Commit 1 standalone: 52 passed, imports OK (bisection-clean).
• ruff: touched files clean; zero new findings vs base.

Dependencies

None on the flashinfer PRs (pure flare-side graph work).