diff --git a/CLAUDE.md b/CLAUDE.md
index d56341cd..e3ad6fd7 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -72,8 +72,8 @@ The guides in `docs/`, by topic:
 
 `.claude-plugin/marketplace.json` publishes the `dw` plugin in `plugins/dw/`: one
 composition skill per model family (`minimax-h3`, `minimax-music3`, `ltx-2.5`,
-`kandinsky-6`) that chooses a template for a request's shape and states the family's
-hard rules, plus
+`kandinsky-6`, `flux3-klein`) that chooses a template for a request's shape and
+states the family's hard rules, plus
 cross-cutting composition skills (`script-to-video`, `series-episodes`) - shapes above
 the families that orchestrate the decision trees and cast consistency across multiple
 generations. Every skill the directory holds is named in `plugins/dw/README.md` and here,
diff --git a/docs/ACCELERATION.md b/docs/ACCELERATION.md
index e864eb7b..e1db7444 100644
--- a/docs/ACCELERATION.md
+++ b/docs/ACCELERATION.md
@@ -159,20 +159,58 @@ Select the attention implementation diffusers uses for the duration of each pipe
 }
 ```
 
-Common values: `"flash"`, `"flash_hub"`, `"sage"`, `"sage_hub"`, `"native"`, `"flex"`. The full set is diffusers' `AttentionBackendName` enum - availability depends on what's installed (`flash-attn`, `sageattention`, etc.) and the platform. `_hub`-suffixed backends are fetched from the Hugging Face Hub kernel registry on first use, which needs the `kernels` package installed (`pip install kernels`) - it is not a dw dependency, and no bundled workflow sets a backend, so each runs on a plain install. diffusers also refuses a Hub kernel whose publisher it does not list as trusted - `sage_hub` among them, since SageAttention 2 comes from `SageAttention/sage-attention` - until `DIFFUSERS_TRUST_REMOTE_KERNELS=true`, which allows remote code from any such publisher. On an RTX 3090 `sage_hub` measured about 30% faster per MiniMax-H3 step (13.8 s against 19.2 s at 960x544x124, 54.7 s against 81.2 s at 345 frames); the local `sage` backend needs `sageattention>=2.1.1`, which PyPI does not carry.
+Common values: `"flash"`, `"flash_hub"`, `"sage"`, `"sage_hub"`, `"native"`, `"flex"`. The full set is diffusers' `AttentionBackendName` enum - availability depends on what's installed (`flash-attn`, `sageattention`, etc.) and the platform. `_hub`-suffixed backends are fetched from the Hugging Face Hub kernel registry on first use, which needs the `kernels` package installed (`pip install kernels`) - it is not a dw dependency. The only backend a bundled workflow sets is `sparse`, the default on every MiniMax-H3 template, and it needs no `kernels` install (comfy-kitchen is a core dependency), so each bundled workflow runs on a plain install. diffusers also refuses a Hub kernel whose publisher it does not list as trusted - `sage_hub` among them, since SageAttention 2 comes from `SageAttention/sage-attention` - until `DIFFUSERS_TRUST_REMOTE_KERNELS=true`, which allows remote code from any such publisher. On an RTX 3090 `sage_hub` measured about 30% faster per MiniMax-H3 step (13.8 s against 19.2 s at 960x544x124, 54.7 s against 81.2 s at 345 frames); the local `sage` backend needs `sageattention>=2.1.1`, which PyPI does not carry.
 
 Every MiniMax-H3 template in [templates/minimax/](../workflows/templates/minimax/)
 exposes this as a variable: `attention_backend`, pinned on the H3 step's transformer
 (`components.transformer`, or `components.transformer_ref` for a ref2va workflow) and
-`null` by default. That covers the shots, chains and episodes - `dialogue-short`,
+`"sparse"` by default (with `sparse_tau`, below). That covers the shots, chains and episodes - `dialogue-short`,
 `shots-batch`, `music-video` and `storyboard` among them - and only their H3 steps: a
 Z-Image still or Music3 song beside an H3 shot keeps the process default. Pass
-`attention_backend=sage_hub` to a box with the `kernels` package and
-`DIFFUSERS_TRUST_REMOTE_KERNELS=true` in its `.env`; on MPS leave it null, since a
-CUDA-only kernel fails there at load (validation warns, below). LTX-2.5 cannot use it: its transformer
+`attention_backend=sage_hub` (or `native`) to override the default; `sage_hub` needs a box with the `kernels` package and
+`DIFFUSERS_TRUST_REMOTE_KERNELS=true` in its `.env`; on MPS the default falls back to dense, but a CUDA-only kernel such as `sage_hub` fails there at load (validation warns, below). LTX-2.5 cannot use it: its transformer
 passes an attention mask, and sage attention refuses one ("`attn_mask` is not supported
 for sage attention", measured 2026-10-10), so the LTX templates expose no backend.
 
+### `sparse` (MiniMax-H3)
+
+`attention_backend: "sparse"` runs H3's attention through comfy-kitchen's block-sparse kernel: each query tile attends only to the key tiles that matter, so the cost of the long video-token sequence falls. It applies to the H3 transformer only, at pipeline or component level, and is the default on every H3 template (#931). Set at both levels, the component's own `attention_backend` wins, as it does for every backend: a pipeline-level `sparse` skips a component pinned to `sage_hub` (or anything else) and warns `attention_backend 'sparse' at pipeline level skips '<component>', which pins '<backend>'`. When it does install, the run logs `Using attention backend: sparse (tau <tau>) on <components>`, or `(topk <k>)` with top-k routing. `sparse_tau` (number, minimum 0, default 0.5; anything else, such as a `variable:` that resolves to a string or a bool, fails the step rather than running dense) sets how much of the attention mass a tile may drop; 0 keeps the most. Observed at Ref2VA 1344x768, seed 42: tau 1.0 ran 42.1 s/forward against 44.8 s at 0.5, and by Don's eye 1.0 gave smoother skin while 0.5 matched dense (the table below). That is one shape and one seed, not a rule that higher is always faster or smoother.
+
+`sparse_topk` (a number strictly between 0 and 1; the H3 templates set 0.15, and a workflow that sets none routes by `sparse_tau`) switches the kernel to top-k routing: each query tile keeps that fraction of key tiles and drops the rest outright, with `sparse_tau` ignored. It is the selection lightx2v's Turbo-SLA LoRAs were trained against (85% sparsity, so `0.15`). Measured on `video-with-audio-768p`, seed 42 (#932): top-k 0.15 ran 21.1 s/forward against 23.6 s at tau 0.5, about 11% faster, and Don saw no difference on that clip, with either the Turbo-SLA LoRA or the default v1.2 turbo (so dw does not adopt the SLA LoRA). That clip has no faces, so it was checked on the H3 quality ramp's 4-reference sitcom shot at seeds 42, 7 and 1234 against tau 0.5. Don judged top-k equal or better: on the turbo L7 rung tau showed blue ghosting at seed 7 and slight smearing at all three, and on the 30-step base-model L5 rung the skin held. Top-k 0.15 is therefore the H3 templates' default; pass `sparse_topk=null` to route by `sparse_tau` instead.
+
+| rung (minutes per job, seeds 42 / 7 / 1234) | tau 0.5 | top-k 0.15 |
+|---|---|---|
+| L7: ref2v 4-step turbo, int8 | 6.5 / 6.5 / 6.5 | 6.1 / 6.2 / 5.8 |
+| L5: base model, int8, 30 steps | 26.8 / 26.6 / 26.4 | 23.9 / 25.5 / 23.9 |
+
+**What the default buys depends on what it replaces.** Against `native` attention, which is what an H3 template ran before #931 unless `attention_backend` was set, sparse is 2.2-4.4x faster per step. Against `sage_hub`, the gain is much smaller: 6-16% depending on the shape (the second table). So sparse's main win is for a run that set no backend, and it needs no `kernels` package or `DIFFUSERS_TRUST_REMOTE_KERNELS`. A box already on `sage_hub` gains a little, at equal quality: on the H3 skill's quality-ramp rungs, Don judged faces, skin and draft-to-final staging equal under both backends across three seeds (#931 stage 3).
+
+Measured on an RTX 3090, seed 42, s per transformer forward (one per denoise step), lower is faster:
+
+| shape | native | `sage_hub` | sparse | sparse vs native | sparse vs `sage_hub` |
+|---|---|---|---|---|---|
+| T2VA 960x544, 4-step turbo, tau 1.0 | 24.3 | - | 10.8 | 2.25x | - |
+| T2VA 1344x768, 4-step turbo, tau 1.0 | 96.1 | - | 21.9 | 4.38x | - |
+| Ref2VA 1344x768, 8-step ref2v turbo, tau 1.0 | 108.4 | - | 42.1 | 2.58x | - |
+| Ref2VA 1344x768, 8-step ref2v turbo, tau 0.5 (the default) | 108.4 | 51.0 | 44.1-44.8 | 2.42x | 1.16x |
+
+Wall time, same order: 150 -> 95 s, 457 -> 158 s, 965 -> 430 s, and for the last row 965 s native, 489 s `sage_hub`, 442-450 s sparse.
+
+Against `sage_hub` on the H3 skill's quality-ramp rungs (ep 6 cold open, 4 references, 1344x768, 124 frames; minutes per job, seeds 42 / 7 / 1234, all on the same diffusers):
+
+| rung | `sage_hub` | sparse | sparse vs `sage_hub` |
+|---|---|---|---|
+| L1: ref2v 4-step turbo, int4, 5 steps | 5.5 / 5.5 / 5.5 | 5.2 / 5.2 / 5.1 | 1.06-1.08x |
+| L7: ref2v 4-step turbo, int8, 5 steps | 7.1 / 6.9 / 7.1 | 6.5 / 6.5 / 6.5 | 1.06-1.09x |
+| B3: base model, int8, 12 steps | 13.0 / 12.9 / 12.9 | 12.3 / 12.0 / 12.1 | 1.06-1.07x |
+| L5: base model, int8, 30 steps | 29.7 / 29.7 / 29.7 | 26.8 / 26.6 / 26.4 | 1.11-1.12x |
+
+The `first_block` cache on `sage_hub` (23.1 min at L5's settings) is still faster than sparse alone there; sparse with that cache is not measured. The native and tau 1.0 figures come from the #931 prototype. The `sage_hub` figure and the 44.1 s come from the engine on lem after the deploy, with a newer diffusers (jobs 94c04976d21d and 593131ca713f), so the sage comparison is between those two jobs only. The T2VA rows have no `sage_hub` run. Peak VRAM did not change. Judged by eye, tau 0.5 matched dense; tau 1.0 was smoother in skin.
+
+It needs CUDA with compute capability 8.0 or higher. Anywhere else (MPS, CPU, an older card, an unsupported dtype or head size) the run goes dense instead of failing, and says so twice: `validate_workflow` warns `sparse_attention_fallback` when the server's device is not CUDA, and the run reports `<label>: sparse attention ran dense - <reason>` once per pipeline call. A job of one call warns once; a chained, `shots-batch` or `dialogue-short` job calls the pipeline once per segment or shot, so it warns once for each, under that segment's or shot's label. A comfy-kitchen kernel that fails on its first invocation in a call also runs that call dense, with `sparse kernel failed: <error>` as the reason; one that fails after it has run in the call fails the run, since some blocks have already run sparse.
+
+Unlike sage, sparse **moves composition** relative to dense: the same subject, story and cuts, but different framing and set dressing. A draft and its final must therefore use the same backend; mixing `sparse` and `sage_hub` between tiers means the draft no longer predicts the final.
+
 A component can also pin its backend persistently instead, via `set_attention_backend`:
 
 ```json
diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md
index 4cc5c11c..920f76cb 100644
--- a/docs/ARCHITECTURE.md
+++ b/docs/ARCHITECTURE.md
@@ -106,6 +106,7 @@ one to open.
 | Inherited cost | `dw/server/deps.py`: `inherited_observed`, `dw/vram_inheritance.py`: `inherited_differences`, `dw/plan.py`: `_observed` (basis `inherited`), `dw/server/routes/jobs.py`: `_inherited_cost_warnings` | An inline workflow (no catalog name) is priced from the observed runs of the catalog template with the same `component_type` + `model_name` + `workflow` key as `vram_inheritance`; the template with the most cold runs wins, then name. `differs` lists offload, quantization, frame count, attention backend, cache, LoRA and reference count (the `references` list lengths, per-entry `item:` ones read off the `for_each` list; named, not scaled, #915) set differently from the template, and sets `low_confidence` when it lists any (#866). More pipeline steps than the template run (a `for_each` counted per member, against the list the bucket ran, so a fallback to the default bucket re-prices a longer list) re-price its minutes linearly, and the mean frames, inference steps, width and height per pipeline step are scaled by `scale_curated` itself - the one rule the catalog figure uses, so an inline copy and its template quote one request alike - with `scaled` naming why and `low_confidence` set (#851, #866). It is warned, never refused. | `tests/test_inherited_cost.py::TestPricedByPipelineIdentity::test_an_inline_copy_inherits_the_templates_runs`, `tests/test_inherited_cost.py::TestDifferences::test_offload_quantization_and_frames_are_named`, `tests/test_inherited_cost.py::TestDifferences::test_a_reference_count_other_than_the_templates_is_named`, `tests/test_inherited_cost.py::TestThePlanReportsIt::test_the_estimate_is_inherited_and_the_validate_answer_warns`, `tests/test_inherited_cost.py::TestTheTemplateAndAnInlineCopyAgree::test_the_same_minutes_within_rounding`, `tests/test_inherited_cost.py::TestAListLongerThanTheFallbackBucket::test_an_inline_six_shot_copy_scales_by_members` |
 | Projected host-RAM peak | `dw/server/host_ram_need.py`: `memory_key`, `projected_peak`, `host_memory_block`; the fit is `dw/host_memory_projection.py`: `projected_mb`; history by key is `dw/server/job_history.py`: `peaks_for_key` | A run's memory key is the sorted pipeline identity of its pipeline steps plus every `quantization_config` / `offload` / `group_offload` value, with arguments substituted through `replace_variables`; never the workflow's name, so a renamed or inline copy shares the template's history. `observed` is the max peak over this machine's successful same-key runs and comes ahead of the list-run fit, unless the shape holds its pipeline across the list and the fit is the larger (the key leaves list length out, #910); with neither there is no figure. It never refuses; dispatch may delay a start on it (`dw/server/dispatch.py`: `Dispatcher._next_dispatch`, #869) (`Admission.host_ram_need`, validate's `plan.host_memory`). | `tests/test_host_ram_need.py::TestMemoryKey::test_an_inline_copy_without_its_metadata_has_the_same_key`, `tests/test_host_ram_need.py::TestMemoryKey::test_a_different_weights_dtype_is_a_different_key`, `tests/test_host_ram_need.py::TestProjectedPeak::test_an_observed_peak_beats_the_fit`, `tests/test_host_ram_need.py::TestALongerListThanObserved::test_an_accumulating_list_takes_the_larger_fit`, `tests/test_host_ram_need.py::TestProjectedPeak::test_a_failed_run_is_not_observed`, `tests/test_host_ram_need.py::TestValidateRoute::test_an_observed_run_is_the_plans_host_memory` |
 | Acceleration warnings | `dw/acceleration_warnings.py`: `acceleration_warnings`, `CACHE_MIN_USEFUL_STEPS`, `CUDA_ONLY_ATTENTION_BACKENDS` (the last entry of `WARNING_CHECKS`) | An acceleration setting that can't pay off (a `first_block`/`mag` cache under `CACHE_MIN_USEFUL_STEPS`, any `taylorseer` cache, `compile.fullgraph` with a cache, a cache on a pipeline class with no transformer or whose transformer lacks `enable_cache()`, a CUDA-only `attention_backend` on a non-CUDA device) is a warning and never a refusal, and an unresolvable value (steps, backend, device) leaves it silent. | `tests/test_validation.py::TestAccelerationWarnings::test_warnings_never_refuse`, `tests/test_validation.py::TestAccelerationWarnings::test_steps_that_resolve_to_nothing_are_silent`, `tests/test_validation.py::TestAccelerationWarnings::test_an_unknown_device_is_silent`, `tests/test_validation.py::TestAccelerationWarnings::test_an_unresolvable_backend_is_silent_on_mps` |
+| H3 sparse attention | `dw/sparse_attention.py`: `sparse_call`, `install_sparse`, `install_sparse_for_call`, `apply_sparse_settings`, `SparseH3AttnProcessor`; wired from `dw/pipeline_processors/components.py`: `configure_components` and `dw/pipeline_processors/pipeline.py`: `apply_runtime_settings` | Whether a pipeline call runs sparse is decided once per call, all or nothing (the call's first kernel invocation included); it never changes diffusers' process-wide backend and never reaches `AttentionBackendName`; it installs by a processor swap plus forward hooks, never a `forward` wrapper; and `sparse_tau` is a runtime setting, not part of the weights identity (#931). | `tests/test_sparse_attention_processor.py`, `tests/test_sparse_attention_wiring.py`, `tests/test_sparse_attention_tiles.py`, `tests/test_sparse_attention_backends.py` |
 | H3 adapter partition | `dw/adapter_compatibility.py`; the server's index is `dw/server/deps.py` `lora_index` | The LoRA catalog decides first, on the server only: a `proven` entry's `workflow` refuses a step in the other partition, a `trial`/`rejected` entry's only warns. A file no entry places falls to its name: an FL2VA LoRA on a reference step is refused, and one whose name says neither `ref2v` nor `fl2v` is warned. | `tests/test_h3_adapters.py::TestWhatIsRefused::test_a_keyframe_adapter_on_the_reference_path`, `tests/test_h3_adapters.py::TestWhatIsRefused::test_an_unrecognised_name_is_a_warning_not_a_refusal`, `tests/test_h3_adapters.py::TestTheCatalogDecidesFirst::test_a_proven_entry_refuses_the_other_partition`, `tests/test_h3_adapters.py::TestTheCatalogDecidesFirst::test_a_weaker_entry_only_warns`, `tests/test_server_loras.py::TestTheCatalogPlacesAnAdapter::test_a_trial_entry_warns_and_promoting_it_refuses` |
 | H3 audio hold, refine and guide layout | Five modules, imported one way: `dw/pipeline_processors/h3_rules.py` holds the names and rules, torch- and diffusers-free (`refine_problems`, the per-argument refine rules asked before validation and before the call; `not_h3`, the step rule; `snap_guide_length`, `guide_frame_problem`, `guide_chain_problems`, `guide_end_problem`; `CHAIN_CONTINUITY_MODES`; the chunk constants), `dw/pipeline_processors/h3_hold.py` puts the hold and refine blocks in (`insert_audio_hold`, `core_denoise_sequences`, `refines`), and `dw/pipeline_processors/h3_guides.py` the guide layout (`LAYOUT_ANCHORS`, `insert_guides`), which imports `h3_hold` and never the reverse; the blocks themselves, and the arithmetic they run, are `dw/pipeline_processors/h3_hold_steps.py` (`encode_audio_span`, `refine_sigmas`) and `dw/pipeline_processors/h3_guide_steps.py` (`splice_guide_rows`), which import diffusers when they load, so the two owners import them only inside `blocks()` and `guide_blocks()` (#790), and `h3_guide_steps` imports `h3_hold_steps` and never the reverse (`_with_guides` in `dw/pipeline_processors/pipeline.py` adds its blocks for a `guides` call), `dw/guides.py`: the `guides` validation check and the chain `continuity: "guide"` check, `guide_chain_errors`, which asks the `guides` check's own step rule (`_takes_guides_problem`, built on `h3_rules.not_h3` and `REFERENCE_WORKFLOWS`) and reads the mode names from `h3_rules.CHAIN_CONTINUITY_MODES`, the names `chain.py`'s `CONTINUITY_MODES` is zipped against (both registered in `dw/validation.py`; a `previous_result:` guide is checked at run time), `dw/hold_audio.py`: `hold_audio_errors`, `refine_strength_errors` | The one place dw modifies a diffusers modular pipeline's block graph: three blocks go in, before `set_timesteps`, `denoise` and `after_denoise`, in every H3 core-denoise sequence (the whole graph and the `workflow=`-pruned flat graph), and they are no-ops without `hold_audio` / `refine_strength`. A `hold_audio` path is opened only after `locations.validate_media_path` against the step's workflow directory. `dw/introspection.py` builds the same graph without weights, hold included, so `get_pipeline_signature` lists a modular pipeline's block inputs. The copies of diffusers behaviour are pinned to the installed diffusers: `shifted_sigma_grid` (the spacing `refine_sigmas` rests on) to stock `set_timesteps`, `GUIDE_FRAMES_PER_CHUNK`/`GUIDE_LATENTS_PER_CHUNK` to the H3 video VAE's `clip_length` and latents per clip, and every name in `LAYOUT_ANCHORS` (`_fill_audio_positions` among them) to `before_denoise`. | `tests/test_h3_hold_audio.py::TestAnchors::test_inserted_next_to_the_anchors_in_every_shape`, `tests/test_h3_hold_audio.py::TestHoldAudioLocation::test_a_path_outside_the_roots_is_refused_at_the_call`, `tests/test_h3_hold_audio.py::TestRefusals::test_a_non_h3_step_is_refused`, `tests/test_h3_hold_audio.py::TestSignature::test_the_h3_signature_shows_hold_audio`, `tests/test_h3_refine.py::TestAnchors::test_inserted_before_denoise_in_every_shape`, `tests/test_h3_refine.py::TestSigmaGridDrift::test_the_full_grid_is_stock_set_timesteps`, `tests/test_h3_guides.py::TestChunkDrift::test_frames_per_chunk_is_the_vae_clip_length`, `tests/test_h3_guides.py::TestChunkDrift::test_latents_per_chunk_is_the_vae_tokens_per_clip`, `tests/test_h3_guides.py::TestAnchors::test_installed_diffusers_has_every_anchor`, `tests/test_guide_chain_validation.py::TestRefused::test_the_step_rule_is_the_guides_rule`, `tests/test_guide_chain_validation.py::TestRefused::test_every_run_mode_is_known_to_validate`, `tests/test_h3_rules.py::test_h3_rules_imports_neither_torch_nor_diffusers`, `tests/test_h3_rules.py::test_the_block_owners_import_no_diffusers` |
 | IC-LoRA reference scale | `workflows/templates/ltx2/` | The three conditioning templates run at `reference_downscale_factor: 1`, and the two upscalers at 2. | `tests/test_ltx2_ic_loras.py::TestEachTemplateMatchesItsCard::test_the_reference_is_encoded_at_the_output_resolution`, `tests/test_ltx2_ic_loras.py::TestTheGenerativeUpscaleMatchesTheSameCard::test_it_loads_the_upscaler_at_factor_two` |
@@ -147,6 +148,8 @@ one to open.
 | Locations from a workflow | `dw/locations.py` | A local path in a workflow's media arguments (named like their media, or declared by the task's `@register_command(media_arguments=...)`, read through `TASK_MEDIA_ARGUMENTS`) is confined to a known root, a location written as a URL is one `security.validate_url` accepts, and a URL must not name a host inside the deployment. A host that does not resolve is refused. The requests themselves are `dw/outbound.py`'s. | `tests/test_locations.py::TestMediaPathContainment::test_absolute_path_outside_every_root_is_refused`, `tests/test_locations.py::TestMediaPathContainment::test_a_url_that_is_not_http_is_refused`, `tests/test_locations.py::TestMediaPathContainment::test_an_upper_case_https_url_is_not_refused_as_another_scheme`, `tests/test_security_ssrf.py::TestInternalAddressSpellings::test_a_name_that_resolves_inside`, `tests/test_locations.py::TestTaskMediaArguments::test_an_unreadable_source_is_an_error_at_its_path` |
 | Outbound requests | `dw/outbound.py`: `safe_get`, `safe_post` | Every outbound request is validated per hop against `dw/locations.py`'s policy, resolved once and dialed at the address the policy checked, capped and timed. No other module under `dw/` makes an HTTP request or builds a session or adapter. | `tests/test_outbound.py::TestSafeRequest::test_one_lookup_per_hop_and_the_dial_is_the_checked_address` |
 | Trust gate | `dw/trust.py`: `require_trusted_dotted_name` | In an untrusted workflow (the default), a dotted type outside the allowlist is a validation error before anything is imported. | `tests/test_security_trust_gate.py::TestValidationRefusesBeforeImport::test_a_dotted_type_is_a_validation_error` |
+| Remote generate code | `dw/trust.py`: `require_trusted_generate_arguments`; `dw/tasks/text_generation.py`: `_validated_generate_kwargs`, `_validated_chat_template_kwargs` | Untrusted, `generate_kwargs` may not set `custom_generate` or `trust_remote_code` (transformers would download and run a repo's `custom_generate/generate.py`); both it and `chat_template_kwargs` hold only scalars (or, for `generate_kwargs`, lists of them) and none of the pipeline call's own keys. All checked before the model loads. | `tests/test_security_trust_gate.py::TestRemoteGenerateCodeUntrusted::test_refused_before_the_model_loads`, `tests/test_text_generation.py::TestGenerateKwargsAreFiltered::test_a_structural_key_is_refused_before_any_load`, `tests/test_text_generation.py::TestGenerateKwargsAreFiltered::test_a_nested_value_is_refused` |
+| Hub-file system prompts | `dw/tasks/text_generation.py`: `resolve_system_prompt` | A `system_prompt.from_hub` file is pinned to a full commit, asked of the Hub anonymously before every use (failing closed on any error, offline or under `HF_HUB_OFFLINE`), downloaded with `token=False`, and refused over 1 MiB or when the Hub reports no size. | `tests/test_text_generation.py::TestSystemPromptFromHub::test_a_file_the_hub_will_not_serve_publicly_is_refused`, `tests/test_text_generation.py::TestSystemPromptFromHub::test_the_download_never_carries_the_server_token`, `tests/test_text_generation.py::TestSystemPromptFromHub::test_a_file_of_unknown_size_is_refused_before_downloading` |
 | CodeQL path-injection model | `.github/codeql/dw-security/DwPathSanitizers.qll`, `.github/workflows/codeql.yml` | The local pack models the `dw/security.py` validators (and `dw/locations.py`'s `validate_media_path`) as sanitizers, so a validator that moves is re-modelled in the same commit. | `.github/codeql/dw-security/DwPathInjection.ql` |
 | Archives never follow links | `dw/server/outputs.py`: `zip_download` | A gallery listing drops a symlink that leaves its root, and an archive skips one. | `tests/test_security_symlinks.py::TestOutputs::test_the_archive_route_does_not_follow_the_link`, `tests/test_security_symlinks.py::TestOutputs::test_the_gallery_listing_does_not_enumerate_the_link` |
 | Engine/server import direction | `dw/workspace.py`: `EXPORTS_SUBDIR` | No engine module imports `dw.server` except the entry point `dw/serve.py`, and a constant both sides need lives engine-side. | `docs/stabilization/baseline.json`: `import_cycles` ratchet (indirect: it fails only on an import that closes a cycle) |
diff --git a/docs/DEPENDENCIES.md b/docs/DEPENDENCIES.md
index f208d5f1..d015a611 100644
--- a/docs/DEPENDENCIES.md
+++ b/docs/DEPENDENCIES.md
@@ -49,6 +49,8 @@ pyproject; install.ps1 installs it explicitly on Windows.
 
 **All platforms (core ML):** peft, transformers, accelerate, safetensors, controlnet_aux, sentencepiece, torchsde, torchao, optimum-quanto, gguf, kornia, ftfy, sdnq, spandrel, facexlib (spandrel + facexlib back the `upscale` and `restore_faces` tasks). On first use, `restore_faces` has facexlib download its face detection and parsing weights (about 110 MB) from facexlib's own GitHub releases into the facexlib package directory. It is the one model download that bypasses the Hugging Face cache, dw's download manager and the `plan.downloads_required` estimate.
 
+**All platforms (sparse attention):** comfy-kitchen (Sol-Attn sparse attention for MiniMax H3's generated-video rows, #931). Its compiled CUDA/HIP kernels ship for Linux and Windows; elsewhere it installs an eager-only build.
+
 **All platforms (utilities):** fastapi, uvicorn (the `dw.serve` HTTP server and web UI), av, aiohttp, matplotlib, opencv-python-headless, concurrent-log-handler, qrcode, protobuf, imageio, imageio-ffmpeg, beautifulsoup4, soundfile, jsonschema, black, python-dotenv
 
 **Linux (CUDA):** bitsandbytes
diff --git a/docs/MCP.md b/docs/MCP.md
index 436c0bbb..94f72e32 100644
--- a/docs/MCP.md
+++ b/docs/MCP.md
@@ -278,12 +278,12 @@ tools) rather than relying on the session pin.
 | Tool | Arguments | Purpose |
 | --- | --- | --- |
 | `validate_workflow(workflow=None, name=None, workspace=None, arguments=None)` | exactly one of `workflow` (inline definition) or `name` (a stored workflow, as `list_workflows` reports it), optional `workspace`, optional `arguments` | Check a workflow against the schema and against real pipeline signatures. Free and instant. Validating by name uses the workflow file's own directory as the base directory, so it sees what a run would. Returns every schema violation in `errors`, each with the JSON path it sits at, so a draft is fixed in one pass, and a `previous_result:` that names no earlier step is one of them. `warnings` covers what still runs but is probably wrong - a signature mismatch, and, for a list-driven variable, an entry key no step reads, at the entry's path. `workspace` names the workspace for this one call without switching the session to it - use it to pin a job whose `output:` or `asset:` references live in a workspace other than the session's. Pass the same `arguments` you will pass to `run_workflow` and they are checked too - an undeclared or renamed variable name, a value that will not coerce to the declared type, and an `asset:`, `prompt:` or `output:` reference that names nothing this workspace can reach, each reported at `arguments.<name>`. `checked_arguments` lists what was covered, so a `valid: true` about the stored defaults cannot be mistaken for one about your values. A reference set the model would refuse - too many images, videos or audio clips, or, for MiniMax-H3, audio as the only reference - is an error here too, rather than a failure minutes into a run you acknowledged. `run_workflow` makes the same check and refuses a bad argument rather than queuing a job that fails on its first step. A valid answer carries `plan` - the fingerprint, step count, list lengths, `downloads_required`, `estimate` (with `basis`), `host_memory` (`{projected_mb, basis, runs}`, the projected host-RAM peak; `basis` is `observed` from same-key successful runs on this machine or `fit`; absent when there is no figure) and `elided_steps` for the arguments given; quote from it. `steps` counts what will run: a step nothing reads and which saves no file does not run, and is named in `elided_steps` instead |
-| `list_workspaces()` | — | The server's workspaces and which one this session is using. Each has its own workflows, assets and outputs; the prompt library is shared by all of them |
+| `list_workspaces()` | — | The server's workspaces and which one this session is using. Each has its own workflows, assets and outputs; the prompt library is shared by all of them. Compact entries are `name`/`default`/`usage` plus any `note` (clipped, `note_truncated` when cut); `detail=true` adds each entry's folder paths |
 | `use_workspace(name)` | `name` | Work in that workspace for the rest of the session - every later call reads and writes there. This is how to keep your work out of another agent's namespace rather than sharing the default one. Checked against the server, so a typo fails here rather than scoping every later call to nothing. On a `dw.serve --mcp` endpoint the pin is shared by every connected client (#298, see the note above the table) - a `warning` field appears when this call overwrote a pin already pointed away from `default` |
 | `create_workspace(name, use=False)` | `name`, `use` | Create a workspace. Pass use=true to switch this session to it as well; otherwise the session stays where it was and the result says so. The result names the workspace (`name`, `default`, `current`, `next`), not its folders - `list_workspaces(detail=true)` is the opt-in for those. `use=true` carries the same mounted-server caveat and `warning` field as `use_workspace` |
 | `copy_to_workspace(destination, runs=None, assets=None, source=None)` | `destination`, `runs`, `assets`, `source` | Copy runs and assets from one workspace into another. Each `runs` entry is `<workflow>/<run id>` as `list_gallery` names it, or a bare `<workflow>` for all its runs; each `assets` entry is a path as after `asset:`, or a folder (`proj/`) for every file under it, keeping its path, note and kept shots. `source` defaults to this session's workspace. Free: no `acknowledged_cost`. Media is hard-linked (a copy across devices falls back to a real copy) and JSON sidecars are always copied, so an edit in one workspace never reaches the other. All or nothing; a run or identical asset the destination already has is skipped as `already_present`, a different file at an asset's path refuses the whole request, so a repeat is idempotent, and a `vN` it already uses is renumbered after its highest and reported in `renumbered`. Warnings: `unresolved_output_refs`, `absolute_paths`, `no_jobs`. A copied run has no job record - it shows in `list_gallery` and resolves as an `output:` reference, not in `list_jobs`. A run whose job is still queued or running is refused. To move, copy then `delete_output` the source runs and `delete_asset` the source assets. See [Workspaces](WORKSPACES.md#copying-between-workspaces) |
 | `delete_workspace(name, acknowledged_cost=False)` | `name`, `acknowledged_cost` | Permanently delete a workspace and everything in it. Refuses without the acknowledgement, reporting what it would remove |
-| `list_assets(limit=50, prefix)` | `limit`, `prefix` | The input media on the server, each with the `asset:` reference a workflow argument carries. Look here before asking for a file - what a workflow needs may already be there. `libraries` names the roots searched and which are writable; `shadowed` lists names a nearer library hides. Newest first; `prefix` keeps names starting with it (e.g. `cast/`), `limit` bounds the answer, `total` is the count matched before the cut |
+| `list_assets(limit=50, prefix)` | `limit`, `prefix` | The input media on the server, each with the `asset:` reference a workflow argument carries. Look here before asking for a file - what a workflow needs may already be there. `libraries` names the roots searched and which are writable; `shadowed` lists names a nearer library hides. Compact entries are `name`/`reference`/`kind`/`size`/`origin` plus any `note` (clipped, `note_truncated` when cut); `detail=true` adds `folder`, `mtime`, `url`, `writable`, and `absolute_url`/`used_by` when set. Newest first; `prefix` keeps names starting with it (e.g. `cast/`), `limit` bounds the answer, `total` is the count matched before the cut |
 | `keep_output(name, asset_name=None, overwrite=False, shared=False, workspace=None, note=None)` | `name`, optional `asset_name`, `overwrite`, `shared`, `workspace`, `note` | Keep a generated file as an input asset under a stable `asset:` name, so a later workflow can rely on it. The copy happens on the server: nothing is downloaded or re-uploaded. `note` is kept with the asset; left out, the source file's note is copied. `asset_name` may name a folder and takes the kept file's extension when it has none; `shared=true` keeps it in the library every workspace shares, which is where a recurring cast belongs. `workspace` names the workspace for this one call without switching the session to it - the same pin `run_workflow` takes, so a job run into another workspace stays reachable from the session that queued it |
 | `set_note(target, note=None, workspace=None)` | `target` (a run `<workflow>/<run id>`, a gallery file name, `asset:<name>` or `workspace:<name>`), `note`, `workspace` | Set the note on a run, an output file, an asset or a workspace; null or `""` clears it. Plain text up to 4000 characters saying what the thing is for - what a run tested, why a file is the keeper. Free: no `acknowledged_cost`. Returns `{target, note, note_source}`. `run_workflow(note=...)` sets a run's note at submission and it shows on every file the run wrote; `list_gallery`, `list_assets`, `list_workspaces` and `list_jobs` carry each note clipped to 200 characters (`note_truncated: true` when cut), while `get_job` and `get_gallery_metadata` return it whole. `get_job` shows the run's current note, so one set here after submission replaces the submitted one. `workspace` names the workspace a run or file name is read in for this one call without switching the session to it - the same pin `run_workflow` takes |
 | `upload_asset(file_path=None, content=None, asset_name=None, shared=False, note=None)` | exactly one of `file_path` or `content` (base64), optional `asset_name`, `shared`, `note` (kept with the asset) | Push an image, video or audio file, or a `.cube` 3D LUT for `apply_lut`, into the server's asset library and get back its `asset:` reference. `file_path` is read from the machine the MCP server runs on, so this is how an input reaches a dw.serve running somewhere else - but only when the caller shares a filesystem with that machine. `content` is the alternative for an agent that does not: the bytes travel inline, base64-encoded, in the tool call itself, capped at 4MB (well under `file_path`'s 200MB) because inline bytes compete with the calling agent's own context budget rather than being a bulk-transfer path (#203). `asset_name` is required with `content` (there is no file name to infer one from) and, either way, stores it under a readable name (`cast/priya-voice.wav`) instead of a random one; `shared=true` puts it in the library every workspace shares |
diff --git a/docs/QUANTIZATION.md b/docs/QUANTIZATION.md
index 2c680261..f2765e16 100644
--- a/docs/QUANTIZATION.md
+++ b/docs/QUANTIZATION.md
@@ -151,6 +151,8 @@ examples use for their large transformers and text encoders:
 
 **Examples:** [text-to-video.json](../workflows/templates/ltx2/text-to-video.json), [video-with-audio.json](../workflows/templates/minimax/video-with-audio.json)
 
+The H3 templates also default to `attention_backend: "sparse"`; the quantization is independent of it ([Attention Backends](ACCELERATION.md#sparse-minimax-h3)).
+
 ### Cached on-the-fly (`DW_QUANTIZED_CACHE`)
 
 An on-the-fly load reads the bf16 weights and quantizes them on every cold load. With `DW_QUANTIZED_CACHE=1` the server keeps the result: the first cold load saves each quantized component to disk with sdnq's `save_sdnq_model` (safetensors plus JSON, no pickle), and a later load of the same key reads it back with `load_sdnq_model`, skipping the bf16 read and the quantize. Any other value leaves it off, with no events. It covers both ways a component is quantized with a `sdnq.SDNQConfig` `quantization_config`: a modular pipeline's `load_components`, one config per component (MiniMax H3), and a component loaded on its own through its class's `from_pretrained` (LTX-2.5's transformer and Gemma text encoder). A hit is placed on the config's `return_device` (LTX's transformer goes straight to `cuda`) and loads with no download.
diff --git a/docs/RECIPES_24GB.md b/docs/RECIPES_24GB.md
index 1ed6c2c8..ed8824ed 100644
--- a/docs/RECIPES_24GB.md
+++ b/docs/RECIPES_24GB.md
@@ -116,7 +116,7 @@ pipeline-level `offload`. The working 24GB configuration at 960x544:
 | `text_encoder` | `remove_modules: ["lm_head"]` - the encoder path never calls it |
 | `text_encoder.model` | SDNQ int4, `truncate_layers: {"language_model.layers": 51}`, `group_offload` `leaf_level` |
 | `vae`, `audio_vae` | SDNQ int8, `device: "cuda"`, `residency: "on_demand"` |
-| pipeline | `cache: first_block` (`threshold: 0.05`) only on a ~30-step base-model run (`lora_model_name: null`): -22% denoise there, identical staging and faces. It skips nothing at 12 steps or on a turbo schedule (consecutive distilled steps differ too much), and every H3 template takes it as a `cache` argument (null by default): `{"type": "first_block", "threshold": 0.05}`. Measured on a 3090 with `sage_hub`; see the `minimax-h3` skill's `references/quality-and-speed.md` |
+| pipeline | `cache: first_block` (`threshold: 0.05`) only on a ~30-step base-model run (`lora_model_name: null`): -22% denoise there, identical staging and faces. It skips nothing at 12 steps or on a turbo schedule (consecutive distilled steps differ too much), and every H3 template takes it as a `cache` argument (null by default): `{"type": "first_block", "threshold": 0.05}`. Measured on a 3090 with `sage_hub`; every H3 template now defaults to `attention_backend: "sparse"` ([Attention Backends](ACCELERATION.md#sparse-minimax-h3)), which needs no extra install. See the `minimax-h3` skill's `references/quality-and-speed.md` |
 
 The VAEs are the piece worth calling out. They hold roughly 3GiB, are used only to
 encode references and decode the result, and group offloading them is worse than useless
diff --git a/docs/RELEASING.md b/docs/RELEASING.md
index 997e7f1a..98e3cf5f 100644
--- a/docs/RELEASING.md
+++ b/docs/RELEASING.md
@@ -7,6 +7,67 @@ notes from commits at tag time (see below). This section is a scratch pad
 for items a branch's author wants the next release note to name; clear it
 when a release ships.
 
+### 0.15.0
+
+<!-- Drafted from v0.14.0..develop (0c4ed5ea). Paste into the GitHub release body once the tag has published: gh release edit v0.15.0 --notes-file ... -->
+
+A release about speed for MiniMax H3 and a new image family. H3 now runs
+sparse attention by default, 2-4x faster per step than plain attention and
+6-20% faster than `sage_hub`, with no extra install and equal quality on
+Don's judging. FLUX 3 Image Klein joins the catalog with its own templates
+and skill. It also closes a remote-code hole in `speech_generation`.
+
+**Sparse attention for MiniMax H3** (#931, #932)
+
+- A new `attention_backend: "sparse"` runs H3's generated-video attention
+  through comfy-kitchen's Sol-Attn kernel. Text, references and audio stay
+  exact. It is the default on every H3 template, routed by top-k 0.15
+  (`sparse_topk`), with `sparse_tau` as the alternative routing.
+  - Against plain attention it is 2.2-4.4x faster per step on an RTX 3090.
+  - Against `sage_hub`, on the H3 quality-ramp rungs, it is 6-20% faster.
+    The L5 cinema final runs in 23.9-25.5 min, against 29.7 on sage.
+  - Don judged faces, skin and draft-to-final staging equal or better on
+    three seeds.
+- It needs CUDA with compute capability 8.0+. Anywhere else (mps, cpu, an
+  older card) H3 runs dense instead of failing. On mps and cpu
+  `validate_workflow` warns `sparse_attention_fallback`; on an older card
+  or a CUDA box missing the kernels, the run says why it went dense.
+- Sparse moves details against dense and sage (same shot, different set
+  dressing), so the `minimax-h3` skill's quality ramp keeps a draft and its
+  final on one backend. The ramp's TV and cinema paths now run sparse; the
+  sage B3 -> P1 pair stays as the fastest cached cinema final.
+- `/api/health` lists the attention backends the server can run, and the
+  web UI's `attention_backend` fields are dropdowns of that list.
+- A component that pins a backend keeps it under a pipeline-level
+  `sparse`, with a warning, and the run log names sparse's routing.
+- lightx2v's Turbo-SLA LoRA was evaluated and not adopted: top-k routing
+  gives the same result on the existing turbo LoRA (#932).
+
+**FLUX 3 Image Klein** (#930)
+
+- Templates for text-to-image, upsample-then-generate, image edit,
+  multi-reference and layout-with-boxes, plus the model entry and a
+  `flux3-klein` composition skill.
+- `text_generation` gains `chat_template_kwargs`, a `revision`, a list of
+  images, and a `system_prompt` read from a Hub repo file at a pinned
+  commit (anonymous, public files only, size-capped). Its `generate_kwargs`
+  are filtered, and `custom_generate` / `trust_remote_code` need trusted
+  workflows.
+
+**Security**
+
+- `speech_generation` passed a workflow's `generate_kwargs` and
+  `forward_params` to the model's `generate()` unfiltered, so an untrusted
+  workflow could set `custom_generate` / `trust_remote_code` and run code
+  from the Hub. Both are now refused unless workflows are trusted, before
+  the model loads. Every release through 0.14.0 is affected.
+
+**Dependencies and deploy**
+
+- New core dependency: `comfy-kitchen>=0.2.38,<0.3` (Apache-2.0). Linux and
+  Windows get the compiled CUDA/HIP kernels; macOS gets a pure-Python wheel
+  and runs H3 dense. `scripts/deploy.sh` reinstalls on the pyproject change.
+
 ### 0.14.0
 
 <!-- Drafted from v0.13.0..develop (7b72a7de). Paste into the GitHub release body once the tag has published: gh release edit v0.14.0 --notes-file ... -->
diff --git a/docs/SECURITY.md b/docs/SECURITY.md
index fd63c0fe..3c46143e 100644
--- a/docs/SECURITY.md
+++ b/docs/SECURITY.md
@@ -120,6 +120,32 @@ diffusers' remote-code paths open. No bundled catalog entry sets either
 (`tests/test_catalog_structure.py` refuses one that does); a workflow that
 needs them needs `--trust-workflows`.
 
+`text_generation`'s `generate_kwargs` reach the model's `generate()`, which
+has a remote-code path of its own: `custom_generate` names a Hub repo whose
+`custom_generate/generate.py` transformers downloads and runs, and
+`trust_remote_code` lets it. Both are refused untrusted
+(`require_trusted_generate_arguments` in `dw/trust.py`), before the model
+loads. Its other keys must be scalars or lists of them, and none may be one of
+the pipeline call's own arguments - the same filter `chat_template_kwargs`
+gets, so neither can pass `tokenizer_encode_kwargs`, `images` or a template
+of its own around the task's checks.
+
+`speech_generation` has the same path twice: the text-to-audio pipeline hands
+both its `generate_kwargs` and its `forward_params` to `generate()` for a
+generative model (Bark, VibeVoice). Each must be an object, and
+`custom_generate` / `trust_remote_code` in either are refused untrusted, before
+the model loads (released versions through 0.14.0 passed them through).
+
+`text_generation`'s `system_prompt` may be read from a Hub repo file
+(`{"from_hub": {...}}`). That fetch is anonymous only: the Hub is asked
+without credentials (`token=False`) whether it serves the file publicly at the
+pinned 40-hex commit before every use, and the download carries no token
+either, so the server's own login never reaches a gated or private file on a
+workflow's say-so. It fails closed - any error from that ask, being offline,
+or `HF_HUB_OFFLINE` refuses the run rather than fall back to the cache - and
+it is capped at 1 MiB, checked against the Hub's reported size before the
+download (no reported size is a refusal) and against the file after it.
+
 ### Where a workflow may read and reach (`dw/locations.py`)
 
 Code execution is not the only thing a workflow file chooses. Its arguments
diff --git a/docs/TASKS.md b/docs/TASKS.md
index 974c80d3..4127bb18 100644
--- a/docs/TASKS.md
+++ b/docs/TASKS.md
@@ -2848,8 +2848,21 @@ Generate or expand text using a local language model. Useful for expanding short
 | `model_name` | No | HuggingFace model ID (default: `Qwen/Qwen2.5-1.5B-Instruct`, or `HuggingFaceTB/SmolVLM-256M-Instruct` when an image is supplied) |
 | `image` | No | PIL Image, URL/path, or `previous_result:` reference — see below |
 | `repetition_penalty` | No | Vision path only (default: 1.15) — see below |
-| `generate_kwargs` | No | Anything else to pass to the model's `generate()` — `no_repeat_ngram_size`, `top_p`, `min_new_tokens`. Merged last, so it overrides the settings above |
+| `generate_kwargs` | No | Anything else to pass to the model's `generate()` — `no_repeat_ngram_size`, `top_p`, `min_new_tokens`, `stop_strings`. Merged last, so it overrides the settings above. Filtered like `chat_template_kwargs` — see below |
 | `max_new_tokens` | No | Maximum tokens to generate (default: 500) |
+| `chat_template_kwargs` | No | Extra keyword arguments for the model's chat template (for a template that takes switches such as a thinking toggle). Values must be scalars (boolean, number, string or null), and the generation call's own keys (`images`, `tools`, `max_new_tokens`, `tokenizer_encode_kwargs`, ...) are refused |
+| `revision` | No | Model revision (branch, tag or commit) to load `model_name` at |
+
+`image` may also be a list of images, each sent as its own picture in the one user message. A list is one prompt over all the images, in order, and returns one answer — not one answer per image. The same holds for `judge` and `image_to_text`, which hand their `image` to this task. An empty list, or one holding only nulls, is no image.
+
+`system_prompt` may name a file in a Hugging Face repo instead of carrying the text,
+for a vendor that ships its prompt instructions there:
+`{"from_hub": {"repo": "owner/name", "file": "system_prompts.json", "revision": "<40-hex commit>", "key": "t2i"}}`.
+The revision must be a full commit, so the text can't move under the workflow. A `.json`
+file takes `key` to pick one string; any other file is read whole. Only public repos are
+reachable (the download never uses the server's Hugging Face token), and a file over 1 MiB
+is refused. The Hub is asked, without credentials, whether the file is public before every
+use, so `from_hub` needs network access even when the file is already cached.
 
 ### Writing a prompt from a picture
 
@@ -2890,6 +2903,8 @@ For anything the arguments above do not cover, `generate_kwargs` goes straight t
 
 It is merged after everything else, so it can override `repetition_penalty` and the sampling settings as well as add to them.
 
+`generate_kwargs` is checked before the model loads, the same way `chat_template_kwargs` is. Values must be scalars or lists of scalars (`stop_strings` is a list), and the call's own keys are refused (`max_new_tokens`, `tokenizer_encode_kwargs`, `prefix`, `handle_long_generation` and the rest of the pipeline's named arguments). `custom_generate` and `trust_remote_code` need trusted workflows (`--trust-workflows`): with them, transformers downloads a repo's `custom_generate/generate.py` and runs it in place of its own decoding loop.
+
 **Examples:**
 
 - [expand-prompt.json](../workflows/templates/expand-prompt.json) — Expand a short prompt and save as `.txt`
diff --git a/docs/WORKFLOW_GUIDE.md b/docs/WORKFLOW_GUIDE.md
index c69a7fe6..e6695ce2 100644
--- a/docs/WORKFLOW_GUIDE.md
+++ b/docs/WORKFLOW_GUIDE.md
@@ -1257,9 +1257,19 @@ For components the pipeline loads itself — which is all of a modular pipeline'
   `diffusion_decoder`, for example).
 - `attention_backend` — a persistent `set_attention_backend` on one component, which a
   compiled component needs (the pipeline-level `attention_backend` applies per call).
-  Every MiniMax-H3 template wires an `attention_backend` variable (default `null`) here,
-  on its H3 step's `transformer` or `transformer_ref`; see
-  [ACCELERATION.md](ACCELERATION.md) for `sage_hub` and what it needs.
+  Every MiniMax-H3 template wires an `attention_backend` variable here, on its H3 step's
+  `transformer` or `transformer_ref`, defaulting to `"sparse"` (dw's comfy-kitchen sparse
+  attention, which needs no extra install), with `sparse_topk` 0.15; pass `sage_hub` or
+  `native` to override it. See [ACCELERATION.md](ACCELERATION.md#sparse-minimax-h3) for
+  `sparse` and [Attention Backends](ACCELERATION.md#attention-backends) for `sage_hub`
+  and what it needs.
+- `sparse_tau` — the sparsity threshold for a component whose `attention_backend` is
+  `"sparse"` (number, minimum 0, default 0.5). A runtime setting: changing it reuses the
+  loaded pipeline. See [ACCELERATION.md](ACCELERATION.md#sparse-minimax-h3).
+- `sparse_topk` — top-k routing instead of `sparse_tau`: keep this fraction of key tiles
+  (strictly between 0 and 1). The H3 templates set 0.15; when set, `sparse_tau` is
+  ignored, and a component that sets none routes by `sparse_tau`. A runtime setting,
+  like `sparse_tau`.
 - `attn_processor_type` — the attention processor the component runs, constructed with no
   arguments and handed to `set_attn_processor`. The `unet` and `transformer` blocks cover
   those two; this covers any other component that carries attention (LTX-2.5's
@@ -1532,7 +1542,14 @@ stays alive for the steps that reuse it.
   cost to speed. Automatic on MPS unless `disable_attention_slicing` is set
   (UNet/ControlNet models only; worth disabling for SDXL on a Mac).
 - `attention_backend` — selects a diffusers attention backend (e.g. `"flash_hub"`) for
-  the duration of each pipeline call.
+  the duration of each pipeline call. `"sparse"` is dw's own instead: comfy-kitchen sparse
+  attention on a MiniMax-H3 transformer, installed for the call only, and dense with a
+  warning where it cannot run. See [ACCELERATION.md](ACCELERATION.md#sparse-minimax-h3).
+- `sparse_tau` — the sparsity threshold for a pipeline-level `attention_backend:
+  "sparse"` (number, minimum 0, default 0.5). See
+  [ACCELERATION.md](ACCELERATION.md#sparse-minimax-h3).
+- `sparse_topk` — top-k routing for a pipeline-level `"sparse"` instead of `sparse_tau`
+  (strictly between 0 and 1); unset unless the workflow sets it.
 - `prompt_weighting` — enables A1111-style prompt weighting (`(word:1.5)`, `[word]`,
   `((word))`) and prompts over 77 tokens. Currently supports Flux pipelines. Mutually
   exclusive with `remote_text_encoder`.
diff --git a/docs/proposals/audits/2026-10-15-flux-3-klein-audit.md b/docs/proposals/audits/2026-10-15-flux-3-klein-audit.md
new file mode 100644
index 00000000..3982a690
--- /dev/null
+++ b/docs/proposals/audits/2026-10-15-flux-3-klein-audit.md
@@ -0,0 +1,271 @@
+# FLUX 3 Image Klein: vendor knowledge for onboarding
+
+Researched 2026-10-15, the vendor's launch day. Every source below is less than 72 hours old, and the vendor repos were still taking README commits at 22:58Z. Re-check the volatile items (marked **[volatile]**) before you pin anything.
+
+Naming: the vendor calls the model "FLUX 3 Image Klein", not "FLUX.3 [klein]". Diffusers calls the family "FLUX.3", with classes named `Flux3*`.
+
+## Sources
+
+| URL | Type | Date | Contributes |
+|---|---|---|---|
+| https://huggingface.co/black-forest-labs/flux-3-image-klein (+ README via `/resolve/main/README.md`, readable without auth) | primary | repo created 2026-10-13, last modified 2026-10-15T22:57Z | Variant table (16 steps, no guidance), "do not use without upsampler", Diffusers `ModularPipeline` snippet, VRAM table, box format, license |
+| https://huggingface.co/api/models/black-forest-labs/flux-3-image-klein | primary | 2026-10-15 | `gated: auto`, `library_name: diffusers`, file list (no `model_index.json`; has `modular_model_index.json`), 5,548,681,984 BF16 params |
+| https://huggingface.co/black-forest-labs/flux-3-image-klein-base | primary | created 2026-10-13 | Undistilled model: 50 steps, CFG 3.5, for LoRA and fine-tuning; FP8 VRAM 29 GB, NVFP4 26 GB |
+| https://huggingface.co/black-forest-labs/flux-3-image-klein-pup | primary | created 2026-10-14, sha 3f3edb52 | Prompt upsampler: Qwen3.5-9B fine-tune, Apache-2.0, not gated, 18.8 GB; `system_prompts.json` (`t2i`, `i2i`, `t2i_bbox`, `i2i_bbox`); decoding settings |
+| https://huggingface.co/black-forest-labs/flux-3-image-klein-comfy | primary | created 2026-10-14 | int8/NVFP4/BF16 single files; int8 runs on 8 GB GPUs; VAE file is `flux2-vae.safetensors`; sampler defaults |
+| https://github.com/black-forest-labs/flux-3-image-klein (commit bbfe317d) | primary | created 2026-10-15 | Reference code: `src/flux3/pipeline.py` constants (MAX_REFERENCES=10, sides 64-4096, alpha 6.93), CLI defaults, example JSONs holding the upsampled captions, base-vs-distilled timing |
+| https://bfl.ai/blog/flux-3-image-klein | primary | 2026-10-15 | Announcement: 5.6B, 10 refs, 4K, Elo against FLUX.2 [klein] 9B, int8 on 8 GB RTX, LoRA via Diffusers / AI Toolkit / NeMo |
+| https://docs.bfl.ml/flux_3/flux3_image_klein.md | primary | undated (launch) | Spec table (lists distilled "Guidance (CFG) 1"), LoRA training config, LoRA-on-distilled scale 0.75 |
+| https://docs.bfl.ml/flux_3/flux3_image_bounding_boxes.md | primary | undated | Box format: `[y0,x0,y1,x1]` on a 0-1000 grid; edit rows `from`/`src_bbox`/`tgt_bbox`; kinds new/move/anchor |
+| https://docs.bfl.ml/guides/prompting_summary.md and `prompting_unified_basics`, `_building`, `_style`, `_technical`, `prompting_layout`, `prompting_editing_*` | primary | undated | Prompting guide. **Written for the FLUX 3 Image API model**, which upsamples on the server side; covers quoting text, refs by position, no negative prompts, aspect ratios |
+| https://docs.bfl.ml/api-reference/utility/generate-an-image-with-flux-3-klein.md | primary | undated | API: `steps` 1-16 (default 16), `seed`, `aspect_ratio` (default `auto`), up to 10 `images`; "pixel restoration" is API-only |
+| https://github.com/huggingface/diffusers/pull/15046 (merge commit 7ecb1e1b4fe500be7fb7381a7bb79a24d7fa3941) | primary (library) | merged 2026-10-15T16:30Z | Adds `src/diffusers/modular_pipelines/flux3/`, `Flux3Transformer2DModel`, `BFLQuantizationConfig`, `Flux3LoraLoaderMixin`, DreamBooth LoRA scripts |
+| https://github.com/huggingface/diffusers/blob/7ecb1e1b4f/docs/source/en/api/pipelines/flux3.md (rendered at https://huggingface.co/docs/diffusers/main/en/api/pipelines/flux3) | primary (library) | 2026-10-15 | Diffusers docs: defaults, guider, refs `<ref_image_N>`, memory, single-file and quantized loading |
+| https://github.com/huggingface/diffusers/blob/7ecb1e1b4f/docs/source/en/quantization/bfl.md | primary (library) | 2026-10-15 | fp8r needs CC >= 8.9 to run fused; NVFP4 needs Blackwell + flashinfer; on other devices weights are dequantized per forward pass |
+| https://github.com/huggingface/diffusers/pull/15058 | primary (library), **open** | opened 2026-10-15T22:32Z | `Flux3PromptUpsampleStep`, plus the constants `SYSTEM_PROMPTS` and `PROMPT_UPSAMPLER_REPO` in `diffusers/modular_pipelines/flux3/prompt_upsampler.py` (not merged) |
+| https://huggingface.co/api/models?filter=base_model:adapter:black-forest-labs/flux-3-image-klein-base | secondary | 2026-10-15 | First community LoRAs, e.g. `Muinez/flux3-klein-distil-4step` and `diffusers-modular/flux3-tarot-lora` |
+| Web search "FLUX 3 Image Klein" | secondary | 2026-10-15 | **No independent coverage yet.** Every result is about FLUX.2 [klein] (Jan 2026). |
+
+Fetch failures:
+- `raw/main/model_index.json`: 401. The file does not exist; the repo ships `modular_model_index.json` instead.
+- `modular_model_index.json`, `transformer/config.json` and the other config files: 401. They are gated, and there is no local HF token.
+- `github.com/black-forest-labs/flux-3`, linked from the diffusers docs (flux3.md line 175): does not resolve. The real repo is `flux-3-image-klein`.
+
+## Model facts
+
+- **Parameters.** The transformer is 5.6B by the vendor's count, 5,548,681,984 by the Hub safetensors count, and 5.5B in the diffusers docs (flux3.md:203). The Qwen3-VL-4B-Instruct text encoder (~4B) is not counted in that figure.
+- **Variants** (HF card table):
+
+  | Variant | Repo | Weights | Steps | Guidance | Built for |
+  |---|---|---|---|---|---|
+  | Klein (distilled) | `flux-3-image-klein` | step-distilled flow map, bf16 | 16 | none | generation and editing; the model behind the BFL API |
+  | Klein Base | `flux-3-image-klein-base` | undistilled | 50 | CFG 3.5 | fine-tuning, LoRA, research |
+
+  Both repos carry `variants/fp8r` and `variants/nvfp4`. The vendor names no size other than 5.6B.
+- **Siblings on the Hub (org listing):**
+  - `flux-3-image-klein-pup`: the prompt upsampler.
+  - `flux-3-image-klein-comfy`: ComfyUI repack.
+  - `flux-3-action-{base,droid,so101}`: a 7B robot-action model released 2026-09-22. It is irrelevant here.
+  - "FLUX 3 Image", the full model, is API-only. No weights.
+- **License.** Weights are under the FLUX Kommunity License v1.0: non-commercial use, plus commercial *output* use for Qualifying Users under US$5M gross annual revenue. The text encoder and the upsampler are Apache-2.0. The reference code is Apache-2.0.
+- **Gating.** Both weight repos are gated with `gated: "auto"`: you click-accept and access is granted automatically. The pup repo is not gated. `hf auth login` plus accepting the terms on both the Klein and Klein Base repos is required.
+- **Text encoder.** Qwen3-VL-4B-Instruct, class `transformers.Qwen3VLForConditionalGeneration` with an `AutoProcessor` tokenizer. Embeddings stack hidden layers (4, 8, …, 32).
+- **VAE.** `AutoencoderKLFlux2`, the same FLUX.2 autoencoder: the comfy file is `vae/flux2-vae.safetensors`, and diffusers flux3.md:17 agrees. 8x downsample with 2x2 packing gives a 16 px token. Latent channels 32 x 4 = 128.
+- **Tasks.** One model covers text-to-image, single-reference edit, multi-reference composition (up to 10 refs), bounding-box layout and box edits, and text rendering.
+- **Resolution.** "Up to 4K" (GitHub README, BFL docs). Reference code: `MIN_SIDE, MAX_SIDE = 64, 4096` (`src/flux3/pipeline.py:26`). Default output is 1024x1024.
+- **VRAM, as the vendor states it:**
+  - B200, 1024², upsampler off: distilled 31 GB bf16 / 26 GB FP8 / 25 GB NVFP4; base 31 / 29 / 26 GB.
+  - The upsampler adds ~28 GB.
+  - BFL docs say it "fits on consumer GPUs, down to an RTX 3090".
+  - Blog and comfy card: int8 runs on 8 GB RTX (3070) in ComfyUI.
+  - Diffusers: ~20 GB of bf16 weights in total, with the VAE in fp32 (flux3.md:203).
+- **Speed.** H200 at 1 MP: about 3 s distilled vs 12 s base (GitHub README). RTX 4070 int8 distilled, 1024², 16 steps: 8.9 s (blog chart).
+- **Quantized checkpoints from the vendor:**
+  - fp8r (rowwise FP8) and NVFP4 (ModelOpt layout), under `variants/` in both repos.
+  - Comfy int8 "convrot" files for the DiT, the text encoder and the upsampler.
+  - NVFP4 needs Blackwell. fp8r runs fused only on CC >= 8.9 (Ada and newer); the RTX 3090 (8.6) falls back to per-forward dequantization (bfl.md).
+
+## Pipeline facts (diffusers @ 7ecb1e1b4f, PR #15046)
+
+**Local install.** `venv/.../diffusers` is 0.41.0.dev0 at commit 1e004eb6. It has `pipelines/flux`, `pipelines/flux2` (`Flux2Pipeline`, `Flux2KleinPipeline`, `…KleinInpaint`, `…KleinKV`) and `modular_pipelines/flux2`. It has **no flux3**. Reinstall diffusers from main at or after 7ecb1e1b. Local transformers 5.19.0 already has `Qwen3VLForConditionalGeneration` and `Qwen3_5ForConditionalGeneration`.
+
+**Klein does NOT load through `Flux2Pipeline` or `Flux2KleinPipeline`.** It needs a new transformer (`Flux3Transformer2DModel`) and a new text encoder. It ships **only as a modular pipeline**: there is no `pipelines/flux3` and no `DiffusionPipeline` class. (The HF sidebar snippet's `DiffusionPipeline.from_pretrained` is the Hub's auto-generated snippet; the card itself uses `ModularPipeline`.)
+
+**Classes and modules:**
+- `src/diffusers/modular_pipelines/flux3/modular_pipeline.py:24`: `Flux3ModularPipeline(ModularPipeline, Flux3LoraLoaderMixin)`. Its default blocks are `Flux3AutoBlocks`.
+- `modular_pipeline.py:52`: `Flux3DistilledModularPipeline`. Its default blocks are `Flux3DistilledAutoBlocks` (`modular_blocks_flux3_distilled.py:256`).
+- `modular_pipelines/modular_pipeline.py` maps the `"flux3"` and `"flux3-distilled"` model names. Per diffusers docs flux3.md:161, the repo's `modular_model_index.json` resolves to the distilled classes.
+- Load with `ModularPipeline.from_pretrained("black-forest-labs/flux-3-image-klein")`, then `pipe.load_components(dtype=torch.bfloat16)`.
+
+**trust_remote_code.** Inferred: not needed. Every class named is in the diffusers library, and the file list has no `.py` files. The `modular_model_index.json` itself could not be read (gated). Verify after you accept the gate.
+
+**Components** (`modular_blocks_flux3_distilled.py:265-268`):
+
+| Component | Class |
+|---|---|
+| `text_encoder` | `Qwen3VLForConditionalGeneration` |
+| `tokenizer` | `AutoProcessor` |
+| `image_processor` | `Flux3ImageProcessor` (from_config) |
+| `vae` | `AutoencoderKLFlux2` |
+| `transformer` | `Flux3Transformer2DModel` (`models/transformers/transformer_flux3.py:341`, `flow_map` config at :406) |
+| `scheduler` | `FlowMatchEulerDiscreteScheduler` (from_config, shift 6.93) |
+| `guider` | `ClassifierFreeGuidance`, base only |
+
+**Call inputs and defaults** (`Flux3DistilledAutoBlocks` docstring, `modular_blocks_flux3_distilled.py:270-304`):
+- `prompt`: a **str only**. Batched prompts raise (`encoders.py:229`). Use `num_images_per_prompt` (default 1) for several images.
+- `max_sequence_length`: 8192 (`encoders.py:196`). The text window is right-padded to a multiple of 80 tokens (`encoders.py:166`). The padding "is part of the model recipe".
+- `text_encoder_out_layers`: `(4, 8, 12, 16, 20, 24, 28, 32)`.
+- `image`: a PIL image or a list of them. Non-PIL input raises (`encoders.py:84`).
+- `height` / `width`:
+  - Text-to-image default is 1024 x 1024 (`before_denoise.py:186`).
+  - With `image`, the default is 1 MP at the **first reference's** aspect ratio, rounded to 16 (`inputs.py:246, 302-309`).
+  - Both must be divisible by 16 or the call raises (`before_denoise.py:232`).
+- `num_inference_steps`: 16 distilled (`modular_blocks_flux3_distilled.py:48,116`), 50 base (`before_denoise.py:95`). The default sigmas are `np.linspace(1.0, 1/n, n)` with scheduler `shift=6.93` (`before_denoise.py:95,151`).
+- Also accepted: `timesteps` and `sigmas` (overrides), `latents`, `generator`, `output_type` (`pil`).
+- `output="images"` selects the return value.
+
+**Guidance:**
+- Distilled: no guider, no `negative_prompt`. The transformer is a flow map that gets the current and the target timestep at each step (flux3.md:161; `transformer_flux3.py:546`).
+- Base: real CFG through the `guider` component, `ClassifierFreeGuidance(guidance_scale=3.5)` (`denoise.py:48`). **There is no `guidance_scale` call argument.** You change it with `pipe.guider = pipe.guider.new(guidance_scale=…)` (flux3.md:151). The base model takes `negative_prompt`.
+- Diffusers says the distilled model "is trained for 4 to 16 steps" (flux3.md:171). The API caps `steps` at 1-16.
+
+**References:**
+- Each reference keeps its own resolution. It is downscaled only above 4096x4096 and center-cropped to the 16 px grid (`encoders.py:88`).
+- In prompts, refer to references as `<ref_image_0>`, `<ref_image_1>`, … (flux3.md:108).
+- **Diffusers enforces no maximum count.** The reference code enforces `MAX_REFERENCES = 10` (`src/flux3/pipeline.py:27`), and the vendor states 10 everywhere.
+
+**Reference handling differs between diffusers and the vendor code:**
+- **Vendor, single reference:** pads the image to a canvas of at most 4 MP (`MATCH_MAX_PIXELS`), then crops the output back. The output size defaults to the reference's own size.
+- **Vendor, multi-reference:** each reference is resized to at most 1 MP.
+- **Diffusers:** keeps references at up to 16 MP and defaults the output to 1 MP.
+
+**Prompt upsampler / enhancer helper:**
+- **Not in merged diffusers.** Open PR #15058 adds `Flux3PromptUpsampleStep` and the module constants `SYSTEM_PROMPTS` (a dict of `t2i`/`i2i`/`t2i_bbox`/`i2i_bbox`) and `PROMPT_UPSAMPLER_REPO = "black-forest-labs/flux-3-image-klein-pup"`, in `diffusers/modular_pipelines/flux3/prompt_upsampler.py`. The PR copies `system_prompts.json` at pup commit 8b069751. The pup head is now 3f3edb52 **[volatile]**.
+- Until that merges, the vendor text lives only in the pup repo's `system_prompts.json` and in the reference repo's `src/flux3/pup_prompts.json`. Pin to the diffusers constant once it lands, rather than copying the text.
+
+**Quantized loading:**
+- `BFLQuantizationConfig(compute_dtype=torch.bfloat16)` works **only through `Flux3Transformer2DModel.from_single_file(…/variants/{fp8r,nvfp4}/model.safetensors, config=<repo>, subfolder="transformer")`**, followed by `pipe.update_components(transformer=…)`. Pipeline-level loading of these checkpoints is unsupported (bfl.md).
+- Load the other components by name first. A bare `load_components()` would also load the bf16 transformer.
+
+**Other library facts:**
+- **LoRA:** `Flux3LoraLoaderMixin` is on the pipeline. DreamBooth LoRA scripts are at `examples/dreambooth/train_dreambooth_lora_flux3_klein{,_img2img}.py`.
+- **`_repeated_blocks`:** `["Flux3ModeTransformerBlock", "Flux3SingleTransformerBlock"]`, which is usable for regional compile.
+- **Memory:** flux3.md:208 suggests `pipe.enable_auto_cpu_offload(device="cuda")`. The base-model docs use VAE fp32 (`dtype={"vae": torch.float32, "default": torch.bfloat16}`); the distilled card uses bf16 throughout.
+
+## Vendor recommended settings
+
+| Variant | Steps | Guidance | Resolution | Source |
+|---|---|---|---|---|
+| Klein (distilled) | 16 (trained for 4-16; API 1-16) | none. BFL docs list "CFG 1" (equivalent to none), and the reference code raises on anything but None/1.0 | 1024² default; up to 4K; sides 64-4096, multiple of 16 | HF card table; `src/flux3/generate.py`; docs.bfl.ml klein page; flux3.md:171 |
+| Klein Base | 50 | CFG 3.5 | same | HF card; CLI `--model` help; `pipeline.py:20` |
+| LoRA on distilled | 16 | CFG 1 | — | LoRA scale 0.75 (0.5-1.0), docs.bfl.ml klein page |
+| LoRA training | rank/alpha 32/32, AdamW (0.9, 0.95), lr 1e-4 with 200 warmup steps then linear decay, 4000 steps, ~1 MP native aspect ratio, train on **Base** | — | — | docs.bfl.ml klein page |
+| Upsampler decoding | greedy, `max_new_tokens=3584`, `enable_thinking=False` | — | — | pup card (note below) |
+
+The upsampler decoding note: the pup card also says "top_p 0.95, top_k 20, presence penalty 1.5 for t2i / 0 for edits". That reads as contradictory alongside greedy decoding; the card's own snippet uses `do_sample=False`.
+
+Vendor example sizes are 1024x1024, 832x1248 (portrait) and 1248x832 (landscape) (`examples/README.md`). The vendor does not state a scheduler shift; it is alpha 6.93 in `pipeline.py:63` and in diffusers.
+
+## Prompt format
+
+- **Mandatory upsampling.** "Do not use the model without a prompt upsampler" (HF card; GitHub README `[!IMPORTANT]`). The model is trained on the captions the upsampler writes, and short prompts give generic output.
+  - **Text-to-image:** the upsampler (`t2i` system prompt) expands the request into one English scene caption, about 200 words in the vendor examples (e.g. `examples/distilled/man_dog.json`). The caption covers medium/style, framing, subject with colors, materials and positions, background and lighting.
+  - **Edits** (`i2i`): the user message is the reference images followed by a three-line text: "Reference images follow in order (the first image, the second image, ...).\nUser request: …\nOutput the caption." The output is a complete caption of the reference with the edit folded in. Pass the same images to both the upsampler and the pipeline.
+  - **Any other LLM** may stand in, given these system prompts.
+- **Natural language, not tags.** Describe attributes (palette, stroke, texture) rather than naming an artwork (HF card *Prompting*).
+- **Text rendering.** Quote the exact words, then say where they go and how they look (docs.bfl.ml `prompting_unified_basics`; the upsampler keeps quoted text verbatim, per the pup card).
+- **No negative prompts.** Rephrase each negation as a positive description (docs.bfl.ml `prompting_unified_technical`). The distilled pipeline also rejects `negative_prompt`.
+- **Layout / JSON.**
+  - Write the caption with `<id>` tags, then append a JSON array of `{"id","bbox":[top,left,bottom,right] on 0-1000,"desc"}`.
+  - For box edits, add `from: "ref_image_N"`, `src_bbox` and `tgt_bbox`. A `null` target removes the element; equal boxes anchor it.
+  - Boxes are a hint, not a hard mask.
+  - Sources: HF card; https://docs.bfl.ml/flux_3/flux3_image_bounding_boxes; flux3.md:122-147.
+  - The reference CLI's `boxes.json` uses 0-1 floats and converts them (`bbox.to_canvas`).
+- **Naming references.** Diffusers and the vendor box format use `<ref_image_0>` (zero-based). The BFL API guide uses "image 1", "image 2" (one-based). The upsampler input uses "the first image, the second image". Use the convention of whichever layer the prompt is going to.
+- **Scope of the API guide.** Its prompting guide (https://docs.bfl.ml/guides/prompting_summary.md) is written for the FLUX 3 Image *API*, where a short prompt is expanded on the server side ("A short prompt works"). For local Klein, that advice holds only once an upsampler is in front of the model.
+
+## Missing knowledge / caveats
+
+- **Diffusers support is hours old.** It merged 2026-10-15 16:30Z and is not in any release. The upsampler block (PR #15058) is unmerged. The diffusers docs link a nonexistent `github.com/black-forest-labs/flux-3`.
+- **Gated configs unread.** I could not read `modular_model_index.json`, `transformer/config.json` or `variants/*/hf_quant_config.json` (gated, no token). The trust_remote_code status and the exact block mapping are inferred, not observed.
+- **No guider support in the repo.** A grep of `docs/WORKFLOW_GUIDE.md` and `dw/pipeline_processors/` found no handling for modular `guider` components, so a Base CFG other than 3.5 has no knob today. The distilled template is unaffected.
+- **The vendor's quantized variants need repo support** for `from_single_file` + `update_components` on a modular pipeline. That is unverified for this engine. The fallbacks are SDNQ/TorchAO through `load_components.quantization_config`, which is how the H3 templates quantize.
+- **24 GB fit.** ~11.1 GB transformer + ~8.9 GB text encoder + VAE ≈ 20 GB bf16 is tight on 24 GB at 1 MP. The upsampler (18.8 GB bf16; 9.8 GB int8 in the comfy repo) cannot be resident alongside. It must run as a separate prior step, or as a remote LLM. `enable_auto_cpu_offload` (`components_manager`) is CUDA-only per the repo docs.
+- **MPS** is completely unstated by the vendor. The fp8r and NVFP4 kernels are CUDA-only; elsewhere they dequantize per forward pass. bf16 on MPS needs ~20 GB of unified memory plus activations.
+- **Known failure modes** (HF card *Limitations*):
+  - Rendered text can be inaccurate.
+  - Boxes are not masks; small boxed elements may not appear, and elements can extend past their box.
+  - Edits can change content outside the requested region. API "pixel restoration" fixes this, but it is API-only.
+  - A one-line edit instruction sent raw "reframes the shot".
+  - The upsampler resizes references to ≤1 MP, so it can misdescribe small details. It never refuses, and its output is English only.
+- **Seeds.** Seeds reproduce only when noise is drawn as the vendor draws it (flux3.md:175-185).
+- **Text encoder version quirk.** Qwen3-VL padding position ids differ between transformers 4.57 and 5.x. Diffusers passes them explicitly (`encoders.py:269-273`), so do not bypass the pipeline's text encoder step.
+- **LoRA.** Train on Base; the LoRA runs on distilled without conversion at scale ~0.75. Trainers: Diffusers DreamBooth scripts, Ostris AI Toolkit (`arch: flux3`), NVIDIA NeMo AutoModel. A LoRA adds ~5% to generation time (blog). Community LoRAs exist from day one, including a "4-step distil" LoRA by Muinez, not vendor-verified.
+- **FLUX.2 vs FLUX.3.** FLUX.2 [klein] (4B Apache / 9B non-commercial, released 2026-01-15) is the previous release.
+  - It has its own diffusers classes (`Flux2KleinPipeline`, already local). The blog claims Klein beats FLUX.2 [klein] 9B by +91 Elo t2i and +70 edit with 38% fewer parameters (internal evaluation).
+  - Shared with FLUX.2: the VAE, 10 references, and "up to 4MP"-style editing.
+  - Different from FLUX.2: the transformer, the text encoder (Qwen3-VL-4B), mandatory upsampling, bbox prompts, and the license (Kommunity rather than Apache/non-commercial).
+  - Do not carry FLUX.2 [klein] settings or guides over; the BFL docs' FLUX.2 pages (training, HEX/JSON prompting use cases) are about the earlier release.
+- **No independent secondary coverage** exists yet. Every claim above rests on vendor or diffusers sources alone.
+
+## What carries over from `workflows/models/flux2-dev.json`
+
+- **Carries over:** the result block (`image/jpeg`, `embed_metadata`), `seed: variable:seed`, `cost_drivers`, `configures: templates/text-to-image`, and the `hf auth login` gating pattern.
+- **Differs:**
+  - `component_type` becomes `ModularPipeline` (as in the H3 templates), not `Flux2Pipeline`.
+  - There is no `offload`; use `components_manager` / on-demand residency instead.
+  - Per-component dtype and quantization go through `load_components`.
+  - There is no `guidance_scale` argument (distilled has none; base uses the guider).
+  - `output: "images"`.
+  - A prompt-upsampler step must precede the generation step.
+  - Steps are 16, not 40.
+  - The text encoder is a transformers Qwen3-VL model and is not pre-quantized by the vendor except in comfy int8.
+- **Repo conventions** (RECIPES_24GB, ACCELERATION, QUANTIZATION):
+  - Unquantized FLUX uses `offload: "model"`, which modular pipelines cannot use.
+  - `mag_ratios: "flux"` is a FLUX.1 preset and is not valid for Flux3; calibrate instead.
+  - `is_guidance_distilled` (FasterCache) is FLUX.1 guidance embedding, which does not apply here. The distilled Klein is a flow map with no CFG batch.
+
+## What the templates should teach (reading order)
+
+1. **text-to-image (distilled)**
+   - Setup: `black-forest-labs/flux-3-image-klein`, 16 steps, 1024², bf16, no guidance.
+   - The prompt is already a full caption, or comes from an upsampler step.
+   - Vendor example: "A man walking with his dog, afternoon sun", seed 7 (`examples/README.md`); the expanded caption is in `examples/distilled/man_dog.json`.
+2. **upsample-then-generate**
+   - Two steps: a `text_generation` step with `flux-3-image-klein-pup` (`Qwen3_5ForConditionalGeneration`, system prompt `t2i`, greedy, `max_new_tokens` 3584, `enable_thinking=False`), whose output is passed by `previous_result:` as `prompt`.
+   - Unload between the steps on 24 GB.
+   - Pin the system prompt to diffusers `SYSTEM_PROMPTS` once PR #15058 merges.
+   - Source: HF card *Prompt upsampling*.
+3. **image edit (single reference)**
+   - `image` = one asset; the `i2i` upsampler caption gets the same image; 16 steps.
+   - Output defaults to 1 MP at the reference's aspect ratio.
+   - Vendor examples: "put a red bandana around the dog's neck" (seed 22), "fill the mug with coffee and put a croissant next to it" (seed 21).
+4. **multi-reference**
+   - 2-10 images, referred to as `<ref_image_N>`; the first image sets the aspect ratio.
+   - Vendor example: "print the dog from the second image onto the mug" (seed 23). Diffusers example: fox + bench at 1360x768.
+5. **layout with bounding boxes**
+   - Caption with `<id>` tags plus a JSON box table on 0-1000.
+   - Vendor examples: the silhouette example (HF card) and the balloons boxes (`examples/inputs/balloons_boxes.json`). Docs: docs.bfl.ml bounding-box page.
+6. **typography**
+   - Quoted text, 832x1248 portrait.
+   - Vendor example: the gig poster, seed 1 (`examples/typography/`).
+7. **base + CFG** (optional, for LoRA users)
+   - `flux-3-image-klein-base`, 50 steps, guider 3.5, `negative_prompt` allowed.
+   - The repo needs guider support to vary the CFG.
+8. **LoRA on distilled**
+   - A Base-trained LoRA at scale 0.75, 16 steps (docs.bfl.ml klein page).
+9. **low-VRAM 24 GB CUDA**
+   - Option A, the vendor fp8r `from_single_file` + `BFLQuantizationConfig`: fused on Ada+ only, dequant fallback on a 3090. Needs engine support.
+   - Option B, SDNQ/TorchAO int8 through `load_components.quantization_config` on the transformer and text encoder (H3 pattern).
+   - With either option, `components_manager` auto-offload and the upsampler as a separate step. Measure; the vendor gives no 24 GB recipe.
+10. **Apple MPS**
+    - bf16 with no vendor quantization (the kernels are CUDA-only), 1024² or lower.
+    - Upsampler run separately or replaced by another LLM.
+    - The vendor says nothing about MPS; it must be measured.
+
+## Assessment
+
+**Trust as-is.** These facts are consistent across the HF card, the reference code, the BFL docs and the diffusers source:
+- Distilled: 16 steps, no CFG. Base: 50 steps, CFG 3.5. Shift 6.93.
+- 1024² default; sides a multiple of 16, at most 4096.
+- Up to 10 references (vendor-enforced; diffusers does not enforce it).
+- Qwen3-VL-4B text encoder and the FLUX.2 VAE.
+- `max_sequence_length` 8192; prompt must be a single string.
+- No negative prompt on distilled.
+- The bbox format.
+- The mandatory upsampler and its decoding settings.
+- The LoRA recipe (train on Base, scale 0.75 on distilled).
+- The class names: `Flux3DistilledModularPipeline` / `Flux3ModularPipeline`, loaded via `ModularPipeline.from_pretrained`.
+
+**Uncertain:**
+- The upsampler system prompts are still moving (pup repo updated hours ago; the diffusers PR pins an older commit). Do not pin text yet.
+- Diffusers and the vendor code prepare references differently (1 MP vs native-size output default; 16 MP vs 4 MP/1 MP reference cap). Expect diffusers output to differ from the vendor's for edits.
+- The distilled guidance label differs: "none" (card) vs "CFG 1" (BFL docs). They are equivalent.
+- 24 GB and MPS fit are unmeasured. The vendor's VRAM figures are B200 peaks.
+- trust_remote_code: inferred not needed; the gated index is unread.
+
+**Blockers:**
+1. **The local diffusers has no flux3.** Diffusers must be updated to main ≥ 7ecb1e1b (merged today; unreleased).
+2. **Gated weights.** Accept the Kommunity license on the Klein and Base repos, and set an HF token on the server.
+3. **The upsampler.** A faithful template needs either a 9B upsampler step (18.8 GB bf16) or a different LLM given BFL's system prompts. The library constant for those prompts is not merged yet.
+4. **Engine gaps.** The vendor fp8r/NVFP4 variants and a non-default Base CFG require engine support for modular `from_single_file`/`update_components` and the `guider`. Neither is present today.
diff --git a/docs/stabilization/baseline.json b/docs/stabilization/baseline.json
index a4e7bc90..4bafe43e 100644
--- a/docs/stabilization/baseline.json
+++ b/docs/stabilization/baseline.json
@@ -1,10 +1,10 @@
 {
-  "modules": 219,
+  "modules": 220,
   "modules_over_size_ceiling": 0,
   "functions_over_150_lines": 0,
   "prefix_literals": 0,
   "prefix_handling": 0,
-  "test_dw_patch_targets": 327,
+  "test_dw_patch_targets": 309,
   "claude_md_lines": 129,
   "duplicate_blocks": 0,
   "complex_functions": 2,
diff --git a/docs/superpowers/plans/2026-10-15-flux3-klein-catalog.md b/docs/superpowers/plans/2026-10-15-flux3-klein-catalog.md
new file mode 100644
index 00000000..f244d2f1
--- /dev/null
+++ b/docs/superpowers/plans/2026-10-15-flux3-klein-catalog.md
@@ -0,0 +1,1158 @@
+# FLUX 3 Image Klein Catalog Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Onboard FLUX 3 Image Klein (distilled) into the dw catalog: upsampler support in `text_generation`, two upsampler builtins, five templates, a model entry, a family README, GPU-measured costs, and the `flux3-klein` composition skill.
+
+**Architecture:** Model knowledge stays in JSON, prompts and the skill. The engine gains three model-agnostic `text_generation` options (`chat_template_kwargs`, `revision`, a list for `image`) and a `system_prompt` that can name a JSON file in a Hub repo at a pinned commit. Two builtins (`flux3_klein_upsample`, `flux3_klein_upsample_edit`) carry BFL's upsampler settings once, and every template that upsamples composes one of them.
+
+**Tech Stack:** Python 3.12+, transformers 5.19 pipelines, huggingface_hub `hf_hub_download`, diffusers `ModularPipeline` at or after 7ecb1e1b (PR #15046), pytest.
+
+**Spec:** [docs/superpowers/specs/2026-10-15-flux-3-klein-catalog-design.md](../specs/2026-10-15-flux-3-klein-catalog-design.md), audit [docs/proposals/audits/2026-10-15-flux-3-klein-audit.md](../../proposals/audits/2026-10-15-flux-3-klein-audit.md).
+
+## Global Constraints
+
+- Branch `feat/flux3-klein`. Commits end with `Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>`.
+- No per-model Python. Nothing in `dw/` names Flux3, Klein or BFL.
+- diffusers must be at or after `7ecb1e1b4fe500be7fb7381a7bb79a24d7fa3941` (the Flux3 merge). Install it locally in Task 0; lem already has it.
+- Klein repo `black-forest-labs/flux-3-image-klein`; upsampler repo `black-forest-labs/flux-3-image-klein-pup` pinned at `3f3edb52b2c55de0d49feab28598b68f7f8e4830` for both its weights and its `system_prompts.json`.
+- Distilled settings: `num_inference_steps` 16, no guidance argument, no `negative_prompt`, `width`/`height` multiples of 16, default 1024x1024, at most 10 references.
+- Every Klein pipeline step places every component explicitly: `"components": {"transformer": {"device": "cuda"}, "text_encoder": {"device": "cuda"}, "vae": {"device": "cuda"}}`. An unplaced component leaves `_execution_device` on the CPU (spec, P1a/P1b). Never put `residency: on_demand` on the text encoder.
+- Upsampler decoding: greedy (the task's default), `max_new_tokens` 3584, `chat_template_kwargs: {"enable_thinking": false}`, `repetition_penalty: 1.0` on the image path.
+- No vendor prompt text copied into the repo. The system prompts are read with `from_hub`. The edit scaffold (three short lines from BFL's `src/flux3/pup.py` at `bbfe317dd81c825c30d76090a67d3d0db51da3cc`) is the one quoted vendor string, and the builtin's description cites that file and commit.
+- Descriptions name rules without single quotes (the drift check reads a single-quoted name as a variable or step).
+- Security: validate the Hub repo id with `dw.locations.validate_hub_repo_id`; the `file` is a relative POSIX path with no `..`, no absolute part and no backslash; the `revision` is exactly 40 lowercase hex characters. No `eval`, `exec` or `shell=True`.
+- Unit tests: `venv/bin/python -m pytest tests/<file> -v` locally (the venv has torch). The full suite runs with `-n auto` from `pytest.ini`.
+- `tests/test_catalog_structure.py::test_the_compact_listing_fits_the_budget` may fail once the templates land. Raising that budget needs Don's OK: stop and ask, don't edit the number.
+
+## Review Focus
+
+1. **`from_hub` naming a key that isn't in the file, or a value that isn't text.** Expect a `ValueError` that lists the keys the file has, raised before any model loads, not a `KeyError` traceback. Test in Task 2.
+2. **`image` given as `[]` or `[null]`.** That's an optional reference list left empty by a template. Expect the text-only path, exactly as with no image. Test in Task 1.
+3. **A short `revision` (`3f3edb52`) or a branch name (`main`) in `from_hub`.** Expect a refusal naming the 40-hex rule. Without one, the prompt text could move under a pinned template. Test in Task 2.
+4. **The Klein step with a component left unplaced**, as a cold agent copying the template might write it. Expect a catalog test to refuse it: `test_every_flux3_pipeline_step_places_every_component` in Task 4.
+5. **More than 10 references.** Diffusers doesn't refuse it, and the model was trained on 10. Expect the multi-reference description and the skill to state the cap; an enforcing check is a dated follow-up. Test that the text says it in Task 6.
+
+---
+
+### Task 0: Local diffusers with Flux3
+
+**Files:** none (environment)
+
+- [ ] **Step 1: Install diffusers at the Flux3 merge or later**
+
+Run: `venv/bin/pip install -q --force-reinstall --no-deps git+https://github.com/huggingface/diffusers@7ecb1e1b4fe500be7fb7381a7bb79a24d7fa3941`
+
+- [ ] **Step 2: Confirm the modular package imports**
+
+Run: `venv/bin/python -c "from diffusers.modular_pipelines.flux3 import modular_blocks_flux3_distilled as m; print(m.__file__)"`
+Expected: a path ending in `modular_pipelines/flux3/modular_blocks_flux3_distilled.py`.
+
+---
+
+### Task 1: `text_generation` takes chat-template settings, a pinned revision and a list of images
+
+**Files:**
+- Modify: `dw/tasks/text_generation.py` (`_image_part`, `_build_messages`, `generate_text`, `_generate`)
+- Test: `tests/test_text_generation.py`
+
+**Interfaces:**
+- Produces: `generate_text(prompt, device="cpu", **kwargs)` now also reads `chat_template_kwargs: dict | None`, `revision: str | None`, and `image: PIL | str | list[PIL | str] | None`. The return value doesn't change.
+
+- [ ] **Step 1: Write the failing tests** (append to `tests/test_text_generation.py`, inside `TestTextGeneration`)
+
+```python
+    @patch("dw.tasks.text_generation.hf_pipeline")
+    def test_chat_template_kwargs_reach_the_text_template(self, mock_pipeline):
+        pipe = MagicMock()
+        pipe.return_value = [{"generated_text": "out"}]
+        mock_pipeline.return_value = pipe
+
+        generate_text(
+            "a cat", device="cpu", model_name="m/text-chat-kwargs",
+            chat_template_kwargs={"enable_thinking": False},
+        )
+
+        self.assertEqual(
+            pipe.call_args[1]["tokenizer_encode_kwargs"], {"enable_thinking": False}
+        )
+
+    @patch("dw.tasks.text_generation.hf_pipeline")
+    def test_chat_template_kwargs_reach_the_vision_template(self, mock_pipeline):
+        pipe = MagicMock()
+        pipe.return_value = [{"generated_text": "out"}]
+        mock_pipeline.return_value = pipe
+
+        generate_text(
+            "a cat", device="cpu", model_name="m/vision-chat-kwargs",
+            image="https://example.com/a.png",
+            chat_template_kwargs={"enable_thinking": False},
+        )
+
+        self.assertIs(pipe.call_args[1]["enable_thinking"], False)
+
+    @patch("dw.tasks.text_generation.hf_pipeline")
+    def test_no_chat_template_kwargs_passes_nothing_extra(self, mock_pipeline):
+        pipe = MagicMock()
+        pipe.return_value = [{"generated_text": "out"}]
+        mock_pipeline.return_value = pipe
+
+        generate_text("a cat", device="cpu", model_name="m/no-chat-kwargs")
+
+        self.assertNotIn("tokenizer_encode_kwargs", pipe.call_args[1])
+
+    def test_chat_template_kwargs_must_be_a_mapping(self):
+        with self.assertRaises(ValueError):
+            generate_text("a cat", device="cpu", chat_template_kwargs=["enable_thinking"])
+
+    @patch("dw.tasks.text_generation.hf_pipeline")
+    def test_revision_reaches_the_loader(self, mock_pipeline):
+        pipe = MagicMock()
+        pipe.return_value = [{"generated_text": "out"}]
+        mock_pipeline.return_value = pipe
+
+        generate_text("a cat", device="cpu", model_name="m/revision", revision="a" * 40)
+
+        self.assertEqual(mock_pipeline.call_args[1]["revision"], "a" * 40)
+
+    @patch("dw.tasks.text_generation.hf_pipeline")
+    def test_a_list_of_images_becomes_one_part_each_in_order(self, mock_pipeline):
+        pipe = MagicMock()
+        pipe.return_value = [{"generated_text": "out"}]
+        mock_pipeline.return_value = pipe
+
+        generate_text(
+            "edit", device="cpu", model_name="m/image-list",
+            image=["https://example.com/1.png", "https://example.com/2.png"],
+        )
+
+        user = pipe.call_args[1]["text"][-1]["content"]
+        self.assertEqual(
+            [part.get("url") for part in user[:2]],
+            ["https://example.com/1.png", "https://example.com/2.png"],
+        )
+        self.assertEqual(user[2], {"type": "text", "text": "edit"})
+        self.assertEqual(mock_pipeline.call_args[0][0], "image-text-to-text")
+
+    @patch("dw.tasks.text_generation.hf_pipeline")
+    def test_an_empty_or_all_null_image_list_is_the_text_path(self, mock_pipeline):
+        pipe = MagicMock()
+        pipe.return_value = [{"generated_text": "out"}]
+        mock_pipeline.return_value = pipe
+
+        for empty in ([], [None]):
+            generate_text("a cat", device="cpu", model_name=f"m/empty-{len(empty)}", image=empty)
+            self.assertEqual(mock_pipeline.call_args[0][0], "text-generation")
+```
+
+Each test uses its own `model_name` because `cached_model` keys on it and a shared name would return an earlier test's mock.
+
+- [ ] **Step 2: Run them and watch them fail**
+
+Run: `venv/bin/python -m pytest tests/test_text_generation.py -v -n0`
+Expected: the seven new tests FAIL (`KeyError: 'tokenizer_encode_kwargs'`, `'enable_thinking'`, `'revision'`, no `ValueError` raised, and the list tests on the message shape or pipeline task).
+
+- [ ] **Step 3: Implement**
+
+In `dw/tasks/text_generation.py`, replace `_build_messages` with the version below (keep `_image_part` as it is):
+
+```python
+def _images(image):
+    """The images a call carries, as a list in order, or None for none.
+
+    A template's optional reference list arrives as [] or [None] when the
+    caller supplied nothing, and that is the same statement as no image.
+    """
+    if image is None:
+        return None
+    images = list(image) if isinstance(image, (list, tuple)) else [image]
+    images = [i for i in images if i is not None and i != ""]
+    return images or None
+
+
+def _build_messages(prompt, system_prompt, images):
+    """Chat messages in the shape the chosen pipeline expects.
+
+    Text-generation models take plain string content. Vision models take a
+    list of typed parts, because the images are part of the message rather
+    than something alongside it - every image first, in order, then the text.
+    """
+    messages = []
+    if images is None:
+        if system_prompt is not None:
+            messages.append({"role": "system", "content": system_prompt})
+        messages.append({"role": "user", "content": prompt})
+    else:
+        if system_prompt is not None:
+            messages.append(
+                {"role": "system", "content": [{"type": "text", "text": system_prompt}]}
+            )
+        messages.append(
+            {
+                "role": "user",
+                "content": [_image_part(i) for i in images]
+                + [{"type": "text", "text": prompt}],
+            }
+        )
+    return messages
+```
+
+In `generate_text`, document the three new kwargs in the docstring:
+
+```
+            image: Optional PIL image, URL or path, or a list of them - every
+                one goes to the model, in order. Its presence is what selects
+                the vision pipeline; an empty list is no image.
+            chat_template_kwargs: Settings for the model's chat template,
+                such as {"enable_thinking": false} for a Qwen3 model that
+                must not reason before answering.
+            revision: The model repo's commit, branch or tag to load.
+```
+
+Then change the body:
+
+```python
+    images = _images(kwargs.get("image", None) or None)
+    system_prompt = kwargs.get("system_prompt", None)
+    max_new_tokens = int(kwargs.get("max_new_tokens", 500))
+    revision = kwargs.get("revision", None)
+    chat_template_kwargs = kwargs.get("chat_template_kwargs") or {}
+    if not isinstance(chat_template_kwargs, dict):
+        raise ValueError(
+            "text_generation: chat_template_kwargs must be an object of settings "
+            f"for the chat template, got {type(chat_template_kwargs).__name__}"
+        )
+
+    if images is None:
+        pipeline_task = "text-generation"
+        model_name = kwargs.get("model_name", _DEFAULT_MODEL)
+    else:
+        pipeline_task = "image-text-to-text"
+        model_name = kwargs.get("model_name", DEFAULT_VISION_MODEL)
+```
+
+`load_pipe` passes the revision only when one is set:
+
+```python
+    def load_pipe():
+        logger.info(f"Generating text with {model_name} on {device}")
+        placement = hf_pipeline_placement(device)
+        if revision is not None:
+            placement = {**placement, "revision": revision}
+        return hf_pipeline(
+            pipeline_task,
+            model=model_name,
+            torch_dtype=dtype,
+            **placement,
+        )
+```
+
+The cache key gains the revision, so two pins of one repo don't share a model:
+
+```python
+    pipe = cached_model(
+        ("text_generation", pipeline_task, model_name, str(revision), str(device), str(dtype)),
+        load_pipe,
+```
+
+Pass `images` where the body used `image`: `_build_messages(prompt, system_prompt, images)`, `if images is not None:` around the repetition penalty, and `_generate(pipe, messages, images, max_new_tokens, generation, chat_template_kwargs)`.
+
+`_generate` hands the template settings to each path the way that pipeline accepts them:
+
+```python
+def _generate(pipe, messages, images, max_new_tokens, generation, chat_template_kwargs):
+    """Run the pipeline, which each path calls differently."""
+    if images is None:
+        # This pipeline collects anything it does not name into the arguments it
+        # forwards to generate(), so settings go in as plain keywords. Chat
+        # template settings have their own argument, which it hands to
+        # apply_chat_template
+        extra = {"tokenizer_encode_kwargs": chat_template_kwargs} if chat_template_kwargs else {}
+        results = pipe(
+            messages,
+            max_new_tokens=max_new_tokens,
+            return_full_text=False,
+            **generation,
+            **extra,
+        )
+    else:
+        # (keep the existing comment) ... Keywords this pipeline does not name
+        # go to the processor's apply_chat_template, which is where the chat
+        # template settings belong
+        results = pipe(
+            text=messages,
+            max_new_tokens=max_new_tokens,
+            return_full_text=False,
+            generate_kwargs=generation,
+            **chat_template_kwargs,
+        )
+```
+
+- [ ] **Step 4: Run the file and the callers' tests**
+
+Run: `venv/bin/python -m pytest tests/test_text_generation.py tests/test_image_to_text.py tests/test_judge.py -v -n0` (skip any of those names that don't exist; `ls tests | grep -i "image_to_text\|judge"`)
+Expected: all PASS, including the existing tests, which call `_build_messages`'s callers with a single image.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add dw/tasks/text_generation.py tests/test_text_generation.py
+git commit -m "feat(text_generation): chat_template_kwargs, revision and a list of images
+
+A Qwen3.5 upsampler must run with enable_thinking off, an edit sends every
+reference, and a pinned prompt wants pinned weights.
+
+Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
+```
+
+---
+
+### Task 2: `system_prompt` can name a JSON file in a Hub repo at a pinned commit
+
+**Files:**
+- Modify: `dw/tasks/text_generation.py` (new `resolve_system_prompt`, called at the top of `generate_text`)
+- Modify: `docs/TASKS.md` (the `text_generation` section)
+- Test: `tests/test_text_generation.py` (new class `TestSystemPromptFromHub`)
+
+**Interfaces:**
+- Consumes: `dw.locations.validate_hub_repo_id(name, what=...)`.
+- Produces: `resolve_system_prompt(value) -> str | None`. `value` is `None`, a `str`, or `{"from_hub": {"repo": str, "file": str, "revision": str, "key": str (optional)}}`. Tasks 3-4 write the dict form in JSON.
+
+- [ ] **Step 1: Write the failing tests** (append to `tests/test_text_generation.py`)
+
+```python
+import json as _json
+
+from dw.tasks.text_generation import resolve_system_prompt
+
+PIN = "3f3edb52b2c55de0d49feab28598b68f7f8e4830"
+
+
+def _spec(**over):
+    spec = {"repo": "black-forest-labs/flux-3-image-klein-pup",
+            "file": "system_prompts.json", "revision": PIN, "key": "t2i"}
+    spec.update(over)
+    return {"from_hub": spec}
+
+
+class TestSystemPromptFromHub(unittest.TestCase):
+    def setUp(self):
+        import tempfile, os
+        self.dir = tempfile.mkdtemp()
+        self.json_path = os.path.join(self.dir, "system_prompts.json")
+        with open(self.json_path, "w") as f:
+            _json.dump({"t2i": "expand the request", "i2i": "edit it", "n": 3}, f)
+
+    def test_a_string_or_none_passes_through(self):
+        self.assertEqual(resolve_system_prompt("plain"), "plain")
+        self.assertIsNone(resolve_system_prompt(None))
+
+    @patch("dw.tasks.text_generation.hf_hub_download")
+    def test_the_key_s_text_is_returned_from_the_pinned_file(self, download):
+        download.return_value = self.json_path
+        self.assertEqual(resolve_system_prompt(_spec()), "expand the request")
+        download.assert_called_once_with(
+            "black-forest-labs/flux-3-image-klein-pup", "system_prompts.json", revision=PIN
+        )
+
+    @patch("dw.tasks.text_generation.hf_hub_download")
+    def test_a_missing_key_names_the_keys_the_file_has(self, download):
+        download.return_value = self.json_path
+        with self.assertRaises(ValueError) as caught:
+            resolve_system_prompt(_spec(key="t2v"))
+        self.assertIn("i2i", str(caught.exception))
+        self.assertIn("t2i", str(caught.exception))
+
+    @patch("dw.tasks.text_generation.hf_hub_download")
+    def test_a_value_that_is_not_text_is_refused(self, download):
+        download.return_value = self.json_path
+        with self.assertRaises(ValueError):
+            resolve_system_prompt(_spec(key="n"))
+
+    def test_a_short_hash_or_branch_is_refused(self):
+        for revision in ("3f3edb52", "main", PIN.upper()):
+            with self.assertRaises(ValueError) as caught:
+                resolve_system_prompt(_spec(revision=revision))
+            self.assertIn("40", str(caught.exception))
+
+    def test_a_path_that_escapes_the_repo_is_refused(self):
+        for file in ("../secrets.json", "/etc/passwd", "a\\b.json", "", "x/../../y.json"):
+            with self.assertRaises(ValueError):
+                resolve_system_prompt(_spec(file=file))
+
+    def test_a_bad_repo_id_is_refused(self):
+        from dw.security import InvalidInputError
+        with self.assertRaises((ValueError, InvalidInputError)):
+            resolve_system_prompt(_spec(repo="https://evil.example/x"))
+
+    def test_an_unknown_field_or_shape_is_refused(self):
+        for bad in ({"from_hub": {**_spec()["from_hub"], "branch": "main"}},
+                    {"from_url": "x"}, ["t2i"]):
+            with self.assertRaises(ValueError):
+                resolve_system_prompt(bad)
+
+    @patch("dw.tasks.text_generation.hf_pipeline")
+    @patch("dw.tasks.text_generation.hf_hub_download")
+    def test_generate_text_sends_the_resolved_text(self, download, mock_pipeline):
+        download.return_value = self.json_path
+        pipe = MagicMock()
+        pipe.return_value = [{"generated_text": "out"}]
+        mock_pipeline.return_value = pipe
+
+        generate_text("a dog", device="cpu", model_name="m/from-hub", system_prompt=_spec())
+
+        messages = pipe.call_args[0][0]
+        self.assertEqual(messages[0], {"role": "system", "content": "expand the request"})
+```
+
+- [ ] **Step 2: Run them and watch them fail**
+
+Run: `venv/bin/python -m pytest tests/test_text_generation.py -v -n0 -k FromHub`
+Expected: ImportError on `resolve_system_prompt`.
+
+- [ ] **Step 3: Implement**
+
+At the top of `dw/tasks/text_generation.py`, add module-level imports (a module-level `hf_hub_download` is what the tests patch):
+
+```python
+import json
+import re
+from pathlib import PurePosixPath
+
+from huggingface_hub import hf_hub_download
+
+from ..locations import validate_hub_repo_id
+```
+
+If importing `..locations` here creates an import cycle (run the tests to see), import `validate_hub_repo_id` inside `resolve_system_prompt` instead.
+
+Add, above `generate_text`:
+
+```python
+# A pinned prompt has to stay pinned: a short hash can become ambiguous and a
+# branch moves, so only a full commit is accepted
+_FULL_COMMIT = re.compile(r"^[0-9a-f]{40}$")
+_FROM_HUB_FIELDS = {"repo", "file", "revision", "key"}
+
+
+def _hub_file(file):
+    """A file path inside a repo, refused if it could name anything outside it."""
+    if not isinstance(file, str) or not file or "\\" in file:
+        raise ValueError(f"system_prompt.from_hub.file must be a path inside the repo, got {file!r}")
+    path = PurePosixPath(file)
+    if path.is_absolute() or ".." in path.parts:
+        raise ValueError(f"system_prompt.from_hub.file must be a path inside the repo, got {file!r}")
+    return file
+
+
+def resolve_system_prompt(value):
+    """The system prompt text, reading it from a Hub repo when one is named.
+
+    Some vendors ship the instructions their model was trained against as a
+    file in its repo, and change them. Naming the file and a full commit runs
+    exactly that text without copying it into a workflow, where it would
+    drift from the source.
+
+    Args:
+        value: None, the text itself, or {"from_hub": {"repo", "file",
+            "revision", "key"}}. `revision` is a full 40-character commit.
+            A .json file takes `key` to pick one string out of a top-level
+            object; any other file is read whole as text
+
+    Raises:
+        ValueError: On any other shape, a revision that is not a full commit,
+            a file path that leaves the repo, a missing key, or a value that
+            is not text
+    """
+    if value is None or isinstance(value, str):
+        return value
+    if not isinstance(value, dict) or set(value) != {"from_hub"} or not isinstance(value["from_hub"], dict):
+        raise ValueError(
+            'system_prompt must be text or {"from_hub": {"repo", "file", "revision", "key"}}'
+        )
+    spec = value["from_hub"]
+    unknown = set(spec) - _FROM_HUB_FIELDS
+    if unknown:
+        raise ValueError(f"system_prompt.from_hub does not take {sorted(unknown)}")
+    repo = validate_hub_repo_id(spec.get("repo"), what="system_prompt.from_hub.repo")
+    file = _hub_file(spec.get("file"))
+    revision = spec.get("revision")
+    if not isinstance(revision, str) or not _FULL_COMMIT.match(revision):
+        raise ValueError(
+            "system_prompt.from_hub.revision must be a full 40-character lowercase "
+            f"commit hash, so the text cannot change under the workflow; got {revision!r}"
+        )
+    key = spec.get("key")
+
+    path = hf_hub_download(repo, file, revision=revision)
+    with open(path, encoding="utf-8") as f:
+        if file.endswith(".json"):
+            data = json.load(f)
+        else:
+            data = f.read()
+    if key is not None:
+        if not isinstance(data, dict) or key not in data:
+            keys = sorted(data) if isinstance(data, dict) else []
+            raise ValueError(
+                f"system_prompt.from_hub: {file} at {revision[:8]} has no key {key!r}; "
+                f"it has {keys}"
+            )
+        data = data[key]
+    if not isinstance(data, str) or not data.strip():
+        raise ValueError(
+            f"system_prompt.from_hub: {file}{'[' + repr(key) + ']' if key else ''} "
+            "is not text"
+        )
+    return data
+```
+
+In `generate_text`, replace `system_prompt = kwargs.get("system_prompt", None)` with:
+
+```python
+    # Resolved before anything loads, so a bad reference costs nothing
+    system_prompt = resolve_system_prompt(kwargs.get("system_prompt", None))
+```
+
+In `docs/TASKS.md`'s `text_generation` section, add the three Task 1 arguments and this paragraph with an example:
+
+```markdown
+`system_prompt` may name a file in a Hugging Face repo instead of carrying the text,
+for a vendor that ships its prompt instructions there:
+`{"from_hub": {"repo": "owner/name", "file": "system_prompts.json", "revision": "<40-hex commit>", "key": "t2i"}}`.
+The revision must be a full commit, so the text can't move under the workflow. A `.json`
+file takes `key` to pick one string; any other file is read whole.
+```
+
+- [ ] **Step 4: Run the tests**
+
+Run: `venv/bin/python -m pytest tests/test_text_generation.py -v -n0`
+Expected: all PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add dw/tasks/text_generation.py tests/test_text_generation.py docs/TASKS.md
+git commit -m "feat(text_generation): system_prompt from a Hub repo file at a pinned commit
+
+Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
+```
+
+---
+
+### Task 3: The upsampler builtins
+
+**Files:**
+- Create: `dw/workflows/flux3_klein_upsample.json`
+- Create: `dw/workflows/flux3_klein_upsample_edit.json`
+- Test: `tests/test_flux3_catalog.py` (new)
+
+**Interfaces:**
+- Consumes: `text_generation` arguments from Tasks 1-2; the `compose_text` task (`parts`, `separator`).
+- Produces: `builtin:flux3_klein_upsample.json` (variables `prompt`, `device`) and `builtin:flux3_klein_upsample_edit.json` (variables `instruction`, `images`, `device`). Each returns the caption text from its last step.
+
+- [ ] **Step 1: Write the failing test** (`tests/test_flux3_catalog.py`)
+
+```python
+"""The FLUX 3 Image Klein catalog: the upsampler builtins, the templates' settings
+and their placement. The vendor values here are the ones the design states
+(docs/superpowers/specs/2026-10-15-flux-3-klein-catalog-design.md)."""
+
+import json
+import os
+
+import pytest
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+BUILTINS = os.path.join(ROOT, "dw", "workflows")
+PUP = "black-forest-labs/flux-3-image-klein-pup"
+PUP_PIN = "3f3edb52b2c55de0d49feab28598b68f7f8e4830"
+
+
+def load(path):
+    with open(path) as f:
+        return json.load(f)
+
+
+def generation_steps(definition):
+    return [s for s in definition["steps"] if s.get("task", {}).get("command") == "text_generation"]
+
+
+@pytest.mark.parametrize("name,key", [
+    ("flux3_klein_upsample.json", "t2i"),
+    ("flux3_klein_upsample_edit.json", "i2i"),
+])
+def test_each_upsampler_runs_the_pinned_pup_as_bfl_does(name, key):
+    definition = load(os.path.join(BUILTINS, name))
+    (step,) = generation_steps(definition)
+    args = step["task"]["arguments"]
+    assert args["model_name"] == PUP
+    assert args["revision"] == PUP_PIN
+    assert args["system_prompt"] == {"from_hub": {
+        "repo": PUP, "file": "system_prompts.json", "revision": PUP_PIN, "key": key}}
+    assert args["chat_template_kwargs"] == {"enable_thinking": False}
+    assert args["max_new_tokens"] == 3584
+
+
+def test_the_edit_upsampler_wraps_the_instruction_in_bfl_s_scaffold():
+    definition = load(os.path.join(BUILTINS, "flux3_klein_upsample_edit.json"))
+    compose = next(s for s in definition["steps"] if s["task"]["command"] == "compose_text")
+    parts = compose["task"]["arguments"]["parts"]
+    assert parts == [
+        "Reference images follow in order (the first image, the second image, ...).\nUser request: ",
+        "variable:instruction",
+        "\nOutput the caption.",
+    ]
+    assert compose["task"]["arguments"]["separator"] == ""
+    (step,) = generation_steps(definition)
+    assert step["task"]["arguments"]["image"] == "variable:images"
+    assert step["task"]["arguments"]["repetition_penalty"] == 1.0
+    assert "bbfe317d" in definition["description"]
+```
+
+- [ ] **Step 2: Run it and watch it fail**
+
+Run: `venv/bin/python -m pytest tests/test_flux3_catalog.py -v -n0`
+Expected: FAIL, `FileNotFoundError`.
+
+- [ ] **Step 3: Write the two builtins**
+
+`dw/workflows/flux3_klein_upsample.json`:
+
+```json
+{
+    "id": "flux3_klein_upsample",
+    "description": "Expands a short request into the caption FLUX 3 Image Klein was trained on, with Black Forest Labs' own prompt upsampler, flux-3-image-klein-pup, a Qwen3.5-9B fine-tune. BFL says not to use Klein without it. The weights and the text-to-image system prompt are both pinned to pup commit 3f3edb52, and the prompt is read from the repo's system_prompts.json rather than copied. Thinking is switched off and decoding is greedy, as BFL runs it. BFL also applies a presence penalty of 1.5 for text-to-image, which transformers' generate() has no equivalent for, so it is left out. About 18 GB in bf16.",
+    "variables": {
+        "prompt": "A man walking with his dog, afternoon sun",
+        "device": "cuda"
+    },
+    "steps": [
+        {
+            "name": "upsample",
+            "task": {
+                "command": "text_generation",
+                "arguments": {
+                    "prompt": "variable:prompt",
+                    "model_name": "black-forest-labs/flux-3-image-klein-pup",
+                    "revision": "3f3edb52b2c55de0d49feab28598b68f7f8e4830",
+                    "system_prompt": {"from_hub": {
+                        "repo": "black-forest-labs/flux-3-image-klein-pup",
+                        "file": "system_prompts.json",
+                        "revision": "3f3edb52b2c55de0d49feab28598b68f7f8e4830",
+                        "key": "t2i"
+                    }},
+                    "chat_template_kwargs": {"enable_thinking": false},
+                    "max_new_tokens": 3584,
+                    "device": "variable:device"
+                }
+            },
+            "result": {"content_type": "text/plain", "save": false}
+        }
+    ]
+}
+```
+
+`dw/workflows/flux3_klein_upsample_edit.json` has the same shape, with these differences:
+- `id` `flux3_klein_upsample_edit`.
+- `variables`: `{"instruction": "put a red bandana around the dog's neck", "images": [], "device": "cuda"}`.
+- A first step `scaffold` with `"command": "compose_text"`, `"arguments": {"parts": [<the three parts from the test>], "separator": ""}`, and `"result": {"content_type": "text/plain", "save": false}`.
+- The `upsample` step uses `"prompt": "previous_result:scaffold"`, `"image": "variable:images"`, `"repetition_penalty": 1.0` and `"key": "i2i"`.
+- The description says the upsampler sees every reference in order, as the pipeline will, and that the scaffold's three lines are BFL's `I2I_SCAFFOLD` from `src/flux3/pup.py` at commit bbfe317d in github.com/black-forest-labs/flux-3-image-klein. It also says BFL resizes each reference to a pixel budget (1 MP for one reference, 724x724 for two, 512x512 for three or more) before the upsampler sees it, while transformers' processor applies its own sizing, so the two can describe small details differently.
+
+- [ ] **Step 4: Run the test and the library tests**
+
+Run: `venv/bin/python -m pytest tests/test_flux3_catalog.py tests/test_library_path.py tests/test_library_sources.py -v -n0`
+Expected: PASS.
+
+Then validate each builtin against the schema: `venv/bin/python -m dw.validate dw/workflows/flux3_klein_upsample.json` and the same for `flux3_klein_upsample_edit.json`. Expected: valid.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add dw/workflows/flux3_klein_upsample.json dw/workflows/flux3_klein_upsample_edit.json tests/test_flux3_catalog.py
+git commit -m "feat(flux3): Klein prompt-upsampler builtins on the pinned pup
+
+Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
+```
+
+---
+
+### Task 4: Text-to-image template, model entry and stored prompt
+
+**Files:**
+- Create: `prompts/flux3/man_dog.json`
+- Create: `workflows/templates/flux3/text-to-image.json`
+- Create: `workflows/models/flux3-klein.json`
+- Test: `tests/test_flux3_catalog.py`
+
+**Interfaces:**
+- Produces: the Klein pipeline step shape every later template copies:
+
+```json
+{
+    "name": "text_to_image",
+    "pipeline": {
+        "configuration": {
+            "component_type": "ModularPipeline",
+            "load_components": {"dtype": "torch.bfloat16"},
+            "components": {
+                "transformer": {"device": "cuda"},
+                "text_encoder": {"device": "cuda"},
+                "vae": {"device": "cuda"}
+            }
+        },
+        "from_pretrained_arguments": {"model_name": "black-forest-labs/flux-3-image-klein"},
+        "arguments": {
+            "prompt": "variable:prompt",
+            "width": "variable:width",
+            "height": "variable:height",
+            "num_inference_steps": 16,
+            "output": "images"
+        }
+    },
+    "result": {"content_type": "image/jpeg", "embed_metadata": true, "subfolder": "final"}
+}
+```
+
+- [ ] **Step 1: Write the failing tests** (append to `tests/test_flux3_catalog.py`)
+
+```python
+TEMPLATES = os.path.join(ROOT, "workflows", "templates", "flux3")
+KLEIN = "black-forest-labs/flux-3-image-klein"
+
+
+def klein_steps(definition):
+    return [s for s in definition["steps"]
+            if s.get("pipeline", {}).get("from_pretrained_arguments", {}).get("model_name") == KLEIN]
+
+
+def flux3_definitions():
+    paths = [os.path.join(TEMPLATES, n) for n in sorted(os.listdir(TEMPLATES)) if n.endswith(".json")]
+    paths.append(os.path.join(ROOT, "workflows", "models", "flux3-klein.json"))
+    return paths
+
+
+@pytest.mark.parametrize("path", flux3_definitions())
+def test_every_flux3_pipeline_step_places_every_component(path):
+    steps = klein_steps(load(path))
+    assert steps, f"{path} runs no Klein step"
+    for step in steps:
+        components = step["pipeline"]["configuration"]["components"]
+        for name in ("transformer", "text_encoder", "vae"):
+            assert components.get(name, {}).get("device") == "cuda", (path, name)
+        assert components["text_encoder"].get("residency") is None
+
+
+@pytest.mark.parametrize("path", flux3_definitions())
+def test_every_klein_step_runs_the_distilled_schedule_without_guidance(path):
+    for step in klein_steps(load(path)):
+        args = step["pipeline"]["arguments"]
+        assert args["num_inference_steps"] == 16
+        assert "guidance_scale" not in args and "negative_prompt" not in args
+        assert args["output"] == "images"
+
+
+@pytest.mark.parametrize("path", flux3_definitions())
+def test_size_variables_are_held_to_the_16_pixel_grid(path):
+    definition = load(path)
+    constraints = definition.get("variable_constraints", {})
+    for name in ("width", "height"):
+        if name in definition.get("variables", {}):
+            assert constraints[name]["modulus"] == 16 and constraints[name].get("remainder", 0) == 0
+
+
+def test_the_16_pixel_grid_and_16_step_default_are_the_pipeline_s():
+    import inspect
+    from diffusers.modular_pipelines.flux3 import before_denoise, modular_blocks_flux3_distilled
+    assert "num_inference_steps" in inspect.getsource(modular_blocks_flux3_distilled)
+    assert "16" in inspect.getsource(modular_blocks_flux3_distilled)
+    assert "vae_scale_factor * 2" in inspect.getsource(before_denoise)
+```
+
+- [ ] **Step 2: Run them and watch them fail**
+
+Run: `venv/bin/python -m pytest tests/test_flux3_catalog.py -v -n0`
+Expected: collection error (the `flux3` templates folder doesn't exist).
+
+- [ ] **Step 3: Write the files**
+
+`prompts/flux3/man_dog.json`: `{"text": "<BFL's upsampled man_dog caption>"}`. Copy the `prompt` field of `examples/distilled/man_dog.json` in github.com/black-forest-labs/flux-3-image-klein at bbfe317d byte for byte (`gh api "repos/black-forest-labs/flux-3-image-klein/contents/examples/distilled/man_dog.json?ref=bbfe317dd81c825c30d76090a67d3d0db51da3cc" --jq .content | base64 -d`). It's the vendor's example caption, already the length and form the model was trained on. Match the other files' shape in `prompts/` (`cat prompts/kandinsky6/mountain_steam_train.json`).
+
+`workflows/templates/flux3/text-to-image.json`:
+
+```json
+{
+    "id": "Flux3KleinT2I",
+    "description": "FLUX 3 Image Klein (distilled, 5.6B) text to image: the family's baseline. The prompt here is already a full caption - BFL's own upsampled caption for their man walking a dog example - because Klein was trained on long upsampler captions and turns short prompts into generic pictures; upsample-then-generate shows how to get one from a short request. Sixteen steps with no guidance: the distilled model is a flow map, so it takes no guidance scale and no negative prompt. Width and height must be multiples of 16, up to 4096. Every component is placed on the GPU explicitly, about 19 GB of bf16 weights, which fits a 24 GB card at 1024x1024 with under 2 GB to spare. The weights are gated under the FLUX Kommunity License: accept it on the model page and log in with hf auth login first.",
+    "summary": "<one line under the summary cap; see test_every_template_has_a_summary_that_fits>",
+    "cost_drivers": ["width", "height"],
+    "variables": {
+        "prompt": "prompt:flux3/man_dog",
+        "width": 1024,
+        "height": 1024,
+        "seed": 7
+    },
+    "variable_constraints": {
+        "width": {"modulus": 16, "remainder": 0, "reason": "FLUX 3 Image Klein's pipeline refuses a width not divisible by 16 (the VAE's 8x compression times the 2x2 latent packing), and only after the weights have loaded, so it is checked here first"},
+        "height": {"modulus": 16, "remainder": 0, "reason": "FLUX 3 Image Klein's pipeline refuses a height not divisible by 16 (the VAE's 8x compression times the 2x2 latent packing), and only after the weights have loaded, so it is checked here first"}
+    },
+    "seed": "variable:seed",
+    "steps": ["<the Klein step from Interfaces>"]
+}
+```
+
+`workflows/models/flux3-klein.json`: the same Klein step with `"configures": "templates/text-to-image"`. Copy `variables` and `cost_drivers` from `workflows/templates/text-to-image.json` (`prompt` there is a short prompt, and the description says so: generic output without the upsampler). Add a `width`/`height` pair and their constraints only if that template declares them. Its description names the gated license and points at `templates/flux3/upsample-then-generate` for full captions.
+
+Fill `summary` to pass `test_every_template_has_a_summary_that_fits`.
+
+- [ ] **Step 4: Run the catalog tests**
+
+Run: `venv/bin/python -m pytest tests/test_flux3_catalog.py tests/test_catalog_structure.py tests/test_catalog_shape.py tests/test_template_defaults.py tests/test_template_subfolders.py tests/test_prompt_library.py tests/test_prompt_references.py -v -n0`
+Expected: all PASS. If only `test_the_compact_listing_fits_the_budget` fails, stop and report its numbers (Global Constraints).
+
+Then: `venv/bin/python -m dw.validate workflows/templates/flux3/text-to-image.json` and the same for `workflows/models/flux3-klein.json`. Expected: valid.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add prompts/flux3/man_dog.json workflows/templates/flux3/text-to-image.json workflows/models/flux3-klein.json tests/test_flux3_catalog.py
+git commit -m "feat(flux3): Klein text-to-image template and model entry
+
+Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
+```
+
+---
+
+### Task 5: Upsample-then-generate template
+
+**Files:**
+- Create: `workflows/templates/flux3/upsample-then-generate.json`
+- Test: `tests/test_flux3_catalog.py`
+
+**Interfaces:**
+- Consumes: `builtin:flux3_klein_upsample.json` (Task 3) and the Klein step (Task 4).
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+def test_upsample_then_generate_feeds_the_builtin_caption_to_klein():
+    definition = load(os.path.join(TEMPLATES, "upsample-then-generate.json"))
+    first, second = definition["steps"]
+    assert first["workflow"]["path"] == "builtin:flux3_klein_upsample.json"
+    assert first["release_models"] is True
+    assert second["pipeline"]["arguments"]["prompt"] == f"previous_result:{first['name']}"
+```
+
+- [ ] **Step 2: Run it and watch it fail**
+
+Run: `venv/bin/python -m pytest tests/test_flux3_catalog.py -v -n0 -k upsample_then`
+Expected: FAIL, file not found.
+
+- [ ] **Step 3: Write the template**
+
+Steps: `upsample` (`"workflow": {"path": "builtin:flux3_klein_upsample.json", "arguments": {"prompt": "variable:request"}}`, `"release_models": true`, result `text/plain`, `subfolder` `intermediate`), then the Klein step (Task 4 Interfaces) with `"prompt": "previous_result:upsample"`. Variables: `request` ("A man walking with his dog, afternoon sun"), `width`, `height`, `seed` 7, with the Task 4 constraints. The description says why `release_models` is there: the 18 GB upsampler and the 19 GB generator don't fit a 24 GB card together, so the upsampler is released before Klein loads. It also says the caption is saved as an intermediate so it can be reused.
+
+- [ ] **Step 4: Run the catalog tests and validate**
+
+Run: `venv/bin/python -m pytest tests/test_flux3_catalog.py tests/test_catalog_structure.py -v -n0 && venv/bin/python -m dw.validate workflows/templates/flux3/upsample-then-generate.json`
+Expected: PASS and valid.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add workflows/templates/flux3/upsample-then-generate.json tests/test_flux3_catalog.py
+git commit -m "feat(flux3): upsample-then-generate template
+
+Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
+```
+
+---
+
+### Task 6: Probe P3, then the edit and multi-reference templates
+
+**Files:**
+- Create: `workflows/templates/flux3/image-edit.json`
+- Create: `workflows/templates/flux3/multi-reference.json`
+- Modify: `docs/superpowers/specs/2026-10-15-flux-3-klein-catalog-design.md` (P3 row)
+- Test: `tests/test_flux3_catalog.py`
+
+**Interfaces:**
+- Consumes: `builtin:flux3_klein_upsample_edit.json` (Task 3) and the Klein step (Task 4).
+
+- [ ] **Step 1: Probe how a list of images reaches the pipeline (lem, through the dw MCP)**
+
+The Klein pipeline's `image` takes a PIL image or a list of them (`encoders.py:84` refuses anything else). Before writing the templates, find out whether a variable holding `[{"location": "<url>"}, {"location": "<url>"}]` arrives as a list of PIL images. Validate and run, on lem, the Task 4 step with `"image": "variable:images"` added, `images` set to two image URLs (any two public JPEGs), and a prompt naming `<ref_image_0>` and `<ref_image_1>`. Quote the plan's estimate and get Don's go-ahead first. Record the job id and the result in the spec's P3 row, along with peak memory from `get_job_events(kinds=["memory"])`. If the list doesn't load, stop and report: the fix is engine work outside this plan.
+
+- [ ] **Step 2: Write the failing tests**
+
+```python
+@pytest.mark.parametrize("name", ["image-edit.json", "multi-reference.json"])
+def test_the_edit_templates_show_the_upsampler_the_pipeline_s_references(name):
+    definition = load(os.path.join(TEMPLATES, name))
+    upsample = next(s for s in definition["steps"] if "workflow" in s)
+    assert upsample["workflow"]["path"] == "builtin:flux3_klein_upsample_edit.json"
+    (klein,) = klein_steps(definition)
+    assert upsample["workflow"]["arguments"]["images"] == klein["pipeline"]["arguments"]["image"]
+    assert klein["pipeline"]["arguments"]["prompt"] == f"previous_result:{upsample['name']}"
+
+
+def test_multi_reference_states_the_ten_reference_cap_and_the_naming():
+    description = load(os.path.join(TEMPLATES, "multi-reference.json"))["description"]
+    assert "10 references" in description
+    assert "<ref_image_0>" in description
+```
+
+- [ ] **Step 3: Run them and watch them fail**
+
+Run: `venv/bin/python -m pytest tests/test_flux3_catalog.py -v -n0 -k "edit_templates or ten_reference"`
+Expected: FAIL, files not found.
+
+- [ ] **Step 4: Write the templates**
+
+`image-edit.json`: variables `instruction` ("put a red bandana around the dog's neck", BFL's example), `image` (a `{"location": ...}` reference; use the same public dog photo P3 used), `seed` 22, no width/height (diffusers defaults the output to 1 MP at the reference's aspect ratio, rounded to 16, and the description says so). Steps: `upsample` → `builtin:flux3_klein_upsample_edit.json` with `"images": ["variable:image"]` and `"instruction": "variable:instruction"`, `release_models: true`; then the Klein step with `"image": ["variable:image"]` and `"prompt": "previous_result:upsample"`.
+
+`multi-reference.json`: the same, with `images` a list variable of two references, `instruction` "print the dog from the second image onto the mug" (BFL's example), seed 23. Both the builtin and the Klein step read `"variable:images"`. The description states: references are named `<ref_image_0>`, `<ref_image_1>`, … (zero-based) in a caption written by hand, while the upsampler's own wording is "the first image, the second image"; the first reference sets the output's aspect ratio; and BFL trained Klein on up to 10 references, a cap the pipeline doesn't enforce, so more than 10 runs but is outside what the model learned.
+
+Add `"cost_drivers"` naming the image variable(s).
+
+- [ ] **Step 5: Run the catalog tests and validate both**
+
+Run: `venv/bin/python -m pytest tests/test_flux3_catalog.py tests/test_catalog_structure.py -v -n0 && venv/bin/python -m dw.validate workflows/templates/flux3/image-edit.json && venv/bin/python -m dw.validate workflows/templates/flux3/multi-reference.json`
+Expected: PASS and valid.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add workflows/templates/flux3/image-edit.json workflows/templates/flux3/multi-reference.json tests/test_flux3_catalog.py docs/superpowers/specs/2026-10-15-flux-3-klein-catalog-design.md
+git commit -m "feat(flux3): image-edit and multi-reference templates
+
+Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
+```
+
+---
+
+### Task 7: Layout-with-boxes template
+
+**Files:**
+- Create: `workflows/templates/flux3/layout-boxes.json`
+- Create: `prompts/flux3/balloons_layout.json`
+- Test: `tests/test_flux3_catalog.py`
+
+Scope note: BFL's box upsampling (`t2i_bbox`) goes through extra scaffolding in their `bbox.plan`/`bbox.reconcile` code. This template takes a caption written in the box format directly, as the Hugging Face card shows. Upsampled boxes are a dated follow-up.
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+def test_the_layout_caption_carries_tags_and_a_0_to_1000_box_table():
+    import re
+    with open(os.path.join(ROOT, "prompts", "flux3", "balloons_layout.json")) as f:
+        text = json.load(f)["text"]
+    table = json.loads(text[text.index("["):])
+    assert table and all({"id", "bbox", "desc"} <= set(row) for row in table)
+    for row in table:
+        assert f"<{row['id']}>" in text
+        top, left, bottom, right = row["bbox"]
+        assert 0 <= top < bottom <= 1000 and 0 <= left < right <= 1000
+    assert klein_steps(load(os.path.join(TEMPLATES, "layout-boxes.json")))
+```
+
+- [ ] **Step 2: Run it and watch it fail**
+
+Run: `venv/bin/python -m pytest tests/test_flux3_catalog.py -v -n0 -k layout`
+Expected: FAIL, file not found.
+
+- [ ] **Step 3: Write the prompt and template**
+
+`prompts/flux3/balloons_layout.json`: a caption in BFL's box format (see the audit's *Prompt format → Layout / JSON* and https://docs.bfl.ml/flux_3/flux3_image_bounding_boxes). That's prose naming each boxed element as `<id>`, then a JSON array of `{"id", "bbox": [top, left, bottom, right] on 0-1000, "desc"}`. Base it on BFL's `examples/inputs/balloons_boxes.json` at bbfe317d, converting its 0-1 floats to 0-1000 integers. Write the prose yourself: the example file holds boxes, not the caption.
+
+`layout-boxes.json`: the Task 4 template shape with `"prompt": "prompt:flux3/balloons_layout"` and seed 7. The description says boxes are a hint, not a mask: small boxed elements may not appear, and elements can run past their box.
+
+- [ ] **Step 4: Run the catalog tests and validate**
+
+Run: `venv/bin/python -m pytest tests/test_flux3_catalog.py tests/test_catalog_structure.py tests/test_prompt_library.py -v -n0 && venv/bin/python -m dw.validate workflows/templates/flux3/layout-boxes.json`
+Expected: PASS and valid.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add workflows/templates/flux3/layout-boxes.json prompts/flux3/balloons_layout.json tests/test_flux3_catalog.py
+git commit -m "feat(flux3): layout-with-boxes template
+
+Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
+```
+
+---
+
+### Task 8: Family README
+
+**Files:**
+- Create: `workflows/templates/flux3/README.md`
+- Test: the existing README link checks (`grep -rln "README" tests/ | head` to find them; `tests/test_plugin_skills.py` and `tests/test_catalog_structure.py` are likely)
+
+- [ ] **Step 1: Write the README**
+
+Follow `workflows/templates/kandinsky6/README.md`:
+- **First paragraph:** the model (5.6B distilled flow map, 16 steps, no guidance; the FLUX.2 VAE; the Qwen3-VL-4B text encoder), the sources (the Hugging Face card, github.com/black-forest-labs/flux-3-image-klein, docs.bfl.ml, diffusers `modular_pipelines/flux3`, merged 2026-10-15 and not yet released, so diffusers must be installed from git), the gated FLUX Kommunity License, and a link to `../../../docs/proposals/audits/2026-10-15-flux-3-klein-audit.md`.
+- **A prompt paragraph:** BFL says not to use Klein without its upsampler, and the upsampler builtins read BFL's system prompts from the pup repo at a pinned commit. For writing captions by hand, link BFL's prompting guide (https://docs.bfl.ml/guides/prompting_summary) and note it's written for the API model, which upsamples on the server side.
+- **A reading-order table:** text-to-image, upsample-then-generate, image-edit, multi-reference, layout-boxes, one idea each.
+- **A placement note** marked as dw craft: every component placed explicitly, and why.
+- **The agent pointer** to the `flux3-klein` skill of the dw plugin.
+
+- [ ] **Step 2: Run the link and catalog tests**
+
+Run: `venv/bin/python -m pytest tests/test_catalog_structure.py tests/test_plugin_skills.py -v -n0`
+Expected: PASS.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add workflows/templates/flux3/README.md
+git commit -m "docs(flux3): Klein templates README
+
+Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
+```
+
+---
+
+### Task 9: GPU runs and costs (lem)
+
+**Files:**
+- Modify: every `workflows/templates/flux3/*.json` and `workflows/models/flux3-klein.json` (`cost`)
+- Modify: the spec's probe table
+
+- [ ] **Step 1: Deploy the branch to lem**
+
+Ask Don to deploy `feat/flux3-klein` to lem (the auto-mode classifier refuses `deploy.sh` over ssh). Then confirm with `get_diffusers_state` that the commit is at or after 7ecb1e1b. If `update_diffusers` was used, `dw-serve` must be restarted before validation sees the new classes.
+
+- [ ] **Step 2: Run each template once warm**
+
+For each template: `validate_workflow` with `workflow_path` set to the catalog name, quote the estimate, get Don's go-ahead (one batch approval for all five is fine), then `run_workflow`, `wait_for_job`, `get_job`, and look at each output (`get_output_image`, `get_output_text` for captions). Run each one a second time to get a warm timing, since the first run loads the models.
+
+- [ ] **Step 3: Write `cost`**
+
+Add `"cost": [{"device": "cuda", "name": "RTX 3090", "vram_gb": 24, "minutes": <warm minutes, one decimal, rounded up>}]` to each template and the model entry. Record each job id, warm minutes and peak reserved memory in the spec's probe table.
+
+- [ ] **Step 4: Run the catalog tests, then commit**
+
+Run: `venv/bin/python -m pytest tests/test_catalog_structure.py tests/test_flux3_catalog.py -v -n0`
+
+```bash
+git add workflows/templates/flux3 workflows/models/flux3-klein.json docs/superpowers/specs/2026-10-15-flux-3-klein-catalog-design.md
+git commit -m "feat(flux3): measured RTX 3090 costs
+
+Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
+```
+
+---
+
+### Task 10: The `flux3-klein` composition skill
+
+**Files:**
+- Create: `plugins/dw/skills/flux3-klein/SKILL.md`
+- Modify: `plugins/dw/README.md` (name the skill)
+- Modify: `CLAUDE.md` (the plugin paragraph lists every skill)
+- Modify: `tests/test_plugin_skills.py` (new `TestFlux3KleinSkill`)
+
+- [ ] **Step 1: Write the failing tests** (append to `tests/test_plugin_skills.py`)
+
+```python
+FLUX3_SKILL = os.path.join(PLUGIN_DIR, "skills", "flux3-klein", "SKILL.md")
+
+
+class TestFlux3KleinSkill:
+    """The Klein skill's numbers come from the diffusers modular blocks that
+    enforce them; the 10-reference cap is the vendor's, which the pipeline
+    does not enforce, and the skill says so."""
+
+    def test_the_step_count_and_grid_are_the_pipeline_s(self):
+        import inspect
+        from diffusers.modular_pipelines.flux3 import before_denoise, modular_blocks_flux3_distilled
+        text = skill_text(FLUX3_SKILL)
+        assert "16" in inspect.getsource(modular_blocks_flux3_distilled)
+        assert "vae_scale_factor * 2" in inspect.getsource(before_denoise)
+        assert "16 steps" in text
+        assert "multiples of 16" in text
+
+    def test_the_distilled_model_takes_no_guidance(self):
+        assert "no guidance" in skill_text(FLUX3_SKILL)
+
+    def test_the_reference_cap_is_stated_as_the_vendor_s(self):
+        text = skill_text(FLUX3_SKILL)
+        assert "10 references" in text and "<ref_image_0>" in text
+
+    def test_the_skill_defers_prompt_format_to_bfl(self):
+        text = skill_text(FLUX3_SKILL)
+        assert "docs.bfl.ml" in text
+        assert "flux3_klein_upsample" in text
+
+    def test_the_skill_starts_with_the_server(self):
+        text = skill_text(FLUX3_SKILL)
+        assert text.index("get_server_info") < text.index("list_workflows")
+```
+
+Read the existing `TestKandinsky6Skill` and `skill_text` helper first and match their style. If the parametrized skill tests (size cap, links, catalog names) already pick up every `SKILL.md` under `plugins/dw/skills/`, they cover the new file with no change.
+
+- [ ] **Step 2: Run them and watch them fail**
+
+Run: `venv/bin/python -m pytest tests/test_plugin_skills.py -v -n0 -k Flux3`
+Expected: FAIL, file not found.
+
+- [ ] **Step 3: Write the skill**
+
+Start from a copy of `plugins/dw/skills/kandinsky-6/SKILL.md` and replace every section:
+- **Frontmatter `description`:** written for triggering ("Use when a dw MCP server is connected and the user wants an image from FLUX 3 Image Klein - a picture from a request, an edit of their photo, several references combined, or a layout with boxes…").
+- **Start with the server:** `get_server_info`, then `list_workflows(shape="image")` / `shape="image-edit"`.
+- **The shape decision:** short request → upsample-then-generate; full caption → text-to-image; one photo to change → image-edit; several → multi-reference; positions → layout-boxes.
+- **Hard rules:** 16 steps, no guidance, multiples of 16, up to 4096, 10 references named `<ref_image_N>`, gated license and `hf auth login`, explicit placement.
+- **Prompts:** use the upsampler builtins (`flux3_klein_upsample`, `flux3_klein_upsample_edit`), and for hand-written captions BFL's guide at docs.bfl.ml. Nothing transcribed.
+- **Validate, quote cost, run, look.**
+- **Failure modes:** generic output from short prompts without the upsampler; boxes are hints; edits can change content outside the requested region; small reference details can be misdescribed.
+- **Sources with dates.**
+
+Keep it under the 12 KB cap.
+
+Add the skill to `plugins/dw/README.md`'s list and to `CLAUDE.md`'s plugin paragraph (one composition skill per model family: add `flux3-klein`).
+
+- [ ] **Step 4: Run the plugin tests**
+
+Run: `venv/bin/python -m pytest tests/test_plugin_skills.py -v -n0`
+Expected: all PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add plugins/dw/skills/flux3-klein plugins/dw/README.md CLAUDE.md tests/test_plugin_skills.py
+git commit -m "feat(plugin): flux3-klein composition skill
+
+Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
+```
+
+---
+
+### Task 11: Full suite, cold drill, close
+
+- [ ] **Step 1: Full suite and lint**
+
+Run: `venv/bin/python -m pytest tests/ -q` and `venv/bin/ruff check dw tests`
+Expected: all pass, no lint errors.
+
+- [ ] **Step 2: Cold drill**
+
+Follow `.claude/skills/model-family-onboarding/references/cold-drill-example.md`. Use lem on this branch with `dw-serve` restarted, a fresh Claude Code session in an empty directory with the plugin installed, and the request "make me a picture of a lighthouse keeper's cat on a stormy night". Run a control without the plugin. Record both transcripts' paths and the verdict (the skill fired, upsample-then-generate was chosen, cost was quoted before the run, the image was looked at) in the spec.
+
+- [ ] **Step 3: Follow-ups in the spec, dated**
+
+The spec's *Follow-ups* section holds these; add any new ones:
+- Base + CFG (`guider`)
+- fp8r/NVFP4
+- LoRA at 0.75
+- typography
+- MPS on mini-ai
+- upsampled boxes (`t2i_bbox`)
+- a list-length constraint for the 10-reference cap
+- the `downloads_required` gaps
+- re-pinning the system prompts and the scaffold when diffusers PR #15058 merges
+
+- [ ] **Step 4: Hand off**
+
+Use superpowers:finishing-a-development-branch.
diff --git a/docs/superpowers/plans/2026-10-16-develop-followups.md b/docs/superpowers/plans/2026-10-16-develop-followups.md
new file mode 100644
index 00000000..4f34679e
--- /dev/null
+++ b/docs/superpowers/plans/2026-10-16-develop-followups.md
@@ -0,0 +1,68 @@
+# Develop follow-ups after FLUX 3 Klein (#930), 2026-10-15
+
+What is still owed on develop once #930 is merged. Order is by risk, then by what unblocks what.
+Owner `don` means the step needs a ruling or a hand on lem; everything else an agent can do.
+
+## 1. Security: the remaining `generate()` kwargs splats (agent, then don)
+
+#930 closed the `custom_generate` + `trust_remote_code` hole in `text_generation`. The same
+pattern is still open elsewhere, and has been in every release since a0e8cb15.
+
+- [x] `dw/tasks/speech_generation.py:190-219` - `forward_params` and `generate_kwargs` reach the
+      transformers pipeline unfiltered. Reuse the text_generation filter (`custom_generate`,
+      `trust_remote_code` gated on `dw/trust.py`; structural keys and non-scalars refused).
+      Test with an untrusted workflow that sets each key.
+- [ ] `dw/tasks/image_utils.py:84-124` - `repo_kwargs` / `call_kwargs` / `kwargs` splat into
+      `controlnet_aux` `from_pretrained` and the detector call. Audit which keys can load code or
+      reach the network (`trust_remote_code`, `cache_dir`, `filename`, a repo id) and allowlist.
+- [ ] Sweep for any other `**kwargs` into `from_pretrained`/`generate`/`pipeline(...)` in
+      `dw/tasks/` (grep), record the result in docs/SECURITY.md.
+- [ ] **don:** GHSA for the released exposure (0.x through 0.14.0)? Fix ships in 0.14.1 or 0.15.0.
+
+## 2. Finish Klein on lem (don deploys, agent runs)
+
+- [ ] **don:** deploy develop to lem (diffusers must stay at or after 7ecb1e1b; restart dw-serve
+      after any `update_diffusers`).
+- [ ] Task 9: warm `cost` blocks for the five `workflows/templates/flux3/` templates and the
+      model entry, from one GPU run each. Check the compact listing stays under 11_400.
+- [ ] diffusers main has moved past 7ecb1e1b: the upsampler step (PR #15058) appears merged
+      (d42ebf9c touches `modular_pipelines/flux3/prompt_upsampler.py`). The audit and the family
+      README still call it open. Check before pinning, and decide whether the builtin upsampler
+      should move to it.
+- [ ] Fold in the parked doc fix: docs/TASKS.md `generate_kwargs` row still says "merged last,
+      overrides the settings above" though `max_new_tokens`/`max_length` are now reserved.
+- [ ] Task 11: cold drill with the `flux3-klein` plugin skill, plus a control without it.
+- [ ] Delete `.superpowers/sdd/2026-10-15-flux3-klein-catalog/` once 9 and 11 are done.
+
+## 3. Engine gaps found during Klein (agent)
+
+- [ ] `validate_workflow` `downloads_required` is empty for uncached modular-pipeline and task
+      repos, then over-counts `variants/` (40.3 GB for Klein). Size from the files the loader
+      will actually fetch.
+- [ ] `update_diffusers` leaves the running server on a half-old diffusers import (validation
+      raises RuntimeError) until dw.serve restarts. Same gap as #663. Either restart the worker
+      and refuse admission until it does, or say so in the tool result. **don** picks which.
+
+## 4. #928 roles (don)
+
+- [ ] gilded-echoes' outputs stay `final` until its assembly run consumes them (Don chose to
+      wait). Post the mini-ai diagnosis on #928 so the issue says why it looks unfixed.
+- [ ] Decide on the `set_role` override (MCP tool + gallery toggle, sidecar beside notes) for
+      0.15.0, or close #928 after the assembly run.
+
+## 5. Release housekeeping (don)
+
+- [ ] v0.14.0's GitHub release body is the auto-generated stub. Paste the notes from
+      docs/RELEASING.md (`gh release edit v0.14.0 --notes-file ...`).
+- [ ] Deploy 0.14.0 to lem if it is not already there (mini-ai was deployed 21:19).
+
+## 6. Parked guided-editing proposal
+
+- `feat/guided-editing` holds `docs/proposals/guided-editing.md` (options only). Pick it up
+  when wanted; nothing on develop depends on it.
+
+## 7. Parked, no action unless asked
+
+- `generate_kwargs` refuses lists of lists, so `bad_words_ids` cannot be set.
+- Klein README thinking-mode line could cite the pup card.
+- Template summary trim candidates (about 40 tokens total).
diff --git a/docs/superpowers/plans/2026-10-17-h3-sparse-attention.md b/docs/superpowers/plans/2026-10-17-h3-sparse-attention.md
new file mode 100644
index 00000000..f3629dfa
--- /dev/null
+++ b/docs/superpowers/plans/2026-10-17-h3-sparse-attention.md
@@ -0,0 +1,452 @@
+# H3 Sparse Attention Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Make `sparse` (comfy-kitchen `sol_attn`, tau 0.5) the default attention for MiniMax H3's generated-video rows on CUDA. It falls back to dense everywhere else. The server reports which backends it can run, and the UI offers them as a dropdown.
+
+**Architecture:** A new `dw/sparse_attention.py` holds the tile map, the processor and the per-call decision. It attaches to a `MiniMaxH3Transformer3DModel` by replacing the processors on `transformer_blocks[*].attn`, and by adding an `nn.Module` forward pre-hook and post-hook. The hooks read `token_tags`/`position_ids`; the transformer's `forward` is never wrapped. `attention_backend: "sparse"` is intercepted before diffusers sees it, both at component level (`components.py`) and at pipeline level (`pipeline.py`). Every pipeline call enters `sparse_call(...)`. That context decides sparse or dense once, before the first forward, and emits the run-time fallback warning.
+
+**Tech Stack:** Python 3.12, PyTorch, diffusers 0.41 dev (modular MiniMax-H3), comfy-kitchen 0.2.38, FastAPI/Pydantic, Svelte 5 + Vitest.
+
+**Spec:** `docs/superpowers/specs/2026-10-17-h3-sparse-attention-design.md`. Evidence is on issue #931. The prototype it ported was `docs/superpowers/plans/931/h3_sol_proto.py`, removed after stage 3 (in git history before that commit).
+
+## Global Constraints
+
+- **Backend name:** `sparse`. Tau setting: `sparse_tau`, default `0.5`. Validate warning code: `sparse_attention_fallback`.
+- **Dependency:** `comfy-kitchen>=0.2.38` in `pyproject.toml` `dependencies`. It's the single dependency source; `install.sh` installs `-e ".[server,dev]"`.
+- **Kernel requirements:** CUDA sm_80+ (or HIP with matrix cores), bf16/fp16, head_dim 128. The check is `comfy_kitchen.sol_attn_is_available(device)`.
+- **Sparse never refuses and never fails a run that dense would have run.**
+- **Decided once per pipeline call, all or nothing.** A check that fails after the decision raises; it never drops that forward to dense.
+- **Target video = the trailing run of video rows** (`token_tags == 0` after the last non-video row).
+- **Tile coordinates come from ranking each axis's distinct `position_ids` values.** Tiles are 4x4x4 (64 rows). Prefix tiles are segment-pure, at most 64 rows each, and listed first. `sink_blocks = sink_q = [0, num_prefix_tiles]`.
+- **No model knowledge beyond the class name `MiniMaxH3Transformer3DModel`** and the layout tensors diffusers passes it.
+- **`sparse` never changes diffusers' process-wide active backend**, and is never added to `CUDA_ONLY_ATTENTION_BACKENDS`.
+- **The server process must not initialize CUDA** to answer which backends it can run: `torch.cuda.is_initialized()` stays `False`.
+- **`sparse_tau` is a runtime setting**, like a LoRA scale: excluded from `weights_identity`, and re-applied on a pipeline-cache hit.
+- **Security rules from CLAUDE.md apply**; no new file, URL or subprocess surface.
+- **Ratchets** (modules count, `test_dw_patch_targets`, catalog budgets) are moved only in their own commit, with the reason.
+
+## Review Focus
+
+1. **A cached H3 transformer re-used with a different backend.** The worker keeps models between jobs. A job asking for `sage_hub` or none, after a `sparse` job on the same weights, must run without the sparse processors. Owned by Task 4: `test_non_sparse_backend_uninstalls_sparse`.
+2. **Pipeline-level `attention_backend: "sparse"` on a non-H3 pipeline** (SD 1.5, FLUX, LTX). It must run dense and warn once, and must never pass the string `sparse` to diffusers' `attention_backend()` context, which would raise. Owned by Task 4: `test_pipeline_level_sparse_on_non_h3_runs_dense`.
+3. **A Mac (MPS) H3 run with the template default.** Validate gives one `sparse_attention_fallback` warning, not `attention_backend_unavailable`, and the run completes dense. Owned by Tasks 3 and 5: `test_fallback_on_non_cuda_device`, `test_sparse_on_mps_warns_fallback_not_unavailable`.
+4. **A chained or multi-segment H3 job** (`chained-segments`, `shots-batch`). Each pipeline call decides afresh, and a later call can't inherit a stale tile map from a previous segment's shape. Owned by Task 3: `test_tile_map_rebuilt_when_layout_changes`, `test_each_call_decides_afresh`.
+5. **The text token refiner and a Ref2VA reference image** must stay dense and exact: only `transformer_blocks[*].attn` is swapped, and reference rows go into the dense prefix. Owned by Tasks 2 and 3: `test_ref2va_reference_rows_in_prefix`, `test_refiner_processors_untouched`.
+
+---
+
+### Task 1: comfy-kitchen dependency
+
+**Files:**
+- Modify: `pyproject.toml` (the `dependencies` list, after `"kernels>=0.17.2"`)
+- Modify: `docs/DEPENDENCIES.md`
+- Test: `tests/test_dependencies_declared.py` (create if no equivalent exists; check first with `grep -l "kernels>=" tests/*.py`)
+
+**Interfaces:**
+- Produces: `import comfy_kitchen` works in every install.
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+import tomllib, pathlib
+
+def test_comfy_kitchen_is_a_core_dependency():
+    data = tomllib.loads(pathlib.Path("pyproject.toml").read_text())
+    deps = data["project"]["dependencies"]
+    assert any(d.replace(" ", "").startswith("comfy-kitchen>=0.2.38") for d in deps)
+```
+
+- [ ] **Step 2: Run it:** `venv/bin/python -m pytest tests/test_dependencies_declared.py -v -n0`. Expected: FAIL.
+- [ ] **Step 3: Add the dependency.** Add `"comfy-kitchen>=0.2.38",` with a two-line comment, written in the style of the `kernels` entry: "Sol-Attn sparse attention for MiniMax H3's generated-video rows (#931); compiled CUDA/HIP kernels on Linux and Windows, an eager-only wheel elsewhere". Then add a row to `docs/DEPENDENCIES.md`'s table in its existing format.
+- [ ] **Step 4: Install locally and check.** Run `venv/bin/pip install -e ".[server,dev]" && venv/bin/python -c "import comfy_kitchen; print(comfy_kitchen.__name__)"`. Expected: prints `comfy_kitchen`, and the test passes.
+- [ ] **Step 5: Commit:** `git commit -m "build: comfy-kitchen dependency for H3 sparse attention (#931)"`
+
+### Task 2: The tile map
+
+**Files:**
+- Create: `dw/sparse_attention.py` (module docstring: what sparse is, the layout rule, and the decided-once rule)
+- Test: `tests/test_sparse_attention_tiles.py`
+
+**Interfaces:**
+- Produces:
+  - `class SparseLayoutError(ValueError)`
+  - `@dataclass(frozen=True) class TileMap`, with fields:
+    - `dst: torch.Tensor`: long `(rows,)`, the packed row -> padded tiled row
+    - `block_len: torch.Tensor`: int32 `(tiles,)`
+    - `num_prefix_tiles: int`
+    - `padded_rows: int`
+    - `rows: int`
+    - `video_grid: tuple[int, int, int]`
+  - `build_tile_map(position_ids: torch.Tensor, token_tags: torch.Tensor, device) -> TileMap`
+
+- [ ] **Step 1: Write the failing tests.** A helper `_layout(text, ref_rows, audio, t, h, w)` in the test builds `token_tags` and fractional `position_ids` the way diffusers does: text rows tag 1, reference-image rows tag 0, audio rows tag 2, then target video tag 0 last. Spatial positions use `np.linspace(left, left+ratio, n, endpoint=False) * 32`; time uses cumulative `5/3 * (1,4,4,4...)` from `text`.
+
+```python
+def test_t2va_grid_and_tiles():
+    tags, pos = _layout(text=356, ref_rows=0, audio=414, t=37, h=17, w=30)
+    tm = build_tile_map(pos, tags, "cpu")
+    assert tm.video_grid == (37, 17, 30)
+    assert tm.block_len.sum().item() == tm.rows == len(tags)
+    assert tm.num_prefix_tiles == 13           # 356 -> 6 tiles, 414 -> 7
+    assert len(tm.block_len) - tm.num_prefix_tiles == 10 * 5 * 8
+    assert torch.unique(tm.dst).numel() == tm.rows
+    assert (tm.block_len <= 64).all()
+
+def test_ref2va_reference_rows_in_prefix():
+    tags, pos = _layout(text=356, ref_rows=5506, audio=414, t=37, h=24, w=42)
+    tm = build_tile_map(pos, tags, "cpu")
+    assert tm.video_grid == (37, 24, 42)
+    ref = torch.arange(356, 356 + 5506)
+    assert (tm.dst[ref] < tm.num_prefix_tiles * 64).all()
+
+def test_prefix_tiles_are_segment_pure():
+    tags, pos = _layout(text=70, ref_rows=0, audio=70, t=4, h=4, w=4)
+    tm = build_tile_map(pos, tags, "cpu")
+    # 70 text -> 64 + 6, 70 audio -> 64 + 6: four prefix tiles, never one mixed
+    assert tm.block_len[: tm.num_prefix_tiles].tolist() == [64, 6, 64, 6]
+
+def test_rows_within_a_video_tile_are_spatially_local():
+    tags, pos = _layout(text=8, ref_rows=0, audio=8, t=8, h=8, w=8)
+    tm = build_tile_map(pos, tags, "cpu")
+    # every full video tile spans at most 4 distinct values per axis
+    ...
+
+def test_not_a_full_grid_raises():
+    tags, pos = _layout(text=8, ref_rows=0, audio=8, t=4, h=4, w=4)
+    with pytest.raises(SparseLayoutError):
+        build_tile_map(pos[:-1], tags[:-1], "cpu")
+
+def test_no_target_video_raises():
+    tags = torch.ones(128, dtype=torch.long)
+    with pytest.raises(SparseLayoutError):
+        build_tile_map(torch.zeros(128, 3, dtype=torch.float64), tags, "cpu")
+```
+
+- [ ] **Step 2: Run it:** `venv/bin/python -m pytest tests/test_sparse_attention_tiles.py -v -n0`. Expected: FAIL (module missing).
+- [ ] **Step 3: Implement `build_tile_map`.** Port the prototype's `build_tile_map`, with the trailing-run target rule and per-axis ranking. Two differences from the prototype:
+  - Every prototype `assert` becomes `raise SparseLayoutError(...)`.
+  - Prefix segments are contiguous runs of equal `token_tags`. The prototype also keyed on the timestep index; the tile map no longer takes timestep indices.
+- [ ] **Step 4: Run it.** Expected: PASS.
+- [ ] **Step 5: Commit:** `git commit -m "feat(attention): H3 sparse tile map (#931)"`
+
+### Task 3: The processor, installation and the per-call decision
+
+**Files:**
+- Modify: `dw/sparse_attention.py`
+- Test: `tests/test_sparse_attention_processor.py`
+
+**Interfaces:**
+- Consumes: `build_tile_map`, `TileMap`, `SparseLayoutError` (Task 2).
+- Produces:
+  - `SPARSE_BACKEND = "sparse"`, `DEFAULT_TAU = 0.5`
+  - `install_sparse(component, tau: float) -> bool`. Returns `False`, changing nothing, when `type(component).__name__ != "MiniMaxH3Transformer3DModel"`. Idempotent: a second call only updates tau.
+  - `uninstall_sparse(component) -> None`. Restores the original processor objects and removes both hooks. A no-op when nothing is installed.
+  - `is_sparse_installed(component) -> bool`
+  - `set_sparse_tau(component, tau: float) -> None`
+  - `sparse_unavailable_reason(device, dtype, head_dim: int) -> str | None`. Returns `None` when the kernel can run. Otherwise one of: `"device <type> is not CUDA"`, `"compute capability <M>.<m> is below 8.0"`, `"dtype <dtype> is not bfloat16/float16"`, `"head_dim <n> is not 128"`, `"comfy-kitchen kernels unavailable: <exc>"`
+  - `@contextmanager sparse_call(pipeline, label: str) -> Iterator[SparseCallReport]`. Resets every installed component's per-call decision on entry. On exit, if any installed component fell back, calls `emit_warning(f"{label}: sparse attention ran dense - {reason}", attention_backend="sparse", reason=reason)` once per call.
+  - `@dataclass class SparseCallReport`: `ran_sparse: bool`, `reason: str | None`
+  - Module-level `_sol_attn = None`, a seam: `_kernel()` returns `_sol_attn` if set, else imports `comfy_kitchen.sol_attn` and enters `ck.use_backend("cuda")`. Tests monkeypatch it.
+
+- [ ] **Step 1: Write the failing tests.** They use a tiny real `MiniMaxH3Transformer3DModel` built from config: `num_layers=2`, `num_refiner_layers=1`, `num_attention_heads=2`, `attention_head_dim=128`, small `hidden_size`/`ffn_dim`/`text_dim`. Fake inputs come from Task 2's `_layout` helper (move it to `tests/sparse_layouts.py`).
+
+```python
+def test_install_swaps_only_block_processors(tiny_h3):
+    refiner_before = [l.attn.processor for l in tiny_h3.token_refiner.refiner_blocks]  # adjust to the class's attribute
+    assert install_sparse(tiny_h3, 0.5) is True
+    assert all(type(b.attn.processor).__name__ == "SparseH3AttnProcessor" for b in tiny_h3.transformer_blocks)
+    assert [l.attn.processor for l in tiny_h3.token_refiner.refiner_blocks] == refiner_before
+
+def test_refiner_processors_untouched(tiny_h3): ...  # the same assertion after a forward
+
+def test_install_on_non_h3_returns_false():
+    assert install_sparse(torch.nn.Linear(2, 2), 0.5) is False
+
+def test_signature_unchanged(tiny_h3):
+    before = inspect.signature(tiny_h3.forward)
+    install_sparse(tiny_h3, 0.5)
+    assert inspect.signature(tiny_h3.forward) == before
+
+def test_permutation_is_exact(tiny_h3, monkeypatch):
+    # A fake kernel computing dense SDPA over the tiled tensors, padding
+    # masked by block_len: the sparse path must equal the stock processor
+    monkeypatch.setattr(sparse_attention, "_sol_attn", dense_sol_attn_fake)
+    monkeypatch.setattr(sparse_attention, "sparse_unavailable_reason", lambda *a: None)
+    ref = tiny_h3(**inputs).sample
+    install_sparse(tiny_h3, 0.5)
+    with sparse_call(SimpleNamespace(transformer=tiny_h3), "t") as report:
+        out = tiny_h3(**inputs).sample
+    assert report.ran_sparse
+    torch.testing.assert_close(out, ref, rtol=1e-4, atol=1e-4)
+
+def test_fallback_on_non_cuda_device(tiny_h3, monkeypatch):
+    warnings = capture(monkeypatch, sparse_attention, "emit_warning")
+    install_sparse(tiny_h3, 0.5)
+    ref_free = ...  # output with sparse uninstalled
+    with sparse_call(SimpleNamespace(transformer=tiny_h3), "step") as report:
+        out = tiny_h3(**inputs).sample
+    assert not report.ran_sparse and "is not CUDA" in report.reason
+    assert len(warnings) == 1 and "ran dense" in warnings[0][0]
+    torch.testing.assert_close(out, ref_free)
+
+def test_failure_after_decision_raises(tiny_h3, monkeypatch):
+    # decided sparse on forward 1; forward 2 brings a layout that isn't a grid
+    with pytest.raises(SparseLayoutError): ...
+
+def test_each_call_decides_afresh(tiny_h3, monkeypatch): ...  # call 1 falls back, call 2 runs sparse
+def test_tile_map_rebuilt_when_layout_changes(tiny_h3, monkeypatch): ...  # two shapes, two maps, both exact
+def test_uninstall_restores_original_processors(tiny_h3): ...
+def test_active_backend_unchanged(tiny_h3):
+    from diffusers.models.attention_dispatch import _AttentionBackendRegistry
+    before = _AttentionBackendRegistry._active_backend
+    install_sparse(tiny_h3, 0.5); uninstall_sparse(tiny_h3)
+    assert _AttentionBackendRegistry._active_backend == before
+```
+
+`dense_sol_attn_fake(q, k, v, *, sink_blocks, sink_q, block_len, tau, **_)` lives in `tests/sparse_layouts.py`. It masks the padded key rows (rows `>= block_len[tile]` within each 64-row tile) and runs `F.scaled_dot_product_attention`.
+
+- [ ] **Step 2: Run them:** `venv/bin/python -m pytest tests/test_sparse_attention_processor.py -v -n0`. Expected: FAIL.
+- [ ] **Step 3: Implement.**
+  - `SparseH3AttnProcessor` is the prototype's `sol_call`, reading its `TileMap` and tau from a per-component `_SparseState` that the forward pre-hook fills.
+  - The pre-hook is `component.register_forward_pre_hook(hook, with_kwargs=True)`. On the call's first forward it computes the decision: `sparse_unavailable_reason(hidden_states.device, block dtype, attention_head_dim)`, then `build_tile_map`. A `SparseLayoutError` at decision time becomes a fallback with that reason.
+  - On later forwards, a decided-sparse state rebuilds the map only when `(position_ids.shape, token_tags.sum())` changes, and lets `SparseLayoutError` propagate.
+  - A decided-dense state makes the processor call the original processor object.
+  - Keep the original processors on the state object, for `uninstall_sparse`.
+- [ ] **Step 4: Run them.** Expected: PASS.
+- [ ] **Step 5: Commit:** `git commit -m "feat(attention): sparse H3 processor, install, per-call decision (#931)"`
+
+### Task 4: Wiring into components, pipeline, schema and the runtime settings
+
+**Files:**
+- Modify:
+  - `dw/pipeline_processors/components.py`: `configure_components` around line 124, and `set_component_attention_backend`
+  - `dw/pipeline_processors/pipeline.py`: `_call_pipeline` around line 627-650, and the `apply_runtime_settings` function around line 143
+  - `dw/step_cache.py`: `weights_identity`
+  - `dw/workflow_schema.json`: lines 622 and 703 (the `attention_backend` descriptions) and the new `sparse_tau` siblings
+- Test: `tests/test_sparse_attention_wiring.py`
+
+**Interfaces:**
+- Consumes: `install_sparse`, `uninstall_sparse`, `set_sparse_tau`, `sparse_call`, `SPARSE_BACKEND`, `DEFAULT_TAU` (Task 3).
+- Produces: the config keys `attention_backend: "sparse"` and `sparse_tau: <number 0-4>`, at pipeline `configuration` level and on a `components.<name>` entry.
+
+- [ ] **Step 1: Write the failing tests**
+
+```python
+def test_component_sparse_installs_and_never_reaches_diffusers(monkeypatch): ...
+    # configure_components with {"transformer": {"attention_backend": "sparse", "sparse_tau": 0.7}}
+    # -> install_sparse(transformer, 0.7) called; set_attention_backend never called
+
+def test_component_sparse_default_tau(monkeypatch): ...  # no sparse_tau -> 0.5
+
+def test_non_sparse_backend_uninstalls_sparse(monkeypatch): ...
+    # a component with sparse installed, then configured "sage_hub" -> uninstall_sparse ran
+    # before set_attention_backend("sage_hub")
+
+def test_no_backend_uninstalls_sparse(monkeypatch): ...  # attention_backend absent on re-configure -> uninstalled
+
+def test_pipeline_level_sparse_installs_on_h3_components_for_the_call(monkeypatch): ...
+    # configuration {"attention_backend": "sparse"} -> diffusers attention_backend() never entered;
+    # install_sparse called on each pipeline component whose class is MiniMaxH3Transformer3DModel
+
+def test_pipeline_level_sparse_on_non_h3_runs_dense(monkeypatch): ...
+    # no H3 component -> one emit_warning naming the pipeline, call proceeds
+
+def test_every_call_enters_sparse_call(monkeypatch): ...
+
+def test_sparse_tau_is_runtime_not_identity():
+    a = {"configuration": {"components": {"transformer": {"attention_backend": "sparse", "sparse_tau": 0.5}}}}
+    b = copy.deepcopy(a); b["configuration"]["components"]["transformer"]["sparse_tau"] = 1.0
+    assert pipeline_cache_key(a) == pipeline_cache_key(b)
+
+def test_cache_hit_reapplies_tau(monkeypatch): ...  # apply_runtime_settings -> set_sparse_tau(transformer, 1.0)
+
+def test_schema_accepts_sparse_tau(): ...  # validate a minimal definition carrying sparse_tau at both levels
+```
+
+- [ ] **Step 2: Run them:** `venv/bin/python -m pytest tests/test_sparse_attention_wiring.py -v -n0`. Expected: FAIL.
+- [ ] **Step 3: Implement.**
+  - **`components.py`:** `sparse` goes through `install_sparse(component, cfg.get("sparse_tau", DEFAULT_TAU))`, with the existing `emit_log` line. If `install_sparse` returns False, emit a warning that names the component ("not a MiniMax-H3 transformer; runs dense"). Any other value, or none, calls `uninstall_sparse(component)` first.
+  - **`pipeline.py`:** `_call_pipeline` never hands `sparse` to `attention_backend()`. For pipeline-level `sparse` it installs on the H3 components for the call and uninstalls in the ExitStack callback. `sparse_call(self.pipeline, self.segment_label or self.name)` is always entered.
+  - **`apply_runtime_settings`:** walks `configuration.components` for `sparse_tau` and calls `set_sparse_tau`.
+  - **`weights_identity`:** drops `sparse_tau` the way it drops a LoRA scale.
+  - **Schema:** add `sparse_tau` (`"type": "number", "minimum": 0`) with a description naming the default 0.5 and #931. Both `attention_backend` descriptions mention `'sparse'`.
+- [ ] **Step 4: Run them, plus the neighbours.** Run `venv/bin/python -m pytest tests/test_sparse_attention_wiring.py tests/test_attention_backend_trace.py tests/test_pipeline_components.py tests/test_schema.py tests/test_configuration_schema.py -v -n0`. Expected: PASS.
+- [ ] **Step 5: Commit:** `git commit -m "feat(attention): 'sparse' attention_backend at component and pipeline level (#931)"`
+
+### Task 5: Validate warning
+
+**Files:**
+- Modify: `dw/acceleration_warnings.py` (module docstring list, a new `SPARSE_FALLBACK = "sparse_attention_fallback"`, and the loop at about lines 239-268)
+- Test: add to the existing test module for `acceleration_warnings` (find it with `grep -l "attention_backend_unavailable" tests/*.py`)
+
+**Interfaces:**
+- Consumes: `SPARSE_BACKEND` (Task 3).
+
+- [ ] **Step 1: Write the failing tests**
+
+```python
+def test_sparse_on_mps_warns_fallback_not_unavailable():
+    warnings = acceleration_warnings(context_for(device_type="mps", component_backend="sparse"))
+    assert any("sparse_attention_fallback" in w and "'mps'" in w and "dense" in w for w in warnings)
+    assert not any("attention_backend_unavailable" in w for w in warnings)
+
+def test_sparse_on_cuda_is_silent(): ...
+def test_sparse_unknown_device_is_silent(): ...  # matches the module's "unresolvable stays silent" rule
+```
+
+- [ ] **Step 2: Run them.** Expected: FAIL.
+- [ ] **Step 3: Implement.** In the backend loop, a `sparse` value on a resolved non-CUDA device appends `f"{render_path(path)}: {SPARSE_FALLBACK}: sparse attention needs CUDA; this server is '{device}', so the run uses dense attention{where}"`. Add one line for it to the module docstring list.
+- [ ] **Step 4: Run them.** Expected: PASS.
+- [ ] **Step 5: Commit:** `git commit -m "feat(validate): sparse_attention_fallback warning (#931)"`
+
+### Task 6: The server reports the backends it can run
+
+**Files:**
+- Modify: `dw/sparse_attention.py`: add `available_attention_backends(device_type: str) -> list[str]`
+- Modify: `dw/server/api_models.py` (`HealthInfo`), `dw/server/routes/system.py` (`health`)
+- Regenerate: `ui/src/lib/generated/openapi.json` via `scripts/dump_openapi.py` (under `constraints-openapi.txt`), then `cd ui && npm run gen:api`
+- Test: `tests/test_sparse_attention_backends.py`, plus the existing health route test (`grep -l "api/health" tests/*.py`)
+
+**Interfaces:**
+- Produces: `HealthInfo.attention_backends: list[str]`, with the description "Attention backends this server's device can run, for the UI's dropdown; 'sparse' only where comfy-kitchen's compiled kernels loaded".
+- The list order:
+  - `"native"`, then the other diffusers `native`-family names (`_native_flash`, `_native_efficient`, `_native_math`, `_native_cudnn` on CUDA only, `flex`).
+  - On CUDA, then `sparse` (when the compiled extension imported), then the sorted `CUDA_ONLY_ATTENTION_BACKENDS`.
+  - Names not in diffusers' `AttentionBackendName` are dropped.
+
+- [ ] **Step 1: Write the failing tests**
+
+```python
+def test_mps_lists_no_cuda_backends():
+    names = available_attention_backends("mps")
+    assert "native" in names and "sparse" not in names and "sage_hub" not in names
+
+def test_cuda_lists_sparse_when_kernels_present(monkeypatch):
+    monkeypatch.setattr(sparse_attention, "_kernels_importable", lambda: True)
+    assert "sparse" in available_attention_backends("cuda")
+
+def test_listing_never_initializes_cuda():
+    available_attention_backends("cuda")
+    assert not torch.cuda.is_initialized()
+
+def test_health_carries_attention_backends(client): ...
+```
+
+- [ ] **Step 2: Run them.** Expected: FAIL.
+- [ ] **Step 3: Implement.** `_kernels_importable()` checks `comfy_kitchen.backends.cuda._EXT_AVAILABLE` (or the registry's CUDA availability) and catches every exception. It never calls `torch.cuda.get_device_capability`; the per-card check stays at run time (Task 3). Then regenerate the OpenAPI JSON and the TS types.
+- [ ] **Step 4: Run them, plus the OpenAPI drift test** (`grep -l openapi.json tests/*.py`). Expected: PASS.
+- [ ] **Step 5: Commit:** `git commit -m "feat(server): health reports available attention backends (#931)"`
+
+### Task 7: UI dropdowns
+
+**Files:**
+- Create: `ui/src/lib/attentionBackends.svelte.ts`: a shared `$state` holding the last `health.attention_backends`, set from `App.svelte`'s health poll (line ~148)
+- Modify: `ui/src/lib/editor.ts`: add `attentionBackendVariables(definition: unknown): Set<string>`
+- Modify: `ui/src/lib/editor/VariablesForm.svelte` (a new `backendVariables?: Set<string>` prop), `ui/src/lib/pages/WorkflowPage.svelte`, `ui/src/lib/pages/EditorPage.svelte` (pass the prop), `ui/src/lib/editor/PipelineOptions.svelte` (lines ~249-253: a `<select>`)
+- Test: `ui/src/lib/editor.test.ts`, `ui/src/lib/editor/VariablesForm.test.ts`
+
+**Interfaces:**
+- Consumes: `HealthInfo.attention_backends` (Task 6).
+- Produces:
+  - `attentionBackendVariables(def)`: the names X for every `"attention_backend": "variable:X"` anywhere in `def.steps`, at pipeline configuration and component level, including nested `workflow` steps' inline definitions when present.
+
+- [ ] **Step 1: Write the failing tests**
+
+```ts
+it('finds variables feeding attention_backend at component level', () => {
+  const def = { steps: [{ pipeline: { configuration: { components: { transformer_ref: { attention_backend: 'variable:attention_backend' } } } } }] }
+  expect(attentionBackendVariables(def)).toEqual(new Set(['attention_backend']))
+})
+it('ignores literals and other keys', ...)
+it('renders a select with default (none) plus the server list for a backend variable', ...)
+it('keeps a current value the server does not list, marked unavailable', ...)  // e.g. sage_hub opened on a Mac
+it('falls back to the text field when the server list is empty or missing', ...)
+```
+
+- [ ] **Step 2: Run them:** `cd ui && npx vitest run src/lib/editor.test.ts src/lib/editor/VariablesForm.test.ts`. Expected: FAIL.
+- [ ] **Step 3: Implement.**
+  - A select whose options are "default (none)" -> empty string, then the server's list.
+  - A value not in the list stays selectable, labelled `<name> (not available on this server)`.
+  - In override mode, the empty option means "use the workflow default".
+  - Follow the existing field styling.
+  - Don't use `vi.resetModules` in the Svelte component tests (standing rule).
+- [ ] **Step 4: Run the UI gates:** `cd ui && npm run check && npx vitest run && npm run lint`. Expected: clean.
+- [ ] **Step 5: Commit:** `git add` only the files named above (never `git add -A ui`; Don edits `package.json`), then `git commit -m "feat(ui): attention backend dropdowns from the server's list (#931)"`
+
+### Task 8: H3 template defaults, docs and skill note
+
+**Files:**
+- Modify: the 19 files `grep -l '"attention_backend"' workflows/templates/minimax/*.json` lists (not `music.json`, `music-video-cuts.json`)
+- Modify: `docs/ACCELERATION.md` (*Attention Backends*), `docs/RECIPES_24GB.md` and `docs/QUANTIZATION.md` (their H3 rows note the default backend), `plugins/dw/skills/minimax-h3/references/quality-and-speed.md`, and the `plugins/dw` version per `plugins/dw/README.md`
+- Test: `tests/test_h3_sparse_defaults.py`, plus the existing `test_template_defaults.py`, `test_catalog_speed_defaults.py`, `test_plugin_skills.py`
+
+**Interfaces:**
+- Consumes: the config keys from Task 4.
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+H3 = [p for p in glob("workflows/templates/minimax/*.json") if '"attention_backend"' in open(p).read()]
+
+def test_nineteen_h3_templates():
+    assert len(H3) == 19
+
+@pytest.mark.parametrize("path", H3)
+def test_h3_defaults_to_sparse(path):
+    d = json.load(open(path))
+    assert d["variables"]["attention_backend"] == "sparse"
+    assert d["variables"]["sparse_tau"] == 0.5
+    text = json.dumps(d["steps"])
+    assert text.count('"sparse_tau": "variable:sparse_tau"') == text.count('"attention_backend": "variable:attention_backend"')
+    assert "attention_backend" in d["cost_drivers"]
+```
+
+- [ ] **Step 2: Run it.** Expected: FAIL.
+- [ ] **Step 3: Edit the templates, docs and skill note.**
+  - **Templates:** in each one, set `"attention_backend": "sparse"`, add `"sparse_tau": 0.5`, and put `"sparse_tau": "variable:sparse_tau"` next to every `"attention_backend": "variable:attention_backend"`. Leave `cost` minutes unchanged (spec: stage 3 replaces them).
+  - **`docs/ACCELERATION.md`:** a `sparse` subsection covering:
+    - what it does
+    - the #931 measured table (from the spec)
+    - `sparse_tau`
+    - the CUDA sm_80+ need, and the dense fallback with its two warnings
+    - that it moves composition relative to dense, unlike sage, so a draft and its final use the same backend
+  - **`quality-and-speed.md`:** one paragraph under *Ramp*, step 1. Templates now default to `sparse`. Every ramp row keeps `attention_backend=sage_hub` at both tiers until #931 stage 3 measures the sparse rows, because sparse moves staging and sage doesn't. Check the skill byte cap test still passes.
+- [ ] **Step 4: Run them:** `venv/bin/python -m pytest tests/test_h3_sparse_defaults.py tests/test_template_defaults.py tests/test_catalog_speed_defaults.py tests/test_plugin_skills.py -v -n0`, then the full suite `venv/bin/python -m pytest tests/ -q`. Expected: PASS. Move a catalog budget ratchet only in its own commit, with the measured reason.
+- [ ] **Step 5: Commit:** `git commit -m "feat(templates): H3 defaults to sparse attention, tau 0.5 (#931)"`
+
+### Task 9: Deploy and GPU smoke
+
+**Files:** none changed unless the smoke finds a defect.
+
+- [ ] **Step 1: Deploy.** Run `scripts/deploy.sh` to lem and to mini-ai, following the lem restart and mini-ai LaunchDaemon notes in memory. Confirm `venv/bin/python -c "import comfy_kitchen"` on both.
+- [ ] **Step 2: lem T2VA smoke.**
+  - Run `python -m dw.run workflows/templates/minimax/video-with-audio-768p.json seed=42` against lem.
+  - Expected: completes with no `sparse attention ran dense` warning, and the log shows the backend line.
+  - The transformer time is within 15% of the prototype's 87.7 s for 4 forwards.
+- [ ] **Step 3: lem Ref2VA smoke.** Run `reference-to-video` at `width=1344 height=768 seed=42` with the defaults. Expected: completes in about 450 s wall, no fallback warning. Pull the clip; it should match the prototype's `tau05.mp4` closely (same seed).
+- [ ] **Step 4: Backend switch on a warm worker.** Re-run the same Ref2VA with `attention_backend=sage_hub`. Expected: no sparse processors (a dense-speed transformer time), and the job completes.
+- [ ] **Step 5: mini-ai.** Run `python -m dw.validate workflows/templates/minimax/reference-to-video.json` against mini-ai. Expected: one `sparse_attention_fallback` warning, and no `attention_backend_unavailable`. Open the UI against mini-ai and confirm the dropdown lists no `sparse`.
+- [ ] **Step 6: Report.** Comment on #931 with job ids, timings and any deviations.
+
+### Task 10: Stage 3 measurements and the ramp (lem, Don judges)
+
+**Files:**
+- Modify: `plugins/dw/skills/minimax-h3/references/quality-and-speed.md` (*Quality ladder*, *Ramp*), and the `cost` minutes on `reference-to-video`, `dialogue-short` and `video-with-audio-768p`
+- Test: `tests/test_plugin_skills.py`, `tests/test_catalog_speed_defaults.py`
+
+- [ ] **Step 1: Queue the runs.** Use the rung arguments exactly as `quality-and-speed.md` states them, on `reference-to-video` at 1344x768 with 4 references as in #863, at seeds 42, 7 and 1234:
+  - B3 and L5 with `attention_backend=sparse`, and again with `sage_hub`.
+  - L1 and L7 with `sparse`.
+
+  That's 18 runs (6 rungs × 3 seeds), queued on lem with `dw.run`; nohup any runner script. Record the job ids, wall time, peak reserved memory and the transformer per-forward time.
+- [ ] **Step 2: Hand the clips to Don** in pairs: sparse vs sage per cinema rung and seed, and L1 -> L7 under sparse per seed. Ask for:
+  - the skin verdict on L5 sparse vs sage
+  - whether staging carried B3 -> L5 and L1 -> L7 under sparse
+- [ ] **Step 3: Update the ramp from his verdicts only.**
+  - New ladder rows (`B3s`, `L5s`, `L1s`, `L7s`) with minutes and his face scores.
+  - The *Ramp* path table moves a path to `sparse` only where he said it holds.
+  - Replace "attention never moves composition" with the sage/sparse distinction.
+  - The three templates' `cost` minutes come from the measured runs.
+- [ ] **Step 4: Run** `venv/bin/python -m pytest tests/test_plugin_skills.py tests/test_catalog_speed_defaults.py -v -n0`. Expected: PASS, within the byte cap.
+- [ ] **Step 5: Commit**, then comment on #931 with the table. File the lightx2v Turbo-SLA follow-up issue (spec non-goal).
diff --git a/docs/superpowers/specs/2026-10-15-flux-3-klein-catalog-design.md b/docs/superpowers/specs/2026-10-15-flux-3-klein-catalog-design.md
new file mode 100644
index 00000000..dc2707f4
--- /dev/null
+++ b/docs/superpowers/specs/2026-10-15-flux-3-klein-catalog-design.md
@@ -0,0 +1,162 @@
+# FLUX 3 Image Klein: catalog onboarding design
+
+Date: 2026-10-15. Audit: [2026-10-15-flux-3-klein-audit.md](../../proposals/audits/2026-10-15-flux-3-klein-audit.md).
+Status: draft, probes on lem in progress.
+
+## Decisions taken (Don, 2026-10-15)
+
+- **Scope: the distilled core.** Text-to-image, upsample-then-generate, single edit,
+  multi-reference, bounding-box layout, and a 24 GB recipe. Base + CFG (needs modular
+  `guider` support), LoRA and typography are dated follow-ups.
+- **The upsampler is a prior step** on `black-forest-labs/flux-3-image-klein-pup`
+  (Qwen3.5-9B, Apache-2.0, ungated), released before the generation step loads. BFL:
+  "do not use the model without a prompt upsampler".
+- **lem moved after the loop finished:** diffusers 7ecb1e1b (PR #15046) installed via
+  `update_diffusers` and `dw-serve` restarted, 2026-10-15 18:58 CDT.
+
+## Verified on lem
+
+- `modular_model_index.json` (read with lem's token): `Qwen3VLForConditionalGeneration`,
+  `Qwen3VLProcessor`, `Flux3Transformer2DModel`, `AutoencoderKLFlux2`. No `.py` in the
+  repo, so no `trust_remote_code`. The catalog structure test's refusal does not bite.
+- A `ModularPipeline` step on `black-forest-labs/flux-3-image-klein` validates on lem.
+- `update_diffusers` alone leaves a running `dw.serve` with a half-old diffusers: the lazy
+  `modular_pipeline` import raises `RuntimeError` in `component_types`/`component_names`
+  validation until the server is restarted (the known admission gap from the
+  Kandinsky 6 onboarding).
+- The first in-worker download looked hung (3.0 GB, no traffic for a 5 s sample) and P1
+  was cancelled, but that blob had completed a minute earlier, so it was probably
+  between files: not a confirmed hang. The weights were then fetched with `hf download`
+  on the box (~34 MB/s).
+
+## Probes (results to fill in)
+
+| Probe | Job | Result |
+|---|---|---|
+| P1a as below, text encoder + VAE `residency: on_demand` | 8c88debc90ab | Failed: `index is on cpu` in the text encoder |
+| P1b transformer and text encoder unplaced, VAE on demand | 19ece0b9522a | Failed: `Cannot generate a cpu tensor from a generator of type cuda` |
+| P1d distilled t2i bf16, 1024², 16 steps, vendor `man_dog` caption, seed 7, transformer + text encoder + VAE `device: cuda` | 9cc1ce441555 | **Passed.** 24 s total: load 10.1 s, encode 0.4 s, denoise 12.1 s (0.8 s/step), decode 0.4 s. 19.2 GB allocated, 22.1 GB reserved peak at decode (1.7 GB free). The image follows the caption element by element |
+| P2 pup via `text_generation` as-is, `t2i` system prompt, `man_dog` request | a5471561de18 | Ran (22 s, cuda:1); vendor-style caption, but it opens mid-phrase in lowercase ("medium-wide outdoor photograph ...") |
+| P2b chat template check | (script) | The template's default opens `<think>\n` (thinking on); `enable_thinking=False` gives `<think>\n\n</think>\n\n`. P2 ran in thinking mode |
+| P3 multi-reference edit: `image` a list of two `{"location": url}` refs (BFL examples/inputs 2.png mug, 3.png dog, commit bbfe317d), BFL upsampled mugprint caption, seed 23, 1024², 16 steps | cc7fb1b29091 | **Passed.** The list arrives as PIL images; the output printed the dog on the mug and kept the scene. 45 s total: encode 0.5 s, denoise 41.0 s (2.6 s/step, references add tokens), decode 0.3 s. 19.2 GB allocated, 22.1 GB reserved peak |
+
+What P1 settled:
+
+- `ModularPipeline._execution_device` is the first model component's device unless a
+  group-offload or accelerate hook says otherwise. An unplaced component stays on the
+  CPU, so the pipeline encodes and draws noise on the CPU. **Every Klein component needs
+  an explicit `device`.** `residency: on_demand` on the text encoder breaks for the same
+  reason: the encoder step moves `input_ids` to the execution device before the wrapper
+  moves the weights. On the VAE it is fine once the transformer is placed.
+- bf16 with everything resident fits a 24 GB card at 1024², just. Larger outputs and
+  edits (references add tokens) want the VAE on demand or the components manager.
+
+## Templates (`workflows/templates/flux3/`)
+
+One idea each, in reading order; every setting from the audit's *Vendor recommended
+settings*:
+
+1. `text-to-image.json` - distilled, 16 steps, no guidance, 1024², `width`/`height`
+   modulus-16 constraints (the pipeline raises after load), prompt is a full caption
+   (stored prompt = the vendor's `man_dog` upsampled caption).
+2. `upsample-then-generate.json` - pup `t2i` step -> `previous_result:` prompt;
+   `release_models` between them.
+3. `image-edit.json` - one reference; the `i2i` upsampler sees the same image; output
+   defaults to 1 MP at the reference's aspect ratio (diffusers' rule, not the vendor
+   code's - stated in the description).
+4. `multi-reference.json` - 2-10 references named `<ref_image_N>` in the caption. The
+   10 cap is stated in the description and the skill, not enforced: diffusers does not
+   enforce it, and `variable_constraints` are numeric only, so they cannot check a
+   list's length. An enforcing list-length check is a follow-up.
+5. `layout-boxes.json` - `<id>` caption + 0-1000 box table, written in the box format
+   directly as the HF card shows. Upsampled boxes (`t2i_bbox`) need BFL's
+   `bbox.plan`/`bbox.reconcile` scaffolding, so they're a follow-up.
+
+No separate 24 GB recipe: P1 showed bf16 with every component placed fits the card at
+1024², so the templates above are the 24 GB recipe. SDNQ int8 (the H3 pattern) waits
+until a larger size or an edit is measured not to fit.
+
+The upsampler builtins (`builtin:flux3_klein_upsample.json`,
+`builtin:flux3_klein_upsample_edit.json`) carry the pinned pup settings once. The edit
+one wraps the instruction in BFL's three-line `I2I_SCAFFOLD` (`src/flux3/pup.py` at
+bbfe317d) with `compose_text`. BFL's presence penalty (1.5 for text-to-image) has no
+transformers `generate()` equivalent and is left out.
+
+Plus `workflows/models/flux3-klein.json` and the family README.
+
+## Engine work (generic, no per-model Python)
+
+`text_generation` (`dw/tasks/text_generation.py`) loads and runs the pup as it is (P2). It
+needs two things to run it as BFL specifies:
+
+1. **`chat_template_kwargs`** passed to the chat template (`enable_thinking: false`).
+   Without it the pup runs in thinking mode (P2b).
+2. **A list of images** - an edit sends the upsampler every reference, in order.
+
+`repetition_penalty` is already overridable (1.15 is only the vision default), and
+`generate_kwargs` already passes through, so the vendor's greedy decoding needs no
+change: the edit templates set `repetition_penalty: 1.0`. Built later: `generate_kwargs`
+is filtered like `chat_template_kwargs` (scalars or lists of them, none of the call's own
+keys), and `custom_generate`/`trust_remote_code` need trusted workflows, since
+transformers runs a `custom_generate` repo's code.
+
+## Decision: the upsampler's system prompts are read from the Hub (Don, 2026-10-15)
+
+BFL's four system prompts (`t2i`, `i2i`, `t2i_bbox`, `i2i_bbox`) are in the pup repo's
+`system_prompts.json` and still changing (pup head 3f3edb52; diffusers PR #15058, open,
+copies an older 8b069751). The skill rule is to point at vendor text, not copy it, so
+nothing is transcribed. Considered and not taken: a pinned copy as stored prompts (drifts),
+and waiting for #15058 (no upsampler templates until it merges).
+
+`text_generation` takes `system_prompt` as today, or a generic reference to a JSON file in
+a Hub repo:
+
+```json
+"system_prompt": {"from_hub": {"repo": "black-forest-labs/flux-3-image-klein-pup",
+                               "file": "system_prompts.json",
+                               "revision": "3f3edb52b2c55de0d49feab28598b68f7f8e4830",
+                               "key": "t2i"}}
+```
+
+- Not "one download, then offline": before every use the Hub is asked, anonymously
+  (`get_hf_file_metadata`, `token=False`), whether it serves the file publicly at that
+  commit, and any error refuses the run rather than falling back to the cache. So it
+  fails closed offline or under `HF_HUB_OFFLINE`. Without that ask, a full commit would
+  be answered from the local cache, where files the server fetched with its own login
+  (gated or private repos) would be readable by any workflow.
+- The download is public-only (`hf_hub_download(..., token=False)`) and capped at
+  1 MiB: the Hub's reported size is checked first (no reported size is a refusal),
+  and the downloaded file again before it is read.
+- `revision` is required and must be a full 40-hex commit, so the text a template runs
+  can't move under it.
+- `repo` matches the Hub id pattern, and `file` is a relative path with no `..` or
+  absolute part. `key` is optional; the value it selects (or the file, without one) must
+  be a string.
+- Model-agnostic: any vendor that ships prompts as a repo file can use it. When #15058
+  merges, the skill can cite the diffusers constant beside it. A test compares the
+  constant with the file only if it pins the same revision.
+
+## Follow-ups (dated 2026-10-15)
+
+- Base + CFG: modular `guider` support (`pipe.guider.new(guidance_scale=...)`).
+- Vendor fp8r/NVFP4 via `Flux3Transformer2DModel.from_single_file` + `BFLQuantizationConfig`;
+  fused only on Ada+/Blackwell, so of little use on the 3090s.
+- LoRA on distilled (scale 0.75), typography template, MPS measurement on mini-ai.
+- Re-pin the system prompts when #15058 merges.
+- dw gap: `validate_workflow`'s `plan.downloads_required` was empty for both uncached
+  repos (the modular Klein repo, ~20 GB, and the pup as a `text_generation`
+  `model_name`, 18.8 GB), so the cost quote misses the download. Once a partial
+  cache existed it swung the other way: 40.3 GB, the whole repo including the
+  `variants/` the pipeline never loads.
+- Enforce the multi-reference 10 cap with a list-length check (`variable_constraints`
+  are numeric only).
+- `generate_kwargs` sweep of the other tasks: `text_generation` now refuses
+  `custom_generate`/`trust_remote_code` untrusted and filters the call's own keys and
+  non-scalar values. `speech_generation` still passes a workflow's `generate_kwargs`
+  (`dw/tasks/speech_generation.py:219`) and `forward_params` (`:190`, `:218`) to the
+  transformers pipeline unfiltered, and the controlnet_aux detector handlers splat
+  workflow kwargs into the detector call (`dw/tasks/image_utils.py:103`, `:114`, `:124`).
+  The repo owner decides that fix.
+- `revision` validation parity (M7, deferred): `text_generation`'s model `revision` is
+  passed to the loader as given, while `system_prompt.from_hub.revision` must be a full
+  commit; whether the model revision gets the same pin rule is open.
diff --git a/docs/superpowers/specs/2026-10-17-h3-sparse-attention-design.md b/docs/superpowers/specs/2026-10-17-h3-sparse-attention-design.md
new file mode 100644
index 00000000..d299016d
--- /dev/null
+++ b/docs/superpowers/specs/2026-10-17-h3-sparse-attention-design.md
@@ -0,0 +1,268 @@
+# H3 sparse attention (comfy-kitchen Sol-Attn) - design
+
+Issue: #931. Evidence: the stage-0, prototype, 768p, Ref2VA and skin-recovery comments on #931.
+
+## Intent
+
+Make MiniMax H3 generations 2-4x faster on CUDA by running the generated-video
+part of every DiT attention call through comfy-kitchen's `sol_attn` sparse
+kernel. Text, reference and audio rows stay exact (dense).
+
+Don's words: sparse is **the normal way H3 runs**, not an opt-in. comfy-kitchen
+is installed by default. The UI's attention-backend setting becomes a
+dropdown of the backends the server can actually run. The H3 quality ramp
+(`plugins/dw/skills/minimax-h3/references/quality-and-speed.md`, *Ramp*) takes
+the new backend into account.
+
+Why: H3 is the slowest family dw runs. A 1344x768 Ref2VA final takes ~16 min
+dense on lem's 3090s. Sparse cut that to ~7.5 min at a quality Don judged
+"really good", indistinguishable from dense apart from skin texture at `tau`
+1.0. At `tau` 0.5 he judged the two equal.
+
+## Measured so far (lem, RTX 3090, seed 42)
+
+| shape | dense s/forward | sparse s/forward | wall dense -> sparse |
+|---|---|---|---|
+| T2VA 960x544, 4-step turbo, tau 1.0 | 24.3 | 10.8 | 150 -> 95 s |
+| T2VA 1344x768, 4-step turbo, tau 1.0 | 96.1 | 21.9 | 457 -> 158 s |
+| Ref2VA 1344x768, 8-step ref2v turbo, tau 1.0 | 108.4 | 42.1 | 965 -> 430 s |
+| same, tau 0.5 | 108.4 | 44.8 | 965 -> 450 s |
+
+Dense here means native SDPA, not `sage_hub`. The ramp's numbers are
+`sage_hub`, which is ~30% faster than native per step. The sparse-vs-sage
+ratio is not measured yet; the stage 3 measurements take it.
+
+**Peak memory didn't change.** `torch.cuda.max_memory_allocated` was identical
+dense and sparse in every run: 6.72 GiB (544p T2VA), 10.81 GiB (768p T2VA)
+and 21.16 GiB (768p Ref2VA). The padded tile copies are small next to
+group-offloaded weights, so `vram_estimate` ceilings stay as declared. Stage
+3 records peak reserved as well, to confirm.
+
+Sparse **moves composition** relative to dense: same subject, story and
+cuts, but different framing and set dressing (SSIM 0.75-0.81 against dense).
+This is the main way it differs from sage, which the ramp records as "never
+moves composition".
+
+## Goals
+
+1. **An engine backend.** A new `attention_backend` value, `sparse`, valid
+   wherever `attention_backend` is today: at pipeline level and on a
+   component. On a MiniMax-H3 transformer it routes target-video rows through
+   `sol_attn` and keeps everything else dense. A `sparse_tau` setting
+   (default 0.5) sits next to it.
+2. **A dependency.** `comfy-kitchen` becomes a regular dependency in
+   `pyproject.toml`, installed by `install.sh` on every platform.
+3. **Template defaults.** Every H3 template that takes `attention_backend`
+   (19 under `workflows/templates/minimax/`, not the two Music3 ones)
+   defaults it to `sparse`.
+4. **Graceful fallback.** Where `sparse` can't run, the run uses the
+   transformer's normal dense attention and completes. That covers no CUDA
+   (MPS, CPU), a card below sm_80, a non-H3 transformer, a dtype or
+   head_dim the kernel refuses, or comfy-kitchen failing to import.
+   Validate and the run both say so (see *Warnings*).
+5. **A UI dropdown.** In the workflow page and editor, a variable that feeds
+   an `attention_backend` setting is shown as a dropdown of the backends the
+   connected server can run, plus "default (none)". The server reports that
+   list.
+6. **Ramp.** The H3 skill's ramp is updated:
+   - The TV path (L1 draft -> L7 final, plus the L0 sketch) moves to
+     `sparse` at both tiers, once stage 3 shows its staging carries.
+   - Cinema (B3 -> L5/P1) and close-up (C1) stay on `sage_hub` at both
+     tiers until stage 3 is measured.
+   - The rule "attention never moves composition" is corrected:
+     sage doesn't, sparse does, so draft and final use the same backend.
+7. **Measurements (stage 3).** On lem, run the cinema pair B3 -> L5 (base
+   model, int8, 1344x768, 12 then 30 steps) with `sparse` against
+   `sage_hub`, at seeds 42, 7 and 1234. Record wall time, per-forward time,
+   staging carry from draft to final, and Don's skin verdict. Run the TV
+   pair L1 -> L7 under `sparse` on the same 3 seeds. Its carry was measured
+   under sage, which never moves staging, so it has to be re-shown under
+   `sparse`; those runs also give the TV timing. Each path moves to
+   `sparse` only on Don's verdict for it.
+
+## Non-goals
+
+- Sparse attention for any family other than H3. LTX-2.5, Kandinsky 6 and
+  FLUX 3 have different token layouts. The backend no-ops with a warning
+  on them.
+- Trained-gate VSA (the FastH3 `to_gate_compress` transplant from the Kablex
+  repo) and the `topk` modes. `tau` mode needs no extra weights, and it
+  measured well.
+- lightx2v Turbo-SLA LoRAs. A separate follow-up issue, filed during this
+  work.
+- An MPS or CPU sparse path. comfy-kitchen ships only an eager PyTorch
+  reference there, which is slower than dense.
+
+## Anti-goals
+
+- **A run must never fail because of `sparse`.** Being the default, a
+  `sparse` that can't run must degrade to dense, never refuse at validate
+  or at load. A Mac user running an H3 template must get today's behavior.
+- **No silent change of staging between a draft and its final.** The ramp
+  must never pair a sparse draft with a dense final, or the reverse.
+- **No model knowledge in engine code beyond the diffusers class it
+  patches.** The backend keys off the transformer class
+  (`MiniMaxH3Transformer3DModel`) and the layout tensors diffusers passes
+  it. It doesn't key off model names or template ids (CLAUDE.md, *Before
+  you edit*).
+
+## Constraints
+
+- **Kernel requirements:** sm_80+ CUDA (or a HIP card with matrix cores),
+  bf16/fp16, head_dim 128 (H3's is 128).
+  `comfy_kitchen.sol_attn_is_available(device)` is the check.
+- **comfy-kitchen 0.2.38** has wheels for Linux x86_64/aarch64 (cp310,
+  cp311, cp312 abi3) and Windows, plus a `py3-none-any` wheel elsewhere
+  (macOS gets the eager-only build). Apache-2.0. No required dependencies.
+- **Signature passthrough.** diffusers' H3 denoiser picks the layout kwargs
+  it passes by `inspect.signature(transformer.forward)`. Anything that wraps
+  `forward` must keep the signature (`functools.wraps`). Otherwise
+  `token_tags`/`position_ids`/indices silently stop arriving
+  (prototype-learned).
+- **Fractional position ids.** H3's `position_ids` are fractional:
+  aspect-normalized space onto [0, 32), and uneven time steps of
+  5/3 x (1,4,4,4,...). Tile coordinates come from ranking each axis's
+  distinct values.
+- **Finding the target video.** Target video is the trailing run of video
+  rows: diffusers packs text, references in request order, target audio,
+  then target video. A Ref2VA reference image can share the target's
+  timestep index, so noise level can't identify it.
+- **The process-wide default.** `set_attention_backend` sets a process
+  global, and dw restores it today (*Attention backend global leak*,
+  `docs/ACCELERATION.md`). `sparse` must not leak onto the next job in the
+  persistent worker either: not onto a Music3 job, nor onto an H3 job that
+  asked for `native`.
+- **CodeQL and security rules** apply as usual. No new file or subprocess
+  surface is expected.
+
+## The how, as decided
+
+- **The name is `sparse`** (my call; Don said "sparse"). It's one more
+  `attention_backend` value, not a separate key, so the template variable,
+  the dropdown, validate and the docs all treat it like `sage_hub`.
+- **`tau` defaults to 0.5** (Don's verdict on the Ref2VA skin A/B). It's
+  exposed as a template variable `sparse_tau` on the H3 templates (my
+  call on the name).
+- **The dense prefix:** every row that isn't target video goes first, in
+  segment-pure 64-row tiles. Those tiles are `sink_blocks` and `sink_q`:
+  always attended, and their queries attend everything. Target video goes
+  after, in 4x4x4 tiles. `block_len` carries each tile's live-row count.
+  This is the prototype's layout, which passed the full-grid check on T2VA
+  and Ref2VA.
+- **The fallback is decided once per pipeline call, all or nothing** (my
+  call). The backend decides before the first transformer forward whether
+  this call runs sparse. If any check fails later in that call, it raises
+  rather than dropping that forward to dense: a call that mixes sparse and
+  dense forwards would be a hidden staging change inside one generation.
+  The prototype's per-call fallback is not ported. The text token refiner
+  (text-only rows, no video target) always runs dense; that isn't a
+  fallback and isn't reported. Each pipeline call of a chained job decides
+  for itself, and the run-time warning names the calls that fell back.
+- **The fallback warns instead of refusing.** Being the default, every H3
+  validate on mini-ai (MPS) would otherwise carry a warning nobody can act
+  on. My call is a distinct, quieter code (see *Warnings*) rather than
+  reusing `attention_backend_unavailable`.
+
+## Warnings
+
+- **Validate: `sparse_attention_fallback`.** Validate reports it when
+  `sparse` is set and the server's device is not CUDA. It names the device
+  and says the run will use dense attention. Every H3 run on a Mac shows it.
+  The builder decides whether the catalog/UI surfaces collapse it; it is
+  never a refusal.
+- **Run time.** The worker's event stream reports once per job when
+  `sparse` fell back, with the reason: device, compute capability, dtype,
+  head_dim, non-H3 transformer, or import failure. Run-time warnings must
+  reach the caller (standing rule from the #82-84 cycle).
+- **CUDA list.** `sparse` is **not** added to
+  `CUDA_ONLY_ATTENTION_BACKENDS`. It never fails at load, so
+  `attention_backend_unavailable` would be the wrong message.
+
+## Server and UI
+
+- **The server reports the backends this device can run.** It lists them on
+  an existing system route (`/api/health` or `/api/server`, builder's
+  choice): on CUDA the `native` family, the CUDA-only set, and `sparse`
+  when `sol_attn_is_available()` holds on at least one card; on MPS/CPU the
+  `native` family only. Hub-kernel backends need the `kernels` package and,
+  for some publishers, `DIFFUSERS_TRUST_REMOTE_KERNELS`. The builder decides
+  whether to filter on those or list them with a note.
+- **The UI turns the matching variables into dropdowns.** `VariablesForm`
+  gets a dropdown for any variable that feeds an `attention_backend` key in
+  the workflow. Whether it detects that by tracing references or by the
+  variable's name is the builder's call. The UI has no dropdown for
+  variables today.
+- **The pipeline-level editor field** (`PipelineOptions.svelte`, a free-text
+  `attention_backend` input) uses the same list.
+- **Remote servers.** The dropdown reflects the *connected server's*
+  device, not the browser's machine (`docs/REMOTE.md`).
+
+## Docs and skill
+
+- **`docs/ACCELERATION.md` *Attention Backends*:** a `sparse` subsection.
+  What it does, the measured table, `sparse_tau`, the fallback, and that it
+  moves composition relative to dense, unlike sage.
+- **`docs/QUANTIZATION.md` / `RECIPES_24GB.md`:** the H3 rows note the
+  default backend.
+- **`plugins/dw/skills/minimax-h3`:**
+  - The ramp and its *Quality ladder* get sparse rows.
+  - The *Ramp* path table gets a backend column.
+  - The composition rule is corrected.
+  - The cinema rows set `attention_backend=sage_hub` explicitly until
+    stage 3 lands.
+  - Mind the 12 KiB skill byte cap (memory: H3 skill is at its cap). New
+    text goes in `references/quality-and-speed.md`, not `SKILL.md`, where
+    possible.
+- **Template metadata (my call):** stages 1-2 ship with today's
+  `cost` minutes. Those are sage/native-era numbers, so they over-quote on
+  CUDA, which is the safe direction for the acknowledged-cost gate. Stage 3
+  replaces the minutes on the templates its runs cover
+  (`reference-to-video`, `dialogue-short`, `video-with-audio-768p`).
+  The others keep their minutes until observed cost (`dw/server/observed_cost.py`)
+  or a later measurement corrects them; no per-template GPU runs. New
+  minutes come from measurements, never from scaling. `attention_backend`
+  is already in `cost_drivers` on the ones I read; the builder confirms it
+  on all 19.
+- **`plugins/dw` versioning and its pinned tests** follow
+  `plugins/dw/README.md`.
+
+## Stages
+
+0. **Dependency.** comfy-kitchen in `pyproject.toml`, `install.sh` and
+   `docs/DEPENDENCIES.md`. Deploy to lem and mini-ai, and confirm it imports
+   on both.
+1. **The engine backend.**
+   - `sparse` recognized at pipeline and component level, so the value
+     never reaches diffusers' `AttentionBackendName`.
+   - The H3 processor and tiling, ported from the prototype with its
+     checks. The full-grid and injectivity asserts become errors that
+     trigger the fallback.
+   - The fallback, decided once per pipeline call; the warnings; no global
+     leak.
+   - Unit tests on CPU: tiling for T2VA and Ref2VA layouts, the
+     target-video rule, the fallback on non-CUDA, the signature
+     passthrough, and no leak to the next job.
+   - Then a lem GPU smoke.
+2. **Templates, UI, docs.**
+   - The 19 template defaults and the `sparse_tau` variable.
+   - The server's backend list and the UI dropdowns.
+   - `docs/ACCELERATION.md`.
+3. **Measurements (lem), then the ramp.**
+   - Cinema B3 -> L5, sparse vs `sage_hub`, 3 seeds.
+   - TV L1 -> L7 under `sparse`, the same 3 seeds: staging carry and timing.
+   - Peak reserved memory recorded on every run.
+   - Don judges skin and staging.
+   - The ramp and template `cost` updated from the numbers.
+
+## Left to the builder
+
+- Where the backend code lives (a new `dw/` module is likely). How it
+  attaches to the transformer: a processor swap on load, or a
+  `set_attention_backend` interception.
+- Caching the tile map per layout signature (the prototype keyed on
+  shapes and sums), and its memory cost.
+- Whether the pipeline-level and component-level `sparse` share one code
+  path.
+- Test fixtures for H3 layout tensors without loading the model.
+- Reconciling the ratchets (modules, `test_dw_patch_targets`, catalog
+  budgets) as they move.
diff --git a/dw/acceleration_warnings.py b/dw/acceleration_warnings.py
index 738fdd98..9d072d12 100644
--- a/dw/acceleration_warnings.py
+++ b/dw/acceleration_warnings.py
@@ -27,6 +27,9 @@
   cache's skip decision needs (`docs/ACCELERATION.md`).
 - `attention_backend_unavailable`: a CUDA-only attention backend on a device
   that isn't CUDA passes validate and fails at load.
+- `sparse_attention_fallback`: the `sparse` attention backend on a device that
+  isn't CUDA. It never fails a run: it falls back to dense attention, so this
+  says the speedup is not coming, not that the job will break.
 
 Every one is a warning and never a refusal. A value that cannot be resolved
 before the run (a null variable, an unknown device) leaves its warning
@@ -39,6 +42,8 @@
 from . import get_device_type
 from .introspection import load_pipeline_class
 from .references import iter_steps, render_path
+from . import sparse_attention
+from .sparse_attention import SPARSE_BACKEND
 from .vram_estimate import required_vram_gb
 
 # The fewest denoise steps a threshold cache is expected to skip any of. A
@@ -82,6 +87,7 @@
 TAYLORSEER_STATE = "taylorseer_state_unestimated"
 FULLGRAPH_WITH_CACHE = "compile_fullgraph_with_cache"
 BACKEND_UNAVAILABLE = "attention_backend_unavailable"
+SPARSE_FALLBACK = "sparse_attention_fallback"
 CACHE_UNSUPPORTED = "cache_unsupported"
 
 # The component names a cache hook attaches to, as in
@@ -258,6 +264,13 @@ def acceleration_warnings(context):
             continue
         for path, block in backends:
             name = block.get("attention_backend")
+            if name == SPARSE_BACKEND:
+                warnings.append(
+                    f"{render_path(path)}: {SPARSE_FALLBACK}: sparse attention "
+                    f"needs CUDA; this server is '{context.device_type}', so "
+                    f"the run uses dense attention{where}"
+                )
+                continue
             if name not in CUDA_ONLY_ATTENTION_BACKENDS:
                 continue
             warnings.append(
@@ -273,3 +286,26 @@ def acceleration_warnings(context):
         path, _, rest = warning.partition(": ")
         said.setdefault((path, rest.partition(": ")[0]), warning)
     return list(said.values())
+
+
+def available_attention_backends(device_type: str) -> list[str]:
+    """The attention backends a server on `device_type` can run, in menu order.
+
+    `native` first, then the other `native`-family names; on CUDA, `sparse`
+    (only where the compiled kernels loaded) and the CUDA-only names. A name
+    diffusers' `AttentionBackendName` lacks is dropped, so the menu never
+    offers one the pipeline would refuse.
+    """
+    from diffusers.models.attention_dispatch import AttentionBackendName
+
+    known = {backend.value for backend in AttentionBackendName}
+    cuda = device_type == "cuda"
+    names = ["native", "_native_flash", "_native_efficient", "_native_math"]
+    if cuda:
+        names.append("_native_cudnn")
+    names.append("flex")
+    if cuda:
+        if sparse_attention._kernels_importable():
+            names.append(SPARSE_BACKEND)
+        names.extend(sorted(CUDA_ONLY_ATTENTION_BACKENDS))
+    return [name for name in names if name == SPARSE_BACKEND or name in known]
diff --git a/dw/pipeline_processors/components.py b/dw/pipeline_processors/components.py
index 47a6aedc..849036b3 100644
--- a/dw/pipeline_processors/components.py
+++ b/dw/pipeline_processors/components.py
@@ -15,6 +15,12 @@
 from ..events import WorkflowCancelled, emit_log, emit_phase, emit_warning
 from .. import download_watch
 from .. import quantized_cache
+from ..sparse_attention import (
+    DEFAULT_TAU,
+    SPARSE_BACKEND,
+    install_sparse,
+    uninstall_sparse,
+)
 from huggingface_hub.errors import HfHubHTTPError
 from .timing import counting_forwards, report_cache_stats
 from .h3_guides import insert_guides
@@ -77,6 +83,15 @@ def configure_components(pipeline, configuration, default_device, reused_compone
             )
             continue
 
+        # The worker keeps models loaded between jobs, so a component an
+        # earlier job set to 'sparse' still carries its processors: anything
+        # but 'sparse' takes them off before its own backend or processor goes on
+        component_attention_backend = component_configuration.get(
+            "attention_backend", None
+        )
+        if component_attention_backend != SPARSE_BACKEND:
+            uninstall_sparse(component)
+
         # Prune before any hooks are installed - an offload hook pins and tracks
         # exactly the modules that exist when it is applied, so pruning afterwards
         # would leave it streaming weights that can never run
@@ -124,18 +139,32 @@ def configure_components(pipeline, configuration, default_device, reused_compone
         # A compiled component should pin its attention backend - the per-call
         # attention_backend context manager would switch implementations under a
         # compiled graph and force a recompile on every run
-        component_attention_backend = component_configuration.get(
-            "attention_backend", None
-        )
         if component_attention_backend is not None:
             message = f"Setting {component_name} attention backend: {component_attention_backend}"
+            tau = component_configuration.get("sparse_tau", DEFAULT_TAU)
+            topk = component_configuration.get("sparse_topk")
+            if component_attention_backend == SPARSE_BACKEND:
+                # tau and top-k routing differ in speed and output, so the
+                # run's log says which ran (#932)
+                message += f" (topk {topk})" if topk is not None else f" (tau {tau})"
             logger.info(message)
             emit_log(
                 message,
                 component=component_name,
                 attention_backend=str(component_attention_backend),
             )
-            set_component_attention_backend(component, component_attention_backend)
+            if component_attention_backend == SPARSE_BACKEND:
+                # dw's own processor, not a diffusers backend - it never
+                # reaches set_attention_backend (#931)
+                if not install_sparse(component, tau, topk):
+                    emit_warning(
+                        f"{component_name}: attention_backend 'sparse' needs a "
+                        "MiniMax-H3 transformer; runs dense",
+                        component=component_name,
+                        attention_backend=SPARSE_BACKEND,
+                    )
+            else:
+                set_component_attention_backend(component, component_attention_backend)
 
         # Compile last - the graph must capture final dtypes, adapters,
         # quantization, and offload hooks
diff --git a/dw/pipeline_processors/pipeline.py b/dw/pipeline_processors/pipeline.py
index 9297290e..d821f233 100644
--- a/dw/pipeline_processors/pipeline.py
+++ b/dw/pipeline_processors/pipeline.py
@@ -60,6 +60,12 @@
 from ..events import WorkflowCancelled, emit_log, emit_phase, emit_warning, get_context
 from ..media_types import AudioVideo
 from ..step_cache import component_names, copy_containers
+from ..sparse_attention import (
+    SPARSE_BACKEND,
+    apply_sparse_settings,
+    install_sparse_for_call,
+    sparse_call,
+)
 
 logger = logging.getLogger("dw")
 
@@ -154,6 +160,7 @@ def apply_runtime_settings(pipeline_definition, model):
         pipeline_definition.get("audio_scheduler"), model, "audio_scheduler"
     )
     apply_adapter_settings(pipeline_definition.get("loras"), model)
+    apply_sparse_settings(pipeline_definition.get("configuration", {}), model)
 
 
 class Pipeline:
@@ -639,14 +646,21 @@ def _call_pipeline(self, arguments, attn_backend):
         emit_phase("generating", detail=self.segment_label or self.name)
         denoiser = _denoiser(self.pipeline)
         mark("call_started", compiled=is_compiled(denoiser))
+        label = self.segment_label or self.name
         with contextlib.ExitStack() as stack:
-            if attn_backend is not None:
+            if attn_backend == SPARSE_BACKEND:
+                # dw's own processor, never a diffusers backend (#931)
+                install_sparse_for_call(self.pipeline, self.configuration, stack, label)
+            elif attn_backend is not None:
                 logger.info(f"Using attention backend: {attn_backend}")
                 emit_log(
                     f"Using attention backend: {attn_backend}",
                     attention_backend=str(attn_backend),
                 )
                 stack.enter_context(attention_backend(attn_backend))
+            # Entered after the uninstall callbacks are pushed, so it closes
+            # (and reports a fallback) while the processors are still on
+            stack.enter_context(sparse_call(self.pipeline, label))
 
             stack.enter_context(captured_mag_calibration(self.pipeline, arguments))
             stack.enter_context(
diff --git a/dw/server/api_models.py b/dw/server/api_models.py
index 17572e26..f11d1881 100644
--- a/dw/server/api_models.py
+++ b/dw/server/api_models.py
@@ -119,6 +119,11 @@ class HealthInfo(ApiModel):
     hostname: str = Field(description="Which machine answered.")
     device: str
     mcp: bool
+    attention_backends: list[str] = Field(
+        default_factory=list,
+        description="Attention backends this server's device can run, for the UI's "
+        "dropdown; 'sparse' only where comfy-kitchen's compiled kernels loaded",
+    )
 
 
 class ServerAddress(ApiModel):
diff --git a/dw/server/routes/system.py b/dw/server/routes/system.py
index 3a263d17..d1f1dd67 100644
--- a/dw/server/routes/system.py
+++ b/dw/server/routes/system.py
@@ -492,8 +492,10 @@ def health(request: Request):
     import socket
 
     from ... import __version__, get_device, get_device_type
+    from ...acceleration_warnings import available_attention_backends
 
     workers = manager.workers()
+    device = get_device_type(get_device())
     return {
         "status": "ok",
         "version": __version__,
@@ -509,8 +511,9 @@ def health(request: Request):
         # which machine answered - the thing a remote client cannot
         # otherwise tell apart from a stale tunnel pointed at nothing
         "hostname": socket.gethostname(),
-        "device": get_device_type(get_device()),
+        "device": device,
         "mcp": bool(state.mcp_mounted),
+        "attention_backends": available_attention_backends(device),
     }
 
 
diff --git a/dw/sparse_attention.py b/dw/sparse_attention.py
new file mode 100644
index 00000000..c3690ae6
--- /dev/null
+++ b/dw/sparse_attention.py
@@ -0,0 +1,669 @@
+"""Sparse attention for MiniMax H3's generated-video rows (#931).
+
+Sparse here means comfy-kitchen's Sol-Attn: the generated video's rows are
+grouped into 4x4x4 (t, h, w) tiles of 64 rows, and each query tile attends only
+to the key tiles that matter, instead of every row. Everything that is not the
+generated video (text, references, target audio) stays dense.
+
+The layout rule: H3 packs text, then the references in request order, then the
+target audio, then the target video last. A reference image carries the same
+video tag as the target, so the target video is the trailing run of video rows,
+not every video-tagged row. Rows before it go first, in segment-pure tiles
+(contiguous runs of one tag, at most 64 rows each) that are always attended in
+full; the video tiles follow.
+
+The decided-once rule: whether a pipeline call runs sparse is decided once,
+before the first forward, and is all or nothing. A layout check that fails
+after that decision raises; it never drops a single forward back to dense,
+because a run that mixes the two is worse than either. The call's first
+kernel invocation is still part of that decision: a kernel that fails there
+runs the whole call dense, since no block has run sparse yet, and one that
+fails after it has once returned raises.
+"""
+
+import functools
+import logging
+from collections.abc import Iterator, Mapping
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from numbers import Real
+
+import torch
+
+from .events import emit_log, emit_warning
+
+logger = logging.getLogger("dw")
+
+SPARSE_BACKEND = "sparse"
+DEFAULT_TAU = 0.5
+
+# Rows per tile: 4 x 4 x 4 in (t, h, w)
+TILE = 64
+_SIDE = 4
+
+# The one class sparse attention knows how to lay out
+_H3_CLASS = "MiniMaxH3Transformer3DModel"
+
+# The kernel seam: tests set this to a stand-in; None means comfy-kitchen's
+_sol_attn = None
+
+
+class SparseLayoutError(ValueError):
+    """The packed rows are not a layout the tile map can describe."""
+
+
+def _checked_tau(tau):
+    """`tau` when it is a number >= 0; a ValueError otherwise.
+
+    A bad tau is the workflow's error, not a reason to run dense, so it is
+    raised where it is set rather than reaching the kernel. A bool is refused
+    although Python counts it as a number: `true` is never a threshold.
+    """
+    if isinstance(tau, bool) or not isinstance(tau, Real) or not tau >= 0:
+        raise ValueError(f"sparse_tau must be a number >= 0, got {tau!r}")
+    return tau
+
+
+def _checked_topk(topk):
+    """`topk` when it is None or a number strictly between 0 and 1.
+
+    sol_attn refuses anything else (0 means tau routing, 1 is dense), so a
+    bad value is refused here, at install, rather than by the kernel mid-call.
+    """
+    if topk is None:
+        return None
+    if isinstance(topk, bool) or not isinstance(topk, Real) or not 0 < topk < 1:
+        raise ValueError(f"sparse_topk must be a number between 0 and 1, got {topk!r}")
+    return topk
+
+
+@dataclass(frozen=True)
+class TileMap:
+    """Where each packed row lives in the padded, tiled sequence.
+
+    `dst` sends packed row -> padded row; `block_len` is the live row count of
+    each tile; the first `num_prefix_tiles` tiles are the dense prefix and the
+    rest are video tiles of the `video_grid` (t, h, w) latent grid.
+    """
+
+    dst: torch.Tensor
+    block_len: torch.Tensor
+    num_prefix_tiles: int
+    padded_rows: int
+    rows: int
+    video_grid: tuple[int, int, int]
+
+
+def build_tile_map(
+    position_ids: torch.Tensor, token_tags: torch.Tensor, device
+) -> TileMap:
+    """Map each packed row to a padded tiled row.
+
+    Every row that is not target video goes first, in segment-pure tiles; the
+    target video follows in 4x4x4 tiles of its (t, h, w) position ids.
+    """
+    tags = token_tags.cpu()
+    pos = position_ids.cpu()
+    s = tags.numel()
+    if pos.shape != (s, 3):
+        raise SparseLayoutError(
+            f"position_ids {tuple(pos.shape)} do not match {s} token tags"
+        )
+
+    # Target video = the trailing run of video rows
+    non_video = (tags != 0).nonzero()
+    target_start = int(non_video[-1]) + 1 if len(non_video) else 0
+    if target_start >= s:
+        raise SparseLayoutError("no target video rows at the end of the sequence")
+
+    dst = torch.empty(s, dtype=torch.long)
+    live: list[int] = []
+    tile = 0
+
+    # Prefix segments are contiguous runs of one tag
+    prefix_tags = tags[:target_start]
+    breaks = torch.ones(target_start, dtype=torch.bool)
+    if target_start > 1:
+        breaks[1:] = prefix_tags[1:] != prefix_tags[:-1]
+    starts = breaks.nonzero().squeeze(1).tolist() + [target_start]
+    for a, b in zip(starts[:-1], starts[1:]):
+        for c in range(a, b, TILE):
+            n = min(TILE, b - c)
+            dst[c : c + n] = tile * TILE + torch.arange(n)
+            live.append(n)
+            tile += 1
+    num_prefix_tiles = tile
+
+    # H3's rotary coordinates are fractional (aspect-normalized space, uneven
+    # time), so rank each axis's distinct values to get the integer grid index
+    vrows = torch.arange(target_start, s)
+    vp = torch.stack(
+        [torch.unique(pos[vrows, a], return_inverse=True)[1] for a in range(3)], dim=1
+    )
+    gt, gh, gw = (vp.max(0).values + 1).tolist()
+    if gt * gh * gw != len(vrows):
+        raise SparseLayoutError(
+            f"target video is not a full grid: {gt}x{gh}x{gw} != {len(vrows)} rows"
+        )
+    nh, nw = (gh + _SIDE - 1) // _SIDE, (gw + _SIDE - 1) // _SIDE
+    tid = ((vp[:, 0] // _SIDE) * nh + vp[:, 1] // _SIDE) * nw + vp[:, 2] // _SIDE
+    within = ((vp[:, 0] % _SIDE) * _SIDE + vp[:, 1] % _SIDE) * _SIDE + vp[:, 2] % _SIDE
+    order = torch.argsort(tid * TILE + within, stable=True)
+    _, counts = torch.unique_consecutive(tid[order], return_counts=True)
+    offs = 0
+    for n in counts.tolist():
+        dst[vrows[order[offs : offs + n]]] = tile * TILE + torch.arange(n)
+        live.append(n)
+        tile += 1
+        offs += n
+
+    if sum(live) != s or torch.unique(dst).numel() != s:
+        raise SparseLayoutError("tile map does not cover every row exactly once")
+    return TileMap(
+        dst=dst.to(device),
+        block_len=torch.tensor(live, dtype=torch.int32, device=device),
+        num_prefix_tiles=num_prefix_tiles,
+        padded_rows=tile * TILE,
+        rows=s,
+        video_grid=(gt, gh, gw),
+    )
+
+
+def sparse_unavailable_reason(device, dtype, head_dim: int) -> str | None:
+    """Why the Sol-Attn kernel cannot run here, or None when it can.
+
+    Asked once per pipeline call, before the first forward: a reason makes the
+    whole call run dense, with a warning, rather than fail.
+    """
+    device = torch.device(device)
+    if device.type != "cuda":
+        return f"device {device.type} is not CUDA"
+    major, minor = torch.cuda.get_device_capability(device)
+    if (major, minor) < (8, 0):
+        return f"compute capability {major}.{minor} is below 8.0"
+    if dtype not in (torch.bfloat16, torch.float16):
+        return f"dtype {str(dtype).removeprefix('torch.')} is not bfloat16/float16"
+    if head_dim != 128:
+        return f"head_dim {head_dim} is not 128"
+    try:
+        import comfy_kitchen as ck
+
+        if not ck.sol_attn_is_available(device):
+            return "comfy-kitchen kernels unavailable: sol_attn_is_available() is False"
+    except Exception as exc:  # an import or a kernel probe that fails is a no
+        return f"comfy-kitchen kernels unavailable: {exc}"
+    return None
+
+
+def _kernel():
+    """The sol_attn callable: the test seam when set, else comfy-kitchen's.
+
+    The kernel takes bfloat16/float16 only. The decision refuses any other
+    dtype, so the cast here is a guard a real run does not reach. It lives at
+    this seam, not in the processor, so a stand-in gets the tensors as they
+    are: a float32 test then checks the permutation exactly, not to bf16.
+    """
+    if _sol_attn is not None:
+        return _sol_attn
+    import comfy_kitchen as ck
+
+    def run(q, k, v, **kwargs):
+        if q.dtype not in (torch.bfloat16, torch.float16):
+            q, k, v = (x.to(torch.bfloat16) for x in (q, k, v))
+        with ck.use_backend("cuda"):
+            return ck.sol_attn(q, k, v, **kwargs)
+
+    return run
+
+
+@dataclass
+class _SparseState:
+    """One installed component's sparse settings and its per-call decision.
+
+    `decided` is reset by `sparse_call` on entry; the first forward after that
+    sets it, and `reason` is None when that forward decided sparse. `active` is
+    True only inside the component's forward, between the two hooks.
+    `kernel_ran` records that the kernel has returned once in this call: until
+    it has, a kernel error is still part of the decision and runs the call
+    dense; after, it raises.
+    """
+
+    tau: float
+    # sol_attn's top-k mode when set: keep this fraction of key tiles per
+    # query tile and drop the rest outright (no pooled tail), the selection
+    # lightx2v's SLA LoRAs were trained against. tau is ignored then (#932)
+    topk: float | None = None
+    originals: list = field(default_factory=list)
+    handles: list = field(default_factory=list)
+    decided: bool = False
+    reason: str | None = None
+    tile_map: TileMap | None = None
+    layout: tuple | None = None
+    active: bool = False
+    kernel_ran: bool = False
+
+    def reset(self):
+        self.decided = False
+        self.reason = None
+        self.tile_map = None
+        self.layout = None
+        self.active = False
+        self.kernel_ran = False
+
+
+class SparseH3AttnProcessor:
+    """Sol-Attn over one H3 block, or the original processor when the call
+    decided dense.
+
+    The sparse path is the stock processor's with the attention swapped: the
+    same projections, q/k norms and rotary, then the rows are scattered into
+    the padded tile order, attended there, and gathered back.
+    """
+
+    def __init__(self, original, state: _SparseState):
+        self._original = original
+        self._state = state
+
+    # diffusers' set_attention_backend / context parallelism write these onto
+    # every processor; they belong to the original, which the dense path runs
+    @property
+    def _attention_backend(self):
+        return getattr(self._original, "_attention_backend", None)
+
+    @_attention_backend.setter
+    def _attention_backend(self, value):
+        self._original._attention_backend = value
+
+    @property
+    def _parallel_config(self):
+        return getattr(self._original, "_parallel_config", None)
+
+    @_parallel_config.setter
+    def _parallel_config(self, value):
+        self._original._parallel_config = value
+
+    def __call__(self, attn, hidden_states, rotary_emb=None, attention_mask=None):
+        state = self._state
+        if not (state.active and state.decided and state.reason is None):
+            return self._original(attn, hidden_states, rotary_emb, attention_mask)
+
+        tm = state.tile_map
+        if attention_mask is not None:
+            raise SparseLayoutError("sparse attention was given an attention mask")
+        if hidden_states.shape[1] != tm.rows:
+            raise SparseLayoutError(
+                f"{hidden_states.shape[1]} rows reached a block whose tile map has {tm.rows}"
+            )
+
+        from diffusers.models.transformers.transformer_minimax_h3 import (
+            _apply_rotary_emb,
+        )
+
+        if attn.fused_projections:
+            query, key, value = attn.to_qkv(hidden_states).chunk(3, dim=-1)
+        else:
+            query = attn.to_q(hidden_states)
+            key = attn.to_k(hidden_states)
+            value = attn.to_v(hidden_states)
+        query = attn.norm_q(query.unflatten(-1, (attn.heads, -1)))
+        key = attn.norm_k(key.unflatten(-1, (attn.heads, -1)))
+        value = value.unflatten(-1, (attn.heads, -1))
+        if rotary_emb is not None:
+            query = _apply_rotary_emb(query, *rotary_emb)
+            key = _apply_rotary_emb(key, *rotary_emb)
+
+        b, _, h, d = query.shape
+        dst = tm.dst.to(query.device)
+
+        def tiled(x):
+            out = x.new_zeros((b, tm.padded_rows, h, d))
+            out[:, dst] = x
+            return out
+
+        pt = tm.num_prefix_tiles
+        try:
+            out = _kernel()(
+                tiled(query),
+                tiled(key),
+                tiled(value),
+                sink_blocks=[0, pt],
+                sink_q=[0, pt],
+                block_len=tm.block_len.to(query.device),
+                **_routing(state),
+            )
+        except Exception as exc:
+            if state.kernel_ran:
+                raise
+            # The call's first kernel invocation is still the decision: no
+            # block has run sparse yet, so this block and every later one in
+            # the call run dense, and sparse_call reports why
+            state.reason = f"sparse kernel failed: {type(exc).__name__}: {exc}"
+            state.tile_map = state.layout = None
+            return self._original(attn, hidden_states, rotary_emb, attention_mask)
+        state.kernel_ran = True
+        hidden_states = out[:, dst].flatten(2, 3).type_as(query)
+        hidden_states = attn.to_out[0](hidden_states)
+        return attn.to_out[1](hidden_states)
+
+
+# The H3 forward's leading positional parameters, for a caller that passes
+# them positionally; diffusers' denoiser passes them by name
+_FORWARD_ARGS = (
+    "hidden_states",
+    "audio_hidden_states",
+    "encoder_hidden_states",
+    "timestep",
+    "timestep_indices",
+    "token_tags",
+    "position_ids",
+)
+
+
+def _forward_arg(args, kwargs, name):
+    if name in kwargs:
+        return kwargs[name]
+    index = _FORWARD_ARGS.index(name)
+    return args[index] if index < len(args) else None
+
+
+def _block_dtype(component) -> torch.dtype:
+    """The block stack's compute dtype: its first floating-point parameter,
+    which skips the integer storage of a quantized weight."""
+    for p in component.transformer_blocks[0].parameters():
+        if p.is_floating_point():
+            return p.dtype
+    return torch.float32
+
+
+def _same_layout(layout, position_ids, token_tags) -> bool:
+    """Whether the tile map built for `layout` still describes this forward.
+
+    Compared exactly, not by a summary: a transposed grid (h=6, w=5 against
+    h=5, w=6) has the same row count, tag sum and even position sum, and a
+    stale map there is a wrong permutation. The denoiser passes the same
+    tensors every step, so the identity check is the usual answer.
+    """
+    pos, tags = layout
+    if position_ids is pos and token_tags is tags:
+        return True
+    return (
+        pos.shape == position_ids.shape
+        and tags.shape == token_tags.shape
+        and torch.equal(pos, position_ids)
+        and torch.equal(tags, token_tags)
+    )
+
+
+def _pre_hook(component, args, kwargs):
+    """Decide the call on its first forward; keep the tile map current after."""
+    state = component._dw_sparse_state
+    hidden_states = _forward_arg(args, kwargs, "hidden_states")
+    position_ids = _forward_arg(args, kwargs, "position_ids")
+    token_tags = _forward_arg(args, kwargs, "token_tags")
+    if position_ids is None or token_tags is None:
+        missing = "position_ids/token_tags were not passed"
+        if state.decided and state.reason is None:
+            raise SparseLayoutError(missing)
+        state.decided, state.reason = True, state.reason or missing
+        return None
+
+    if not state.decided:
+        state.decided = True
+        # Sparse never fails a run dense would have run: anything that goes
+        # wrong while deciding is a reason to run this call dense
+        try:
+            device = hidden_states.device
+            state.reason = sparse_unavailable_reason(
+                device, _block_dtype(component), component.config.attention_head_dim
+            )
+            if state.reason is None:
+                state.tile_map = build_tile_map(position_ids, token_tags, device)
+                state.layout = (position_ids, token_tags)
+        except Exception as exc:
+            state.reason = f"{type(exc).__name__}: {exc}"
+            state.tile_map = state.layout = None
+    elif state.reason is None and not _same_layout(
+        state.layout, position_ids, token_tags
+    ):
+        # Decided sparse: a layout the map cannot describe now raises
+        state.tile_map = build_tile_map(position_ids, token_tags, hidden_states.device)
+        state.layout = (position_ids, token_tags)
+    state.active = True
+    return None
+
+
+def _post_hook(component, args, output):
+    component._dw_sparse_state.active = False
+    return None
+
+
+def _routing(state):
+    """The kernel's routing arguments: top-k when the state has one, else tau."""
+    if state.topk is not None:
+        return {"topk_ratio": state.topk, "tail": False}
+    return {"tau": state.tau}
+
+
+def install_sparse(component, tau: float, topk: float | None = None) -> bool:
+    """Put the sparse processor on every block of an H3 transformer.
+
+    Returns False, changing nothing, for any other component. A second call
+    only updates tau and topk. A tau that is not a number >= 0, or a topk
+    that is neither None nor strictly between 0 and 1, raises ValueError, for
+    any component. The forward itself is not wrapped: H3's denoiser picks
+    the layout kwargs it passes from the forward's signature, so the decision
+    runs in forward hooks instead.
+    """
+    _checked_tau(tau)
+    _checked_topk(topk)
+    if type(component).__name__ != _H3_CLASS:
+        return False
+    state = getattr(component, "_dw_sparse_state", None)
+    if state is not None:
+        state.tau, state.topk = tau, topk
+        return True
+    state = _SparseState(tau=tau, topk=topk)
+    for block in component.transformer_blocks:
+        state.originals.append(block.attn.processor)
+        block.attn.set_processor(SparseH3AttnProcessor(block.attn.processor, state))
+    state.handles = [
+        component.register_forward_pre_hook(_pre_hook, with_kwargs=True),
+        component.register_forward_hook(_post_hook, always_call=True),
+    ]
+    component._dw_sparse_state = state
+    return True
+
+
+def uninstall_sparse(component) -> None:
+    """Put the original processors back and remove both hooks."""
+    state = getattr(component, "_dw_sparse_state", None)
+    if state is None:
+        return
+    for block, original in zip(component.transformer_blocks, state.originals):
+        block.attn.set_processor(original)
+    for handle in state.handles:
+        handle.remove()
+    del component._dw_sparse_state
+
+
+def is_sparse_installed(component) -> bool:
+    return getattr(component, "_dw_sparse_state", None) is not None
+
+
+def set_sparse_tau(component, tau: float, topk: float | None = None) -> None:
+    """Change an installed component's tau and topk (None clears top-k); a
+    bad value raises ValueError."""
+    state = component._dw_sparse_state
+    state.tau, state.topk = _checked_tau(tau), _checked_topk(topk)
+
+
+@dataclass
+class SparseCallReport:
+    """How one pipeline call ran: sparse throughout, or dense and why."""
+
+    ran_sparse: bool = False
+    reason: str | None = None
+
+
+def pipeline_components(pipeline):
+    """Every distinct component of the pipeline, once each."""
+    for _, value in named_pipeline_components(pipeline):
+        yield value
+
+
+def named_pipeline_components(pipeline):
+    """Every distinct component of the pipeline as (name, component), once each.
+
+    A ModularPipeline lists its components in a `components` mapping; anything
+    else is read through its attributes. A pipeline-level 'sparse' installs on
+    the ones install_sparse accepts, so it finds them the way sparse_call does.
+
+    sparse_call runs on every family's pipeline call, so reading the mapping
+    must never fail one: DiffusionPipeline's `components` property raises
+    ValueError when its attributes and expected modules disagree, and any
+    error there falls back to the attributes.
+    """
+    try:
+        components = getattr(pipeline, "components", None)
+    except Exception:
+        components = None
+    if isinstance(components, Mapping):
+        items = components.items()
+    else:
+        items = getattr(pipeline, "__dict__", {}).items()
+    seen = set()
+    for name, value in list(items):
+        if id(value) not in seen:
+            seen.add(id(value))
+            yield name, value
+
+
+def _installed_components(pipeline):
+    """Every component of the pipeline with sparse installed."""
+    return [c for c in pipeline_components(pipeline) if is_sparse_installed(c)]
+
+
+@contextmanager
+def sparse_call(pipeline, label: str) -> Iterator[SparseCallReport]:
+    """Scope one pipeline call's sparse decision.
+
+    Every installed component decides afresh on its first forward inside the
+    block. A component that fell back is reported once per call, through the
+    run's warnings, since a run that silently ran dense is a speed regression
+    nobody would see. The report is filled on exit, also when the call raises;
+    the warning is emitted only when it completes.
+    """
+    states = [c._dw_sparse_state for c in _installed_components(pipeline)]
+    for state in states:
+        state.reset()
+    report = SparseCallReport()
+    try:
+        yield report
+    finally:
+        decided = [s for s in states if s.decided]
+        reasons = [s.reason for s in decided if s.reason is not None]
+        report.reason = reasons[0] if reasons else None
+        report.ran_sparse = bool(decided) and not reasons
+    if report.reason is not None:
+        emit_warning(
+            f"{label}: sparse attention ran dense - {report.reason}",
+            attention_backend=SPARSE_BACKEND,
+            reason=report.reason,
+        )
+
+
+@functools.cache
+def _kernels_importable() -> bool:
+    """Whether comfy-kitchen's compiled CUDA extension loaded.
+
+    Cached: the first health poll would otherwise import comfy-kitchen inside
+    the request handler, and the answer cannot change in a running process.
+    Reads the import-time flag only. It never asks a card for its compute
+    capability or initializes CUDA: the server answers this without owning a
+    GPU context, and the per-card check stays at run time
+    (`sparse_unavailable_reason`).
+    """
+    try:
+        from comfy_kitchen.backends import cuda
+
+        return bool(cuda._EXT_AVAILABLE)
+    except Exception:  # no package, or one that will not import: not available
+        return False
+
+
+def apply_sparse_settings(configuration, model):
+    """A component-level sparse install's tau and topk, from the definition on a hit.
+
+    The install outlives the call, so a hit that moved only sparse_tau or
+    sparse_topk would otherwise keep the old one. A pipeline-level 'sparse' installs per call
+    with the tau it states, so it needs nothing here.
+    """
+    entries = configuration.get("components")
+    if not isinstance(entries, dict):
+        return
+    for name, entry in entries.items():
+        if (
+            not isinstance(entry, dict)
+            or entry.get("attention_backend") != SPARSE_BACKEND
+        ):
+            continue
+        component = getattr(model, name, None)
+        if component is not None and is_sparse_installed(component):
+            set_sparse_tau(
+                component,
+                entry.get("sparse_tau", DEFAULT_TAU),
+                entry.get("sparse_topk"),
+            )
+
+
+def install_sparse_for_call(pipeline, configuration, stack, label):
+    """A pipeline-level 'sparse': the sparse processor on the pipeline's H3
+    components for one call, taken off by `stack` when the call ends.
+
+    A component already set to 'sparse' at component level keeps that
+    install and its tau: it persists across calls by design, so only what
+    this call installed comes off when it ends. A component pinned to any
+    other backend keeps its pin, the way a component pin beats a
+    pipeline-level backend everywhere else, and the skip is said aloud:
+    overriding it silently ran sparse under a log that named the pin.
+    """
+    tau = configuration.get("sparse_tau", DEFAULT_TAU)
+    topk = configuration.get("sparse_topk")
+    pins = {
+        name: block.get("attention_backend")
+        for name, block in (configuration.get("components") or {}).items()
+        if isinstance(block, dict)
+        and block.get("attention_backend") not in (None, SPARSE_BACKEND)
+    }
+    found = False
+    installed = []
+    for name, component in named_pipeline_components(pipeline):
+        # only an H3 transformer is ever sparse's to skip; a pin on any
+        # other component is no conflict, and must not count as found
+        if name in pins and type(component).__name__ == _H3_CLASS:
+            found = True
+            emit_warning(
+                f"{label}: attention_backend 'sparse' at pipeline level skips "
+                f"'{name}', which pins '{pins[name]}'",
+                attention_backend=SPARSE_BACKEND,
+                component=name,
+            )
+        elif is_sparse_installed(component):
+            found = True
+        elif install_sparse(component, tau, topk):
+            found = True
+            installed.append(name)
+            stack.callback(uninstall_sparse, component)
+    if installed:
+        routing = f"topk {topk}" if topk is not None else f"tau {tau}"
+        message = (
+            f"Using attention backend: sparse ({routing}) on {', '.join(installed)}"
+        )
+        logger.info(message)
+        emit_log(message, attention_backend=SPARSE_BACKEND, components=installed)
+    if not found:
+        emit_warning(
+            f"{label}: attention_backend 'sparse' found no MiniMax-H3 "
+            "transformer; runs dense",
+            attention_backend=SPARSE_BACKEND,
+        )
diff --git a/dw/step_cache.py b/dw/step_cache.py
index da873d65..c09fee4e 100644
--- a/dw/step_cache.py
+++ b/dw/step_cache.py
@@ -149,6 +149,7 @@ def component_names(pipeline_definition, key):
 
 
 RUNTIME_LORA_KEYS = ("scale", "alpha")
+RUNTIME_SPARSE_KEYS = ("sparse_tau", "sparse_topk")
 
 
 def weights_identity(pipeline_definition):
@@ -168,6 +169,10 @@ def weights_identity(pipeline_definition):
     (or nulls the variable behind it) must reload to get the default back,
     where 16 -> 8 just re-applies. A scale needs no marker - an absent scale
     re-applies as 1.0.
+
+    sparse_tau (#931), on the configuration and on each of its components,
+    needs no marker either: it has no checkpoint value to restore, and an
+    absent one re-applies as DEFAULT_TAU.
     """
     identity = {
         k: v
@@ -186,14 +191,31 @@ def weights_identity(pipeline_definition):
         scheduler = identity.get(name)
         if isinstance(scheduler, dict):
             identity[name] = _without_runtime(scheduler, ("shift",), "shift")
+    configuration = identity.get("configuration")
+    if isinstance(configuration, dict):
+        identity["configuration"] = _without_sparse_tau(configuration)
     return identity
 
 
-def _without_runtime(block, runtime_keys, marked):
+def _without_sparse_tau(configuration):
+    """The configuration without sparse_tau, at pipeline or component level."""
+    stripped = _without_runtime(configuration, RUNTIME_SPARSE_KEYS)
+    entries = stripped.get("components")
+    if isinstance(entries, dict):
+        stripped["components"] = {
+            name: _without_runtime(entry, RUNTIME_SPARSE_KEYS)
+            if isinstance(entry, dict)
+            else entry
+            for name, entry in entries.items()
+        }
+    return stripped
+
+
+def _without_runtime(block, runtime_keys, marked=None):
     """`block` without its runtime keys, but with `marked` as True when the
     block states it - see weights_identity for why its presence counts."""
     stripped = {k: v for k, v in block.items() if k not in runtime_keys}
-    if block.get(marked) is not None:
+    if marked is not None and block.get(marked) is not None:
         stripped[marked] = True
     return stripped
 
diff --git a/dw/tasks/speech_generation.py b/dw/tasks/speech_generation.py
index 0fbe8b61..7692abbf 100644
--- a/dw/tasks/speech_generation.py
+++ b/dw/tasks/speech_generation.py
@@ -26,6 +26,7 @@
 from ..media_types import AudioTrack
 from ..dsp import resample_waveform
 from .audio_utils import load_audio
+from ..trust import require_trusted_generate_arguments
 from .model_cache import cached_model, hf_pipeline_placement
 
 logger = logging.getLogger("dw")
@@ -84,6 +85,40 @@ def load_encoder():
     return embedding.squeeze().unsqueeze(0).to(device=device, dtype=dtype)
 
 
+def _check_messages(messages):
+    """Chat-templated input: a non-empty list of {role, content} string dicts."""
+    valid = isinstance(messages, list) and len(messages) > 0
+    if valid:
+        for message in messages:
+            if (
+                not isinstance(message, dict)
+                or not isinstance(message.get("role"), str)
+                or not isinstance(message.get("content"), str)
+            ):
+                valid = False
+                break
+    if not valid:
+        raise ValueError(
+            "generate_speech's 'messages' needs a non-empty list of "
+            "{'role': ..., 'content': ...} dicts, both strings - a bare "
+            "string or a wrong-keyed dict is not chat-templated input"
+        )
+
+
+def _generation_settings(value, name):
+    """A workflow's forward_params or generate_kwargs: an object, with the
+    Hub-code arguments refused unless workflows are trusted."""
+    if not value:
+        return {}
+    if not isinstance(value, dict):
+        raise ValueError(
+            f"generate_speech: {name} must be an object of settings, got "
+            f"{type(value).__name__}"
+        )
+    require_trusted_generate_arguments(value, f"speech_generation ({name})")
+    return value
+
+
 def generate_speech(text=None, device="cpu", seed=None, **kwargs):
     """Speak a line of text with a local text-to-speech model.
 
@@ -141,23 +176,17 @@ def generate_speech(text=None, device="cpu", seed=None, **kwargs):
             "such as VibeVoice"
         )
     if messages is not None:
-        valid = isinstance(messages, list) and len(messages) > 0
-        if valid:
-            for message in messages:
-                if (
-                    not isinstance(message, dict)
-                    or not isinstance(message.get("role"), str)
-                    or not isinstance(message.get("content"), str)
-                ):
-                    valid = False
-                    break
-        if not valid:
-            raise ValueError(
-                "generate_speech's 'messages' needs a non-empty list of "
-                "{'role': ..., 'content': ...} dicts, both strings - a bare "
-                "string or a wrong-keyed dict is not chat-templated input"
-            )
+        _check_messages(messages)
     text_inputs = messages if messages is not None else text
+    # Both reach model.generate() for a generative model, where
+    # custom_generate / trust_remote_code download and run Hub code: refused
+    # for an untrusted workflow before anything loads, as text_generation does
+    forward_params = _generation_settings(
+        kwargs.get("forward_params"), "forward_params"
+    )
+    generate_kwargs = _generation_settings(
+        kwargs.get("generate_kwargs"), "generate_kwargs"
+    )
 
     model_name = kwargs.get("model_name", _DEFAULT_MODEL)
     voice_preset = kwargs.get("voice_preset", None)
@@ -187,7 +216,6 @@ def load_pipe():
             "preset, or use a model with speaker presets such as suno/bark-small"
         )
 
-    forward_params = kwargs.get("forward_params") or {}
     if speaker_embedding:
         model_type = getattr(getattr(pipe.model, "config", None), "model_type", None)
         if model_type != "speecht5":
@@ -216,7 +244,7 @@ def load_pipe():
         text_inputs,
         preprocess_params={"voice_preset": voice_preset} if voice_preset else {},
         forward_params=forward_params,
-        generate_kwargs=kwargs.get("generate_kwargs") or {},
+        generate_kwargs=generate_kwargs,
     )
 
     sample_rate = output.get("sampling_rate")
diff --git a/dw/tasks/text_generation.py b/dw/tasks/text_generation.py
index def832bd..03a81063 100644
--- a/dw/tasks/text_generation.py
+++ b/dw/tasks/text_generation.py
@@ -11,9 +11,16 @@
 workflow whose prompt agrees with its keyframe and one whose prompt fights it.
 """
 
+import json
 import logging
+import os
+import re
+
+from huggingface_hub import get_hf_file_metadata, hf_hub_download, hf_hub_url
 from transformers import pipeline as hf_pipeline
 from .. import preferred_task_dtype
+from ..locations import validate_hub_repo_id, validate_weight_name
+from ..trust import require_trusted_generate_arguments
 from .model_cache import cached_model, hf_pipeline_placement
 
 logger = logging.getLogger("dw")
@@ -42,15 +49,28 @@ def _image_part(image):
     return {"type": "image", "url" if isinstance(image, str) else "image": image}
 
 
-def _build_messages(prompt, system_prompt, image):
+def _images(image):
+    """The images a call carries, as a list in order, or None for none.
+
+    A template's optional reference list arrives as [] or [None] when the
+    caller supplied nothing, and that is the same statement as no image.
+    """
+    if image is None:
+        return None
+    images = list(image) if isinstance(image, (list, tuple)) else [image]
+    images = [i for i in images if i is not None and i != ""]
+    return images or None
+
+
+def _build_messages(prompt, system_prompt, images):
     """Chat messages in the shape the chosen pipeline expects.
 
     Text-generation models take plain string content. Vision models take a
-    list of typed parts, because the image is a part of the message rather
-    than something alongside it.
+    list of typed parts, because the images are part of the message rather
+    than something alongside it - every image first, in order, then the text.
     """
     messages = []
-    if image is None:
+    if images is None:
         if system_prompt is not None:
             messages.append({"role": "system", "content": system_prompt})
         messages.append({"role": "user", "content": prompt})
@@ -62,12 +82,252 @@ def _build_messages(prompt, system_prompt, image):
         messages.append(
             {
                 "role": "user",
-                "content": [_image_part(image), {"type": "text", "text": prompt}],
+                "content": [_image_part(i) for i in images]
+                + [{"type": "text", "text": prompt}],
             }
         )
     return messages
 
 
+# A pinned prompt has to stay pinned: a short hash can become ambiguous and a
+# branch moves, so only a full commit is accepted
+_FULL_COMMIT = re.compile(r"^[0-9a-f]{40}$")
+_FROM_HUB_FIELDS = {"repo", "file", "revision", "key"}
+
+
+# A system prompt is a page of instructions; anything bigger is not one
+_MAX_PROMPT_FILE_BYTES = 1024 * 1024
+
+
+def resolve_system_prompt(value):
+    """The system prompt text, reading it from a Hub repo when one is named.
+
+    Some vendors ship the instructions their model was trained against as a
+    file in its repo, and change them. Naming the file and a full commit runs
+    exactly that text without copying it into a workflow, where it would
+    drift from the source.
+
+    Args:
+        value: None, the text itself, or {"from_hub": {"repo", "file",
+            "revision", "key"}}. `revision` is a full 40-character commit.
+            A .json file takes `key` to pick one string out of a top-level
+            object; any other file is read whole as text
+
+    Raises:
+        ValueError: On any other shape, a revision that is not a full commit,
+            a file path that leaves the repo, a missing key, or a value that
+            is not text
+    """
+    if value is None or isinstance(value, str):
+        return value
+    if (
+        not isinstance(value, dict)
+        or set(value) != {"from_hub"}
+        or not isinstance(value["from_hub"], dict)
+    ):
+        raise ValueError(
+            'system_prompt must be text or {"from_hub": {"repo", "file", "revision", "key"}}'
+        )
+    spec = value["from_hub"]
+    unknown = set(spec) - _FROM_HUB_FIELDS
+    if unknown:
+        raise ValueError(f"system_prompt.from_hub does not take {sorted(unknown)}")
+    repo = spec.get("repo")
+    if not isinstance(repo, str) or not repo:
+        raise ValueError(
+            f"system_prompt.from_hub.repo must be a Hub repo id string, got {repo!r}"
+        )
+    repo = validate_hub_repo_id(repo, what="system_prompt.from_hub.repo")
+    file = validate_weight_name(spec.get("file"), what="system_prompt.from_hub.file")
+    revision = spec.get("revision")
+    if not isinstance(revision, str) or not _FULL_COMMIT.match(revision):
+        raise ValueError(
+            "system_prompt.from_hub.revision must be a full 40-character lowercase "
+            f"commit hash, so the text cannot change under the workflow; got {revision!r}"
+        )
+    key = spec.get("key")
+    if key is not None and not isinstance(key, str):
+        raise ValueError(f"system_prompt.from_hub.key must be a string, got {key!r}")
+
+    # hf_hub_download answers a full commit from the local cache without asking
+    # the Hub, so files the server fetched with its own login (gated or private
+    # repos) would be readable by any workflow. Ask the Hub, anonymously, first,
+    # and fail closed on any error rather than fall back to the cache
+    try:
+        metadata = get_hf_file_metadata(
+            hf_hub_url(repo, file, revision=revision), token=False
+        )
+    except Exception as e:
+        raise ValueError(
+            f"system_prompt.from_hub: {repo}/{file} at {revision[:8]} is not a "
+            f"public file the Hub will serve without credentials ({type(e).__name__})"
+        ) from e
+    # No size is no promise the file is small, so it is refused rather than
+    # downloaded on trust
+    if metadata.size is None:
+        raise ValueError(
+            f"system_prompt.from_hub: the Hub reported no size for {file}, so it "
+            f"cannot be checked against the {_MAX_PROMPT_FILE_BYTES}-byte limit "
+            "before downloading"
+        )
+    if metadata.size > _MAX_PROMPT_FILE_BYTES:
+        raise ValueError(
+            f"system_prompt.from_hub: {file} is larger than "
+            f"{_MAX_PROMPT_FILE_BYTES} bytes, too big for a system prompt"
+        )
+
+    # token=False: the server's own Hub login must not reach a private or gated
+    # file on a workflow's say-so, since the text is echoed into outputs
+    path = hf_hub_download(repo, file, revision=revision, token=False)
+    if os.path.getsize(path) > _MAX_PROMPT_FILE_BYTES:
+        raise ValueError(
+            f"system_prompt.from_hub: {file} is larger than "
+            f"{_MAX_PROMPT_FILE_BYTES} bytes, too big for a system prompt"
+        )
+    with open(path, encoding="utf-8") as f:
+        if file.endswith(".json"):
+            data = json.load(f)
+        else:
+            data = f.read()
+    if key is not None:
+        if not isinstance(data, dict) or key not in data:
+            keys = sorted(data) if isinstance(data, dict) else []
+            raise ValueError(
+                f"system_prompt.from_hub: {file} at {revision[:8]} has no key {key!r}; "
+                f"it has {keys}"
+            )
+        data = data[key]
+    if not isinstance(data, str) or not data.strip():
+        raise ValueError(
+            f"system_prompt.from_hub: {file}{'[' + repr(key) + ']' if key else ''} "
+            "is not text"
+        )
+    return data
+
+
+# The pipelines' and apply_chat_template's own structural arguments. Chat
+# template settings are splatted into those calls, so one of these in a
+# workflow (which is untrusted) would not set a template variable - it would
+# hand transformers an image or video to fetch that dw never validated, or
+# change what the template call does (tokenize, tools, the template itself).
+# The rest are the calls' other named parameters: one of those is a refusal
+# here, before the model loads, rather than a TypeError after it has
+_RESERVED_CHAT_TEMPLATE_KEYS = frozenset(
+    {
+        "images",
+        "videos",
+        "audio",
+        "audios",
+        "text",
+        "timeout",
+        "processor_kwargs",
+        "generate_kwargs",
+        "max_new_tokens",
+        "return_full_text",
+        "return_tensors",
+        "tokenize",
+        "return_dict",
+        "chat_template",
+        "add_generation_prompt",
+        "continue_final_message",
+        "tools",
+        "documents",
+        "tokenizer_encode_kwargs",
+        "conversation",
+        "padding",
+        "truncation",
+        "max_length",
+        "return_assistant_tokens_mask",
+        "sanitize_control_tokens",
+        "tokenizer_kwargs",
+        "load_audio_from_video",
+        "return_type",
+        "return_text",
+        "stop_sequence",
+        "clean_up_tokenization_spaces",
+        "skip_special_tokens",
+        "inputs",
+        "text_inputs",
+        "batch_size",
+        "num_workers",
+        "prefix",
+        "handle_long_generation",
+    }
+)
+
+# generate_kwargs go into the same calls - splatted into the text pipeline's,
+# handed whole to the vision pipeline's generate() - so the call's own
+# arguments are refused there too, along with the text pipeline's
+# preprocessing switches
+_RESERVED_GENERATE_KEYS = _RESERVED_CHAT_TEMPLATE_KEYS | {
+    "tokenizer_encode_kwargs",
+    "prefix",
+    "handle_long_generation",
+}
+
+
+def _is_scalar(value):
+    return value is None or isinstance(value, (bool, int, float, str))
+
+
+def _validated_chat_template_kwargs(value):
+    """Chat template settings: an object of JSON scalars, none of them one of
+    the call's own structural arguments."""
+    if not value:
+        return {}
+    if not isinstance(value, dict):
+        raise ValueError(
+            "text_generation: chat_template_kwargs must be an object of settings "
+            f"for the chat template, got {type(value).__name__}"
+        )
+    for key, setting in value.items():
+        if key in _RESERVED_CHAT_TEMPLATE_KEYS:
+            raise ValueError(
+                f"text_generation: chat_template_kwargs key '{key}' is not a "
+                "chat-template setting - it is an argument of the generation "
+                "call itself"
+            )
+        if not _is_scalar(setting):
+            raise ValueError(
+                f"text_generation: chat_template_kwargs value for '{key}' must be "
+                f"a boolean, number, string or null, got {type(setting).__name__}"
+            )
+    return value
+
+
+def _validated_generate_kwargs(value):
+    """Generation settings: an object of JSON scalars or lists of them
+    (stop_strings is a list), none of them one of the call's own arguments,
+    and none that runs code from the Hub unless workflows are trusted."""
+    if not value:
+        return {}
+    if not isinstance(value, dict):
+        raise ValueError(
+            "text_generation: generate_kwargs must be an object of settings for "
+            f"the model's generate(), got {type(value).__name__}"
+        )
+    # First: custom_generate's value is a plain string, so nothing below would
+    # stop it
+    require_trusted_generate_arguments(value, "text_generation")
+    for key, setting in value.items():
+        if key in _RESERVED_GENERATE_KEYS:
+            raise ValueError(
+                f"text_generation: generate_kwargs key '{key}' is not a "
+                "generation setting - it is an argument of the pipeline call "
+                "itself"
+            )
+        if not (
+            _is_scalar(setting)
+            or (isinstance(setting, list) and all(_is_scalar(v) for v in setting))
+        ):
+            raise ValueError(
+                f"text_generation: generate_kwargs value for '{key}' must be a "
+                "boolean, number, string, null or a list of those, got "
+                f"{type(setting).__name__}"
+            )
+    return value
+
+
 def generate_text(prompt, device="cpu", **kwargs):
     """Generate text from a prompt using a local language model.
 
@@ -81,24 +341,38 @@ def generate_text(prompt, device="cpu", **kwargs):
                 accept one - a text-only model will fail to load as one.
             system_prompt: Optional system instruction for the model.
             max_new_tokens: Max tokens to generate (default: 500).
-            image: Optional PIL image, URL or path. Its presence is what
-                selects the vision pipeline.
+            image: Optional PIL image, URL or path, or a list of them - every
+                one goes to the model, in order. Its presence is what selects
+                the vision pipeline; an empty list is no image.
+            chat_template_kwargs: Settings for the model's chat template,
+                such as {"enable_thinking": false} for a Qwen3 model that
+                must not reason before answering.
+            revision: The model repo's commit, branch or tag to load.
             repetition_penalty: Vision pipeline only (default: 1.15). Raise it
                 if a model still repeats itself, or set 1.0 to disable.
             generate_kwargs: Anything else to hand the model's generate() -
-                no_repeat_ngram_size, top_p, min_new_tokens and so on. Merged
-                over what this function sets, so it can override those too.
+                no_repeat_ngram_size, top_p, min_new_tokens, stop_strings and
+                so on. Merged over what this function sets, so it can override
+                those too. Values are scalars or lists of scalars; the call's
+                own arguments are refused, and custom_generate and
+                trust_remote_code need trusted workflows.
 
     Returns:
         Generated text string.
     """
     # A workflow declaring an optional image passes it through as null when the
     # caller supplies none, and an empty string is the same statement
-    image = kwargs.get("image", None) or None
-    system_prompt = kwargs.get("system_prompt", None)
+    images = _images(kwargs.get("image", None) or None)
+    # Resolved before anything loads, so a bad reference costs nothing
+    system_prompt = resolve_system_prompt(kwargs.get("system_prompt", None))
     max_new_tokens = int(kwargs.get("max_new_tokens", 500))
+    revision = kwargs.get("revision", None)
+    chat_template_kwargs = _validated_chat_template_kwargs(
+        kwargs.get("chat_template_kwargs")
+    )
+    generate_kwargs = _validated_generate_kwargs(kwargs.get("generate_kwargs"))
 
-    if image is None:
+    if images is None:
         pipeline_task = "text-generation"
         model_name = kwargs.get("model_name", _DEFAULT_MODEL)
     else:
@@ -110,6 +384,8 @@ def generate_text(prompt, device="cpu", **kwargs):
     def load_pipe():
         logger.info(f"Generating text with {model_name} on {device}")
         placement = hf_pipeline_placement(device)
+        if revision is not None:
+            placement = {**placement, "revision": revision}
         return hf_pipeline(
             pipeline_task,
             model=model_name,
@@ -120,35 +396,52 @@ def load_pipe():
     # The task is part of the identity - the same model name can be loaded
     # under either pipeline, and they are not interchangeable
     pipe = cached_model(
-        ("text_generation", pipeline_task, model_name, str(device), str(dtype)),
+        (
+            "text_generation",
+            pipeline_task,
+            model_name,
+            str(revision),
+            str(device),
+            str(dtype),
+        ),
         load_pipe,
     )
 
-    messages = _build_messages(prompt, system_prompt, image)
+    messages = _build_messages(prompt, system_prompt, images)
 
     # Decoding is greedy, so the same input returns the same text every run -
     # which is what a workflow wants, and why there is nothing here to seed
     generation = {"do_sample": False}
-    if image is not None:
+    if images is not None:
         generation["repetition_penalty"] = float(
             kwargs.get("repetition_penalty", _VISION_REPETITION_PENALTY)
         )
     # Last, so a workflow can override anything decided above
-    generation.update(kwargs.get("generate_kwargs") or {})
+    generation.update(generate_kwargs)
 
-    return _generate(pipe, messages, image, max_new_tokens, generation)
+    return _generate(
+        pipe, messages, images, max_new_tokens, generation, chat_template_kwargs
+    )
 
 
-def _generate(pipe, messages, image, max_new_tokens, generation):
+def _generate(pipe, messages, images, max_new_tokens, generation, chat_template_kwargs):
     """Run the pipeline, which each path calls differently."""
-    if image is None:
+    if images is None:
         # This pipeline collects anything it does not name into the arguments it
-        # forwards to generate(), so settings go in as plain keywords
+        # forwards to generate(), so settings go in as plain keywords. Chat
+        # template settings have their own argument, which it hands to
+        # apply_chat_template
+        extra = (
+            {"tokenizer_encode_kwargs": chat_template_kwargs}
+            if chat_template_kwargs
+            else {}
+        )
         results = pipe(
             messages,
             max_new_tokens=max_new_tokens,
             return_full_text=False,
             **generation,
+            **extra,
         )
     else:
         # Images live inside the messages, so the chat goes in as `text` - the
@@ -156,12 +449,15 @@ def _generate(pipe, messages, image, max_new_tokens, generation):
         # settings have to go through generate_kwargs here: anything else this
         # pipeline does not name explicitly is forwarded to the processor and
         # dropped, so a bare do_sample=False would leave sampling on. Passing
-        # max_new_tokens both ways is an error, so it stays a direct argument
+        # max_new_tokens both ways is an error, so it stays a direct argument.
+        # Keywords this pipeline does not name go to the processor's
+        # apply_chat_template, which is where the chat template settings belong
         results = pipe(
             text=messages,
             max_new_tokens=max_new_tokens,
             return_full_text=False,
             generate_kwargs=generation,
+            **chat_template_kwargs,
         )
 
     text = results[0]["generated_text"].strip()
diff --git a/dw/trust.py b/dw/trust.py
index 4a922b77..9e9dcd63 100644
--- a/dw/trust.py
+++ b/dw/trust.py
@@ -275,3 +275,36 @@ def require_trusted_from_pretrained_arguments(arguments, what: str) -> None:
                 f"Python - see docs/SECURITY.md. Pass --trust-workflows if you "
                 f"trust this workflow's source."
             )
+
+
+# generate() arguments that load and run code from the Hub. transformers'
+# generate() hands `custom_generate` (a repo id) to load_custom_generate, which
+# downloads that repo's custom_generate/generate.py and executes it in place of
+# the built-in decoding loop; `trust_remote_code` is what lets it. A task that
+# passes a workflow's generate_kwargs through reaches that with no from_pretrained
+# call for require_trusted_from_pretrained_arguments to see
+GENERATE_REMOTE_CODE_ARGUMENTS = ("custom_generate", "trust_remote_code")
+
+
+def require_trusted_generate_arguments(arguments, what: str) -> None:
+    """Refuse generate() arguments that download and execute Python from the
+    Hub unless the workflow is trusted.
+
+    Args:
+        arguments: The generate_kwargs block a workflow supplied
+        what: The task or call being configured, for the error message
+
+    Raises:
+        UntrustedWorkflowError: If untrusted and any of
+            GENERATE_REMOTE_CODE_ARGUMENTS is set
+    """
+    if workflows_are_trusted() or not isinstance(arguments, dict):
+        return
+    for key in GENERATE_REMOTE_CODE_ARGUMENTS:
+        if arguments.get(key):
+            raise UntrustedWorkflowError(
+                f"Refusing to run {what}: its generate_kwargs set '{key}', which "
+                f"downloads and executes Python from a Hub repository, so it "
+                f"needs trusted workflows - see docs/SECURITY.md. Pass "
+                f"--trust-workflows if you trust this workflow's source."
+            )
diff --git a/dw/workflow_schema.json b/dw/workflow_schema.json
index a1c843b3..866f622e 100644
--- a/dw/workflow_schema.json
+++ b/dw/workflow_schema.json
@@ -620,9 +620,22 @@
                     "type": "boolean"
                 },
                 "attention_backend": {
-                    "description": "The attention backend to use for the pipeline.",
+                    "description": "The attention backend to use for the pipeline. 'sparse' is dw's own, not a diffusers backend: comfy-kitchen sparse attention on a MiniMax-H3 transformer's generated-video rows, installed for this call only, with everything else dense. It needs CUDA sm_80+ and bf16/fp16, and runs dense with a warning where it cannot run; on a pipeline with no MiniMax-H3 transformer it also runs dense with a warning (#931).",
                     "type": "string"
                 },
+                "sparse_tau": {
+                    "description": "The sparsity threshold for attention_backend 'sparse': higher is sparser and faster, lower is closer to dense. Defaults to 0.5. A runtime setting like a LoRA scale - changing it reuses the loaded pipeline (#931). Accepts a 'variable:' reference.",
+                    "type": ["number", "string"],
+                    "pattern": "^variable:",
+                    "minimum": 0
+                },
+                "sparse_topk": {
+                    "description": "sol_attn's top-k routing for attention_backend 'sparse': keep this fraction of key tiles per query tile (strictly between 0 and 1) and drop the rest, the selection lightx2v's SLA LoRAs were trained against. When set, sparse_tau is ignored; unset (the default) routes by sparse_tau. A runtime setting like a LoRA scale - changing it reuses the loaded pipeline (#932). Accepts a 'variable:' reference.",
+                    "type": ["number", "string"],
+                    "pattern": "^variable:",
+                    "exclusiveMinimum": 0,
+                    "exclusiveMaximum": 1
+                },
                 "prompt_weighting": {
                     "description": "Enable A1111-style prompt weighting syntax: (word:1.5) for emphasis, [word] for de-emphasis, ((word)) for nested weighting. Also supports prompts longer than 77 tokens. Currently supports Flux pipelines. Mutually exclusive with remote_text_encoder.",
                     "type": "boolean"
@@ -701,9 +714,22 @@
                                 ]
                             },
                             "attention_backend": {
-                                "description": "Pin this component's attention backend persistently via set_attention_backend, e.g. 'flash', 'sage', '_flash_3_hub'. Use this instead of the pipeline-level attention_backend when the component is compiled - the per-call context manager forces recompiles.",
+                                "description": "Pin this component's attention backend persistently via set_attention_backend, e.g. 'flash', 'sage', '_flash_3_hub'. Use this instead of the pipeline-level attention_backend when the component is compiled - the per-call context manager forces recompiles. 'sparse' installs dw's comfy-kitchen sparse attention on a MiniMax-H3 transformer instead of calling set_attention_backend, and stays installed until the component is configured with another backend; on any other component it runs dense with a warning (#931).",
                                 "type": "string"
                             },
+                            "sparse_tau": {
+                                "description": "The sparsity threshold for this component's attention_backend 'sparse': higher is sparser and faster, lower is closer to dense. Defaults to 0.5. A runtime setting like a LoRA scale - changing it reuses the loaded pipeline and is re-applied to it (#931). Accepts a 'variable:' reference.",
+                                "type": ["number", "string"],
+                                "pattern": "^variable:",
+                                "minimum": 0
+                            },
+                            "sparse_topk": {
+                                "description": "sol_attn's top-k routing for attention_backend 'sparse': keep this fraction of key tiles per query tile (strictly between 0 and 1) and drop the rest, the selection lightx2v's SLA LoRAs were trained against. When set, sparse_tau is ignored; unset (the default) routes by sparse_tau. A runtime setting like a LoRA scale - changing it reuses the loaded pipeline (#932). Accepts a 'variable:' reference.",
+                                "type": ["number", "string"],
+                                "pattern": "^variable:",
+                                "exclusiveMinimum": 0,
+                                "exclusiveMaximum": 1
+                            },
                             "attn_processor_type": {
                                 "description": "The attention processor this component runs, by type name, constructed with no arguments and handed to set_attn_processor(). The pipeline-level 'unet' and 'transformer' blocks cover those two components; this covers any other one that carries attention - LTX-2.5's 'diffusion_decoder', whose default processor is a portable FlexAttention fallback rather than the NATTEN path the decoder was built around.",
                                 "type": "string"
diff --git a/dw/workflows/flux3_klein_upsample.json b/dw/workflows/flux3_klein_upsample.json
new file mode 100644
index 00000000..9a2ef5d4
--- /dev/null
+++ b/dw/workflows/flux3_klein_upsample.json
@@ -0,0 +1,33 @@
+{
+    "id": "flux3_klein_upsample",
+    "description": "Expands a short request into the caption FLUX 3 Image Klein was trained on, with Black Forest Labs' own prompt upsampler, flux-3-image-klein-pup, a Qwen3.5-9B fine-tune. BFL says not to use Klein without it. The weights and the text-to-image system prompt are both pinned to pup commit 3f3edb52, and the prompt is read from the repo's system_prompts.json rather than copied. Thinking is switched off and decoding is greedy, as BFL runs it. BFL also applies a presence penalty of 1.5 for text-to-image, which transformers' generate() has no equivalent for, so it is left out. About 18 GB in bf16.",
+    "variables": {
+        "prompt": "A man walking with his dog, afternoon sun",
+        "device": "cuda"
+    },
+    "steps": [
+        {
+            "name": "upsample",
+            "task": {
+                "command": "text_generation",
+                "arguments": {
+                    "prompt": "variable:prompt",
+                    "model_name": "black-forest-labs/flux-3-image-klein-pup",
+                    "revision": "3f3edb52b2c55de0d49feab28598b68f7f8e4830",
+                    "system_prompt": {
+                        "from_hub": {
+                            "repo": "black-forest-labs/flux-3-image-klein-pup",
+                            "file": "system_prompts.json",
+                            "revision": "3f3edb52b2c55de0d49feab28598b68f7f8e4830",
+                            "key": "t2i"
+                        }
+                    },
+                    "chat_template_kwargs": {"enable_thinking": false},
+                    "max_new_tokens": 3584,
+                    "device": "variable:device"
+                }
+            },
+            "result": {"content_type": "text/plain", "save": false}
+        }
+    ]
+}
diff --git a/dw/workflows/flux3_klein_upsample_edit.json b/dw/workflows/flux3_klein_upsample_edit.json
new file mode 100644
index 00000000..d4b9baf6
--- /dev/null
+++ b/dw/workflows/flux3_klein_upsample_edit.json
@@ -0,0 +1,51 @@
+{
+    "id": "flux3_klein_upsample_edit",
+    "description": "Expands an edit instruction into the caption FLUX 3 Image Klein was trained on, with Black Forest Labs' own prompt upsampler, flux-3-image-klein-pup, a Qwen3.5-9B fine-tune. The upsampler sees every reference in order, as the pipeline will. At least one image is required: an empty list produces a caption written without seeing the image. The instruction is wrapped in the three-line scaffold that is BFL's I2I_SCAFFOLD from src/flux3/pup.py at commit bbfe317d in github.com/black-forest-labs/flux-3-image-klein. The weights and the image-edit system prompt are both pinned to pup commit 3f3edb52, and the prompt is read from the repo's system_prompts.json rather than copied. Thinking is switched off and decoding is greedy with no repetition penalty, as BFL runs it. BFL resizes each reference to a pixel budget (1 MP for one reference, 724x724 for two, 512x512 for three or more) before the upsampler sees it, while transformers' processor applies its own sizing, so the two can describe small details differently. About 18 GB in bf16.",
+    "variables": {
+        "instruction": "put a red bandana around the dog's neck",
+        "images": [],
+        "device": "cuda"
+    },
+    "steps": [
+        {
+            "name": "scaffold",
+            "task": {
+                "command": "compose_text",
+                "arguments": {
+                    "parts": [
+                        "Reference images follow in order (the first image, the second image, ...).\nUser request: ",
+                        "variable:instruction",
+                        "\nOutput the caption."
+                    ],
+                    "separator": ""
+                }
+            },
+            "result": {"content_type": "text/plain", "save": false}
+        },
+        {
+            "name": "upsample",
+            "task": {
+                "command": "text_generation",
+                "arguments": {
+                    "prompt": "previous_result:scaffold",
+                    "image": "variable:images",
+                    "model_name": "black-forest-labs/flux-3-image-klein-pup",
+                    "revision": "3f3edb52b2c55de0d49feab28598b68f7f8e4830",
+                    "system_prompt": {
+                        "from_hub": {
+                            "repo": "black-forest-labs/flux-3-image-klein-pup",
+                            "file": "system_prompts.json",
+                            "revision": "3f3edb52b2c55de0d49feab28598b68f7f8e4830",
+                            "key": "i2i"
+                        }
+                    },
+                    "chat_template_kwargs": {"enable_thinking": false},
+                    "max_new_tokens": 3584,
+                    "repetition_penalty": 1.0,
+                    "device": "variable:device"
+                }
+            },
+            "result": {"content_type": "text/plain", "save": false}
+        }
+    ]
+}
diff --git a/dw_mcp/assets.py b/dw_mcp/assets.py
index f018859a..39fdb48c 100644
--- a/dw_mcp/assets.py
+++ b/dw_mcp/assets.py
@@ -166,11 +166,13 @@ def list_assets(
     because that URL would serve the file that shadows it.
 
     Compact by default - each `assets`/`shadowed` entry cut to
-    `name`/`reference`/`kind`/`size`/`origin` - because a library that has
+    `name`/`reference`/`kind`/`size`/`origin` and its `note` (clipped,
+    `note_truncated` when cut) - because a library that has
     accumulated months of episode and regression assets answers in the tens
     of KB otherwise for a question that is usually "what's available and
     under what name" (#249). Pass `detail=True` for each entry's `folder`,
-    `mtime` and `url` too.
+    `mtime`, `url` and `writable` too, and `absolute_url`/`used_by` when
+    set.
 
     Newest first and bounded to `limit` (default 50; None for all), filtered
     server-side by `prefix` (a name or folder start such as 'cast/'), so the
@@ -208,8 +210,9 @@ def list_assets(
         if isinstance(shadowed, list)
         else shadowed,
         "note": (
-            "Compact: each entry is name/reference/kind/size/origin only. "
-            "Call list_assets(detail=True) for folder, mtime and url too."
+            "Compact: each entry is name/reference/kind/size/origin and any "
+            "note. Call list_assets(detail=True) for folder, mtime, url and "
+            "writable too."
         ),
     }
 
diff --git a/dw_mcp/tools_authoring.py b/dw_mcp/tools_authoring.py
index 8150ed33..caf18a0d 100644
--- a/dw_mcp/tools_authoring.py
+++ b/dw_mcp/tools_authoring.py
@@ -18,7 +18,7 @@ def list_workspaces(self, detail: bool = False) -> dict:
         shared asset library that `upload_asset(shared=true)` and
         `keep_output(shared=true)` write into - which is how a recurring
         cast stays reachable from the workspace the next piece is made
-        in. Entries carry name, default and usage (files/bytes) only; pass
+        in. Entries carry name, default, usage (files/bytes) and any note; pass
         detail=true for each entry's full folder paths (workflows, assets,
         outputs, prompts, common_assets)."""
         return workspaces.list_workspaces(self.client, detail=detail)
diff --git a/dw_mcp/tools_media.py b/dw_mcp/tools_media.py
index b525ba43..3a983955 100644
--- a/dw_mcp/tools_media.py
+++ b/dw_mcp/tools_media.py
@@ -325,9 +325,9 @@ def list_assets(
     ) -> dict:
         """List input media on the server, each with the `asset:` reference
         a workflow argument carries. Look here before asking for a file.
-        Entries: name, reference, kind, size and origin; for duration,
-        fps, sample rate or channels pass the reference to
-        `get_gallery_metadata`. detail=true adds folder, mtime, url.
+        Entries: name, reference, kind, size, origin, any note; for
+        duration, fps, sample rate, channels see `get_gallery_metadata`.
+        detail=true adds folder, mtime, url, writable.
 
         Newest first, `limit` default 50 (`total` = all matched); `prefix`
         keeps names starting with it, e.g. 'cast/'. `workspace` scopes one call."""
diff --git a/dw_mcp/workspaces.py b/dw_mcp/workspaces.py
index b327a2be..0497f2bf 100644
--- a/dw_mcp/workspaces.py
+++ b/dw_mcp/workspaces.py
@@ -63,8 +63,9 @@ def _switch(client, name):
 def list_workspaces(client, detail=False):
     """The workspaces on the server, and which one this session is using.
 
-    Compact by default - each entry cut to `name`, `default` and `usage`
-    (files/bytes) - because a server that has accumulated dozens of
+    Compact by default - each entry cut to `name`, `default`, `usage`
+    (files/bytes) and its `note` (clipped, `note_truncated` when cut) -
+    because a server that has accumulated dozens of
     workspaces across episodes and regression runs answers in the tens of
     KB otherwise for a question that is usually "which workspaces exist and
     how big are they" (#249). Pass `detail=True` for each entry's full
@@ -84,8 +85,8 @@ def list_workspaces(client, detail=False):
                     if isinstance(entry, dict)
                 ],
                 "note": (
-                    "Compact: each entry is name/default/usage only. Call "
-                    "list_workspaces(detail=True) for full folder paths."
+                    "Compact: each entry is name/default/usage and any note. "
+                    "Call list_workspaces(detail=True) for full folder paths."
                 ),
             }
     return {**result, "current": client.workspace}
diff --git a/plugins/dw/.claude-plugin/plugin.json b/plugins/dw/.claude-plugin/plugin.json
index 0b5ca297..6b1355fc 100644
--- a/plugins/dw/.claude-plugin/plugin.json
+++ b/plugins/dw/.claude-plugin/plugin.json
@@ -1,7 +1,7 @@
 {
     "name": "dw",
     "description": "Compose MiniMax H3 video, MiniMax Music 3, LTX-2.5 and Kandinsky 6.0 workflows over a dw MCP server, and cut a multi-episode series from them: which template fits which shape, the hard rules, cost, and how to judge the output. Prompt format comes from the vendors' own guides.",
-    "version": "0.14.0",
+    "version": "0.15.0-alpha.1",
     "author": {
         "name": "Don Kackman"
     },
diff --git a/plugins/dw/README.md b/plugins/dw/README.md
index a204d6bb..8b0b4685 100644
--- a/plugins/dw/README.md
+++ b/plugins/dw/README.md
@@ -19,6 +19,7 @@ Install once, from Claude Code:
 | `minimax-music3` | MiniMax Music 3: a song, an instrumental, a score under a film, the soundtrack a music video is cut to; the ceiling semantics, the tag vocabulary, the caps and the 44.1 kHz output. Captions come from MiniMax's own `music-caption-rewriter` skill. |
 | `ltx-2.5` | LTX-2.5 video with a soundtrack: a single clip, first-frame and keyframe conditioning, the three-move two-stage flow, the IC-LoRA upscale, extend and chain; the distilled schedule and the frame and size rules. Prompts follow the trained-caption spec that ships inside diffusers. |
 | `kandinsky-6` | Kandinsky 6.0 video with a soundtrack: a five-second clip from text or from a picture on the 3B Lite-distill checkpoint; the distilled schedule, the size and frame rules the pipeline's own defaults get wrong, and why Apple Silicon is parked. Prompts follow Kandinsky Lab's own beautifier system prompts. |
+| `flux3-klein` | FLUX 3 Image Klein images: a picture from a short request through BFL's prompt upsampler, from a full caption, an edit of one photo, several references combined, or a layout placed by boxes; the 16-step distilled schedule with no guidance, the 16-pixel grid, the 10-reference training limit the pipeline does not enforce, and the gated license. Prompts come from BFL's upsampler builtins or their prompting guide. |
 | `script-to-video` | From a prose script to finished video: decompose into shots, cast recurring characters once, pick each shot's template and family, validate cost before spending, run and diagnose, hand off to cut-and-score. The decision tree that turns a script into the shots the other skills know what to do with. |
 | `series-episodes` | A series rather than one generation: several episodes over one cast, each cut and scored from its own template runs. The five-beat recut-bed-match_levels-normalize-pair procedure, an optional per-shot look (one shared palette through `apply_lut`, then `film_grain`) before the recut, and the one step that must not be skipped or the cast drifts between episodes. |
 
diff --git a/plugins/dw/skills/flux3-klein/SKILL.md b/plugins/dw/skills/flux3-klein/SKILL.md
new file mode 100644
index 00000000..73bd71de
--- /dev/null
+++ b/plugins/dw/skills/flux3-klein/SKILL.md
@@ -0,0 +1,149 @@
+---
+name: flux3-klein
+description: Use when a dw MCP server is connected and the user wants an image from FLUX 3 Image Klein - a picture from a short request or a full caption, an edit of their photo, several reference pictures combined into one, or a layout with elements placed by box. Picks the template, states the distilled schedule, the size grid and the reference rules the pipeline does not check for you, quotes cost, and points at Black Forest Labs' upsampler and prompting guide.
+---
+
+# FLUX 3 Image Klein on a dw server
+
+FLUX 3 Image Klein (Black Forest Labs) is a 5.6B distilled flow map that
+draws text-to-image, edits and multi-reference images in 16 steps. It pairs
+the FLUX.2 VAE with a Qwen3-VL-4B text encoder, about 19 GB of bf16 weights.
+Klein was trained on long captions written by BFL's prompt upsampler, and BFL
+says not to run it without one: a short prompt gives a generic picture.
+
+## Before anything
+
+1. `get_server_info`: the device. The templates place every component on
+   `cuda`. Apple Silicon is unmeasured (the same 19 GB of weights in unified
+   memory, plus activations); on `mps` say so before spending, and
+   on `cpu` stop.
+2. `get_diffusers_state`, then `list_classes` for
+   `Flux3DistilledModularPipeline`. The modular pipeline is in diffusers
+   `main` only (merged 2026-10-15). If it is missing, the server needs
+   `update_diffusers` and a restart. That is the user's call; ask first.
+3. The weights are gated under the FLUX Kommunity License (non-commercial,
+   plus commercial use of outputs below US$5M annual revenue). The user
+   accepts it on the model page and the server runs `hf auth login`; a 401 or
+   `GatedRepoError` in `get_job` means one of those is missing. The
+   upsampler is Apache-2.0 and ungated.
+4. `list_workflows(shape="image")` for the text-to-image templates and
+   `list_workflows(shape="image-edit")` for the edit ones. Take names,
+   `summary` and `cost` from the listing over the names quoted below, then
+   `get_workflow` on the one chosen, for its variables.
+
+## Which shape is the request
+
+- **A short request** ("a man walking his dog"):
+  `templates/flux3/upsample-then-generate`. The upsampler writes the caption,
+  is released, and Klein draws from it. The caption is saved as an
+  `intermediate` text file: read it, and reuse or edit it as the prompt of
+  text-to-image without paying for the upsampler again.
+- **A full caption already written** (or one the upsampler wrote earlier):
+  `templates/flux3/text-to-image`.
+- **One photo to change**: `templates/flux3/image-edit`, an `instruction`
+  and an `image`. The upsampler sees the same picture as the pipeline. With
+  no width or height the output is 1 MP at the reference's aspect ratio.
+- **Several pictures combined** ("the dog from this one on that mug"):
+  `templates/flux3/multi-reference`, an `instruction` and `images` in order.
+  The first reference sets the aspect ratio.
+- **Elements at given positions**: `templates/flux3/layout-boxes`. The
+  caption carries the boxes; the format is in `references/layout-boxes.md`.
+  Boxes from a short request (BFL's box upsampler) are not in the catalog
+  yet, so the caption is written by hand.
+- **The base (non-distilled) checkpoint, guidance, LoRA, fp8 or NVFP4**: not
+  in the catalog. Say so rather than improvising.
+
+Input media must be on the server: `upload_asset`, then `asset:` in the
+argument, or `output:` for an earlier run's file.
+
+## Hard rules
+
+- 16 steps, no guidance and no negative prompt. The distilled model is a
+  flow map; BFL's reference code raises on any guidance other than None
+  or 1.0. Leave
+  `num_inference_steps` at 16 (trained for 4-16) and add no
+  `guidance_scale` or `negative_prompt` to a workflow you write.
+- `width` and `height` are multiples of 16 (the VAE's 8x times the 2x2
+  latent packing). The pipeline only refuses an off-grid size after the
+  weights load, so the templates declare the rule and `validate_workflow`
+  catches it first.
+- Sides run from 64 to 4096, as BFL states it. Nothing in the templates or
+  the pipeline checks that ceiling, and above 1024x1024 a 24 GB card has not
+  been measured: everything resident leaves under 2 GB spare at 1024x1024.
+- Up to 10 references. That is BFL's training limit, and the pipeline does
+  not enforce it: an 11th reference runs, outside what the model learned.
+- In a caption written by hand, name references `<ref_image_0>`,
+  `<ref_image_1>` and so on, zero-based in the order given. The upsampler's
+  own captions say "the first image", "the second image".
+- Every component carries an explicit `device`. The modular pipeline runs
+  on its first component's device, so one left unplaced keeps the prompt
+  and the noise on the CPU (`index is on cpu`, `Cannot generate a cpu
+  tensor from a generator of type cuda`). For the same reason the text
+  encoder cannot be `residency: on_demand`.
+- The upsampler (about 18 GB) and Klein (about 19 GB) do not fit a 24 GB
+  card together. Keep `release_models` on the upsample step and load Klein
+  after it.
+
+## Prompts
+
+The prompt path is the upsampler. The builtins `flux3_klein_upsample` (a
+request to a caption) and `flux3_klein_upsample_edit` (an instruction plus
+the references to a caption) run BFL's `flux-3-image-klein-pup` with BFL's
+own system prompts, read from the pup repository at a pinned commit. The
+templates call them; a workflow you compose names them as a `builtin:` step
+before the Klein step.
+
+To write a caption by hand, read BFL's prompting guide:
+https://docs.bfl.ml/guides/prompting_summary. It is written for the API
+model, which upsamples on the server side, so read it as a description of
+the caption Klein expects, not as advice for a short prompt. The stored
+`flux3/` prompts (`list_prompts`, `get_prompt`) are BFL's own upsampled
+captions, `man_dog` and `balloons_layout`: read one before writing your own.
+The upsampler writes English only.
+
+## Run and judge
+
+1. `validate_workflow` first - free, and catches an off-grid size.
+2. Quote `plan.estimate` and name any `downloads_required` (Klein, plus the
+   upsampler for every template but text-to-image and layout-boxes). Do not
+   quote minutes from memory: the estimate is the number. More references
+   cost more per step, because each one adds tokens. Get the go-ahead, then
+   `run_workflow` with `acknowledged_cost` set to the plan's
+   `{fingerprint, minutes, downloads}`.
+3. `wait_for_job`, `timeout_seconds` = estimate plus margin. Call again
+   while `still_running`. If the call dies client-side first, call again
+   with `timeout_seconds` 60 and loop.
+4. A saving step carries a `subfolder`: the image shown to the user is
+   `final`, the upsampler's caption `intermediate`.
+   `list_gallery(subfolder="final")` lists only deliverables, so keep both
+   in anything you compose.
+5. Judge it yourself: `get_output_image` on the `final` image against the
+   ask, and `get_output_text` on the caption when the picture misses - the
+   caption is what Klein drew. Then `get_job` for the manifest and its
+   warnings, and give the user the gallery `url`.
+6. Save a keeper (`get_job_workflow`, `save_workflow`) to rerun it by name.
+
+What goes wrong, and where to look:
+- A generic, flat picture: a short prompt went to text-to-image without the
+  upsampler. Rerun through upsample-then-generate.
+- An edit that changed more than was asked: Klein can alter content outside
+  the requested region (BFL's fix for that is API-only). Narrow the
+  instruction, or try another seed; compare with `compare_outputs`.
+- A small detail of a reference rendered wrong: the upsampler can
+  misdescribe fine detail in a reference, and dw sizes references for it
+  differently from BFL's own pipeline. Read the caption with
+  `get_output_text`. The edit templates always re-upsample: their
+  prompt is the upsampler's output and they have no caption variable. Either narrow the
+  instruction and rerun, or reuse the corrected caption: `get_workflow` on
+  the edit template, and compose a one-step workflow from its Klein step
+  with the caption as `prompt` and the same image list. Text-to-image is no
+  answer here, since it drops the references.
+- A boxed element missing or spilling over: boxes are hints, not masks.
+  Enlarge the box or describe the element more, in the prose and the table.
+
+## Sources
+
+The flux-3-image-klein and flux-3-image-klein-pup model cards (Hugging Face),
+BFL's flux-3-image-klein GitHub repository (commit bbfe317d), docs.bfl.ml,
+and `diffusers.modular_pipelines.flux3`. Read 2026-10-15; audit
+`docs/proposals/audits/2026-10-15-flux-3-klein-audit.md`.
diff --git a/plugins/dw/skills/flux3-klein/references/layout-boxes.md b/plugins/dw/skills/flux3-klein/references/layout-boxes.md
new file mode 100644
index 00000000..fa2bbe67
--- /dev/null
+++ b/plugins/dw/skills/flux3-klein/references/layout-boxes.md
@@ -0,0 +1,31 @@
+# Layout boxes for `templates/flux3/layout-boxes`
+
+Read this when a request places elements at given positions. The format is
+BFL's, from the Klein model card and the box captions in their reference
+repository (read 2026-10-15); the stored caption `flux3/balloons_layout`
+(`get_prompt`) is a complete worked example, and the clearest one to copy.
+
+A layout caption is one prompt with two parts:
+
+1. **Prose with tags.** The usual long caption, with each placed element
+   followed by an id in angle brackets where it is described, such as
+   `<obj_1>` or `<sky_1>`. Ids are short and unique; BFL's examples use a
+   kind and a number.
+2. **A JSON table after the prose.** A list with one object per id:
+   `{"id": "obj_1", "bbox": [top, left, bottom, right], "desc": "..."}`.
+   The box is on a 0 to 1000 grid over the image, whatever its pixel size,
+   with `top < bottom` and `left < right`. `desc` describes that element
+   alone, in the same detail as the prose.
+
+Every tag in the prose has a row, and every row's id is tagged in the prose.
+Background regions (sky, ground) can be boxed too; boxes may overlap.
+
+Boxes are hints, not masks. A small boxed element may not appear at all, and
+an element can run past its box. When one is missing, enlarge its box or give
+it more words in both the prose and `desc`, and try another seed before
+rewriting the layout.
+
+Writing the boxes from a short request (BFL's `t2i_bbox` upsampler mode)
+needs BFL's box planning code and is not in the catalog yet, so a layout
+caption is written by hand or adapted from the stored example. Keep the
+width and height on the 16-pixel grid as for any Klein run.
diff --git a/plugins/dw/skills/minimax-h3/SKILL.md b/plugins/dw/skills/minimax-h3/SKILL.md
index 58869d10..d1fa8fab 100644
--- a/plugins/dw/skills/minimax-h3/SKILL.md
+++ b/plugins/dw/skills/minimax-h3/SKILL.md
@@ -99,7 +99,7 @@ section).
   `transformer_ref` alone, so anything handed there degrades output.
   `validate_workflow` refuses it and warns on a `weight_name` naming neither.
 - Smeary faces (int8 base) or draft -> final tiers: `references/quality-and-speed.md`.
-- CUDA: `attention_backend=sage_hub` (null elsewhere; mps fails at run).
+- Backend: default `sparse` (dense off CUDA); same one at draft and final.
 - Fit a crowd's action to what it holds: candle-holders asked to clap
   rendered three-handed people.
 - A directed crowd move needs its landmark in frame: "marches up to the
diff --git a/plugins/dw/skills/minimax-h3/references/quality-and-speed.md b/plugins/dw/skills/minimax-h3/references/quality-and-speed.md
index 8399a87b..cc679ef9 100644
--- a/plugins/dw/skills/minimax-h3/references/quality-and-speed.md
+++ b/plugins/dw/skills/minimax-h3/references/quality-and-speed.md
@@ -29,13 +29,18 @@ shift the LoRA names.
 | L6 | 1344x768 | int8 | none | 30 | native | 44.2 | 4 |
 | P1 | 1344x768 | int8 | none | 30 | sage_hub + `first_block` 0.05 | 23.1 | 4 |
 | C1 / C2 (close-up) | 1344x768 | int8 | none | 12 / 30 | sage_hub | 13.9 / 22.8 | 4 / 4 |
+| L1s / L7s | 1344x768 | int4 / int8 | ref2v 4-step v0.1 | 5 | sparse | 5.2 / 6.5 | = L1 / L7 (Don, 3 seeds) |
+| B3s | 1344x768 | int8 | none | 12 | sparse | 12.1 | = B3 (Don, 3 seeds) |
+| L5s | 1344x768 | int8 | none | 30 | sparse | 26.6 | = L5 (Don, 3 seeds) |
 
 - **Faces**: turbo LoRAs plus int4 cause the smeary faces, not resolution. The
   base model at int8 fixes it: `lora_model_name: null`, 12-30 steps, shift
   12/3. A close-up is already 4/5 at 12 steps.
-- **Composition** (who stands where): attention never moves it; quantization
-  doesn't on a turbo LoRA (L1 = L7) but does on the base model (int4 vs
-  int8); a different LoRA family re-stages; base step count doesn't.
+- **Composition** (who stands where): `sage_hub` against `native` never moves
+  it. `sparse` against either keeps the shot but shifts details (a figure's
+  height, props), so a draft and its final use the same backend. Quantization
+  doesn't move it on a turbo LoRA (L1 = L7) but does on the base model (int4
+  vs int8); a different LoRA family re-stages; base step count doesn't.
 - **Steps**: the base floor is 12. 8 steps duplicated a character (B6).
 - **Two-character shots at 960x544 smear** (~60 px faces): render them at
   1344x768 from the start, not at 544 and upscaled.
@@ -59,6 +64,15 @@ Both tiers use the same template (`templates/minimax/reference-to-video`, or
 is an argument on every H3 template, `dialogue-short` included. Set it at
 both tiers on CUDA: it never moves composition.
 
+The H3 templates default to `attention_backend=sparse` with top-k routing
+(`sparse_topk` 0.15), which shifts details against sage (see *Composition*).
+The sparse rows below were timed at `sparse_tau` 0.5, 6-12% faster than
+`sage_hub` with equal faces and staging on 3 seeds (#931). Top-k is faster
+again at equal or better faces (#932): L7 ~6.0 min, L5 ~24.4 min. Its
+draft-to-final carry is not separately measured; the draft and the final
+share the setting either way. Draft and final always share one backend: pass
+the backend the row names at both tiers.
+
 **`dialogue-short` at 1344x768** (every rung below is that canvas): a shot
 with 4 references must be 124 frames (*Frame ceiling* above). The default
 `shots` list's `tag` (`shots[4]`) is 141 frames with 4 references, so
@@ -71,15 +85,19 @@ shot's line still fits 5.17 s.
 
 | Target | Draft | Final | Only these change |
 |---|---|---|---|
-| **TV** (sitcom, social, previs) | **L1**, ~5.4 min | **L7**, ~7.2 min | `weights_dtype` `{int4}` to `{int8}` |
-| **Cinema** (realistic faces) | **B3**, ~12.9 min | **L5**, ~29.5 min, or **P1**, ~23.1 min | `num_inference_steps` 12 to 30; P1 adds `cache` |
+| **TV** (sitcom, social, previs) | **L1s**, ~5.2 min | **L7s**, ~6.5 min | `weights_dtype` `{int4}` to `{int8}` |
+| **Cinema** (realistic faces), sage | **B3**, ~12.9 min | **P1**, ~23.1 min (or L5, ~29.5) | `num_inference_steps` 12 to 30; P1 adds `cache` |
+| **Cinema**, sparse | **B3s**, ~12.1 min | **L5s**, ~26.6 min | `num_inference_steps` 12 to 30 |
 | **Close-up** | **C1**, ~13.9 min | ship the draft | nothing |
 
 - **TV.** Both rungs are 1344x768 on the 4-step Ref2VA v0.1 LoRA:
   `lora_model_name` `lightx2v/Minimax-h3-Turbo`, `lora_weight_name`
   `minimax_h3_ref2v_turbo_4step_v0.1_bf16.safetensors`,
   `num_inference_steps` 5, `video_shift` 12, `audio_shift` 3. L1 is
-  `weights_dtype` `{int4}`, L7 is `{int8}`. **L0** (the same at 960x544,
+  `weights_dtype` `{int4}`, L7 is `{int8}`; `attention_backend=sparse` (the
+  default) at both tiers. Under sparse, L1s -> L7s kept staging on 3 of 3
+  seeds and matched sage; the TV faces smear a little under either backend
+  (the turbo LoRA, not attention; #931). **L0** (the same at 960x544,
   ~3.5 min) is a throwaway sketch only. Its staging did carry to L7 (below),
   but it smeared a face at both new seeds, so a face can't be approved on it,
   and two-character shots at 960x544 smear. Render those at 1344x768 from
@@ -91,21 +109,27 @@ shot's line still fits 5.17 s.
   faces). Both tiers warn `lora_disabled`. That is expected: the warning asks
   for the base schedule, and these values are it. Never draft at B4 (960x544
   int4 base) for a 1344x768 final: its staging held on only 2 of 4 seeds.
+  The sparse pair (B3s -> L5s) is the same arguments with
+  `attention_backend=sparse`: skin equal to sage and staging carried on 3 of 3
+  seeds (#931). The sage pair with P1 is still the fastest cinema final;
+  sparse with the `first_block` cache is not measured, so don't combine them.
 - **Close-ups**: C1 is B3's arguments on a close-up shot. It scores 4/5 at
   12 steps (C1 = C2), so the draft is the deliverable.
 
 ### 2. What carries from draft to final
 
-The composition rules under *Quality ladder* hold: attention never moves
-staging, and neither does base step count; a different LoRA family
-re-stages; so does int4 against int8 on the base model. On top of those:
+The composition rules under *Quality ladder* hold: sage never moves
+staging, sparse shifts details (so it never changes between tiers), and
+neither does base step count; a different LoRA family re-stages; so does int4
+against int8 on the base model. On top of those:
 
 - keep the seed, canvas, prompt and references identical between the tiers;
 - blocking carries, but props and set dressing sometimes don't (a jacket on
   a chair in C1 only).
 
 Measured (#861) on seeds 42, 7 and 1234, judged by Don: B3 -> P1, C1 -> C2
-and L0 -> L7 each held staging on **3 of 3** seeds. L1 = L7 (the TV pair
+and L0 -> L7 each held staging on **3 of 3** seeds, and B3s -> L5s under
+sparse too (#931). L1 = L7 (the TV pair
 itself) is measured on **1 seed** (42). B4 -> B5 held on only 2 of 4 seeds
 (42, 7, 1234, 99). At seed 1234, B5 (int4) staged like B3 (int8): on the
 base model the canvas moved staging more than the weights did. That is one
@@ -137,9 +161,9 @@ Quote `validate_workflow`'s `plan.estimate` for each tier, draft plus
 final. It scales by steps, canvas and frames (#866), but not by
 `weights_dtype`, `attention_backend`, `cache` or a null LoRA. When one of
 those moves it sets `low_confidence` and names the variable in `differs`.
-With `sage_hub` set, every rung above moves one. Quote that rung's minutes
-from the ladder instead (they were measured with `sage_hub`), and say which
-figure you are quoting.
+Every rung above moves one. Quote that rung's minutes from the ladder instead
+(the *Attn* column says which backend they were measured with), and say
+which figure you are quoting.
 
 ## Prompting the base model
 
@@ -175,11 +199,13 @@ Per phase, from the job event log (minutes unless noted):
 Denoise is 80-91% of a job, ~56 s/pass with int8 weights streamed by
 block-level group offload: compute-bound, not PCIe-bound.
 
-- **`sage_hub`**: -23% at turbo 8-step, -33% at base 30, visually lossless.
-  Advise it first where the box has it: `attention_backend=sage_hub`, an
-  argument on every H3 template (default `null`, the H3 step only). It needs
-  CUDA, the `kernels` package and `DIFFUSERS_TRUST_REMOTE_KERNELS=true`; leave
-  it `null` on mps or cpu, where it passes validate and fails at run time.
+- **`sage_hub`**: -23% at turbo 8-step, -33% at base 30 against `native`,
+  visually lossless. `attention_backend` is an argument on every H3 template
+  (the H3 step only); the default is `sparse`, 6-12% faster than `sage_hub`
+  on the ramp rungs and runnable without extra packages. `sage_hub` needs
+  CUDA, the `kernels` package and `DIFFUSERS_TRUST_REMOTE_KERNELS=true`; on
+  mps or cpu it passes validate and fails at run time, while `sparse` there
+  falls back to dense with a warning.
 - **`first_block` 0.05**: -22% at 30 base steps with identical staging and
   faces (PSNR 27.5 dB against L5). It skips nothing at 12 steps or on a
   turbo schedule, yet still perturbs the result: use it at ~20 or more base
diff --git a/prompts/flux3/balloons_layout.json b/prompts/flux3/balloons_layout.json
new file mode 100644
index 00000000..637aef44
--- /dev/null
+++ b/prompts/flux3/balloons_layout.json
@@ -0,0 +1,3 @@
+{
+  "text": "Full-color outdoor photograph at sunrise, with a broad dawn sky <sky_1> above a green valley <valley_1>. On the left, a large hot-air balloon <obj_1> floats over the valley, while a smaller blue hot-air balloon <obj_2> hangs farther back on the right. Along the horizon, the rising sun <sun_1> appears between distant mountain ridges <mountain_1>, casting low orange light across the slopes and leaving the foreground meadow in cooler shadow. [{\"id\": \"obj_1\", \"bbox\": [80, 60, 480, 380], \"desc\": \"A large red and yellow striped hot-air balloon with alternating vertical fabric panels, a rounded envelope, dark suspension cables, and a small rectangular wicker basket hanging below; the lower edge of the envelope is partly shaded by the sunrise angle.\"}, {\"id\": \"obj_2\", \"bbox\": [200, 620, 420, 800], \"desc\": \"A small blue hot-air balloon with a rounded cobalt-blue envelope, narrow darker seams, fine suspension lines, and a tiny brown basket.\"}, {\"id\": \"sky_1\", \"bbox\": [0, 0, 650, 1000], \"desc\": \"A clear sunrise sky grading from pale orange near the horizon through peach to muted blue overhead, with several thin horizontal clouds catching warm light.\"}, {\"id\": \"sun_1\", \"bbox\": [470, 455, 535, 525], \"desc\": \"A low circular sunrise disk in bright yellow-orange, partially veiled by the distant ridge line.\"}, {\"id\": \"mountain_1\", \"bbox\": [430, 0, 690, 1000], \"desc\": \"Layered distant mountain ridges forming an uneven horizon, with blue-gray silhouettes in front and warmer brown-green slopes along their upper edges.\"}, {\"id\": \"valley_1\", \"bbox\": [560, 0, 1000, 1000], \"desc\": \"A broad green valley with rolling grassy slopes, scattered darker tree masses, and a winding river reflecting a narrow strip of orange morning light; the nearest meadow contains patches of deep green shadow and uneven vegetation.\"}]"
+}
diff --git a/prompts/flux3/man_dog.json b/prompts/flux3/man_dog.json
new file mode 100644
index 00000000..0583568c
--- /dev/null
+++ b/prompts/flux3/man_dog.json
@@ -0,0 +1,3 @@
+{
+  "text": "Full-color outdoor photograph taken at eye level in the afternoon, with low sunlight coming from frame-right and casting long shadows across a neighborhood park. In the center, a white man in his thirties with fair skin, short brown hair, and light stubble walks along a paved path while holding a medium-sized golden retriever on a dark green leash. He wears a faded blue overshirt over a grey T-shirt, tan trousers, and worn brown walking shoes. His body faces left as he takes a step forward, looking down toward the dog with a neutral expression. The leash hangs in a loose curve between his right hand and the dog’s red collar. The golden retriever walks beside him on the left, its cream-gold coat lit along the back and ears, head lowered toward the grass and tail raised behind it. Dry leaves and small twigs lie near the edge of the path in the foreground. On the right, the sun sits just above the line of trees, producing a bright patch of glare and warm highlights on the man’s sleeve and the dog’s fur. Behind them, an open lawn extends toward scattered shrubs and mature tree trunks, with a wooden bench resting near the path. In the background, muted brick houses and parked cars form simple shapes beyond the foliage, while the pale blue sky occupies a narrow band above the treetops."
+}
diff --git a/pyproject.toml b/pyproject.toml
index 25bcfa24..61fe9eff 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -8,7 +8,7 @@ name = "diffusers-workflow"
 # runtime (static in TOML because importing dw at build time would drag
 # torch into the build environment). Release tags must match it - see
 # docs/RELEASING.md
-version = "0.14.0"
+version = "0.15.0-alpha.1"
 description = "Declarative workflow engine and web UI for Hugging Face Diffusers"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -70,6 +70,10 @@ dependencies = [
     # without it that decoder falls back to a FlexAttention path diffusers' own
     # docstring calls larger than device memory at production grids
     "kernels>=0.17.2",
+    # Sol-Attn sparse attention for MiniMax H3's generated-video rows (#931);
+    # compiled CUDA/HIP kernels on Linux and Windows, an eager-only wheel elsewhere
+    # pre-1.0 kernel API; bump deliberately after a GPU smoke
+    "comfy-kitchen>=0.2.38,<0.3",
     # Upscaling and face restoration tasks
     "spandrel>=0.4.2",
     "facexlib>=0.3.0",
diff --git a/tests/sparse_layouts.py b/tests/sparse_layouts.py
new file mode 100644
index 00000000..c2ba9297
--- /dev/null
+++ b/tests/sparse_layouts.py
@@ -0,0 +1,62 @@
+"""Shared helpers for the H3 sparse-attention tests (#931): packed layouts the
+way diffusers builds them, and a dense stand-in for the comfy-kitchen kernel."""
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+# A tiny MiniMaxH3Transformer3DModel: head_dim 128, the one the kernel takes,
+# and two blocks, so a per-call decision is seen across more than one
+CONFIG = dict(
+    num_attention_heads=2,
+    attention_head_dim=128,
+    hidden_size=256,
+    num_layers=2,
+    num_refiner_layers=1,
+    ffn_dim=64,
+    in_channels=4,
+    audio_in_channels=4,
+    patch_size=(1, 2, 2),
+    text_dim=32,
+    freq_dim=32,
+    time_embed_hidden_dim=32,
+    time_embed_dim=32,
+    rope_freq_dim=16,
+)
+
+
+def _layout(text, ref_rows, audio, t, h, w):
+    """token_tags and fractional position_ids packed the way diffusers does:
+    text (tag 1), reference-image rows (tag 0), target audio (tag 2), then the
+    target video (tag 0) last."""
+    tags = [1] * text + [0] * ref_rows + [2] * audio + [0] * (t * h * w)
+    pos = np.zeros((len(tags), 3), dtype=np.float64)
+    # Rows before the target video carry positions the tile map never reads
+    pos[:, 0] = np.arange(len(tags))
+
+    def spatial(n):
+        ratio = n / np.sqrt(h * w)
+        left = (1 - ratio) / 2
+        return np.linspace(left, left + ratio, n, endpoint=False) * 32
+
+    spans = 5 / 3 * np.array([1] + [4] * (t - 1))
+    times = text + np.cumsum(spans)
+    grid = np.stack(np.meshgrid(times, spatial(h), spatial(w), indexing="ij"), axis=-1)
+    pos[len(tags) - t * h * w :] = grid.reshape(-1, 3)
+    return torch.tensor(tags, dtype=torch.long), torch.from_numpy(pos)
+
+
+def dense_sol_attn_fake(q, k, v, *, sink_blocks, sink_q, block_len, tau, **_):
+    """Full attention over the padded, tiled tensors the sparse processor hands
+    the kernel. Within each 64-row tile, rows at or past `block_len[tile]` are
+    padding: they are masked as keys, and their query rows are discarded by the
+    caller. Equal to the stock processor exactly when the permutation is."""
+    within = torch.arange(q.shape[1], device=q.device) % 64
+    live = within < block_len.long().repeat_interleave(64)
+    out = F.scaled_dot_product_attention(
+        q.transpose(1, 2),
+        k.transpose(1, 2),
+        v.transpose(1, 2),
+        attn_mask=live[None, None, None, :],
+    )
+    return out.transpose(1, 2)
diff --git a/tests/test_api_contract.py b/tests/test_api_contract.py
index c4c4824a..173dd44a 100644
--- a/tests/test_api_contract.py
+++ b/tests/test_api_contract.py
@@ -253,6 +253,7 @@ def test_health_sends_exactly_its_keys(server):
         "device",
         "mcp",
         "workers",
+        "attention_backends",
     }
     assert type(body["queued"]) is int
     # One worker, not yet started: no process, so no host memory to read
diff --git a/tests/test_catalog_structure.py b/tests/test_catalog_structure.py
index d040038a..ecc670f1 100644
--- a/tests/test_catalog_structure.py
+++ b/tests/test_catalog_structure.py
@@ -484,7 +484,10 @@ def test_no_stale_entry_in_the_allowlist():
 # Then to 10_850 for the whole-object `cache` variable on the same nineteen H3
 # templates (#865, stage #884, 2026-10-13), measured at 10_800: about 42
 # tokens, so first_block on a long base-model schedule is an argument too.
-COMPACT_BUDGET = 10_850
+# Then to 11_400 for the five FLUX 3 Klein templates (#930, 2026-10-15),
+# measured at 11_256: a new family, its summaries already trimmed to the idea
+# each template adds, with about 85 tokens held for its Task 9 cost blocks.
+COMPACT_BUDGET = 11_400
 FILTERED_BUDGET = 1_500
 
 
@@ -616,13 +619,14 @@ def test_there_are_h3_templates():
 def test_every_h3_transformer_step_wires_attention_backend(path):
     """sage_hub is 23-33% faster per step and lossless on CUDA, and the only way
     to reach it from `arguments` is a template variable wired to the
-    transformer (#865). Every H3 template exposes it, null by default so mps
-    and cpu keep the process default; one that doesn't makes the cinema path
-    a JSON edit again."""
+    transformer (#865). Every H3 template exposes it; on mps
+    and cpu the default falls back to dense; one that doesn't makes the cinema path
+    a JSON edit again. The default is `sparse` since #931 (tests/
+    test_h3_sparse_defaults.py pins it, `sparse_tau` and `sparse_topk`)."""
     definition = load(path)
 
-    assert definition["variables"].get("attention_backend", "missing") is None, (
-        f"{path} declares no attention_backend variable defaulting to null"
+    assert definition["variables"].get("attention_backend", "missing") == "sparse", (
+        f"{path} declares no attention_backend variable defaulting to sparse"
     )
     for step in _h3_steps(definition):
         transformers = _transformers(step)
@@ -631,6 +635,12 @@ def test_every_h3_transformer_step_wires_attention_backend(path):
             assert component.get("attention_backend") == "variable:attention_backend", (
                 f"{path} step '{step['name']}' does not wire {name}.attention_backend"
             )
+            assert component.get("sparse_tau") == "variable:sparse_tau", (
+                f"{path} step '{step['name']}' does not wire {name}.sparse_tau"
+            )
+            assert component.get("sparse_topk") == "variable:sparse_topk", (
+                f"{path} step '{step['name']}' does not wire {name}.sparse_topk"
+            )
 
 
 def test_only_h3_steps_wire_attention_backend():
@@ -716,8 +726,8 @@ def test_a_default_cache_drops_the_key():
     assert "cache" not in steps["shot"]["pipeline"]["configuration"]
 
 
-def test_a_default_attention_backend_drops_the_key():
-    steps = _dialogue_short_after_substitution()
+def test_a_null_attention_backend_drops_the_key():
+    steps = _dialogue_short_after_substitution(attention_backend=None)
 
     shot = steps["shot"]["pipeline"]["configuration"]["components"]["transformer_ref"]
     assert "attention_backend" not in shot
diff --git a/tests/test_dependencies_declared.py b/tests/test_dependencies_declared.py
new file mode 100644
index 00000000..4d7341b9
--- /dev/null
+++ b/tests/test_dependencies_declared.py
@@ -0,0 +1,9 @@
+import pathlib
+import tomllib
+
+
+def test_comfy_kitchen_is_a_core_dependency():
+    data = tomllib.loads(pathlib.Path("pyproject.toml").read_text())
+    deps = data["project"]["dependencies"]
+    # Pre-1.0 kernel API: the upper bound keeps a minor bump from landing unseen
+    assert "comfy-kitchen>=0.2.38,<0.3" in [d.replace(" ", "") for d in deps]
diff --git a/tests/test_flux3_catalog.py b/tests/test_flux3_catalog.py
new file mode 100644
index 00000000..53898c90
--- /dev/null
+++ b/tests/test_flux3_catalog.py
@@ -0,0 +1,188 @@
+"""The FLUX 3 Image Klein catalog: the upsampler builtins, the templates' settings
+and their placement. The vendor values here are the ones the design states
+(docs/superpowers/specs/2026-10-15-flux-3-klein-catalog-design.md)."""
+
+import json
+import os
+
+import pytest
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+BUILTINS = os.path.join(ROOT, "dw", "workflows")
+PUP = "black-forest-labs/flux-3-image-klein-pup"
+PUP_PIN = "3f3edb52b2c55de0d49feab28598b68f7f8e4830"
+
+
+def load(path):
+    with open(path) as f:
+        return json.load(f)
+
+
+def generation_steps(definition):
+    return [
+        s
+        for s in definition["steps"]
+        if s.get("task", {}).get("command") == "text_generation"
+    ]
+
+
+@pytest.mark.parametrize(
+    "name,key",
+    [
+        ("flux3_klein_upsample.json", "t2i"),
+        ("flux3_klein_upsample_edit.json", "i2i"),
+    ],
+)
+def test_each_upsampler_runs_the_pinned_pup_as_bfl_does(name, key):
+    definition = load(os.path.join(BUILTINS, name))
+    (step,) = generation_steps(definition)
+    args = step["task"]["arguments"]
+    assert args["model_name"] == PUP
+    assert args["revision"] == PUP_PIN
+    assert args["system_prompt"] == {
+        "from_hub": {
+            "repo": PUP,
+            "file": "system_prompts.json",
+            "revision": PUP_PIN,
+            "key": key,
+        }
+    }
+    assert args["chat_template_kwargs"] == {"enable_thinking": False}
+    assert args["max_new_tokens"] == 3584
+
+
+def test_the_edit_upsampler_wraps_the_instruction_in_bfl_s_scaffold():
+    definition = load(os.path.join(BUILTINS, "flux3_klein_upsample_edit.json"))
+    compose = next(
+        s for s in definition["steps"] if s["task"]["command"] == "compose_text"
+    )
+    parts = compose["task"]["arguments"]["parts"]
+    assert parts == [
+        "Reference images follow in order (the first image, the second image, ...).\nUser request: ",
+        "variable:instruction",
+        "\nOutput the caption.",
+    ]
+    assert compose["task"]["arguments"]["separator"] == ""
+    (step,) = generation_steps(definition)
+    assert step["task"]["arguments"]["image"] == "variable:images"
+    assert step["task"]["arguments"]["repetition_penalty"] == 1.0
+    assert "bbfe317d" in definition["description"]
+
+
+TEMPLATES = os.path.join(ROOT, "workflows", "templates", "flux3")
+KLEIN = "black-forest-labs/flux-3-image-klein"
+
+
+def klein_steps(definition):
+    return [
+        s
+        for s in definition["steps"]
+        if s.get("pipeline", {}).get("from_pretrained_arguments", {}).get("model_name")
+        == KLEIN
+    ]
+
+
+def flux3_definitions():
+    paths = [
+        os.path.join(TEMPLATES, n)
+        for n in sorted(os.listdir(TEMPLATES))
+        if n.endswith(".json")
+    ]
+    paths.append(os.path.join(ROOT, "workflows", "models", "flux3-klein.json"))
+    return paths
+
+
+@pytest.mark.parametrize("path", flux3_definitions())
+def test_every_flux3_pipeline_step_places_every_component(path):
+    steps = klein_steps(load(path))
+    assert steps, f"{path} runs no Klein step"
+    for step in steps:
+        components = step["pipeline"]["configuration"]["components"]
+        for name in ("transformer", "text_encoder", "vae"):
+            assert components.get(name, {}).get("device") == "cuda", (path, name)
+        assert components["text_encoder"].get("residency") is None
+
+
+@pytest.mark.parametrize("path", flux3_definitions())
+def test_every_klein_step_runs_the_distilled_schedule_without_guidance(path):
+    for step in klein_steps(load(path)):
+        args = step["pipeline"]["arguments"]
+        assert args["num_inference_steps"] == 16
+        assert "guidance_scale" not in args and "negative_prompt" not in args
+        assert args["output"] == "images"
+
+
+@pytest.mark.parametrize("path", flux3_definitions())
+def test_size_variables_are_held_to_the_16_pixel_grid(path):
+    definition = load(path)
+    constraints = definition.get("variable_constraints", {})
+    for name in ("width", "height"):
+        if name in definition.get("variables", {}):
+            assert (
+                constraints[name]["modulus"] == 16
+                and constraints[name].get("remainder", 0) == 0
+            )
+
+
+def test_the_16_step_default_is_the_distilled_pipeline_s():
+    from diffusers.modular_pipelines.flux3.modular_blocks_flux3_distilled import (
+        Flux3DistilledCoreDenoiseStep,
+    )
+
+    defaults = {p.name: p.default for p in Flux3DistilledCoreDenoiseStep().inputs}
+    assert defaults["num_inference_steps"] == 16
+
+
+def test_the_16_pixel_grid_is_the_vae_scale_times_the_2x2_packing():
+    import inspect
+
+    from diffusers.modular_pipelines.flux3 import before_denoise
+
+    # Source check: the multiple is derived from the loaded VAE, so it cannot
+    # be read without weights; 8 (VAE) * 2 (packing) = 16 is the vendor's.
+    assert "vae_scale_factor * 2" in inspect.getsource(before_denoise)
+
+
+def test_upsample_then_generate_feeds_the_builtin_caption_to_klein():
+    definition = load(os.path.join(TEMPLATES, "upsample-then-generate.json"))
+    first, second = definition["steps"]
+    assert first["workflow"]["path"] == "builtin:flux3_klein_upsample.json"
+    assert first["release_models"] is True
+    assert first["result"]["subfolder"] == "intermediate"
+    assert (
+        second["pipeline"]["arguments"]["prompt"] == f"previous_result:{first['name']}"
+    )
+
+
+@pytest.mark.parametrize("name", ["image-edit.json", "multi-reference.json"])
+def test_the_edit_templates_show_the_upsampler_the_pipeline_s_references(name):
+    definition = load(os.path.join(TEMPLATES, name))
+    upsample = next(s for s in definition["steps"] if "workflow" in s)
+    assert upsample["workflow"]["path"] == "builtin:flux3_klein_upsample_edit.json"
+    (klein,) = klein_steps(definition)
+    assert (
+        upsample["workflow"]["arguments"]["images"]
+        == klein["pipeline"]["arguments"]["image"]
+    )
+    assert (
+        klein["pipeline"]["arguments"]["prompt"]
+        == f"previous_result:{upsample['name']}"
+    )
+
+
+def test_multi_reference_states_the_ten_reference_cap_and_the_naming():
+    description = load(os.path.join(TEMPLATES, "multi-reference.json"))["description"]
+    assert "10 references" in description
+    assert "<ref_image_0>" in description
+
+
+def test_the_layout_caption_carries_tags_and_a_0_to_1000_box_table():
+    with open(os.path.join(ROOT, "prompts", "flux3", "balloons_layout.json")) as f:
+        text = json.load(f)["text"]
+    table = json.loads(text[text.index("[") :])
+    assert table and all({"id", "bbox", "desc"} <= set(row) for row in table)
+    for row in table:
+        assert f"<{row['id']}>" in text
+        top, left, bottom, right = row["bbox"]
+        assert 0 <= top < bottom <= 1000 and 0 <= left < right <= 1000
+    assert klein_steps(load(os.path.join(TEMPLATES, "layout-boxes.json")))
diff --git a/tests/test_h3_sparse_defaults.py b/tests/test_h3_sparse_defaults.py
new file mode 100644
index 00000000..d646e483
--- /dev/null
+++ b/tests/test_h3_sparse_defaults.py
@@ -0,0 +1,45 @@
+"""The MiniMax-H3 templates default to sparse attention (#931).
+
+Sparse is the default because it measured 2.2-4.4x faster per forward on a
+3090; off CUDA it falls back to dense with a warning, so the default is safe
+everywhere. Its routing defaults to top-k 0.15 (#932): faster than tau 0.5 at
+equal or better faces and skin on the ramp's L7 and L5, judged by Don on three
+seeds. Each template that pins a backend must also pass `sparse_tau` and
+`sparse_topk` beside it, or the variables would be declared and never reach
+the transformer.
+"""
+
+import json
+from glob import glob
+
+import pytest
+
+
+def _read(path):
+    with open(path) as f:
+        return f.read()
+
+
+# selected by the H3 transformer, not by any attention_backend: a Music 3
+# template that pins a backend is no H3 default
+H3 = sorted(
+    p for p in glob("workflows/templates/minimax/*.json") if "MiniMaxH3" in _read(p)
+)
+
+
+def test_nineteen_h3_templates():
+    assert len(H3) == 19
+
+
+@pytest.mark.parametrize("path", H3)
+def test_h3_defaults_to_sparse(path):
+    d = json.loads(_read(path))
+    assert d["variables"]["attention_backend"] == "sparse"
+    assert d["variables"]["sparse_tau"] == 0.5
+    assert d["variables"]["sparse_topk"] == 0.15
+    text = json.dumps(d["steps"])
+    pins = text.count('"attention_backend": "variable:attention_backend"')
+    assert text.count('"sparse_tau": "variable:sparse_tau"') == pins
+    assert text.count('"sparse_topk": "variable:sparse_topk"') == pins
+    assert text.count('"attention_backend": "variable:attention_backend"') >= 1
+    assert "attention_backend" in d["cost_drivers"]
diff --git a/tests/test_observed_cost.py b/tests/test_observed_cost.py
index 9aac5e31..b08ed037 100644
--- a/tests/test_observed_cost.py
+++ b/tests/test_observed_cost.py
@@ -681,9 +681,10 @@ def test_a_driver_is_a_size_not_a_piece_of_text(self):
 
         The exception is a configuration choice drawn from a short list:
         H3's weights dtype and LoRA move the wall clock and are text, and
-        bucket by exact value (#866, Q5)."""
+        bucket by exact value (#866, Q5). So is the attention backend, which
+        changes the wall clock by 2-4x (#931)."""
         never = {"seed", "prompt", "negative_prompt"}
-        choices = {"weights_dtype", "lora_model_name"}
+        choices = {"weights_dtype", "lora_model_name", "attention_backend"}
         for path in sorted(
             glob.glob(
                 os.path.join(REPO_ROOT, "workflows", "**", "*.json"), recursive=True
diff --git a/tests/test_plugin_skills.py b/tests/test_plugin_skills.py
index 42fcb78e..be3c3cad 100644
--- a/tests/test_plugin_skills.py
+++ b/tests/test_plugin_skills.py
@@ -719,6 +719,58 @@ def test_the_skill_starts_with_the_server(self):
         assert text.index("get_server_info") < text.index("templates/kandinsky6/")
 
 
+FLUX3_SKILL = os.path.join(PLUGIN_DIR, "skills", "flux3-klein", "SKILL.md")
+
+
+def flux3_text():
+    """The Klein skill with its line wraps collapsed, so a phrase the tests
+    pin does not break when a paragraph is rewrapped."""
+    return " ".join(skill_text(FLUX3_SKILL).split())
+
+
+class TestFlux3KleinSkill:
+    """The Klein skill's numbers come from the diffusers modular blocks that
+    enforce them; the 10-reference cap is the vendor's training limit, which
+    the pipeline does not enforce, and the skill says so."""
+
+    def test_the_step_count_is_the_distilled_pipeline_s(self):
+        # The distilled denoise step, not Flux3SetTimestepsStep (which
+        # defaults to 50), holds the 16 the templates run.
+        from diffusers.modular_pipelines.flux3.modular_blocks_flux3_distilled import (
+            Flux3DistilledCoreDenoiseStep,
+        )
+
+        defaults = {p.name: p.default for p in Flux3DistilledCoreDenoiseStep().inputs}
+        assert defaults["num_inference_steps"] == 16
+        assert "16 steps" in flux3_text()
+
+    def test_the_grid_is_the_vae_scale_times_the_2x2_packing(self):
+        from diffusers.modular_pipelines.flux3 import before_denoise
+
+        # The multiple is read off the loaded VAE, so only the source shows it.
+        assert "vae_scale_factor * 2" in inspect.getsource(before_denoise)
+        assert "multiples of 16" in flux3_text()
+
+    def test_the_distilled_model_takes_no_guidance(self):
+        assert "no guidance" in flux3_text()
+
+    def test_the_reference_cap_is_stated_as_the_vendor_s(self):
+        text = flux3_text()
+        assert "10 references" in text and "<ref_image_0>" in text
+        assert "does not enforce" in text
+
+    def test_the_skill_defers_prompt_format_to_bfl(self):
+        text = flux3_text()
+        assert "https://docs.bfl.ml/guides/prompting_summary" in text
+        assert "`flux3_klein_upsample`" in text
+        assert "`flux3_klein_upsample_edit`" in text
+
+    def test_the_skill_starts_with_the_server(self):
+        text = flux3_text()
+        assert text.index("get_server_info") < text.index("list_workflows")
+        assert text.index("get_server_info") < text.index("templates/flux3/")
+
+
 SERIES_SKILL = os.path.join(PLUGIN_DIR, "skills", "series-episodes", "SKILL.md")
 SERIES_LOOK = os.path.join(os.path.dirname(SERIES_SKILL), "references", "look.md")
 
diff --git a/tests/test_security_ssrf.py b/tests/test_security_ssrf.py
index 557a3033..28a39bac 100644
--- a/tests/test_security_ssrf.py
+++ b/tests/test_security_ssrf.py
@@ -786,3 +786,17 @@ def test_trust_lifts_the_scope(self, no_real_sockets, monkeypatch):
         monkeypatch.setenv(TRUST_WORKFLOWS_ENV_VAR, "0")
         transport = _encode("https://evil.example/encode", monkeypatch)
         assert not _carried_token(transport.sent[0])
+
+
+class TestImageListElementsAreValidated:
+    """An `image` argument may be a list (text_generation sends every one to a
+    model); each element goes through the same location check as a lone string."""
+
+    def test_a_blocked_url_in_a_list_is_refused(self, untrusted, no_real_sockets):
+        import pytest
+
+        from dw.arguments import realize_args
+
+        arguments = {"image": ["http://169.254.169.254/x.png"]}
+        with pytest.raises(Exception, match="Refusing to fetch an image"):
+            realize_args(arguments)
diff --git a/tests/test_security_trust_gate.py b/tests/test_security_trust_gate.py
index 2b0a1eac..3f25468e 100644
--- a/tests/test_security_trust_gate.py
+++ b/tests/test_security_trust_gate.py
@@ -779,6 +779,106 @@ def test_an_in_package_class_of_no_accepted_kind_is_refused(self, untrusted, nam
 # --------------------------------------------------- validate-time probes
 
 
+class TestRemoteGenerateCodeUntrusted:
+    """text_generation's generate_kwargs reach model.generate(), and
+    `custom_generate` there makes transformers download a repo's
+    custom_generate/generate.py and run it. Untrusted, both it and
+    trust_remote_code are refused before the model loads or the Hub is asked."""
+
+    @pytest.mark.parametrize(
+        "settings",
+        [
+            pytest.param(
+                {"custom_generate": "attacker/repo", "trust_remote_code": True},
+                id="both",
+            ),
+            pytest.param({"custom_generate": "attacker/repo"}, id="custom_generate"),
+            pytest.param({"trust_remote_code": True}, id="trust_remote_code"),
+        ],
+    )
+    @pytest.mark.parametrize("image", [None, "https://example.com/a.png"])
+    def test_refused_before_the_model_loads(
+        self, untrusted, no_network, monkeypatch, settings, image
+    ):
+        from dw.tasks import text_generation
+
+        loader = MagicMock()
+        monkeypatch.setattr(text_generation, "hf_pipeline", loader)
+        key = next(iter(settings))
+        with pytest.raises(UntrustedWorkflowError, match=f"'{key}'.*trusted"):
+            text_generation.generate_text(
+                "a cat",
+                device="cpu",
+                model_name="m/untrusted-generate",
+                image=image,
+                generate_kwargs=settings,
+            )
+        loader.assert_not_called()
+        assert list(no_network) == []
+
+    def test_trusted_lets_them_through(self, trusted):
+        from dw.trust import require_trusted_generate_arguments
+
+        require_trusted_generate_arguments(
+            {"custom_generate": "a/b", "trust_remote_code": True}, "text_generation"
+        )
+
+
+class TestSpeechRemoteGenerateCodeUntrusted:
+    """speech_generation hands generate_kwargs and forward_params to the
+    text-to-audio pipeline, which passes both to model.generate() for a
+    generative model (Bark, VibeVoice). The same two arguments that run Hub
+    code through text_generation are refused here before the model loads."""
+
+    @pytest.mark.parametrize("where", ["generate_kwargs", "forward_params"])
+    @pytest.mark.parametrize(
+        "settings",
+        [
+            pytest.param({"custom_generate": "attacker/repo"}, id="custom_generate"),
+            pytest.param({"trust_remote_code": True}, id="trust_remote_code"),
+        ],
+    )
+    def test_refused_before_the_model_loads(
+        self, untrusted, no_network, monkeypatch, settings, where
+    ):
+        from dw.tasks import speech_generation
+
+        loader = MagicMock()
+        monkeypatch.setattr(speech_generation, "hf_pipeline", loader)
+        key = next(iter(settings))
+        with pytest.raises(UntrustedWorkflowError, match=f"'{key}'.*trusted"):
+            speech_generation.generate_speech(
+                "hello", device="cpu", **{where: settings}
+            )
+        loader.assert_not_called()
+        assert list(no_network) == []
+
+    @pytest.mark.parametrize("where", ["generate_kwargs", "forward_params"])
+    def test_ordinary_settings_still_pass_untrusted(
+        self, untrusted, monkeypatch, where
+    ):
+        from dw.tasks import speech_generation
+
+        pipe = MagicMock(
+            return_value={"audio": __import__("numpy").zeros(8), "sampling_rate": 16000}
+        )
+        monkeypatch.setattr(
+            speech_generation, "hf_pipeline", MagicMock(return_value=pipe)
+        )
+        speech_generation.generate_speech(
+            "hello", device="cpu", **{where: {"do_sample": True, "temperature": 0.7}}
+        )
+        assert pipe.call_args[1][where] == {"do_sample": True, "temperature": 0.7}
+
+    @pytest.mark.parametrize("where", ["generate_kwargs", "forward_params"])
+    def test_a_non_object_is_refused(self, monkeypatch, where):
+        from dw.tasks import speech_generation
+
+        monkeypatch.setattr(speech_generation, "hf_pipeline", MagicMock())
+        with pytest.raises(ValueError, match=f"{where} must be an object"):
+            speech_generation.generate_speech("hello", device="cpu", **{where: "x"})
+
+
 def _probe_recorder(info):
     """A `probe=` callable that records every path it is asked about.
 
diff --git a/tests/test_sparse_attention_backends.py b/tests/test_sparse_attention_backends.py
new file mode 100644
index 00000000..debb6b13
--- /dev/null
+++ b/tests/test_sparse_attention_backends.py
@@ -0,0 +1,111 @@
+"""The backends the server reports it can run (#931): the UI's dropdown."""
+
+import pytest
+import torch
+
+from dw import sparse_attention
+from dw.acceleration_warnings import CUDA_ONLY_ATTENTION_BACKENDS
+from dw.acceleration_warnings import available_attention_backends
+
+from tests.test_server import server, success_script  # noqa: F401
+
+
+@pytest.fixture(autouse=True)
+def fresh_kernel_probe():
+    """The probe is cached for the process: each test starts and ends cold,
+    so one that patches the import sees its own answer, and leaves none.
+    Held here, since a test may have swapped the module's name by teardown."""
+    probe = sparse_attention._kernels_importable
+    probe.cache_clear()
+    yield
+    probe.cache_clear()
+
+
+def test_mps_lists_no_cuda_backends():
+    names = available_attention_backends("mps")
+    assert "native" in names and "sparse" not in names and "sage_hub" not in names
+    assert "_native_cudnn" not in names
+    assert not set(names) & CUDA_ONLY_ATTENTION_BACKENDS
+
+
+def test_cuda_lists_sparse_when_kernels_present(monkeypatch):
+    monkeypatch.setattr(sparse_attention, "_kernels_importable", lambda: True)
+    names = available_attention_backends("cuda")
+    assert names[0] == "native"
+    assert "sparse" in names and "_native_cudnn" in names
+    # sparse comes before the sorted CUDA-only names
+    assert names[names.index("sparse") + 1 :] == sorted(CUDA_ONLY_ATTENTION_BACKENDS)
+
+
+def test_cuda_omits_sparse_without_kernels(monkeypatch):
+    monkeypatch.setattr(sparse_attention, "_kernels_importable", lambda: False)
+    names = available_attention_backends("cuda")
+    assert "sparse" not in names and "sage_hub" in names
+
+
+def test_names_are_all_diffusers_backends(monkeypatch):
+    from diffusers.models.attention_dispatch import AttentionBackendName
+
+    monkeypatch.setattr(sparse_attention, "_kernels_importable", lambda: True)
+    known = {b.value for b in AttentionBackendName}
+    assert set(available_attention_backends("cuda")) - {"sparse"} <= known
+
+
+def test_listing_never_initializes_cuda():
+    available_attention_backends("cuda")
+    assert not torch.cuda.is_initialized()
+
+
+def test_listing_never_touches_the_card(monkeypatch):
+    def boom(*args, **kwargs):
+        raise AssertionError("the listing touched CUDA")
+
+    monkeypatch.setattr(torch.cuda, "get_device_capability", boom)
+    monkeypatch.setattr(torch.cuda, "init", boom)
+    monkeypatch.setattr(sparse_attention, "_kernels_importable", lambda: True)
+    assert "sparse" in available_attention_backends("cuda")
+
+
+def test_kernel_probe_swallows_every_error(monkeypatch):
+    import builtins
+
+    real = builtins.__import__
+
+    def failing(name, *args, **kwargs):
+        if name.startswith("comfy_kitchen"):
+            raise RuntimeError("broken install")
+        return real(name, *args, **kwargs)
+
+    monkeypatch.setattr(builtins, "__import__", failing)
+    assert sparse_attention._kernels_importable() is False
+
+
+def test_kernel_probe_imports_once(monkeypatch):
+    """The first health poll pays for the import; later ones do not."""
+    import builtins
+
+    # Loaded first, so the count below sees the probe's own import statements
+    # and not comfy-kitchen loading its submodules: whether that happens here
+    # depends on which tests ran earlier in this worker
+    import comfy_kitchen.backends.cuda  # noqa: F401
+
+    real = builtins.__import__
+    imports = []
+
+    def counting(name, *args, **kwargs):
+        if name.startswith("comfy_kitchen"):
+            imports.append(name)
+        return real(name, *args, **kwargs)
+
+    monkeypatch.setattr(builtins, "__import__", counting)
+    first = sparse_attention._kernels_importable()
+    paid = len(imports)
+    assert sparse_attention._kernels_importable() is first
+    assert len(imports) == paid  # the later call imported nothing
+
+
+def test_health_carries_attention_backends(server):  # noqa: F811
+    with server(success_script) as client:
+        body = client.get("/api/health").json()
+    assert "native" in body["attention_backends"]
+    assert isinstance(body["attention_backends"], list)
diff --git a/tests/test_sparse_attention_processor.py b/tests/test_sparse_attention_processor.py
new file mode 100644
index 00000000..f6a2b774
--- /dev/null
+++ b/tests/test_sparse_attention_processor.py
@@ -0,0 +1,597 @@
+"""The H3 sparse processor, its installation and the per-call decision (#931).
+
+A tiny real MiniMaxH3Transformer3DModel runs on CPU in float32. The sparse path
+needs a CUDA kernel, so the tests that take it swap `sparse_unavailable_reason`
+for one that says yes and `_sol_attn` for a dense stand-in over the tiled
+tensors: the output then equals the stock processor's exactly when the
+gather into the padded tile order and back is a true permutation.
+"""
+
+import inspect
+from types import SimpleNamespace
+
+import pytest
+import torch
+
+from dw import sparse_attention
+from dw.sparse_attention import (
+    DEFAULT_TAU,
+    SPARSE_BACKEND,
+    SparseLayoutError,
+    install_sparse,
+    is_sparse_installed,
+    set_sparse_tau,
+    sparse_call,
+    sparse_unavailable_reason,
+    uninstall_sparse,
+)
+from tests.sparse_layouts import CONFIG, _layout, dense_sol_attn_fake
+
+
+@pytest.fixture
+def tiny_h3():
+    from diffusers.models.transformers.transformer_minimax_h3 import (
+        MiniMaxH3Transformer3DModel,
+    )
+
+    torch.manual_seed(0)
+    return MiniMaxH3Transformer3DModel(**CONFIG).eval()
+
+
+def _inputs(text=70, ref_rows=20, audio=70, t=5, h=6, w=5, batch=2):
+    """Forward kwargs for one packed layout. h=6, w=5 leaves partial tiles, so
+    the padding mask is exercised; batch=2 stands in for CFG."""
+    tags, pos = _layout(text, ref_rows, audio, t, h, w)
+    target = len(tags) - t * h * w
+    timestep_indices = torch.zeros(len(tags), dtype=torch.long)
+    timestep_indices[text + ref_rows :] = 1  # target audio and video are noised
+    g = torch.Generator().manual_seed(1)
+    video = (tags == 0).nonzero().squeeze(1)
+    audio_idx = (tags == 2).nonzero().squeeze(1)
+    text_idx = (tags == 1).nonzero().squeeze(1)
+    assert video[-1] == len(tags) - 1 and target > 0
+    patch = CONFIG["in_channels"] * 4
+    return dict(
+        hidden_states=torch.randn(batch, len(video), patch, generator=g),
+        audio_hidden_states=torch.randn(batch, len(audio_idx), 4, generator=g),
+        encoder_hidden_states=torch.randn(batch, len(text_idx), 32, generator=g),
+        timestep=torch.tensor([0.0, 0.6]),
+        timestep_indices=timestep_indices,
+        token_tags=tags,
+        position_ids=pos,
+        video_indices=video,
+        audio_indices=audio_idx,
+        text_indices=text_idx,
+    )
+
+
+def _pipe(component):
+    return SimpleNamespace(transformer=component)
+
+
+@pytest.fixture
+def kernel_calls(monkeypatch):
+    """Say the kernel can run, and record each call to the dense stand-in."""
+    calls = []
+
+    def fake(q, k, v, **kw):
+        calls.append(dict(dtype=q.dtype, rows=q.shape[1], **kw))
+        return dense_sol_attn_fake(q, k, v, **kw)
+
+    monkeypatch.setattr(sparse_attention, "_sol_attn", fake)
+    monkeypatch.setattr(sparse_attention, "sparse_unavailable_reason", lambda *a: None)
+    return calls
+
+
+@pytest.fixture
+def warnings(monkeypatch):
+    seen = []
+    monkeypatch.setattr(
+        sparse_attention,
+        "emit_warning",
+        lambda message, **data: seen.append((message, data)),
+    )
+    return seen
+
+
+def _refiner_processors(model):
+    return [b.attn.processor for b in model.token_refiner.refiner_blocks]
+
+
+def test_constants():
+    assert SPARSE_BACKEND == "sparse"
+    assert DEFAULT_TAU == 0.5
+
+
+def test_install_swaps_only_block_processors(tiny_h3):
+    refiner_before = _refiner_processors(tiny_h3)
+    assert install_sparse(tiny_h3, 0.5) is True
+    assert is_sparse_installed(tiny_h3)
+    assert all(
+        type(b.attn.processor).__name__ == "SparseH3AttnProcessor"
+        for b in tiny_h3.transformer_blocks
+    )
+    assert _refiner_processors(tiny_h3) == refiner_before
+
+
+def test_refiner_processors_untouched(tiny_h3, kernel_calls):
+    refiner_before = _refiner_processors(tiny_h3)
+    install_sparse(tiny_h3, 0.5)
+    with sparse_call(_pipe(tiny_h3), "t"):
+        tiny_h3(**_inputs())
+    assert _refiner_processors(tiny_h3) == refiner_before
+    assert all(type(p).__name__ == "MiniMaxH3AttnProcessor" for p in refiner_before)
+    # One kernel call per block, none for the refiner
+    assert len(kernel_calls) == CONFIG["num_layers"]
+
+
+def test_install_on_non_h3_returns_false():
+    linear = torch.nn.Linear(2, 2)
+    assert install_sparse(linear, 0.5) is False
+    assert not is_sparse_installed(linear)
+    assert not linear._forward_pre_hooks and not linear._forward_hooks
+
+
+def test_install_is_idempotent(tiny_h3, kernel_calls):
+    install_sparse(tiny_h3, 0.5)
+    processors = [b.attn.processor for b in tiny_h3.transformer_blocks]
+    assert install_sparse(tiny_h3, 0.25) is True
+    assert [b.attn.processor for b in tiny_h3.transformer_blocks] == processors
+    assert len(tiny_h3._forward_pre_hooks) == 1 and len(tiny_h3._forward_hooks) == 1
+    with sparse_call(_pipe(tiny_h3), "t"):
+        tiny_h3(**_inputs())
+    assert {c["tau"] for c in kernel_calls} == {0.25}
+
+
+def test_set_sparse_tau_reaches_the_kernel(tiny_h3, kernel_calls):
+    install_sparse(tiny_h3, 0.5)
+    set_sparse_tau(tiny_h3, 0.8)
+    with sparse_call(_pipe(tiny_h3), "t"):
+        tiny_h3(**_inputs())
+    assert {c["tau"] for c in kernel_calls} == {0.8}
+
+
+def test_topk_reaches_the_kernel_as_topk_ratio_without_tail(tiny_h3, kernel_calls):
+    """sparse_topk is sol_attn's SLA-style selection: keep that fraction of key
+    tiles per query tile, softmax over those only (#932). tau is not passed."""
+    install_sparse(tiny_h3, 0.5, topk=0.15)
+    with sparse_call(_pipe(tiny_h3), "t"):
+        tiny_h3(**_inputs())
+    assert kernel_calls
+    assert {c["topk_ratio"] for c in kernel_calls} == {0.15}
+    assert {c["tail"] for c in kernel_calls} == {False}
+    assert all("tau" not in c for c in kernel_calls)
+
+
+def test_without_topk_the_kernel_gets_tau_only(tiny_h3, kernel_calls):
+    install_sparse(tiny_h3, 0.5)
+    with sparse_call(_pipe(tiny_h3), "t"):
+        tiny_h3(**_inputs())
+    assert all("topk_ratio" not in c and "tail" not in c for c in kernel_calls)
+
+
+def test_topk_output_matches_the_stock_processor(tiny_h3, kernel_calls):
+    """The fake kernel is dense, so top-k must change only what the kernel
+    is asked for, never the tiling around it."""
+    expected = tiny_h3(**_inputs()).sample
+    install_sparse(tiny_h3, 0.5, topk=0.15)
+    with sparse_call(_pipe(tiny_h3), "t"):
+        got = tiny_h3(**_inputs()).sample
+    torch.testing.assert_close(got, expected, rtol=1e-4, atol=1e-4)
+
+
+def test_set_sparse_tau_changes_and_clears_topk(tiny_h3, kernel_calls):
+    install_sparse(tiny_h3, 0.5)
+    set_sparse_tau(tiny_h3, 0.5, topk=0.2)
+    with sparse_call(_pipe(tiny_h3), "t"):
+        tiny_h3(**_inputs())
+    assert {c["topk_ratio"] for c in kernel_calls} == {0.2}
+    kernel_calls.clear()
+    set_sparse_tau(tiny_h3, 0.5)
+    with sparse_call(_pipe(tiny_h3), "t"):
+        tiny_h3(**_inputs())
+    assert all("topk_ratio" not in c for c in kernel_calls)
+
+
+@pytest.mark.parametrize("topk", [0, 1, 1.5, -0.1, "0.2", True, float("nan")])
+def test_install_sparse_refuses_a_bad_topk(tiny_h3, topk):
+    with pytest.raises(
+        ValueError, match=r"sparse_topk must be a number between 0 and 1, got "
+    ):
+        install_sparse(tiny_h3, 0.5, topk=topk)
+    assert not is_sparse_installed(tiny_h3)
+
+
+def test_signature_unchanged(tiny_h3):
+    before = inspect.signature(tiny_h3.forward)
+    install_sparse(tiny_h3, 0.5)
+    assert inspect.signature(tiny_h3.forward) == before
+    assert "token_tags" in before.parameters and "position_ids" in before.parameters
+
+
+def test_permutation_is_exact(tiny_h3, kernel_calls):
+    inputs = _inputs()
+    with torch.no_grad():
+        ref = tiny_h3(**inputs)
+    install_sparse(tiny_h3, 0.5)
+    with torch.no_grad(), sparse_call(_pipe(tiny_h3), "t") as report:
+        out = tiny_h3(**inputs)
+    assert report.ran_sparse and report.reason is None
+    assert len(kernel_calls) == CONFIG["num_layers"]
+    # 70 text -> 2 tiles, 20 refs -> 1, 70 audio -> 2: the prefix is 5 tiles
+    assert kernel_calls[0]["sink_blocks"] == [0, 5]
+    assert kernel_calls[0]["sink_q"] == [0, 5]
+    torch.testing.assert_close(out.sample, ref.sample, rtol=1e-4, atol=1e-4)
+    torch.testing.assert_close(out.audio_sample, ref.audio_sample, rtol=1e-4, atol=1e-4)
+
+
+def test_permutation_test_is_sensitive(tiny_h3, monkeypatch):
+    """The exactness check above means something only if attention moves the
+    output: a kernel that drops a row's attention must not pass it."""
+    inputs = _inputs()
+    with torch.no_grad():
+        ref = tiny_h3(**inputs).sample
+
+    def shifted(q, k, v, **kw):
+        out = dense_sol_attn_fake(q, k, v, **kw)
+        return out.roll(1, dims=1)
+
+    monkeypatch.setattr(sparse_attention, "_sol_attn", shifted)
+    monkeypatch.setattr(sparse_attention, "sparse_unavailable_reason", lambda *a: None)
+    install_sparse(tiny_h3, 0.5)
+    with torch.no_grad(), sparse_call(_pipe(tiny_h3), "t"):
+        out = tiny_h3(**inputs).sample
+    assert not torch.allclose(out, ref, rtol=1e-4, atol=1e-4)
+
+
+def test_fallback_on_non_cuda_device(tiny_h3, warnings):
+    inputs = _inputs()
+    with torch.no_grad():
+        ref_free = tiny_h3(**inputs).sample
+    install_sparse(tiny_h3, 0.5)
+    with torch.no_grad(), sparse_call(_pipe(tiny_h3), "step") as report:
+        out = tiny_h3(**inputs).sample
+        tiny_h3(**inputs)  # a second forward in the same call warns no more
+    assert not report.ran_sparse and "is not CUDA" in report.reason
+    assert len(warnings) == 1
+    message, data = warnings[0]
+    assert message == f"step: sparse attention ran dense - {report.reason}"
+    assert data == {"attention_backend": "sparse", "reason": report.reason}
+    torch.testing.assert_close(out, ref_free)
+
+
+def test_layout_error_at_decision_falls_back(tiny_h3, kernel_calls, warnings):
+    inputs = _inputs()
+    # A layout whose target video is not a full grid
+    inputs["position_ids"] = inputs["position_ids"].clone()
+    inputs["position_ids"][-1, 2] += 0.5
+    with torch.no_grad():
+        ref = tiny_h3(**inputs).sample
+    install_sparse(tiny_h3, 0.5)
+    with torch.no_grad(), sparse_call(_pipe(tiny_h3), "step") as report:
+        out = tiny_h3(**inputs).sample
+    assert not report.ran_sparse and "not a full grid" in report.reason
+    assert not kernel_calls and len(warnings) == 1
+    torch.testing.assert_close(out, ref)
+
+
+def test_failure_after_decision_raises(tiny_h3, kernel_calls, warnings):
+    install_sparse(tiny_h3, 0.5)
+    good = _inputs()
+    # The same layout one target row short: a new shape, so the map is
+    # rebuilt, and no longer a full grid
+    bad = dict(good)
+    for name in ("timestep_indices", "token_tags", "position_ids", "video_indices"):
+        bad[name] = good[name][:-1]
+    bad["hidden_states"] = good["hidden_states"][:, :-1]
+    with torch.no_grad(), sparse_call(_pipe(tiny_h3), "t"):
+        tiny_h3(**good)
+        with pytest.raises(SparseLayoutError):
+            tiny_h3(**bad)
+
+
+def test_each_call_decides_afresh(tiny_h3, kernel_calls, monkeypatch, warnings):
+    answers = iter(["device cpu is not CUDA", None])
+    monkeypatch.setattr(
+        sparse_attention, "sparse_unavailable_reason", lambda *a: next(answers)
+    )
+    install_sparse(tiny_h3, 0.5)
+    inputs = _inputs()
+    with torch.no_grad(), sparse_call(_pipe(tiny_h3), "t") as first:
+        tiny_h3(**inputs)
+        tiny_h3(**inputs)  # decided once: no second question
+    assert not first.ran_sparse and not kernel_calls
+    with torch.no_grad(), sparse_call(_pipe(tiny_h3), "t") as second:
+        tiny_h3(**inputs)
+    assert second.ran_sparse and len(kernel_calls) == CONFIG["num_layers"]
+    assert len(warnings) == 1
+
+
+def test_tile_map_rebuilt_when_layout_changes(tiny_h3, kernel_calls, monkeypatch):
+    built = []
+    real = sparse_attention.build_tile_map
+
+    def counting(*a, **kw):
+        built.append(1)
+        return real(*a, **kw)
+
+    monkeypatch.setattr(sparse_attention, "build_tile_map", counting)
+    small, large = _inputs(t=5, h=6, w=5), _inputs(t=3, h=8, w=9, ref_rows=0)
+    with torch.no_grad():
+        refs = [tiny_h3(**small).sample, tiny_h3(**large).sample]
+    install_sparse(tiny_h3, 0.5)
+    with torch.no_grad(), sparse_call(_pipe(tiny_h3), "t") as report:
+        outs = [
+            tiny_h3(**small).sample,
+            tiny_h3(**small).sample,
+            tiny_h3(**large).sample,
+        ]
+    assert report.ran_sparse
+    assert len(built) == 2  # the repeated layout reuses its map
+    assert {c["rows"] for c in kernel_calls} == {13 * 64, 10 * 64}
+    torch.testing.assert_close(outs[0], refs[0], rtol=1e-4, atol=1e-4)
+    torch.testing.assert_close(outs[1], refs[0], rtol=1e-4, atol=1e-4)
+    torch.testing.assert_close(outs[2], refs[1], rtol=1e-4, atol=1e-4)
+
+
+def test_tile_map_rebuilt_for_a_transposed_grid(tiny_h3, kernel_calls, monkeypatch):
+    """h=6, w=5 and h=5, w=6 share row count, tag sum and position sum; only
+    a rebuilt map gathers the second one correctly."""
+    built = []
+    real = sparse_attention.build_tile_map
+
+    def counting(*a, **kw):
+        tm = real(*a, **kw)
+        built.append(tm.video_grid)
+        return tm
+
+    monkeypatch.setattr(sparse_attention, "build_tile_map", counting)
+    first, second = _inputs(h=6, w=5), _inputs(h=5, w=6)
+    assert first["position_ids"].shape == second["position_ids"].shape
+    assert first["token_tags"].sum() == second["token_tags"].sum()
+    with torch.no_grad():
+        refs = [tiny_h3(**first).sample, tiny_h3(**second).sample]
+    install_sparse(tiny_h3, 0.5)
+    with torch.no_grad(), sparse_call(_pipe(tiny_h3), "t") as report:
+        outs = [tiny_h3(**first).sample, tiny_h3(**second).sample]
+    assert report.ran_sparse
+    assert built == [(5, 6, 5), (5, 5, 6)]
+    torch.testing.assert_close(outs[0], refs[0], rtol=1e-4, atol=1e-4)
+    torch.testing.assert_close(outs[1], refs[1], rtol=1e-4, atol=1e-4)
+
+
+def test_any_error_while_deciding_falls_back(
+    tiny_h3, kernel_calls, monkeypatch, warnings
+):
+    def boom(*a, **kw):
+        raise RuntimeError("boom")
+
+    monkeypatch.setattr(sparse_attention, "build_tile_map", boom)
+    inputs = _inputs()
+    with torch.no_grad():
+        ref = tiny_h3(**inputs).sample
+    install_sparse(tiny_h3, 0.5)
+    with torch.no_grad(), sparse_call(_pipe(tiny_h3), "t") as report:
+        out = tiny_h3(**inputs).sample
+    assert not report.ran_sparse and "RuntimeError: boom" in report.reason
+    assert not kernel_calls and len(warnings) == 1
+    torch.testing.assert_close(out, ref)
+
+
+def test_uninstall_restores_original_processors(tiny_h3):
+    originals = [b.attn.processor for b in tiny_h3.transformer_blocks]
+    install_sparse(tiny_h3, 0.5)
+    uninstall_sparse(tiny_h3)
+    assert [b.attn.processor for b in tiny_h3.transformer_blocks] == originals
+    assert not tiny_h3._forward_pre_hooks and not tiny_h3._forward_hooks
+    assert not is_sparse_installed(tiny_h3)
+    uninstall_sparse(tiny_h3)  # a no-op the second time
+    uninstall_sparse(torch.nn.Linear(2, 2))
+
+
+def test_backend_setting_reaches_the_original_processor(tiny_h3):
+    """diffusers' set_attention_backend writes `_attention_backend` onto each
+    processor; the original, which the dense path runs, must see it."""
+    install_sparse(tiny_h3, 0.5)
+    block = tiny_h3.transformer_blocks[0]
+    block.attn.processor._attention_backend = "native"
+    uninstall_sparse(tiny_h3)
+    assert block.attn.processor._attention_backend == "native"
+
+
+def test_active_backend_unchanged(tiny_h3):
+    from diffusers.models.attention_dispatch import _AttentionBackendRegistry
+
+    before = _AttentionBackendRegistry._active_backend
+    install_sparse(tiny_h3, 0.5)
+    uninstall_sparse(tiny_h3)
+    assert _AttentionBackendRegistry._active_backend == before
+
+
+def test_sparse_call_reads_a_components_mapping(tiny_h3, kernel_calls):
+    install_sparse(tiny_h3, 0.5)
+    pipeline = SimpleNamespace(components={"transformer": tiny_h3, "vae": None})
+    with torch.no_grad(), sparse_call(pipeline, "t") as report:
+        tiny_h3(**_inputs())
+    assert report.ran_sparse
+
+
+def test_sparse_call_with_nothing_installed(tiny_h3, warnings):
+    with sparse_call(_pipe(tiny_h3), "t") as report:
+        pass
+    assert not report.ran_sparse and report.reason is None and not warnings
+
+
+def test_unavailable_reason_off_cuda():
+    assert sparse_unavailable_reason(torch.device("cpu"), torch.bfloat16, 128) == (
+        "device cpu is not CUDA"
+    )
+    assert (
+        sparse_unavailable_reason("mps", torch.bfloat16, 128)
+        == "device mps is not CUDA"
+    )
+
+
+def test_unavailable_reason_on_cuda(monkeypatch):
+    import comfy_kitchen
+
+    cuda = torch.device("cuda", 0)
+    capability = [(8, 0)]
+    monkeypatch.setattr(
+        torch.cuda, "get_device_capability", lambda device=None: capability[0]
+    )
+    monkeypatch.setattr(
+        comfy_kitchen, "sol_attn_is_available", lambda device=None: True
+    )
+    assert sparse_unavailable_reason(cuda, torch.bfloat16, 128) is None
+    assert sparse_unavailable_reason(cuda, torch.float16, 128) is None
+    assert sparse_unavailable_reason(cuda, torch.float32, 128) == (
+        "dtype float32 is not bfloat16/float16"
+    )
+    assert (
+        sparse_unavailable_reason(cuda, torch.bfloat16, 64) == "head_dim 64 is not 128"
+    )
+
+    def broken(device=None):
+        raise RuntimeError("no sm_80 build")
+
+    monkeypatch.setattr(comfy_kitchen, "sol_attn_is_available", broken)
+    assert sparse_unavailable_reason(cuda, torch.bfloat16, 128) == (
+        "comfy-kitchen kernels unavailable: no sm_80 build"
+    )
+    capability[0] = (7, 5)
+    assert sparse_unavailable_reason(cuda, torch.bfloat16, 128) == (
+        "compute capability 7.5 is below 8.0"
+    )
+
+
+# --- a pipeline whose components property raises --------------------------
+
+
+class _RaisingComponents:
+    """DiffusionPipeline's `components` property raises ValueError when the
+    pipeline's attributes and its expected modules disagree."""
+
+    def __init__(self, transformer):
+        self.transformer = transformer
+
+    @property
+    def components(self):
+        raise ValueError("expected modules do not match")
+
+
+def test_sparse_call_survives_a_raising_components_property(tiny_h3, kernel_calls):
+    install_sparse(tiny_h3, 0.5)
+    pipeline = _RaisingComponents(tiny_h3)
+    with torch.no_grad(), sparse_call(pipeline, "t") as report:
+        tiny_h3(**_inputs())
+    # Found through the attribute: the call decided, and ran sparse
+    assert report.ran_sparse and len(kernel_calls) == CONFIG["num_layers"]
+
+
+def test_sparse_call_with_a_raising_components_property_and_nothing_installed(
+    warnings,
+):
+    with sparse_call(_RaisingComponents(torch.nn.Linear(2, 2)), "t") as report:
+        pass
+    assert not report.ran_sparse and report.reason is None and not warnings
+
+
+# --- sparse_tau validation (Ruling 13) -------------------------------------
+
+
+@pytest.mark.parametrize("tau", [-0.1, "0.5", None, True, False, float("nan")])
+def test_install_sparse_refuses_a_bad_tau(tiny_h3, tau):
+    with pytest.raises(ValueError, match=r"sparse_tau must be a number >= 0, got "):
+        install_sparse(tiny_h3, tau)
+    assert not is_sparse_installed(tiny_h3)
+
+
+@pytest.mark.parametrize("tau", [-1, "1.0", True])
+def test_set_sparse_tau_refuses_a_bad_tau(tiny_h3, tau):
+    install_sparse(tiny_h3, 0.5)
+    with pytest.raises(ValueError, match=r"sparse_tau must be a number >= 0, got "):
+        set_sparse_tau(tiny_h3, tau)
+    assert tiny_h3._dw_sparse_state.tau == 0.5
+
+
+def test_bad_tau_message_names_the_value(tiny_h3):
+    with pytest.raises(ValueError) as caught:
+        install_sparse(tiny_h3, -2)
+    assert str(caught.value) == "sparse_tau must be a number >= 0, got -2"
+
+
+@pytest.mark.parametrize("tau", [0, 0.0, 1, 2.5])
+def test_install_sparse_accepts_a_good_tau(tiny_h3, tau):
+    assert install_sparse(tiny_h3, tau)
+    set_sparse_tau(tiny_h3, tau)
+    assert tiny_h3._dw_sparse_state.tau == tau
+
+
+# --- a kernel that fails (Ruling 12) ---------------------------------------
+
+
+def test_first_kernel_failure_falls_back_dense(tiny_h3, monkeypatch, warnings):
+    inputs = _inputs()
+    with torch.no_grad():
+        ref = tiny_h3(**inputs).sample
+    calls = []
+
+    def failing(q, k, v, **kw):
+        calls.append(kw)
+        raise RuntimeError("no kernel image for sm_120")
+
+    monkeypatch.setattr(sparse_attention, "_sol_attn", failing)
+    monkeypatch.setattr(sparse_attention, "sparse_unavailable_reason", lambda *a: None)
+    install_sparse(tiny_h3, 0.5)
+    with torch.no_grad(), sparse_call(_pipe(tiny_h3), "step") as report:
+        out = tiny_h3(**inputs).sample
+        tiny_h3(**inputs)  # the rest of the call stays dense
+    reason = "sparse kernel failed: RuntimeError: no kernel image for sm_120"
+    assert not report.ran_sparse and report.reason == reason
+    # Tried once; every later block and forward ran the original processor
+    assert len(calls) == 1
+    assert len(warnings) == 1 and reason in warnings[0][0]
+    torch.testing.assert_close(out, ref)
+
+
+def test_kernel_failure_after_a_success_raises(tiny_h3, monkeypatch, warnings):
+    calls = []
+
+    def once(q, k, v, **kw):
+        calls.append(kw)
+        if len(calls) > 1:
+            raise RuntimeError("illegal memory access")
+        return dense_sol_attn_fake(q, k, v, **kw)
+
+    monkeypatch.setattr(sparse_attention, "_sol_attn", once)
+    monkeypatch.setattr(sparse_attention, "sparse_unavailable_reason", lambda *a: None)
+    install_sparse(tiny_h3, 0.5)
+    with pytest.raises(RuntimeError, match="illegal memory access"):
+        with torch.no_grad(), sparse_call(_pipe(tiny_h3), "t"):
+            tiny_h3(**_inputs())
+    assert len(calls) == 2 and not warnings
+
+
+def test_kernel_success_resets_each_call(tiny_h3, monkeypatch, warnings):
+    """A kernel that ran in one call has not run in the next: that call's first
+    invocation failing falls back, it does not raise."""
+    fail = [False]
+
+    def kernel(q, k, v, **kw):
+        if fail[0]:
+            raise RuntimeError("card lost")
+        return dense_sol_attn_fake(q, k, v, **kw)
+
+    monkeypatch.setattr(sparse_attention, "_sol_attn", kernel)
+    monkeypatch.setattr(sparse_attention, "sparse_unavailable_reason", lambda *a: None)
+    install_sparse(tiny_h3, 0.5)
+    inputs = _inputs()
+    with torch.no_grad(), sparse_call(_pipe(tiny_h3), "t") as first:
+        tiny_h3(**inputs)
+    assert first.ran_sparse
+    fail[0] = True
+    with torch.no_grad(), sparse_call(_pipe(tiny_h3), "t") as second:
+        tiny_h3(**inputs)
+    assert not second.ran_sparse
+    assert second.reason == "sparse kernel failed: RuntimeError: card lost"
diff --git a/tests/test_sparse_attention_tiles.py b/tests/test_sparse_attention_tiles.py
new file mode 100644
index 00000000..197c6847
--- /dev/null
+++ b/tests/test_sparse_attention_tiles.py
@@ -0,0 +1,63 @@
+"""The H3 sparse-attention tile map (#931): packed rows -> 4x4x4 video tiles."""
+
+import pytest
+import torch
+
+from dw.sparse_attention import SparseLayoutError, TileMap, build_tile_map
+from tests.sparse_layouts import _layout
+
+
+def test_t2va_grid_and_tiles():
+    tags, pos = _layout(text=356, ref_rows=0, audio=414, t=37, h=17, w=30)
+    tm = build_tile_map(pos, tags, "cpu")
+    assert isinstance(tm, TileMap)
+    assert tm.video_grid == (37, 17, 30)
+    assert tm.block_len.sum().item() == tm.rows == len(tags)
+    assert tm.num_prefix_tiles == 13  # 356 -> 6 tiles, 414 -> 7
+    assert len(tm.block_len) - tm.num_prefix_tiles == 10 * 5 * 8
+    assert torch.unique(tm.dst).numel() == tm.rows
+    assert (tm.block_len <= 64).all()
+
+
+def test_ref2va_reference_rows_in_prefix():
+    tags, pos = _layout(text=356, ref_rows=5506, audio=414, t=37, h=24, w=42)
+    tm = build_tile_map(pos, tags, "cpu")
+    assert tm.video_grid == (37, 24, 42)
+    ref = torch.arange(356, 356 + 5506)
+    assert (tm.dst[ref] < tm.num_prefix_tiles * 64).all()
+
+
+def test_prefix_tiles_are_segment_pure():
+    tags, pos = _layout(text=70, ref_rows=0, audio=70, t=4, h=4, w=4)
+    tm = build_tile_map(pos, tags, "cpu")
+    # 70 text -> 64 + 6, 70 audio -> 64 + 6: four prefix tiles, never one mixed
+    assert tm.block_len[: tm.num_prefix_tiles].tolist() == [64, 6, 64, 6]
+
+
+def test_rows_within_a_video_tile_are_spatially_local():
+    tags, pos = _layout(text=8, ref_rows=0, audio=8, t=8, h=8, w=8)
+    tm = build_tile_map(pos, tags, "cpu")
+    video = pos[-8 * 8 * 8 :]
+    ranked = torch.stack(
+        [torch.unique(video[:, a], return_inverse=True)[1] for a in range(3)], dim=1
+    )
+    tile_of = tm.dst[-8 * 8 * 8 :] // 64
+    assert tile_of.min().item() == tm.num_prefix_tiles
+    for tile in tile_of.unique().tolist():
+        rows = ranked[tile_of == tile]
+        # every full tile spans at most 4 distinct values per axis
+        assert rows.shape[0] == 64
+        for axis in range(3):
+            assert rows[:, axis].unique().numel() <= 4
+
+
+def test_not_a_full_grid_raises():
+    tags, pos = _layout(text=8, ref_rows=0, audio=8, t=4, h=4, w=4)
+    with pytest.raises(SparseLayoutError):
+        build_tile_map(pos[:-1], tags[:-1], "cpu")
+
+
+def test_no_target_video_raises():
+    tags = torch.ones(128, dtype=torch.long)
+    with pytest.raises(SparseLayoutError):
+        build_tile_map(torch.zeros(128, 3, dtype=torch.float64), tags, "cpu")
diff --git a/tests/test_sparse_attention_wiring.py b/tests/test_sparse_attention_wiring.py
new file mode 100644
index 00000000..4c0c376b
--- /dev/null
+++ b/tests/test_sparse_attention_wiring.py
@@ -0,0 +1,699 @@
+"""attention_backend 'sparse' wired into components, the call, the cache and
+the schema (#931).
+
+'sparse' is not a diffusers backend: it installs dw's H3 processor instead of
+reaching set_attention_backend or the per-call attention_backend() context,
+and its tau is a runtime setting the pipeline cache re-applies on a hit.
+"""
+
+import contextlib
+import copy
+from types import SimpleNamespace
+
+import pytest
+import torch
+
+from dw.pipeline_processors import components
+from dw import sparse_attention
+from dw.pipeline_processors import pipeline as pipeline_module
+from dw.pipeline_processors.pipeline import Pipeline, apply_runtime_settings
+from dw.schema import load_schema, validate_data
+from dw.sparse_attention import (
+    DEFAULT_TAU,
+    install_sparse,
+    is_sparse_installed,
+)
+from dw.step_cache import pipeline_cache_key, weights_identity
+from tests.sparse_layouts import CONFIG
+
+
+@pytest.fixture
+def tiny_h3():
+    from diffusers.models.transformers.transformer_minimax_h3 import (
+        MiniMaxH3Transformer3DModel,
+    )
+
+    torch.manual_seed(0)
+    return MiniMaxH3Transformer3DModel(**CONFIG).eval()
+
+
+@pytest.fixture
+def component_calls(monkeypatch):
+    """Record what configure_components does with a component's backend."""
+    calls = []
+
+    def install(component, tau, topk=None):
+        calls.append(("install", tau) if topk is None else ("install", tau, topk))
+        return type(component).__name__ == "MiniMaxH3Transformer3DModel"
+
+    monkeypatch.setattr(components, "install_sparse", install)
+    monkeypatch.setattr(
+        components, "uninstall_sparse", lambda component: calls.append(("uninstall",))
+    )
+    monkeypatch.setattr(
+        components,
+        "set_component_attention_backend",
+        lambda component, backend: calls.append(("set_backend", backend)),
+    )
+    monkeypatch.setattr(components, "emit_log", lambda *a, **kw: None)
+    return calls
+
+
+@pytest.fixture
+def component_warnings(monkeypatch):
+    seen = []
+    monkeypatch.setattr(
+        components, "emit_warning", lambda message, **data: seen.append(message)
+    )
+    return seen
+
+
+class MiniMaxH3Transformer3DModel:
+    """Only the class name matters to the recorded install stand-in."""
+
+
+def _configure(component, entry):
+    pipeline = SimpleNamespace(transformer=component)
+    components.configure_components(
+        pipeline, {"components": {"transformer": entry}}, "cpu"
+    )
+
+
+# --- component level -------------------------------------------------------
+
+
+def test_component_sparse_installs_and_never_reaches_diffusers(component_calls):
+    _configure(
+        MiniMaxH3Transformer3DModel(),
+        {"attention_backend": "sparse", "sparse_tau": 0.7},
+    )
+    assert component_calls == [("install", 0.7)]
+
+
+def test_component_sparse_topk_reaches_install(component_calls):
+    _configure(
+        MiniMaxH3Transformer3DModel(),
+        {"attention_backend": "sparse", "sparse_topk": 0.15},
+    )
+    assert component_calls == [("install", DEFAULT_TAU, 0.15)]
+
+
+def test_component_sparse_default_tau(component_calls):
+    _configure(MiniMaxH3Transformer3DModel(), {"attention_backend": "sparse"})
+    assert component_calls == [("install", DEFAULT_TAU)]
+    assert DEFAULT_TAU == 0.5
+
+
+def test_component_sparse_on_non_h3_warns_and_runs_dense(
+    component_calls, component_warnings
+):
+    _configure(SimpleNamespace(), {"attention_backend": "sparse"})
+    assert component_warnings == [
+        "transformer: attention_backend 'sparse' needs a MiniMax-H3 transformer; "
+        "runs dense"
+    ]
+    assert ("set_backend", "sparse") not in component_calls
+
+
+def test_non_sparse_backend_uninstalls_sparse(component_calls):
+    _configure(MiniMaxH3Transformer3DModel(), {"attention_backend": "sage_hub"})
+    assert component_calls == [("uninstall",), ("set_backend", "sage_hub")]
+
+
+def test_no_backend_uninstalls_sparse(component_calls):
+    _configure(MiniMaxH3Transformer3DModel(), {"device": None})
+    assert component_calls == [("uninstall",)]
+
+
+def test_a_real_reconfigure_removes_the_processors(tiny_h3, monkeypatch):
+    monkeypatch.setattr(components, "emit_log", lambda *a, **kw: None)
+    _configure(tiny_h3, {"attention_backend": "sparse", "sparse_tau": 0.7})
+    assert is_sparse_installed(tiny_h3)
+    assert tiny_h3._dw_sparse_state.tau == 0.7
+    _configure(tiny_h3, {})
+    assert not is_sparse_installed(tiny_h3)
+
+
+@pytest.mark.parametrize("tau", [-0.5, "0.5", True])
+def test_component_bad_tau_raises(tiny_h3, monkeypatch, tau):
+    """A 'variable:' reference can resolve to anything: a bad tau is the
+    workflow's error, never a reason to run dense (Ruling 13)."""
+    monkeypatch.setattr(components, "emit_log", lambda *a, **kw: None)
+    with pytest.raises(ValueError, match="sparse_tau must be a number >= 0"):
+        _configure(tiny_h3, {"attention_backend": "sparse", "sparse_tau": tau})
+    assert not is_sparse_installed(tiny_h3)
+
+
+# --- pipeline level --------------------------------------------------------
+
+
+class FakePipeline:
+    """A pipeline whose call records which components ran with sparse installed."""
+
+    def __init__(self, **parts):
+        self.__dict__.update(parts)
+        self.seen = None
+
+    def __call__(self, **arguments):
+        self.seen = {
+            name: is_sparse_installed(value)
+            for name, value in vars(self).items()
+            if name != "seen"
+        }
+        return "output"
+
+
+@pytest.fixture
+def no_diffusers_backend(monkeypatch):
+    """Fail if the call enters diffusers' per-call attention_backend()."""
+
+    def refuse(backend):
+        raise AssertionError(f"attention_backend({backend!r}) entered")
+
+    monkeypatch.setattr(pipeline_module, "attention_backend", refuse)
+
+
+@pytest.fixture
+def call_warnings(monkeypatch):
+    seen = []
+    monkeypatch.setattr(
+        sparse_attention, "emit_warning", lambda message, **data: seen.append(message)
+    )
+    return seen
+
+
+def _wrapper(fake, configuration):
+    definition = {
+        "configuration": configuration,
+        "from_pretrained_arguments": {"model_name": "h3-test"},
+        "arguments": {},
+    }
+    return Pipeline(definition, 1, "cpu", pipeline=fake)
+
+
+def test_pipeline_level_sparse_installs_on_h3_components_for_the_call(
+    tiny_h3, no_diffusers_backend, call_warnings
+):
+    other = torch.nn.Linear(2, 2)
+    fake = FakePipeline(transformer=tiny_h3, vae=other)
+    wrapper = _wrapper(fake, {"attention_backend": "sparse", "sparse_tau": 0.8})
+
+    assert wrapper._execute_pipeline({}) == "output"
+
+    assert fake.seen["transformer"] is True and fake.seen["vae"] is False
+    assert not is_sparse_installed(tiny_h3)
+    assert not call_warnings
+
+
+def test_pipeline_level_sparse_uses_its_tau(tiny_h3, no_diffusers_backend, monkeypatch):
+    taus = []
+    real = sparse_attention.install_sparse
+
+    def recording(component, tau, topk=None):
+        installed = real(component, tau, topk)
+        if installed:
+            taus.append(tau)
+        return installed
+
+    monkeypatch.setattr(sparse_attention, "install_sparse", recording)
+    _wrapper(
+        FakePipeline(transformer=tiny_h3), {"attention_backend": "sparse"}
+    )._execute_pipeline({})
+    _wrapper(
+        FakePipeline(transformer=tiny_h3),
+        {"attention_backend": "sparse", "sparse_tau": 1.0},
+    )._execute_pipeline({})
+    assert taus == [DEFAULT_TAU, 1.0]
+
+
+def test_pipeline_level_sparse_topk_reaches_the_install(
+    tiny_h3, no_diffusers_backend, monkeypatch
+):
+    seen = []
+    real = sparse_attention.install_sparse
+
+    def recording(component, tau, topk=None):
+        installed = real(component, tau, topk)
+        if installed:
+            seen.append((tau, topk))
+        return installed
+
+    monkeypatch.setattr(sparse_attention, "install_sparse", recording)
+    logged = []
+    monkeypatch.setattr(
+        sparse_attention, "emit_log", lambda message, **data: logged.append(message)
+    )
+    _wrapper(
+        FakePipeline(transformer=tiny_h3),
+        {"attention_backend": "sparse", "sparse_topk": 0.15},
+    )._execute_pipeline({})
+    assert seen == [(DEFAULT_TAU, 0.15)]
+    assert "Using attention backend: sparse (topk 0.15) on transformer" in logged
+
+
+def test_pipeline_level_sparse_reads_a_components_mapping(
+    tiny_h3, no_diffusers_backend
+):
+    seen = {}
+
+    class Modular:
+        components = {"transformer": tiny_h3}
+
+        def __call__(self, **arguments):
+            seen["installed"] = is_sparse_installed(tiny_h3)
+            return "output"
+
+    _wrapper(Modular(), {"attention_backend": "sparse"})._execute_pipeline({})
+    assert seen == {"installed": True}
+    assert not is_sparse_installed(tiny_h3)
+
+
+def test_pipeline_level_sparse_on_non_h3_runs_dense(
+    no_diffusers_backend, call_warnings
+):
+    fake = FakePipeline(transformer=torch.nn.Linear(2, 2))
+    wrapper = _wrapper(fake, {"attention_backend": "sparse"})
+
+    assert wrapper._execute_pipeline({}) == "output"
+    assert call_warnings == [
+        "h3-test: attention_backend 'sparse' found no MiniMax-H3 transformer; "
+        "runs dense"
+    ]
+
+
+def test_component_pin_beats_pipeline_level_sparse(
+    tiny_h3, no_diffusers_backend, call_warnings
+):
+    """A component pinned to another backend keeps it, the way a component
+    pin beats a pipeline-level backend everywhere else: the pipeline-level
+    'sparse' skips it and says so, instead of overriding it silently."""
+    fake = FakePipeline(transformer=tiny_h3)
+    wrapper = _wrapper(
+        fake,
+        {
+            "attention_backend": "sparse",
+            "components": {"transformer": {"attention_backend": "sage_hub"}},
+        },
+    )
+
+    assert wrapper._execute_pipeline({}) == "output"
+
+    assert fake.seen["transformer"] is False
+    assert call_warnings == [
+        "h3-test: attention_backend 'sparse' at pipeline level skips "
+        "'transformer', which pins 'sage_hub'"
+    ]
+
+
+def test_pin_on_a_non_h3_component_is_no_conflict(
+    tiny_h3, no_diffusers_backend, call_warnings
+):
+    """Sparse only ever targets the H3 transformer, so a pin on the text
+    encoder skips nothing: no warning, and the transformer runs sparse."""
+    fake = FakePipeline(transformer=tiny_h3, text_encoder=torch.nn.Linear(2, 2))
+    wrapper = _wrapper(
+        fake,
+        {
+            "attention_backend": "sparse",
+            "components": {"text_encoder": {"attention_backend": "sage_hub"}},
+        },
+    )
+
+    assert wrapper._execute_pipeline({}) == "output"
+
+    assert fake.seen["transformer"] is True
+    assert not call_warnings
+
+
+def test_pin_on_a_non_h3_pipeline_still_says_it_runs_dense(
+    no_diffusers_backend, call_warnings
+):
+    fake = FakePipeline(transformer=torch.nn.Linear(2, 2))
+    wrapper = _wrapper(
+        fake,
+        {
+            "attention_backend": "sparse",
+            "components": {"transformer": {"attention_backend": "sage_hub"}},
+        },
+    )
+
+    assert wrapper._execute_pipeline({}) == "output"
+    assert call_warnings == [
+        "h3-test: attention_backend 'sparse' found no MiniMax-H3 transformer; "
+        "runs dense"
+    ]
+
+
+def test_component_pinned_to_sparse_is_not_a_conflict(
+    tiny_h3, no_diffusers_backend, call_warnings
+):
+    fake = FakePipeline(transformer=tiny_h3)
+    wrapper = _wrapper(
+        fake,
+        {
+            "attention_backend": "sparse",
+            "components": {"transformer": {"attention_backend": "sparse"}},
+        },
+    )
+    wrapper._execute_pipeline({})
+    assert fake.seen["transformer"] is True
+    assert not call_warnings
+
+
+def test_pipeline_level_sparse_logs_what_it_installed(
+    tiny_h3, no_diffusers_backend, monkeypatch
+):
+    """Every other backend logs 'Using attention backend'; a run's log must
+    say sparse ran, and where, or a job reads as whatever a component pinned."""
+    logged = []
+    monkeypatch.setattr(
+        sparse_attention,
+        "emit_log",
+        lambda message, **data: logged.append((message, data)),
+    )
+    _wrapper(
+        FakePipeline(transformer=tiny_h3, vae=torch.nn.Linear(2, 2)),
+        {"attention_backend": "sparse", "sparse_tau": 0.8},
+    )._execute_pipeline({})
+
+    assert (
+        "Using attention backend: sparse (tau 0.8) on transformer",
+        {"attention_backend": "sparse", "components": ["transformer"]},
+    ) in logged
+
+
+@pytest.mark.parametrize("tau", [-1, "fast", False])
+def test_pipeline_level_bad_tau_raises(tiny_h3, no_diffusers_backend, tau):
+    fake = FakePipeline(transformer=tiny_h3)
+    wrapper = _wrapper(fake, {"attention_backend": "sparse", "sparse_tau": tau})
+    with pytest.raises(ValueError, match="sparse_tau must be a number >= 0"):
+        wrapper._execute_pipeline({})
+    assert fake.seen is None  # the pipeline was never called
+    assert not is_sparse_installed(tiny_h3)
+
+
+def test_pipeline_level_install_comes_off_when_the_call_raises(
+    tiny_h3, no_diffusers_backend
+):
+    seen = {}
+
+    class Failing(FakePipeline):
+        def __call__(self, **arguments):
+            seen["installed"] = is_sparse_installed(tiny_h3)
+            raise RuntimeError("out of memory")
+
+    wrapper = _wrapper(Failing(transformer=tiny_h3), {"attention_backend": "sparse"})
+    with pytest.raises(RuntimeError, match="out of memory"):
+        wrapper._execute_pipeline({})
+    assert seen == {"installed": True}
+    assert not is_sparse_installed(tiny_h3)
+
+
+def test_component_install_survives_a_pipeline_level_call(
+    tiny_h3, no_diffusers_backend, call_warnings
+):
+    install_sparse(tiny_h3, 0.7)
+    fake = FakePipeline(transformer=tiny_h3)
+    _wrapper(
+        fake, {"attention_backend": "sparse", "sparse_tau": 1.0}
+    )._execute_pipeline({})
+
+    assert fake.seen["transformer"] is True
+    assert is_sparse_installed(tiny_h3)
+    # Not this call's install, so not this call's tau either
+    assert tiny_h3._dw_sparse_state.tau == 0.7
+    assert not call_warnings
+
+
+def test_other_backends_still_reach_diffusers(monkeypatch):
+    entered = []
+
+    @contextlib.contextmanager
+    def recording(backend):
+        entered.append(backend)
+        yield
+
+    monkeypatch.setattr(pipeline_module, "attention_backend", recording)
+    _wrapper(FakePipeline(), {"attention_backend": "sage_hub"})._execute_pipeline({})
+    assert entered == ["sage_hub"]
+
+
+def test_every_call_enters_sparse_call(monkeypatch):
+    labels = []
+
+    @contextlib.contextmanager
+    def recording(pipeline, label):
+        labels.append(label)
+        yield SimpleNamespace(ran_sparse=False, reason=None)
+
+    monkeypatch.setattr(pipeline_module, "sparse_call", recording)
+    wrapper = _wrapper(FakePipeline(), {})
+    wrapper._execute_pipeline({})
+    wrapper.segment_label = "segment 2"
+    wrapper._execute_pipeline({})
+    assert labels == ["h3-test", "segment 2"]
+
+
+# --- the pipeline cache ----------------------------------------------------
+
+
+def test_sparse_tau_is_runtime_not_identity():
+    a = {
+        "configuration": {
+            "components": {
+                "transformer": {"attention_backend": "sparse", "sparse_tau": 0.5}
+            }
+        }
+    }
+    b = copy.deepcopy(a)
+    b["configuration"]["components"]["transformer"]["sparse_tau"] = 1.0
+    assert pipeline_cache_key(a) == pipeline_cache_key(b)
+
+    c = copy.deepcopy(a)
+    del c["configuration"]["components"]["transformer"]["sparse_tau"]
+    assert pipeline_cache_key(a) == pipeline_cache_key(c)
+
+    d = copy.deepcopy(a)
+    d["configuration"]["components"]["transformer"]["attention_backend"] = "sage_hub"
+    assert pipeline_cache_key(a) != pipeline_cache_key(d)
+
+
+def test_pipeline_level_sparse_tau_is_runtime_not_identity():
+    a = {"configuration": {"attention_backend": "sparse", "sparse_tau": 0.5}}
+    b = copy.deepcopy(a)
+    b["configuration"]["sparse_tau"] = 1.0
+    assert pipeline_cache_key(a) == pipeline_cache_key(b)
+
+
+def test_sparse_topk_is_runtime_not_identity():
+    a = {
+        "configuration": {
+            "sparse_topk": 0.15,
+            "components": {
+                "transformer": {"attention_backend": "sparse", "sparse_topk": 0.15}
+            },
+        }
+    }
+    b = copy.deepcopy(a)
+    b["configuration"]["sparse_topk"] = 0.3
+    b["configuration"]["components"]["transformer"]["sparse_topk"] = 0.3
+    assert pipeline_cache_key(a) == pipeline_cache_key(b)
+    c = copy.deepcopy(a)
+    del c["configuration"]["sparse_topk"]
+    del c["configuration"]["components"]["transformer"]["sparse_topk"]
+    assert pipeline_cache_key(a) == pipeline_cache_key(c)
+
+
+def test_cache_hit_reapplies_topk(tiny_h3):
+    install_sparse(tiny_h3, 0.5)
+    model = SimpleNamespace(transformer=tiny_h3)
+    entry = {"attention_backend": "sparse", "sparse_topk": 0.15}
+    definition = {"configuration": {"components": {"transformer": entry}}}
+    apply_runtime_settings(definition, model)
+    assert tiny_h3._dw_sparse_state.topk == 0.15
+
+    del entry["sparse_topk"]
+    apply_runtime_settings(definition, model)
+    assert tiny_h3._dw_sparse_state.topk is None
+
+
+def test_weights_identity_leaves_the_definition_alone():
+    definition = {
+        "configuration": {
+            "sparse_tau": 0.5,
+            "components": {"transformer": {"sparse_tau": 0.5}},
+        }
+    }
+    before = copy.deepcopy(definition)
+    weights_identity(definition)
+    assert definition == before
+
+
+def test_cache_hit_reapplies_tau(tiny_h3):
+    install_sparse(tiny_h3, 0.5)
+    model = SimpleNamespace(transformer=tiny_h3, vae=None)
+    definition = {
+        "configuration": {
+            "components": {
+                "transformer": {"attention_backend": "sparse", "sparse_tau": 1.0}
+            }
+        }
+    }
+    apply_runtime_settings(definition, model)
+    assert tiny_h3._dw_sparse_state.tau == 1.0
+
+    del definition["configuration"]["components"]["transformer"]["sparse_tau"]
+    apply_runtime_settings(definition, model)
+    assert tiny_h3._dw_sparse_state.tau == DEFAULT_TAU
+
+
+def test_cache_hit_bad_tau_raises(tiny_h3):
+    install_sparse(tiny_h3, 0.5)
+    model = SimpleNamespace(transformer=tiny_h3)
+    definition = {
+        "configuration": {
+            "components": {
+                "transformer": {"attention_backend": "sparse", "sparse_tau": -1}
+            }
+        }
+    }
+    with pytest.raises(ValueError, match="sparse_tau must be a number >= 0"):
+        apply_runtime_settings(definition, model)
+    assert tiny_h3._dw_sparse_state.tau == 0.5
+
+
+def test_cache_hit_skips_a_component_without_sparse(tiny_h3):
+    model = SimpleNamespace(transformer=tiny_h3)
+    definition = {
+        "configuration": {
+            "components": {
+                "transformer": {"attention_backend": "sparse", "sparse_tau": 1.0}
+            }
+        }
+    }
+    apply_runtime_settings(definition, model)
+    assert not is_sparse_installed(tiny_h3)
+
+
+# --- the schema ------------------------------------------------------------
+
+
+def test_schema_accepts_sparse_tau():
+    workflow = {
+        "id": "sparse_test",
+        "steps": [
+            {
+                "name": "main",
+                "pipeline": {
+                    "configuration": {
+                        "component_type": "MiniMaxH3ModularPipeline",
+                        "attention_backend": "sparse",
+                        "sparse_tau": 0.5,
+                        "components": {
+                            "transformer": {
+                                "attention_backend": "sparse",
+                                "sparse_tau": 1.0,
+                            }
+                        },
+                    },
+                    "from_pretrained_arguments": {"model_name": "test"},
+                    "arguments": {"prompt": "test"},
+                },
+            }
+        ],
+    }
+    schema = load_schema("workflow")
+    status, message = validate_data(workflow, schema)
+    assert status is True, message
+
+    workflow["steps"][0]["pipeline"]["configuration"]["sparse_tau"] = -1
+    status, _ = validate_data(workflow, schema)
+    assert status is False
+
+
+@pytest.mark.parametrize(
+    "value, ok",
+    [
+        (0.15, True),
+        ("variable:sparse_topk", True),
+        (0, False),
+        (1, False),
+        ("0.2", False),
+    ],
+)
+def test_schema_sparse_topk(value, ok):
+    workflow = {
+        "id": "sparse_test",
+        "steps": [
+            {
+                "name": "main",
+                "pipeline": {
+                    "configuration": {
+                        "component_type": "MiniMaxH3ModularPipeline",
+                        "attention_backend": "sparse",
+                        "sparse_topk": value,
+                        "components": {
+                            "transformer": {
+                                "attention_backend": "sparse",
+                                "sparse_topk": value,
+                            }
+                        },
+                    },
+                    "from_pretrained_arguments": {"model_name": "test"},
+                    "arguments": {"prompt": "test"},
+                },
+            }
+        ],
+    }
+    status, message = validate_data(workflow, load_schema("workflow"))
+    assert status is ok, message
+
+
+def test_schema_describes_sparse():
+    schema = load_schema("workflow")
+    configuration = schema["$defs"]["pipeline_configuration"]["properties"]
+    entry = configuration["components"]["additionalProperties"]["properties"]
+    for block in (configuration, entry):
+        assert "'sparse'" in block["attention_backend"]["description"]
+        # A string is only a 'variable:' reference: every H3 template wires one.
+        assert block["sparse_tau"]["type"] == ["number", "string"]
+        assert block["sparse_tau"]["pattern"] == "^variable:"
+        assert "0.5" in block["sparse_tau"]["description"]
+        assert "#931" in block["sparse_tau"]["description"]
+
+
+@pytest.mark.parametrize(
+    "entry, expected",
+    [
+        (
+            {"attention_backend": "sparse"},
+            "Setting transformer attention backend: sparse (tau 0.5)",
+        ),
+        (
+            {"attention_backend": "sparse", "sparse_tau": 1.0},
+            "Setting transformer attention backend: sparse (tau 1.0)",
+        ),
+        (
+            {"attention_backend": "sparse", "sparse_topk": 0.15},
+            "Setting transformer attention backend: sparse (topk 0.15)",
+        ),
+        (
+            {"attention_backend": "sage_hub"},
+            "Setting transformer attention backend: sage_hub",
+        ),
+    ],
+)
+def test_component_log_names_the_sparse_routing(monkeypatch, entry, expected):
+    """A job's log is how a run is read back (#932): sparse at tau and at top-k
+    differ in speed and output, so the line says which ran."""
+    logged = []
+    monkeypatch.setattr(
+        components, "emit_log", lambda message, **data: logged.append(message)
+    )
+    monkeypatch.setattr(components, "install_sparse", lambda *a, **kw: True)
+    monkeypatch.setattr(components, "uninstall_sparse", lambda component: None)
+    monkeypatch.setattr(
+        components, "set_component_attention_backend", lambda component, backend: None
+    )
+    _configure(MiniMaxH3Transformer3DModel(), entry)
+    assert logged == [expected]
diff --git a/tests/test_step_cache.py b/tests/test_step_cache.py
index e0ef2220..c2c1620d 100644
--- a/tests/test_step_cache.py
+++ b/tests/test_step_cache.py
@@ -618,6 +618,10 @@ def test_normalized_downstream_false_when_nothing_references_it():
 # moved again the same day when an alpha's or a shift's presence (True,
 # never its value) went back in: a hit cannot restore a checkpoint default,
 # so dropping one has to reload.
+#
+# The H3 steps of the nineteen minimax templates that pin an attention backend
+# moved when it defaulted to sparse instead of null (#931): the backend is part of
+# the pipeline's identity, sparse_tau is not.
 TEMPLATE_PIPELINE_KEYS = {
     "assemble-and-score.json": {},
     "attention-processor.json": {
@@ -661,6 +665,21 @@ def test_normalized_downstream_false_when_nothing_references_it():
         "generate": "bfe2e09d70b6bf6e7799266cf735abd779e5a9e3c283b8287d962eab17d95425"
     },
     "expand-prompt.json": {},
+    "flux3/image-edit.json": {
+        "edit": "58be5755e37a15b2780cc4fa3eead66e91e2eeec21e15f15624f60a9a072f235"
+    },
+    "flux3/layout-boxes.json": {
+        "layout_to_image": "58be5755e37a15b2780cc4fa3eead66e91e2eeec21e15f15624f60a9a072f235"
+    },
+    "flux3/multi-reference.json": {
+        "edit": "58be5755e37a15b2780cc4fa3eead66e91e2eeec21e15f15624f60a9a072f235"
+    },
+    "flux3/text-to-image.json": {
+        "text_to_image": "58be5755e37a15b2780cc4fa3eead66e91e2eeec21e15f15624f60a9a072f235"
+    },
+    "flux3/upsample-then-generate.json": {
+        "text_to_image": "58be5755e37a15b2780cc4fa3eead66e91e2eeec21e15f15624f60a9a072f235"
+    },
     "generate-speech.json": {},
     "image-edit.json": {
         "edit": "241e4cc77f00d837873d01e3ea9ec7105513af8362908d8229c740cbca997737"
@@ -768,84 +787,84 @@ def test_normalized_downstream_false_when_nothing_references_it():
         "upscaled": "94618b4210efdaaf17afda812fbcfd9566bdaba1220a5b2518b178a154a9677c"
     },
     "minimax/chain-matched-and-aligned.json": {
-        "audio_aligned_chained_reference_to_video_audio": "95c8ba90efeba9603384619f1db3f275251f078370add6b2a3e7dab8481aacc6"
+        "audio_aligned_chained_reference_to_video_audio": "ba9915580e6a8017d8c68efbddea776985d107222546f84cca18e319298243bf"
     },
     "minimax/chain-matched-to-audio.json": {
-        "chained_reference_to_video_audio": "95c8ba90efeba9603384619f1db3f275251f078370add6b2a3e7dab8481aacc6"
+        "chained_reference_to_video_audio": "ba9915580e6a8017d8c68efbddea776985d107222546f84cca18e319298243bf"
     },
     "minimax/chain-video-continuity.json": {
-        "chained_reference_to_video_audio": "95c8ba90efeba9603384619f1db3f275251f078370add6b2a3e7dab8481aacc6"
+        "chained_reference_to_video_audio": "ba9915580e6a8017d8c68efbddea776985d107222546f84cca18e319298243bf"
     },
     "minimax/chained-segments.json": {
-        "chained_keyframe_to_video_audio": "5fb73e7ccf6a8526a42eb04c4ac2fe777ed528e3e3305c787d4d48abacb158c8"
+        "chained_keyframe_to_video_audio": "0d1cd2532b5c19d97ba165ddb4c715c9ead5e05c2ab6ba4db9bb182e012ec4c0"
     },
     "minimax/composable-references.json": {
-        "video_reference_to_video_audio": "95c8ba90efeba9603384619f1db3f275251f078370add6b2a3e7dab8481aacc6"
+        "video_reference_to_video_audio": "ba9915580e6a8017d8c68efbddea776985d107222546f84cca18e319298243bf"
     },
     "minimax/dialogue-short.json": {
         "draw_character_a": "a3861857f0d412d15cd569c065aac00fcf7c0af9c2e68a7944877c1eb0f796bf",
         "draw_character_b": "a3861857f0d412d15cd569c065aac00fcf7c0af9c2e68a7944877c1eb0f796bf",
-        "shot@button": "95c8ba90efeba9603384619f1db3f275251f078370add6b2a3e7dab8481aacc6",
-        "shot@cold_open": "95c8ba90efeba9603384619f1db3f275251f078370add6b2a3e7dab8481aacc6",
-        "shot@deflect": "95c8ba90efeba9603384619f1db3f275251f078370add6b2a3e7dab8481aacc6",
-        "shot@react": "95c8ba90efeba9603384619f1db3f275251f078370add6b2a3e7dab8481aacc6",
-        "shot@tag": "95c8ba90efeba9603384619f1db3f275251f078370add6b2a3e7dab8481aacc6",
+        "shot@cold_open": "ba9915580e6a8017d8c68efbddea776985d107222546f84cca18e319298243bf",
+        "shot@deflect": "ba9915580e6a8017d8c68efbddea776985d107222546f84cca18e319298243bf",
+        "shot@react": "ba9915580e6a8017d8c68efbddea776985d107222546f84cca18e319298243bf",
+        "shot@button": "ba9915580e6a8017d8c68efbddea776985d107222546f84cca18e319298243bf",
+        "shot@tag": "ba9915580e6a8017d8c68efbddea776985d107222546f84cca18e319298243bf",
     },
     "minimax/enhance-prompt-with-image.json": {
-        "keyframe_to_video_audio": "5fb73e7ccf6a8526a42eb04c4ac2fe777ed528e3e3305c787d4d48abacb158c8"
+        "keyframe_to_video_audio": "0d1cd2532b5c19d97ba165ddb4c715c9ead5e05c2ab6ba4db9bb182e012ec4c0"
     },
     "minimax/enhance-prompt.json": {
-        "text_to_video_audio": "68977225a70231ba3dd93248624501e4d8335c39eed9d4b2f0c970037af89bac"
+        "text_to_video_audio": "2a7fdf989a40500620fb03212502bbda8f52827f5fcd872b8fda182fab2fac77"
     },
     "minimax/first-and-last-frame.json": {
-        "first_and_last_frame_to_video_audio": "5fb73e7ccf6a8526a42eb04c4ac2fe777ed528e3e3305c787d4d48abacb158c8"
+        "first_and_last_frame_to_video_audio": "0d1cd2532b5c19d97ba165ddb4c715c9ead5e05c2ab6ba4db9bb182e012ec4c0"
     },
     "minimax/generated-subject-reference.json": {
         "draw_subject": "a3861857f0d412d15cd569c065aac00fcf7c0af9c2e68a7944877c1eb0f796bf",
-        "reference_to_video_audio": "95c8ba90efeba9603384619f1db3f275251f078370add6b2a3e7dab8481aacc6",
+        "reference_to_video_audio": "ba9915580e6a8017d8c68efbddea776985d107222546f84cca18e319298243bf",
     },
     "minimax/image-to-video.json": {
-        "keyframe_to_video_audio": "5fb73e7ccf6a8526a42eb04c4ac2fe777ed528e3e3305c787d4d48abacb158c8"
+        "keyframe_to_video_audio": "0d1cd2532b5c19d97ba165ddb4c715c9ead5e05c2ab6ba4db9bb182e012ec4c0"
     },
     "minimax/last-frame-only.json": {
-        "last_frame_to_video_audio": "5fb73e7ccf6a8526a42eb04c4ac2fe777ed528e3e3305c787d4d48abacb158c8"
+        "last_frame_to_video_audio": "0d1cd2532b5c19d97ba165ddb4c715c9ead5e05c2ab6ba4db9bb182e012ec4c0"
     },
     "minimax/music-video-cuts.json": {},
     "minimax/music-video.json": {
         "draw_singer": "a3861857f0d412d15cd569c065aac00fcf7c0af9c2e68a7944877c1eb0f796bf",
-        "shot@closeup": "95c8ba90efeba9603384619f1db3f275251f078370add6b2a3e7dab8481aacc6",
-        "shot@finale": "95c8ba90efeba9603384619f1db3f275251f078370add6b2a3e7dab8481aacc6",
-        "shot@room": "95c8ba90efeba9603384619f1db3f275251f078370add6b2a3e7dab8481aacc6",
-        "shot@wide_open": "95c8ba90efeba9603384619f1db3f275251f078370add6b2a3e7dab8481aacc6",
         "write_song": "1abd10e3c899fb5bbc490baa64467ed46d5005f78fa8f94bc777f3ddcaf81fb5",
+        "shot@wide_open": "ba9915580e6a8017d8c68efbddea776985d107222546f84cca18e319298243bf",
+        "shot@closeup": "ba9915580e6a8017d8c68efbddea776985d107222546f84cca18e319298243bf",
+        "shot@room": "ba9915580e6a8017d8c68efbddea776985d107222546f84cca18e319298243bf",
+        "shot@finale": "ba9915580e6a8017d8c68efbddea776985d107222546f84cca18e319298243bf",
     },
     "minimax/music.json": {
         "generate_music": "1abd10e3c899fb5bbc490baa64467ed46d5005f78fa8f94bc777f3ddcaf81fb5"
     },
     "minimax/reference-to-video.json": {
-        "reference_to_video_audio": "95c8ba90efeba9603384619f1db3f275251f078370add6b2a3e7dab8481aacc6"
+        "reference_to_video_audio": "ba9915580e6a8017d8c68efbddea776985d107222546f84cca18e319298243bf"
     },
     "minimax/shots-batch.json": {
-        "shot@shot_1": "68977225a70231ba3dd93248624501e4d8335c39eed9d4b2f0c970037af89bac",
-        "shot@shot_2": "68977225a70231ba3dd93248624501e4d8335c39eed9d4b2f0c970037af89bac",
-        "shot@shot_3": "68977225a70231ba3dd93248624501e4d8335c39eed9d4b2f0c970037af89bac",
-        "shot@shot_4": "68977225a70231ba3dd93248624501e4d8335c39eed9d4b2f0c970037af89bac",
-        "shot@shot_5": "68977225a70231ba3dd93248624501e4d8335c39eed9d4b2f0c970037af89bac",
+        "shot@shot_1": "2a7fdf989a40500620fb03212502bbda8f52827f5fcd872b8fda182fab2fac77",
+        "shot@shot_2": "2a7fdf989a40500620fb03212502bbda8f52827f5fcd872b8fda182fab2fac77",
+        "shot@shot_3": "2a7fdf989a40500620fb03212502bbda8f52827f5fcd872b8fda182fab2fac77",
+        "shot@shot_4": "2a7fdf989a40500620fb03212502bbda8f52827f5fcd872b8fda182fab2fac77",
+        "shot@shot_5": "2a7fdf989a40500620fb03212502bbda8f52827f5fcd872b8fda182fab2fac77",
     },
     "minimax/storyboard.json": {
         "board_1_launch": "a3861857f0d412d15cd569c065aac00fcf7c0af9c2e68a7944877c1eb0f796bf",
         "board_2_gutter": "a3861857f0d412d15cd569c065aac00fcf7c0af9c2e68a7944877c1eb0f796bf",
         "board_3_shore": "a3861857f0d412d15cd569c065aac00fcf7c0af9c2e68a7944877c1eb0f796bf",
-        "voyage": "0f30a4f21253ffdec029b3e2523c077f68629579bb3ae57cc69c09b638665987",
+        "voyage": "9b0899c7c69c86106cdb39d8ba401ced9db175b31b31cb1e8e04440fc1d6801b",
     },
     "minimax/video-with-audio-768p.json": {
-        "text_to_video_audio": "68977225a70231ba3dd93248624501e4d8335c39eed9d4b2f0c970037af89bac"
+        "text_to_video_audio": "2a7fdf989a40500620fb03212502bbda8f52827f5fcd872b8fda182fab2fac77"
     },
     "minimax/video-with-audio.json": {
-        "text_to_video_audio": "68977225a70231ba3dd93248624501e4d8335c39eed9d4b2f0c970037af89bac"
+        "text_to_video_audio": "2a7fdf989a40500620fb03212502bbda8f52827f5fcd872b8fda182fab2fac77"
     },
     "minimax/voice-timbre-reference.json": {
-        "reference_to_video_audio": "95c8ba90efeba9603384619f1db3f275251f078370add6b2a3e7dab8481aacc6"
+        "reference_to_video_audio": "ba9915580e6a8017d8c68efbddea776985d107222546f84cca18e319298243bf"
     },
     "multi-image-reference.json": {
         "txt2img": "6e563b308f1508e0f24a660dcf25636774e2b70c4ccc723e8975421a7224b48d"
diff --git a/tests/test_text_generation.py b/tests/test_text_generation.py
index ca1f778a..b477c6e4 100644
--- a/tests/test_text_generation.py
+++ b/tests/test_text_generation.py
@@ -1,59 +1,80 @@
 """Tests for text_generation task."""
 
+import json as _json
+import os
+import tempfile
 import unittest
 from unittest.mock import patch, MagicMock
 
+import pytest
+
 from dw.tasks.text_generation import (
     generate_text,
     _DEFAULT_MODEL,
     DEFAULT_VISION_MODEL,
     _VISION_REPETITION_PENALTY,
+    resolve_system_prompt,
 )
 
 
+# Each dw target is patched once here; a class opts in with usefixtures and
+# reads the mock off self, so no test carries a patch of its own
+@pytest.fixture
+def fake_pipeline(request):
+    """hf_pipeline replaced for one test, as self.mock_pipeline."""
+    with patch("dw.tasks.text_generation.hf_pipeline") as mock_pipeline:
+        request.instance.mock_pipeline = mock_pipeline
+        yield mock_pipeline
+
+
+@pytest.fixture
+def fake_hub_download(request):
+    """hf_hub_download replaced for one test, as self.download."""
+    with patch("dw.tasks.text_generation.hf_hub_download") as download:
+        request.instance.download = download
+        yield download
+
+
+@pytest.mark.usefixtures("fake_pipeline")
 class TestTextGeneration(unittest.TestCase):
     """Tests for the generate_text function."""
 
-    @patch("dw.tasks.text_generation.hf_pipeline")
-    def test_returns_generated_string(self, mock_pipeline):
+    def test_returns_generated_string(self):
         pipe = MagicMock()
         pipe.return_value = [{"generated_text": "an expanded detailed prompt"}]
-        mock_pipeline.return_value = pipe
+        self.mock_pipeline.return_value = pipe
 
         result = generate_text("a cat", device="cpu")
 
         self.assertEqual(result, "an expanded detailed prompt")
-        mock_pipeline.assert_called_once()
+        self.mock_pipeline.assert_called_once()
 
-    @patch("dw.tasks.text_generation.hf_pipeline")
-    def test_uses_default_model(self, mock_pipeline):
+    def test_uses_default_model(self):
         pipe = MagicMock()
         pipe.return_value = [{"generated_text": "output"}]
-        mock_pipeline.return_value = pipe
+        self.mock_pipeline.return_value = pipe
 
         generate_text("test", device="cpu")
 
-        call_kwargs = mock_pipeline.call_args
+        call_kwargs = self.mock_pipeline.call_args
         self.assertEqual(call_kwargs[1]["model"], _DEFAULT_MODEL)
 
-    @patch("dw.tasks.text_generation.hf_pipeline")
-    def test_custom_model_name(self, mock_pipeline):
+    def test_custom_model_name(self):
         pipe = MagicMock()
         pipe.return_value = [{"generated_text": "output"}]
-        mock_pipeline.return_value = pipe
+        self.mock_pipeline.return_value = pipe
 
         generate_text(
             "test", device="cpu", model_name="meta-llama/Llama-3.2-1B-Instruct"
         )
 
-        call_kwargs = mock_pipeline.call_args
+        call_kwargs = self.mock_pipeline.call_args
         self.assertEqual(call_kwargs[1]["model"], "meta-llama/Llama-3.2-1B-Instruct")
 
-    @patch("dw.tasks.text_generation.hf_pipeline")
-    def test_system_prompt_included(self, mock_pipeline):
+    def test_system_prompt_included(self):
         pipe = MagicMock()
         pipe.return_value = [{"generated_text": "output"}]
-        mock_pipeline.return_value = pipe
+        self.mock_pipeline.return_value = pipe
 
         generate_text(
             "a cat",
@@ -71,11 +92,10 @@ def test_system_prompt_included(self, mock_pipeline):
         self.assertEqual(messages[1]["role"], "user")
         self.assertEqual(messages[1]["content"], "a cat")
 
-    @patch("dw.tasks.text_generation.hf_pipeline")
-    def test_no_system_prompt(self, mock_pipeline):
+    def test_no_system_prompt(self):
         pipe = MagicMock()
         pipe.return_value = [{"generated_text": "output"}]
-        mock_pipeline.return_value = pipe
+        self.mock_pipeline.return_value = pipe
 
         generate_text("a cat", device="cpu")
 
@@ -84,27 +104,165 @@ def test_no_system_prompt(self, mock_pipeline):
         self.assertEqual(len(messages), 1)
         self.assertEqual(messages[0]["role"], "user")
 
-    @patch("dw.tasks.text_generation.hf_pipeline")
-    def test_max_new_tokens(self, mock_pipeline):
+    def test_max_new_tokens(self):
         pipe = MagicMock()
         pipe.return_value = [{"generated_text": "output"}]
-        mock_pipeline.return_value = pipe
+        self.mock_pipeline.return_value = pipe
 
         generate_text("test", device="cpu", max_new_tokens=200)
 
         call_args = pipe.call_args
         self.assertEqual(call_args[1]["max_new_tokens"], 200)
 
-    @patch("dw.tasks.text_generation.hf_pipeline")
-    def test_strips_whitespace(self, mock_pipeline):
+    def test_strips_whitespace(self):
         pipe = MagicMock()
         pipe.return_value = [{"generated_text": "  some text with spaces  \n"}]
-        mock_pipeline.return_value = pipe
+        self.mock_pipeline.return_value = pipe
 
         result = generate_text("test", device="cpu")
         self.assertEqual(result, "some text with spaces")
 
+    def test_chat_template_kwargs_reach_the_text_template(self):
+        pipe = MagicMock()
+        pipe.return_value = [{"generated_text": "out"}]
+        self.mock_pipeline.return_value = pipe
+
+        generate_text(
+            "a cat",
+            device="cpu",
+            model_name="m/text-chat-kwargs",
+            chat_template_kwargs={"enable_thinking": False},
+        )
+
+        self.assertEqual(
+            pipe.call_args[1]["tokenizer_encode_kwargs"], {"enable_thinking": False}
+        )
+
+    def test_chat_template_kwargs_reach_the_vision_template(self):
+        pipe = MagicMock()
+        pipe.return_value = [{"generated_text": "out"}]
+        self.mock_pipeline.return_value = pipe
 
+        generate_text(
+            "a cat",
+            device="cpu",
+            model_name="m/vision-chat-kwargs",
+            image="https://example.com/a.png",
+            chat_template_kwargs={"enable_thinking": False},
+        )
+
+        self.assertIs(pipe.call_args[1]["enable_thinking"], False)
+
+    def test_no_chat_template_kwargs_passes_nothing_extra(self):
+        pipe = MagicMock()
+        pipe.return_value = [{"generated_text": "out"}]
+        self.mock_pipeline.return_value = pipe
+
+        generate_text("a cat", device="cpu", model_name="m/no-chat-kwargs")
+
+        self.assertNotIn("tokenizer_encode_kwargs", pipe.call_args[1])
+
+    def test_chat_template_kwargs_must_be_a_mapping(self):
+        with self.assertRaises(ValueError):
+            generate_text(
+                "a cat", device="cpu", chat_template_kwargs=["enable_thinking"]
+            )
+
+    def test_revision_reaches_the_loader(self):
+        pipe = MagicMock()
+        pipe.return_value = [{"generated_text": "out"}]
+        self.mock_pipeline.return_value = pipe
+
+        generate_text("a cat", device="cpu", model_name="m/revision", revision="a" * 40)
+
+        self.assertEqual(self.mock_pipeline.call_args[1]["revision"], "a" * 40)
+
+    def test_a_list_of_images_becomes_one_part_each_in_order(self):
+        pipe = MagicMock()
+        pipe.return_value = [{"generated_text": "out"}]
+        self.mock_pipeline.return_value = pipe
+
+        generate_text(
+            "edit",
+            device="cpu",
+            model_name="m/image-list",
+            image=["https://example.com/1.png", "https://example.com/2.png"],
+        )
+
+        user = pipe.call_args[1]["text"][-1]["content"]
+        self.assertEqual(
+            [part.get("url") for part in user[:2]],
+            ["https://example.com/1.png", "https://example.com/2.png"],
+        )
+        self.assertEqual(user[2], {"type": "text", "text": "edit"})
+        self.assertEqual(self.mock_pipeline.call_args[0][0], "image-text-to-text")
+
+    def test_an_empty_or_all_null_image_list_is_the_text_path(self):
+        pipe = MagicMock()
+        pipe.return_value = [{"generated_text": "out"}]
+        self.mock_pipeline.return_value = pipe
+
+        for empty in ([], [None]):
+            generate_text(
+                "a cat",
+                device="cpu",
+                model_name=f"m/empty-{len(empty)}",
+                image=empty,
+            )
+            self.assertEqual(self.mock_pipeline.call_args[0][0], "text-generation")
+
+    def test_a_non_scalar_chat_template_value_is_refused(self):
+        with self.assertRaisesRegex(ValueError, "enable_thinking"):
+            generate_text(
+                "a cat",
+                device="cpu",
+                model_name="m/nonscalar",
+                chat_template_kwargs={"enable_thinking": {"a": 1}},
+            )
+        self.mock_pipeline.assert_not_called()
+
+    def test_a_reserved_chat_template_key_is_refused_before_any_call(self):
+        pipe = MagicMock()
+        self.mock_pipeline.return_value = pipe
+        for key in ("images", "tools", "tokenizer_encode_kwargs"):
+            with self.assertRaisesRegex(ValueError, f"'{key}'.*not a chat-template"):
+                generate_text(
+                    "a cat",
+                    device="cpu",
+                    model_name="m/reserved-vision",
+                    image="https://example.com/a.png",
+                    chat_template_kwargs={key: "http://169.254.169.254/x"},
+                )
+            with self.assertRaisesRegex(ValueError, f"'{key}'.*not a chat-template"):
+                generate_text(
+                    "a cat",
+                    device="cpu",
+                    model_name="m/reserved-text",
+                    chat_template_kwargs={key: "x"},
+                )
+        pipe.assert_not_called()
+
+    def test_a_legitimate_setting_passes_on_both_paths(self):
+        pipe = MagicMock()
+        pipe.return_value = [{"generated_text": "out"}]
+        self.mock_pipeline.return_value = pipe
+        settings = {"enable_thinking": False, "effort": "low", "n": 2, "t": 0.5}
+
+        generate_text(
+            "a cat", device="cpu", model_name="m/ok-text", chat_template_kwargs=settings
+        )
+        self.assertEqual(pipe.call_args[1]["tokenizer_encode_kwargs"], settings)
+        generate_text(
+            "a cat",
+            device="cpu",
+            model_name="m/ok-vision",
+            image="https://example.com/a.png",
+            chat_template_kwargs=settings,
+        )
+        self.assertIs(pipe.call_args[1]["enable_thinking"], False)
+
+
+@pytest.mark.usefixtures("fake_pipeline")
 class TestTextGenerationWithImage(unittest.TestCase):
     """An image switches generation onto a vision-language pipeline."""
 
@@ -119,33 +277,29 @@ def _mock_pipe(self, mock_pipeline):
         mock_pipeline.return_value = pipe
         return pipe
 
-    @patch("dw.tasks.text_generation.hf_pipeline")
-    def test_image_selects_the_vision_pipeline(self, mock_pipeline):
-        self._mock_pipe(mock_pipeline)
+    def test_image_selects_the_vision_pipeline(self):
+        self._mock_pipe(self.mock_pipeline)
 
         generate_text("describe it", device="cpu", image=self._make_image())
 
-        self.assertEqual(mock_pipeline.call_args[0][0], "image-text-to-text")
+        self.assertEqual(self.mock_pipeline.call_args[0][0], "image-text-to-text")
 
-    @patch("dw.tasks.text_generation.hf_pipeline")
-    def test_no_image_stays_on_text_generation(self, mock_pipeline):
-        self._mock_pipe(mock_pipeline)
+    def test_no_image_stays_on_text_generation(self):
+        self._mock_pipe(self.mock_pipeline)
 
         generate_text("a cat", device="cpu")
 
-        self.assertEqual(mock_pipeline.call_args[0][0], "text-generation")
+        self.assertEqual(self.mock_pipeline.call_args[0][0], "text-generation")
 
-    @patch("dw.tasks.text_generation.hf_pipeline")
-    def test_image_uses_the_vision_default_model(self, mock_pipeline):
-        self._mock_pipe(mock_pipeline)
+    def test_image_uses_the_vision_default_model(self):
+        self._mock_pipe(self.mock_pipeline)
 
         generate_text("describe it", device="cpu", image=self._make_image())
 
-        self.assertEqual(mock_pipeline.call_args[1]["model"], DEFAULT_VISION_MODEL)
+        self.assertEqual(self.mock_pipeline.call_args[1]["model"], DEFAULT_VISION_MODEL)
 
-    @patch("dw.tasks.text_generation.hf_pipeline")
-    def test_vision_content_is_typed_parts(self, mock_pipeline):
-        pipe = self._mock_pipe(mock_pipeline)
+    def test_vision_content_is_typed_parts(self):
+        pipe = self._mock_pipe(self.mock_pipeline)
         image = self._make_image()
 
         generate_text(
@@ -167,9 +321,8 @@ def test_vision_content_is_typed_parts(self, mock_pipeline):
             ],
         )
 
-    @patch("dw.tasks.text_generation.hf_pipeline")
-    def test_string_image_is_passed_as_a_url(self, mock_pipeline):
-        pipe = self._mock_pipe(mock_pipeline)
+    def test_string_image_is_passed_as_a_url(self):
+        pipe = self._mock_pipe(self.mock_pipeline)
 
         generate_text("describe it", device="cpu", image="https://example.com/cat.jpg")
 
@@ -178,9 +331,8 @@ def test_string_image_is_passed_as_a_url(self, mock_pipeline):
             content[0], {"type": "image", "url": "https://example.com/cat.jpg"}
         )
 
-    @patch("dw.tasks.text_generation.hf_pipeline")
-    def test_sampling_is_disabled_through_generate_kwargs(self, mock_pipeline):
-        pipe = self._mock_pipe(mock_pipeline)
+    def test_sampling_is_disabled_through_generate_kwargs(self):
+        pipe = self._mock_pipe(self.mock_pipeline)
 
         generate_text("describe it", device="cpu", image=self._make_image())
 
@@ -189,9 +341,8 @@ def test_sampling_is_disabled_through_generate_kwargs(self, mock_pipeline):
         self.assertIs(pipe.call_args[1]["generate_kwargs"]["do_sample"], False)
         self.assertNotIn("do_sample", pipe.call_args[1])
 
-    @patch("dw.tasks.text_generation.hf_pipeline")
-    def test_vision_defaults_to_a_repetition_penalty(self, mock_pipeline):
-        pipe = self._mock_pipe(mock_pipeline)
+    def test_vision_defaults_to_a_repetition_penalty(self):
+        pipe = self._mock_pipe(self.mock_pipeline)
 
         generate_text("describe it", device="cpu", image=self._make_image())
 
@@ -202,9 +353,8 @@ def test_vision_defaults_to_a_repetition_penalty(self, mock_pipeline):
             _VISION_REPETITION_PENALTY,
         )
 
-    @patch("dw.tasks.text_generation.hf_pipeline")
-    def test_repetition_penalty_is_overridable(self, mock_pipeline):
-        pipe = self._mock_pipe(mock_pipeline)
+    def test_repetition_penalty_is_overridable(self):
+        pipe = self._mock_pipe(self.mock_pipeline)
 
         generate_text(
             "describe it",
@@ -217,9 +367,8 @@ def test_repetition_penalty_is_overridable(self, mock_pipeline):
             pipe.call_args[1]["generate_kwargs"]["repetition_penalty"], 1.2
         )
 
-    @patch("dw.tasks.text_generation.hf_pipeline")
-    def test_text_path_takes_no_repetition_penalty(self, mock_pipeline):
-        pipe = self._mock_pipe(mock_pipeline)
+    def test_text_path_takes_no_repetition_penalty(self):
+        pipe = self._mock_pipe(self.mock_pipeline)
 
         generate_text("a cat", device="cpu")
 
@@ -227,9 +376,8 @@ def test_text_path_takes_no_repetition_penalty(self, mock_pipeline):
         # the output of every workflow already using them
         self.assertNotIn("generate_kwargs", pipe.call_args[1])
 
-    @patch("dw.tasks.text_generation.hf_pipeline")
-    def test_text_and_vision_variants_cache_separately(self, mock_pipeline):
-        self._mock_pipe(mock_pipeline)
+    def test_text_and_vision_variants_cache_separately(self):
+        self._mock_pipe(self.mock_pipeline)
 
         # Same model name under both pipelines - they are not interchangeable,
         # so the cache must not hand one back for the other
@@ -238,11 +386,12 @@ def test_text_and_vision_variants_cache_separately(self, mock_pipeline):
             "a cat", device="cpu", model_name="some/model", image=self._make_image()
         )
 
-        self.assertEqual(mock_pipeline.call_count, 2)
-        tasks = [call[0][0] for call in mock_pipeline.call_args_list]
+        self.assertEqual(self.mock_pipeline.call_count, 2)
+        tasks = [call[0][0] for call in self.mock_pipeline.call_args_list]
         self.assertEqual(tasks, ["text-generation", "image-text-to-text"])
 
 
+@pytest.mark.usefixtures("fake_pipeline")
 class TestGenerateKwargsPassThrough(unittest.TestCase):
     """Anything generate() understands can be set from a workflow."""
 
@@ -257,9 +406,8 @@ def _mock_pipe(self, mock_pipeline):
         mock_pipeline.return_value = pipe
         return pipe
 
-    @patch("dw.tasks.text_generation.hf_pipeline")
-    def test_reaches_the_text_pipeline(self, mock_pipeline):
-        pipe = self._mock_pipe(mock_pipeline)
+    def test_reaches_the_text_pipeline(self):
+        pipe = self._mock_pipe(self.mock_pipeline)
 
         generate_text(
             "a cat", device="cpu", generate_kwargs={"no_repeat_ngram_size": 25}
@@ -267,9 +415,8 @@ def test_reaches_the_text_pipeline(self, mock_pipeline):
 
         self.assertEqual(pipe.call_args[1]["no_repeat_ngram_size"], 25)
 
-    @patch("dw.tasks.text_generation.hf_pipeline")
-    def test_reaches_the_vision_pipeline(self, mock_pipeline):
-        pipe = self._mock_pipe(mock_pipeline)
+    def test_reaches_the_vision_pipeline(self):
+        pipe = self._mock_pipe(self.mock_pipeline)
 
         generate_text(
             "describe it",
@@ -282,9 +429,8 @@ def test_reaches_the_vision_pipeline(self, mock_pipeline):
             pipe.call_args[1]["generate_kwargs"]["no_repeat_ngram_size"], 25
         )
 
-    @patch("dw.tasks.text_generation.hf_pipeline")
-    def test_overrides_what_the_task_decided(self, mock_pipeline):
-        pipe = self._mock_pipe(mock_pipeline)
+    def test_overrides_what_the_task_decided(self):
+        pipe = self._mock_pipe(self.mock_pipeline)
 
         generate_text(
             "describe it",
@@ -298,6 +444,86 @@ def test_overrides_what_the_task_decided(self, mock_pipeline):
         )
 
 
+@pytest.mark.usefixtures("fake_pipeline")
+class TestGenerateKwargsAreFiltered(unittest.TestCase):
+    """generate_kwargs reach the pipeline call, so they are checked first.
+
+    The untrusted refusal of custom_generate and trust_remote_code lives with
+    the other trust gate tests, in tests/test_security_trust_gate.py; this
+    suite runs trusted (tests/conftest.py).
+    """
+
+    def _mock_pipe(self, mock_pipeline):
+        pipe = MagicMock()
+        pipe.return_value = [{"generated_text": "output"}]
+        mock_pipeline.return_value = pipe
+        return pipe
+
+    def test_trusted_workflows_may_name_remote_generate_code(self):
+        pipe = self._mock_pipe(self.mock_pipeline)
+        settings = {"custom_generate": "someone/decoder", "trust_remote_code": True}
+        with patch("dw.trust.workflows_are_trusted", return_value=True):
+            generate_text(
+                "a cat", device="cpu", model_name="m/trusted", generate_kwargs=settings
+            )
+        self.assertEqual(pipe.call_args[1]["custom_generate"], "someone/decoder")
+        self.assertIs(pipe.call_args[1]["trust_remote_code"], True)
+
+    def test_a_structural_key_is_refused_before_any_load(self):
+        for key in (
+            "tokenizer_encode_kwargs",
+            "prefix",
+            "handle_long_generation",
+            "max_new_tokens",
+            "images",
+        ):
+            for image in (None, "https://example.com/a.png"):
+                with self.assertRaisesRegex(ValueError, f"'{key}'.*not a generation"):
+                    generate_text(
+                        "a cat",
+                        device="cpu",
+                        model_name="m/structural",
+                        image=image,
+                        generate_kwargs={key: "x"},
+                    )
+        self.mock_pipeline.assert_not_called()
+
+    def test_a_nested_value_is_refused(self):
+        for bad in ({"a": 1}, [{"a": 1}], [[1]]):
+            with self.assertRaisesRegex(ValueError, "sequence_bias"):
+                generate_text(
+                    "a cat",
+                    device="cpu",
+                    model_name="m/nested",
+                    generate_kwargs={"sequence_bias": bad},
+                )
+        with self.assertRaisesRegex(ValueError, "must be an object"):
+            generate_text("a cat", device="cpu", generate_kwargs=["top_p"])
+        self.mock_pipeline.assert_not_called()
+
+    def test_legitimate_settings_pass_on_both_paths(self):
+        pipe = self._mock_pipe(self.mock_pipeline)
+        settings = {"no_repeat_ngram_size": 3, "stop_strings": ["\n\n"]}
+
+        generate_text(
+            "a cat", device="cpu", model_name="m/legit", generate_kwargs=settings
+        )
+        self.assertEqual(pipe.call_args[1]["no_repeat_ngram_size"], 3)
+        self.assertEqual(pipe.call_args[1]["stop_strings"], ["\n\n"])
+
+        generate_text(
+            "a cat",
+            device="cpu",
+            model_name="m/legit-vision",
+            image="https://example.com/a.png",
+            generate_kwargs=settings,
+        )
+        forwarded = pipe.call_args[1]["generate_kwargs"]
+        self.assertEqual(forwarded["no_repeat_ngram_size"], 3)
+        self.assertEqual(forwarded["stop_strings"], ["\n\n"])
+
+
+@pytest.mark.usefixtures("fake_pipeline")
 class TestTextGenerationLoadDevice(unittest.TestCase):
     """How the model gets onto the device it runs on.
 
@@ -315,26 +541,194 @@ def _mock_pipe(mock_pipeline):
         mock_pipeline.return_value = pipe
         return pipe
 
-    @patch("dw.tasks.text_generation.hf_pipeline")
-    def test_mps_loads_on_cpu_then_moves(self, mock_pipeline):
-        self._mock_pipe(mock_pipeline)
+    def test_mps_loads_on_cpu_then_moves(self):
+        self._mock_pipe(self.mock_pipeline)
 
         generate_text("test", device="mps")
 
-        kwargs = mock_pipeline.call_args[1]
+        kwargs = self.mock_pipeline.call_args[1]
         self.assertEqual(kwargs["device"], "mps")
         self.assertNotIn("device_map", kwargs)
 
-    @patch("dw.tasks.text_generation.hf_pipeline")
-    def test_other_devices_still_use_device_map(self, mock_pipeline):
-        self._mock_pipe(mock_pipeline)
+    def test_other_devices_still_use_device_map(self):
+        self._mock_pipe(self.mock_pipeline)
 
         generate_text("test", device="cuda")
 
-        kwargs = mock_pipeline.call_args[1]
+        kwargs = self.mock_pipeline.call_args[1]
         self.assertEqual(kwargs["device_map"], "cuda")
         self.assertNotIn("device", kwargs)
 
 
+PIN = "3f3edb52b2c55de0d49feab28598b68f7f8e4830"
+
+
+def _spec(**over):
+    spec = {
+        "repo": "black-forest-labs/flux-3-image-klein-pup",
+        "file": "system_prompts.json",
+        "revision": PIN,
+        "key": "t2i",
+    }
+    spec.update(over)
+    return {"from_hub": spec}
+
+
+@pytest.mark.usefixtures("fake_pipeline", "fake_hub_download")
+class TestSystemPromptFromHub(unittest.TestCase):
+    def setUp(self):
+        meta = patch("dw.tasks.text_generation.get_hf_file_metadata")
+        self.metadata = meta.start()
+        self.addCleanup(meta.stop)
+        self.metadata.return_value = MagicMock(size=100)
+        self.dir = tempfile.mkdtemp()
+        self.json_path = os.path.join(self.dir, "system_prompts.json")
+        with open(self.json_path, "w") as f:
+            _json.dump({"t2i": "expand the request", "i2i": "edit it", "n": 3}, f)
+
+    def test_a_string_or_none_passes_through(self):
+        self.assertEqual(resolve_system_prompt("plain"), "plain")
+        self.assertIsNone(resolve_system_prompt(None))
+
+    def test_the_key_s_text_is_returned_from_the_pinned_file(self):
+        self.download.return_value = self.json_path
+        self.assertEqual(resolve_system_prompt(_spec()), "expand the request")
+        self.download.assert_called_once_with(
+            "black-forest-labs/flux-3-image-klein-pup",
+            "system_prompts.json",
+            revision=PIN,
+            token=False,
+        )
+
+    def test_a_missing_key_names_the_keys_the_file_has(self):
+        self.download.return_value = self.json_path
+        with self.assertRaises(ValueError) as caught:
+            resolve_system_prompt(_spec(key="t2v"))
+        self.assertIn("i2i", str(caught.exception))
+        self.assertIn("t2i", str(caught.exception))
+
+    def test_a_value_that_is_not_text_is_refused(self):
+        self.download.return_value = self.json_path
+        with self.assertRaises(ValueError):
+            resolve_system_prompt(_spec(key="n"))
+
+    def test_a_short_hash_or_branch_is_refused(self):
+        for revision in ("3f3edb52", "main", PIN.upper()):
+            with self.assertRaises(ValueError) as caught:
+                resolve_system_prompt(_spec(revision=revision))
+            self.assertIn("40", str(caught.exception))
+
+    def test_a_path_that_escapes_the_repo_is_refused(self):
+        from dw.security import InvalidInputError, PathTraversalError
+
+        for file in (
+            "../secrets.json",
+            "/etc/passwd",
+            "a\\b.json",
+            "",
+            "x/../../y.json",
+            "a\x00b.json",
+            "~/x",
+            "C:x",
+            "./x",
+            "a//b",
+        ):
+            with self.assertRaises((ValueError, InvalidInputError, PathTraversalError)):
+                resolve_system_prompt(_spec(file=file))
+
+    def test_a_missing_or_non_string_repo_is_refused(self):
+        omitted = _spec()
+        del omitted["from_hub"]["repo"]
+        for bad in (omitted, _spec(repo=None), _spec(repo=3)):
+            with self.assertRaises(ValueError) as caught:
+                resolve_system_prompt(bad)
+            self.assertIn("system_prompt.from_hub.repo", str(caught.exception))
+
+    def test_the_hub_is_asked_anonymously_before_the_download(self):
+        self.download.return_value = self.json_path
+        order = MagicMock()
+        order.attach_mock(self.metadata, "metadata")
+        order.attach_mock(self.download, "download")
+        resolve_system_prompt(_spec())
+        self.assertEqual([c[0] for c in order.mock_calls], ["metadata", "download"])
+        self.assertIs(self.metadata.call_args.kwargs["token"], False)
+
+    def test_a_file_the_hub_will_not_serve_publicly_is_refused(self):
+        from huggingface_hub.errors import HfHubHTTPError
+
+        class _Gated(HfHubHTTPError):
+            def __init__(self, message):
+                Exception.__init__(self, message)
+
+        for err in (Exception("boom"), _Gated("403 gated"), OSError("offline")):
+            self.metadata.side_effect = err
+            with self.assertRaises(ValueError) as caught:
+                resolve_system_prompt(_spec())
+            self.assertIn("public file", str(caught.exception))
+            self.assertIs(caught.exception.__cause__, err)
+        self.download.assert_not_called()
+
+    def test_an_oversize_file_is_refused_before_downloading(self):
+        self.metadata.return_value = MagicMock(size=1024 * 1024 + 1)
+        with self.assertRaises(ValueError):
+            resolve_system_prompt(_spec())
+        self.download.assert_not_called()
+
+    def test_a_file_of_unknown_size_is_refused_before_downloading(self):
+        self.metadata.return_value = MagicMock(size=None)
+        with self.assertRaisesRegex(ValueError, "no size"):
+            resolve_system_prompt(_spec())
+        self.download.assert_not_called()
+
+    def test_a_non_string_key_is_refused(self):
+        for key in (["t2i"], {"a": 1}, 3):
+            with self.assertRaises(ValueError):
+                resolve_system_prompt(_spec(key=key))
+
+    def test_the_download_never_carries_the_server_token(self):
+        self.download.return_value = self.json_path
+        resolve_system_prompt(_spec())
+        self.assertIs(self.download.call_args.kwargs["token"], False)
+
+    def test_an_oversize_file_is_refused_unread(self):
+        big = os.path.join(self.dir, "big.txt")
+        with open(big, "wb") as f:
+            f.truncate(1024 * 1024 + 1)
+        self.download.return_value = big
+        with patch("builtins.open", side_effect=AssertionError("read")):
+            with self.assertRaises(ValueError):
+                resolve_system_prompt(_spec(file="big.txt", key=None))
+
+    def test_a_bad_repo_id_is_refused(self):
+        from dw.security import InvalidInputError
+
+        with self.assertRaises((ValueError, InvalidInputError)):
+            resolve_system_prompt(_spec(repo="https://evil.example/x"))
+
+    def test_an_unknown_field_or_shape_is_refused(self):
+        for bad in (
+            {"from_hub": {**_spec()["from_hub"], "branch": "main"}},
+            {"from_url": "x"},
+            ["t2i"],
+        ):
+            with self.assertRaises(ValueError):
+                resolve_system_prompt(bad)
+
+    def test_generate_text_sends_the_resolved_text(self):
+        self.download.return_value = self.json_path
+        pipe = MagicMock()
+        pipe.return_value = [{"generated_text": "out"}]
+        self.mock_pipeline.return_value = pipe
+
+        generate_text(
+            "a dog", device="cpu", model_name="m/from-hub", system_prompt=_spec()
+        )
+
+        messages = pipe.call_args[0][0]
+        self.assertEqual(
+            messages[0], {"role": "system", "content": "expand the request"}
+        )
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/test_validation.py b/tests/test_validation.py
index b55ddb58..9a344000 100644
--- a/tests/test_validation.py
+++ b/tests/test_validation.py
@@ -452,6 +452,7 @@ class TestAccelerationWarnings:
         "taylorseer_state_unestimated",
         "compile_fullgraph_with_cache",
         "attention_backend_unavailable",
+        "sparse_attention_fallback",
         "cache_unsupported",
     )
 
@@ -786,6 +787,57 @@ def test_an_unresolvable_backend_is_silent_on_mps(self, monkeypatch):
 
         assert self.coded(warnings, "attention_backend_unavailable") == []
 
+    # sparse_attention_fallback
+
+    @pytest.mark.parametrize("level", ["pipeline", "component"])
+    @pytest.mark.parametrize("device", ["mps", "cpu"])
+    def test_sparse_off_cuda_warns_fallback_not_unavailable(
+        self, monkeypatch, level, device
+    ):
+        definition = self.definition(**self.with_backend(level, "sparse"))
+
+        warnings = self.run(monkeypatch, definition, device=device)
+
+        found = self.coded(warnings, "sparse_attention_fallback")
+        assert len(found) == 1
+        assert f"'{device}'" in found[0] and "dense" in found[0]
+        if level == "component":
+            assert "components.transformer.attention_backend" in found[0]
+        assert self.coded(warnings, "attention_backend_unavailable") == []
+
+    @pytest.mark.parametrize("device", ["cuda", "cuda:1"])
+    def test_sparse_on_cuda_is_silent(self, monkeypatch, device):
+        definition = self.definition(attention_backend="sparse")
+
+        warnings = self.run(monkeypatch, definition, device=device)
+
+        assert self.coded(warnings, "sparse_attention_fallback") == []
+        assert self.coded(warnings, "attention_backend_unavailable") == []
+
+    @pytest.mark.parametrize("level", ["pipeline", "component"])
+    def test_sparse_on_an_unknown_device_is_silent(self, level):
+        definition = self.definition(**self.with_backend(level, "sparse"))
+
+        warnings = self.direct(definition, device_type=None)
+
+        assert self.coded(warnings, "sparse_attention_fallback") == []
+        assert self.coded(warnings, "attention_backend_unavailable") == []
+
+    def test_sparse_from_a_template_variable_warns_off_cuda(self, monkeypatch):
+        """H3 templates set the component's backend by `variable:`, default
+        sparse"""
+        definition = self.definition(
+            components={
+                "transformer": {"attention_backend": "variable:attention_backend"}
+            },
+            variables={"attention_backend": "sparse"},
+        )
+
+        warnings = self.run(monkeypatch, definition, device="mps")
+
+        assert len(self.coded(warnings, "sparse_attention_fallback")) == 1
+        assert self.coded(warnings, "attention_backend_unavailable") == []
+
     # shape of the answer
 
     def test_a_for_each_step_says_each_warning_once(self, monkeypatch):
diff --git a/ui/src/App.svelte b/ui/src/App.svelte
index adb04525..6b2d648b 100644
--- a/ui/src/App.svelte
+++ b/ui/src/App.svelte
@@ -49,6 +49,7 @@
   import ModelsPage from './lib/pages/ModelsPage.svelte'
   import SchemaPage from './lib/pages/SchemaPage.svelte'
   import StatusPage from './lib/pages/StatusPage.svelte'
+  import { setAttentionBackends } from './lib/attentionBackends.svelte'
 
   let memory = $state<MemoryInfo | null>(null)
   let health = $state<HealthInfo | null>(null)
@@ -146,6 +147,7 @@
       ])
       memory = memoryInfo.status === 'fulfilled' ? memoryInfo.value : null
       health = healthInfo.status === 'fulfilled' ? healthInfo.value : null
+      setAttentionBackends(health?.attention_backends)
       void watchJobs(health)
     }
     return poll(refreshStatus, 5000)
diff --git a/ui/src/lib/attentionBackends.svelte.ts b/ui/src/lib/attentionBackends.svelte.ts
new file mode 100644
index 00000000..52f452db
--- /dev/null
+++ b/ui/src/lib/attentionBackends.svelte.ts
@@ -0,0 +1,12 @@
+/** The attention backends this server can run, from its last good health
+ * poll. The server lists only what its device supports ('sparse' only on a
+ * CUDA server with the kernels), so a dropdown built from it offers nothing
+ * that would fall back. Empty until a poll answers - and after an older
+ * server that does not report the field - which leaves the text inputs. */
+export const attentionBackends = $state({ list: [] as string[] })
+
+/** Take a health poll's answer. A failed poll (null) or a server that does
+ * not report backends keeps the last known list rather than blanking it. */
+export function setAttentionBackends(list: string[] | null | undefined): void {
+  if (list) attentionBackends.list = list
+}
diff --git a/ui/src/lib/editor.test.ts b/ui/src/lib/editor.test.ts
index 23c34717..28686a64 100644
--- a/ui/src/lib/editor.test.ts
+++ b/ui/src/lib/editor.test.ts
@@ -1,6 +1,7 @@
 import { describe, expect, it } from 'vitest'
 import {
   CONTENT_TYPES,
+  attentionBackendVariables,
   coerce,
   contentTypeOptions,
   optionsWith,
@@ -351,3 +352,57 @@ describe('optionsWith', () => {
     expect(optionsWith(['a', 'b'], null)).toEqual(['a', 'b'])
   })
 })
+
+describe('attentionBackendVariables', () => {
+  it('finds variables feeding attention_backend at component level', () => {
+    const def = {
+      steps: [
+        {
+          pipeline: {
+            configuration: {
+              components: {
+                transformer_ref: { attention_backend: 'variable:attn' },
+              },
+            },
+          },
+        },
+      ],
+    }
+    expect(attentionBackendVariables(def)).toEqual(new Set(['attn']))
+  })
+
+  it('finds pipeline-level and nested workflow-step variables', () => {
+    const def = {
+      steps: [
+        { pipeline: { configuration: { attention_backend: 'variable:a' } } },
+        {
+          workflow: {
+            steps: [
+              {
+                pipeline: {
+                  configuration: { attention_backend: 'variable:b' },
+                },
+              },
+            ],
+          },
+        },
+      ],
+    }
+    expect(attentionBackendVariables(def)).toEqual(new Set(['a', 'b']))
+  })
+
+  it('ignores literals and other keys', () => {
+    const def = {
+      variables: { attn: 'sparse' },
+      steps: [
+        {
+          pipeline: {
+            configuration: { attention_backend: 'sage', other: 'variable:x' },
+          },
+        },
+      ],
+    }
+    expect(attentionBackendVariables(def)).toEqual(new Set())
+    expect(attentionBackendVariables(null)).toEqual(new Set())
+  })
+})
diff --git a/ui/src/lib/editor.ts b/ui/src/lib/editor.ts
index a3350b51..b8088421 100644
--- a/ui/src/lib/editor.ts
+++ b/ui/src/lib/editor.ts
@@ -289,12 +289,39 @@ export const CACHE_TYPES = [
   'text_kv',
 ]
 
+/** The variable names that feed an attention_backend, as
+ * "attention_backend": "variable:X", anywhere in the steps - pipeline
+ * configuration, components, and inline sub-workflow definitions. */
+export function attentionBackendVariables(definition: unknown): Set<string> {
+  const found = new Set<string>()
+  const walk = (node: unknown): void => {
+    if (Array.isArray(node)) {
+      node.forEach(walk)
+    } else if (node !== null && typeof node === 'object') {
+      for (const [key, value] of Object.entries(node)) {
+        if (
+          key === 'attention_backend' &&
+          typeof value === 'string' &&
+          value.startsWith(VARIABLE)
+        ) {
+          found.add(value.slice(VARIABLE.length))
+        } else {
+          walk(value)
+        }
+      }
+    }
+  }
+  walk((definition as { steps?: unknown } | null)?.steps)
+  return found
+}
+
 export const ATTENTION_BACKENDS = [
   'native',
   'flash',
   'flash_hub',
   'sage',
   'sage_hub',
+  'sparse',
   'xformers',
 ]
 
diff --git a/ui/src/lib/editor/PipelineOptions.svelte b/ui/src/lib/editor/PipelineOptions.svelte
index c673f01f..f096c1ad 100644
--- a/ui/src/lib/editor/PipelineOptions.svelte
+++ b/ui/src/lib/editor/PipelineOptions.svelte
@@ -1,6 +1,7 @@
 <script lang="ts">
   import Suggest from '../ui/Suggest.svelte'
   import { editorLists } from '../editorLists.svelte'
+  import { attentionBackends } from '../attentionBackends.svelte'
   import { Boxes, Layers, Timer, Zap } from '@lucide/svelte'
   import ArgumentsEditor from './ArgumentsEditor.svelte'
   import ComponentEditor from './ComponentEditor.svelte'
@@ -10,6 +11,7 @@
     CACHE_TYPES,
     COMPONENT_SLOTS,
     classDescription,
+    isReference,
     emptyComponent,
     setNumber,
   } from '../editor'
@@ -243,16 +245,39 @@
     </div>
 
     <label for={'attn-' + index}>attention backend</label>
-    <Suggest
-      id={'attn-' + index}
-      suggestions={ATTENTION_BACKENDS}
-      value={configuration.attention_backend ?? ''}
-      placeholder="pipeline default"
-      onchange={(v) => {
-        if (v) configuration.attention_backend = v
-        else delete configuration.attention_backend
-      }}
-    />
+    {#if attentionBackends.list.length && typeof (configuration.attention_backend ?? '') === 'string' && !isReference(configuration.attention_backend)}
+      {@const current = configuration.attention_backend ?? ''}
+      <select
+        id={'attn-' + index}
+        value={current}
+        onchange={(e) => {
+          if (e.currentTarget.value)
+            configuration.attention_backend = e.currentTarget.value
+          else delete configuration.attention_backend
+        }}
+      >
+        <option value="">pipeline default</option>
+        {#if current && !attentionBackends.list.includes(current)}
+          <option value={current}
+            >{current} (not available on this server)</option
+          >
+        {/if}
+        {#each attentionBackends.list as backend (backend)}
+          <option value={backend}>{backend}</option>
+        {/each}
+      </select>
+    {:else}
+      <Suggest
+        id={'attn-' + index}
+        suggestions={ATTENTION_BACKENDS}
+        value={configuration.attention_backend ?? ''}
+        placeholder="pipeline default"
+        onchange={(v) => {
+          if (v) configuration.attention_backend = v
+          else delete configuration.attention_backend
+        }}
+      />
+    {/if}
 
     <label for={'pw-' + index}>prompt weighting</label>
     <input
diff --git a/ui/src/lib/editor/VariablesForm.svelte b/ui/src/lib/editor/VariablesForm.svelte
index dd275b7d..5420b305 100644
--- a/ui/src/lib/editor/VariablesForm.svelte
+++ b/ui/src/lib/editor/VariablesForm.svelte
@@ -7,12 +7,14 @@
   import { promptTooltip } from '../prompts'
   import { referenceCompletions } from '../refcomplete.svelte'
   import BrowseButton from '../assets/BrowseButton.svelte'
+  import { attentionBackends } from '../attentionBackends.svelte'
 
   let {
     mode,
     variables = $bindable(),
     overrides = $bindable({}),
     idPrefix,
+    backendVariables = new Set<string>(),
   }: {
     /** define: edit the workflow's own defaults (add/remove/coerce).
      * override: fill per-run values over read-only defaults. */
@@ -20,6 +22,9 @@
     variables: Record<string, unknown>
     overrides?: Record<string, string>
     idPrefix: string
+    /** Variables that feed an attention_backend: a dropdown of the
+     * server's own list while it has one. */
+    backendVariables?: Set<string>
   } = $props()
 
   const keys = $derived(Object.keys(variables ?? {}))
@@ -38,6 +43,28 @@
     return variables[key]
   }
 
+  /** A backend variable is a dropdown when the server listed backends and
+   * both what it holds and what it would override are plain names - a
+   * reference or a non-string stays the text field. */
+  function isBackendSelect(key: string): boolean {
+    if (!backendVariables.has(key) || !attentionBackends.list.length) {
+      return false
+    }
+    const plain = (v: unknown) =>
+      v === undefined ||
+      v === null ||
+      (typeof v === 'string' && !isReference(v))
+    return plain(variables[key]) && (mode === 'define' || plain(overrides[key]))
+  }
+
+  /** Define mode: no backend is null, which the engine skips - an empty
+   * string would reach diffusers as a backend name. Override mode keeps ''
+   * meaning "use the workflow default". */
+  function commitBackend(key: string, raw: string) {
+    if (mode === 'define' && raw === '') variables[key] = null
+    else commit(key, raw)
+  }
+
   function commit(key: string, raw: string) {
     if (mode === 'override') {
       overrides[key] = raw
@@ -69,17 +96,40 @@
   {#each keys as key (key)}
     <label for={idPrefix + key}>{key}</label>
     <div class="field">
-      <ExpandingText
-        id={idPrefix + key}
-        value={shown(key)}
-        placeholder={mode === 'override' ? displayValue(variables[key]) : ''}
-        refStyle={isReference(effective(key))}
-        complete={(text) => referenceCompletions(text)}
-        title={promptTooltip(effective(key), promptLibrary.texts)}
-        oninput={(raw) => draft(key, raw)}
-        onchange={(raw) => commit(key, raw)}
-        onpromptpick={(name) => commit(key, reference(PROMPT, name))}
-      />
+      {#if isBackendSelect(key)}
+        {@const current = shown(key)}
+        <select
+          id={idPrefix + key}
+          value={current}
+          onchange={(e) => commitBackend(key, e.currentTarget.value)}
+        >
+          <option value="">
+            {mode === 'override'
+              ? `default (${displayValue(variables[key]) || 'none'})`
+              : 'default (none)'}
+          </option>
+          {#if current && !attentionBackends.list.includes(current)}
+            <option value={current}>
+              {current} (not available on this server)
+            </option>
+          {/if}
+          {#each attentionBackends.list as backend (backend)}
+            <option value={backend}>{backend}</option>
+          {/each}
+        </select>
+      {:else}
+        <ExpandingText
+          id={idPrefix + key}
+          value={shown(key)}
+          placeholder={mode === 'override' ? displayValue(variables[key]) : ''}
+          refStyle={isReference(effective(key))}
+          complete={(text) => referenceCompletions(text)}
+          title={promptTooltip(effective(key), promptLibrary.texts)}
+          oninput={(raw) => draft(key, raw)}
+          onchange={(raw) => commit(key, raw)}
+          onpromptpick={(name) => commit(key, reference(PROMPT, name))}
+        />
+      {/if}
       <BrowseButton
         value={effective(key)}
         onpick={(value) => commit(key, value)}
diff --git a/ui/src/lib/editor/VariablesForm.test.ts b/ui/src/lib/editor/VariablesForm.test.ts
new file mode 100644
index 00000000..8c527294
--- /dev/null
+++ b/ui/src/lib/editor/VariablesForm.test.ts
@@ -0,0 +1,106 @@
+import { describe, expect, it, afterEach } from 'vitest'
+import { render, screen, fireEvent, cleanup } from '@testing-library/svelte'
+import VariablesForm from './VariablesForm.svelte'
+import { attentionBackends } from '../attentionBackends.svelte'
+
+afterEach(() => {
+  cleanup()
+  attentionBackends.list = []
+})
+
+const props = (over: Record<string, unknown> = {}) => ({
+  mode: 'define' as const,
+  variables: { attn: '' } as Record<string, unknown>,
+  idPrefix: 'v-',
+  backendVariables: new Set(['attn']),
+  ...over,
+})
+
+describe('VariablesForm attention backend variables', () => {
+  it('renders a select with default (none) plus the server list', () => {
+    attentionBackends.list = ['native', 'sparse']
+    render(VariablesForm, props())
+    const select = screen.getByRole('combobox')
+    expect(select.tagName).toBe('SELECT')
+    expect(
+      Array.from(select.querySelectorAll('option')).map((o) => o.textContent),
+    ).toEqual(['default (none)', 'native', 'sparse'])
+  })
+
+  it('keeps a current value the server does not list, marked unavailable', () => {
+    attentionBackends.list = ['native']
+    render(VariablesForm, props({ variables: { attn: 'sage_hub' } }))
+    const select = screen.getByRole('combobox') as HTMLSelectElement
+    expect(select.value).toBe('sage_hub')
+    expect(
+      screen.getByText('sage_hub (not available on this server)'),
+    ).toBeTruthy()
+  })
+
+  it('falls back to the text field when the server list is empty', () => {
+    attentionBackends.list = []
+    render(VariablesForm, props())
+    expect(screen.queryByRole('combobox', { name: '' })).toBeNull()
+    expect(document.querySelector('select')).toBeNull()
+  })
+
+  it('falls back to the text field for a reference or non-string value', () => {
+    attentionBackends.list = ['native']
+    render(
+      VariablesForm,
+      props({
+        variables: { attn: 'variable:other', n: 3 },
+        backendVariables: new Set(['attn', 'n']),
+      }),
+    )
+    expect(document.querySelector('select')).toBeNull()
+  })
+
+  it('does not turn other variables into selects', () => {
+    attentionBackends.list = ['native']
+    render(VariablesForm, props({ variables: { prompt: 'a cat' } }))
+    expect(document.querySelector('select')).toBeNull()
+  })
+
+  it('in override mode shows the workflow default and writes the choice', async () => {
+    attentionBackends.list = ['native', 'sparse']
+    const overrides: Record<string, string> = {}
+    render(
+      VariablesForm,
+      props({ mode: 'override', variables: { attn: 'sparse' }, overrides }),
+    )
+    const select = screen.getByRole('combobox') as HTMLSelectElement
+    expect(select.value).toBe('')
+    expect(screen.getByText('default (sparse)')).toBeTruthy()
+    await fireEvent.change(select, { target: { value: 'native' } })
+    expect(overrides.attn).toBe('native')
+  })
+
+  it('in define mode writes the choice to the variable', async () => {
+    attentionBackends.list = ['native', 'sparse']
+    const variables: Record<string, unknown> = { attn: '' }
+    render(VariablesForm, props({ variables }))
+    await fireEvent.change(screen.getByRole('combobox'), {
+      target: { value: 'sparse' },
+    })
+    expect(variables.attn).toBe('sparse')
+  })
+
+  it('in define mode, default (none) writes null, not an empty string', async () => {
+    attentionBackends.list = ['native', 'sparse']
+    const variables: Record<string, unknown> = { attn: 'sparse' }
+    render(VariablesForm, props({ variables }))
+    await fireEvent.change(screen.getByRole('combobox'), {
+      target: { value: '' },
+    })
+    expect(variables.attn).toBeNull()
+  })
+
+  it('renders a null default as a select with default (none) selected', () => {
+    attentionBackends.list = ['native']
+    render(VariablesForm, props({ variables: { attn: null } }))
+    const select = screen.getByRole('combobox') as HTMLSelectElement
+    expect(select.value).toBe('')
+    expect(select.selectedOptions[0].textContent).toBe('default (none)')
+  })
+})
diff --git a/ui/src/lib/generated/api-schema.ts b/ui/src/lib/generated/api-schema.ts
index bd0bd948..1a97f4cf 100644
--- a/ui/src/lib/generated/api-schema.ts
+++ b/ui/src/lib/generated/api-schema.ts
@@ -2487,6 +2487,11 @@ export interface components {
         };
         /** HealthInfo */
         HealthInfo: {
+            /**
+             * Attention Backends
+             * @description Attention backends this server's device can run, for the UI's dropdown; 'sparse' only where comfy-kitchen's compiled kernels loaded
+             */
+            attention_backends?: string[];
             /**
              * Current Job
              * @description The longest-running job; `workers` names every running one.
diff --git a/ui/src/lib/generated/openapi.json b/ui/src/lib/generated/openapi.json
index 949dd149..d3148376 100644
--- a/ui/src/lib/generated/openapi.json
+++ b/ui/src/lib/generated/openapi.json
@@ -1557,6 +1557,14 @@
       "HealthInfo": {
         "additionalProperties": false,
         "properties": {
+          "attention_backends": {
+            "description": "Attention backends this server's device can run, for the UI's dropdown; 'sparse' only where comfy-kitchen's compiled kernels loaded",
+            "items": {
+              "type": "string"
+            },
+            "title": "Attention Backends",
+            "type": "array"
+          },
           "current_job": {
             "anyOf": [
               {
diff --git a/ui/src/lib/pages/EditorPage.svelte b/ui/src/lib/pages/EditorPage.svelte
index 18545855..d7cdc7fb 100644
--- a/ui/src/lib/pages/EditorPage.svelte
+++ b/ui/src/lib/pages/EditorPage.svelte
@@ -23,7 +23,11 @@
   import { go, goWs } from '../router.svelte'
   import { wsHref } from '../routes'
   import { loadWorkspaces, workspace } from '../workspace.svelte'
-  import { emptyWorkflow, referenceSuggestions } from '../editor'
+  import {
+    attentionBackendVariables,
+    emptyWorkflow,
+    referenceSuggestions,
+  } from '../editor'
   import { danglingReferenceDetails, flowGraph } from '../flow'
   import { groupOf, leafOf } from '../grouping'
   import { loadPromptLibrary, promptLibrary } from '../promptlib.svelte'
@@ -451,6 +455,7 @@
           mode="define"
           bind:variables={ed.doc.variables}
           idPrefix="wfvar-"
+          backendVariables={attentionBackendVariables(ed.doc)}
         />
       </div>
 
diff --git a/ui/src/lib/pages/WorkflowPage.svelte b/ui/src/lib/pages/WorkflowPage.svelte
index c43bbb13..652c8eef 100644
--- a/ui/src/lib/pages/WorkflowPage.svelte
+++ b/ui/src/lib/pages/WorkflowPage.svelte
@@ -3,6 +3,7 @@
   import DownloadLink from '../DownloadLink.svelte'
   import JsonEditor from '../editor/JsonEditor.svelte'
   import VariablesForm from '../editor/VariablesForm.svelte'
+  import { attentionBackendVariables } from '../editor'
   import { api } from '../api'
   import { goWs, route } from '../router.svelte'
   import { leafOf } from '../grouping'
@@ -244,6 +245,7 @@
         variables={workflow.variables ?? {}}
         bind:overrides
         idPrefix="var-"
+        backendVariables={attentionBackendVariables(workflow)}
       />
     </div>
   {:else}
diff --git a/workflows/models/flux3-klein.json b/workflows/models/flux3-klein.json
new file mode 100644
index 00000000..1bf5457c
--- /dev/null
+++ b/workflows/models/flux3-klein.json
@@ -0,0 +1,70 @@
+{
+    "id": "flux3-klein",
+    "description": "FLUX 3 Image Klein (distilled, 5.6B) as a model entry, configured by the text-to-image template. The prompt here is a short one, and Klein turns a short prompt into a generic picture: for full captions run templates/flux3/upsample-then-generate. Sixteen steps with no guidance or negative prompt. The weights are gated under the FLUX Kommunity License: accept it on the model page and log in with hf auth login first.",
+    "configures": "templates/text-to-image",
+    "cost_drivers": [
+        "num_images_per_prompt",
+        "width",
+        "height"
+    ],
+    "variables": {
+        "prompt": "an apple",
+        "num_images_per_prompt": 1,
+        "width": 1024,
+        "height": 1024,
+        "seed": null
+    },
+    "seed": "variable:seed",
+    "steps": [
+        {
+            "name": "text_to_image",
+            "pipeline": {
+                "configuration": {
+                    "component_type": "ModularPipeline",
+                    "load_components": {
+                        "dtype": "torch.bfloat16"
+                    },
+                    "components": {
+                        "transformer": {
+                            "device": "cuda"
+                        },
+                        "text_encoder": {
+                            "device": "cuda"
+                        },
+                        "vae": {
+                            "device": "cuda"
+                        }
+                    }
+                },
+                "from_pretrained_arguments": {
+                    "model_name": "black-forest-labs/flux-3-image-klein"
+                },
+                "arguments": {
+                    "prompt": "variable:prompt",
+                    "width": "variable:width",
+                    "height": "variable:height",
+                    "num_inference_steps": 16,
+                    "output": "images",
+                    "num_images_per_prompt": "variable:num_images_per_prompt"
+                }
+            },
+            "result": {
+                "content_type": "image/jpeg",
+                "embed_metadata": true,
+                "subfolder": "final"
+            }
+        }
+    ],
+    "variable_constraints": {
+        "width": {
+            "modulus": 16,
+            "remainder": 0,
+            "reason": "FLUX 3 Image Klein's pipeline refuses a width not divisible by 16 (the VAE's 8x compression times the 2x2 latent packing), and only after the weights have loaded, so it is checked here first"
+        },
+        "height": {
+            "modulus": 16,
+            "remainder": 0,
+            "reason": "FLUX 3 Image Klein's pipeline refuses a height not divisible by 16 (the VAE's 8x compression times the 2x2 latent packing), and only after the weights have loaded, so it is checked here first"
+        }
+    }
+}
diff --git a/workflows/templates/flux3/README.md b/workflows/templates/flux3/README.md
new file mode 100644
index 00000000..63326842
--- /dev/null
+++ b/workflows/templates/flux3/README.md
@@ -0,0 +1,74 @@
+# FLUX 3 Image Klein workflows
+
+Text-to-image, image editing and multi-reference generation with Black Forest Labs'
+[FLUX 3 Image Klein](https://huggingface.co/black-forest-labs/flux-3-image-klein): a
+5.6B distilled flow map that draws in 16 steps with no guidance scale and no negative
+prompt. It pairs the FLUX.2 VAE with a Qwen3-VL-4B text encoder. The weights are gated
+under the FLUX Kommunity License: accept it on the model page and run `hf auth login`
+before the first download.
+
+Settings come from the Hugging Face card, BFL's
+[flux-3-image-klein](https://github.com/black-forest-labs/flux-3-image-klein)
+repository, [docs.bfl.ml](https://docs.bfl.ml) and the diffusers pipeline source
+(`diffusers.modular_pipelines.flux3`, merged on 2026-10-15 and not yet in a release).
+These templates need diffusers installed from git. Audited against those sources on
+2026-10-15 ([the audit](../../../docs/proposals/audits/2026-10-15-flux-3-klein-audit.md)).
+
+Klein was trained on long captions written by BFL's prompt upsampler, and BFL says not
+to use it without one: a short prompt turns into a generic picture. The two upsampler
+builtins (`flux3_klein_upsample` and `flux3_klein_upsample_edit`) run BFL's
+`flux-3-image-klein-pup` for you, and the system prompts they give it are BFL's own,
+read from the pup repository at a pinned commit (see below). To write a caption by hand,
+read BFL's [prompting guide](https://docs.bfl.ml/guides/prompting_summary). It is
+written for the API model, which upsamples on the server side, so treat it as a
+description of the target caption and not as advice for a short prompt.
+
+An agent driving this family from Claude Code has the `flux3-klein` skill of the
+[dw plugin](../../../plugins/dw/README.md), which chooses between these templates and
+states the family's rules.
+
+Read them in this order and each introduces one new idea on top of the last.
+
+## The templates
+
+| Example | What it introduces |
+| ------- | ------------------ |
+| [text-to-image.json](text-to-image.json) | The baseline. The prompt is already a full upsampled caption (BFL's man-walking-a-dog example), 16 steps, no guidance. Width and height must be multiples of 16, and the pipeline only complains after the load, so the workflow declares that rule up front. BFL states sides of 64 to 4096; that range is not checked. 24 s on an RTX 3090 at 1024x1024 (0.8 s/step), peaking at 22.1GB reserved |
+| [upsample-then-generate.json](upsample-then-generate.json) | A short request becomes a caption first: the pup upsampler writes it, `release_models` frees the upsampler (about 18GB), and Klein draws from the result. The caption is saved as an intermediate, so it can be read, edited or reused as the prompt of text-to-image |
+| [image-edit.json](image-edit.json) | One reference and an instruction. The upsampler sees the same image as the pipeline. With no width or height the output is 1 MP at the reference's aspect ratio, on the 16-pixel grid |
+| [multi-reference.json](multi-reference.json) | Several references, in order. A caption written by hand names them `<ref_image_0>`, `<ref_image_1>` and so on (zero-based). The first reference sets the aspect ratio. BFL trained on up to 10; the pipeline does not enforce that, so more than 10 run but are outside what the model learned. Two references ran in 45 s on an RTX 3090 (2.6 s/step, references add tokens), also peaking at 22.1GB reserved |
+| [layout-boxes.json](layout-boxes.json) | Placement by box. Elements are tagged `<id>` in the prose, and a JSON table gives each id a `[top, left, bottom, right]` box on a 0 to 1000 grid. Boxes are hints, not masks: a small boxed element may not appear, and elements can run past their box |
+
+## dw craft, not vendor guidance
+
+Three things in these templates are this repository's choices. BFL does not say them.
+
+**Every component is placed explicitly.** Each of the transformer, text encoder and VAE
+carries a `device`. The modular pipeline's execution device is its first model
+component's device, so a component left unplaced stays on the CPU, and the pipeline then
+encodes the prompt and draws its noise there. The failures looked like `index is on cpu`
+in the text encoder, and `Cannot generate a cpu tensor from a generator of type cuda`.
+`residency: on_demand` on the text encoder breaks for the same reason, because the
+encoder step moves `input_ids` to the execution device before the wrapper moves the
+weights. The weights are about 19GB in bf16, so with everything resident a 24GB card
+fits 1024x1024 with under 2GB to spare. A larger output, or several references, wants
+the VAE on demand or a quantized transformer, and neither has been measured yet.
+
+**The upsampler is released before Klein loads.** The pup (Qwen3.5-9B, Apache-2.0,
+ungated) is about 18GB and Klein about 19GB, which do not fit a 24GB card together. The
+upsample step sets `release_models`, and the generation step loads after it.
+
+**The upsampler's system prompts are read from the Hub at a pinned commit.** BFL's
+prompts are in the pup repository's `system_prompts.json` and are still changing, so the
+builtins name the file, the key and a full 40-character revision through the
+`system_prompt.from_hub` form of `text_generation`, and never carry a copy. A template
+runs the same text until someone re-pins it. The builtins also turn the chat template's
+thinking mode off, which BFL's usage assumes.
+
+## Not here yet
+
+These follow-ups are dated 2026-10-15 and are in the audit's reading order:
+- The base (non-distilled) checkpoint with classifier-free guidance, which needs the modular `guider` to be reachable from a workflow.
+- Upsampled layout boxes from a short request (BFL's `t2i_bbox`), which need BFL's box planning and reconciling code.
+- LoRA, a typography template, the fp8 and NVFP4 checkpoints (fused only on Ada and Blackwell cards), and a measurement on Apple Silicon.
+- Re-pinning the system prompts when diffusers PR #15058, which carries them, merges.
diff --git a/workflows/templates/flux3/image-edit.json b/workflows/templates/flux3/image-edit.json
new file mode 100644
index 00000000..c94480dd
--- /dev/null
+++ b/workflows/templates/flux3/image-edit.json
@@ -0,0 +1,73 @@
+{
+    "id": "Flux3KleinImageEdit",
+    "description": "FLUX 3 Image Klein image edit: BFL's prompt upsampler reads the reference and the instruction and writes the caption Klein was trained on, then Klein edits the reference by that caption. The upsampler sees the same reference as the pipeline, and is freed (release_models) before Klein loads. The caption is saved as an intermediate. Width and height are left unset, so the output defaults to 1 MP at the reference's aspect ratio, rounded to the 16-pixel grid. Family rules (16 steps, no guidance, component placement, the gated license) are as in text-to-image.json.",
+    "summary": "FLUX 3 Klein edit of one picture, the instruction expanded by BFL's upsampler first.",
+    "cost_drivers": [
+        "image"
+    ],
+    "variables": {
+        "instruction": "put a red bandana around the dog's neck",
+        "image": {
+            "location": "https://raw.githubusercontent.com/black-forest-labs/flux-3-image-klein/bbfe317dd81c825c30d76090a67d3d0db51da3cc/examples/inputs/3.png"
+        },
+        "seed": 22
+    },
+    "seed": "variable:seed",
+    "steps": [
+        {
+            "name": "upsample",
+            "release_models": true,
+            "workflow": {
+                "path": "builtin:flux3_klein_upsample_edit.json",
+                "arguments": {
+                    "instruction": "variable:instruction",
+                    "images": [
+                        "variable:image"
+                    ]
+                }
+            },
+            "result": {
+                "content_type": "text/plain",
+                "subfolder": "intermediate"
+            }
+        },
+        {
+            "name": "edit",
+            "pipeline": {
+                "configuration": {
+                    "component_type": "ModularPipeline",
+                    "load_components": {
+                        "dtype": "torch.bfloat16"
+                    },
+                    "components": {
+                        "transformer": {
+                            "device": "cuda"
+                        },
+                        "text_encoder": {
+                            "device": "cuda"
+                        },
+                        "vae": {
+                            "device": "cuda"
+                        }
+                    }
+                },
+                "from_pretrained_arguments": {
+                    "model_name": "black-forest-labs/flux-3-image-klein"
+                },
+                "arguments": {
+                    "prompt": "previous_result:upsample",
+                    "image": [
+                        "variable:image"
+                    ],
+                    "num_inference_steps": 16,
+                    "output": "images"
+                }
+            },
+            "result": {
+                "content_type": "image/jpeg",
+                "embed_metadata": true,
+                "subfolder": "final"
+            }
+        }
+    ]
+}
diff --git a/workflows/templates/flux3/layout-boxes.json b/workflows/templates/flux3/layout-boxes.json
new file mode 100644
index 00000000..3a0ec424
--- /dev/null
+++ b/workflows/templates/flux3/layout-boxes.json
@@ -0,0 +1,67 @@
+{
+    "id": "Flux3KleinLayoutBoxes",
+    "summary": "FLUX 3 Klein image placed by a caption with layout boxes (BFL's balloons example).",
+    "description": "FLUX 3 Image Klein text to image from a caption with layout boxes: the prose tags each element as <id>, and a JSON table gives every id a bbox as [top, left, bottom, right] on a 0 to 1000 grid plus a description. The caption here is BFL's own upsampled balloons example, used as written; upsampling boxes from a short request is not covered yet. Boxes are hints, not masks: a small boxed element may not appear, and elements can run past their box. The family rules for steps, guidance, size, placement and the license are in text-to-image.",
+    "cost_drivers": [
+        "width",
+        "height"
+    ],
+    "variables": {
+        "prompt": "prompt:flux3/balloons_layout",
+        "width": 1024,
+        "height": 1024,
+        "seed": 1
+    },
+    "variable_constraints": {
+        "width": {
+            "modulus": 16,
+            "remainder": 0,
+            "reason": "FLUX 3 Image Klein's pipeline refuses a width not divisible by 16 (the VAE's 8x compression times the 2x2 latent packing), and only after the weights have loaded, so it is checked here first"
+        },
+        "height": {
+            "modulus": 16,
+            "remainder": 0,
+            "reason": "FLUX 3 Image Klein's pipeline refuses a height not divisible by 16 (the VAE's 8x compression times the 2x2 latent packing), and only after the weights have loaded, so it is checked here first"
+        }
+    },
+    "seed": "variable:seed",
+    "steps": [
+        {
+            "name": "layout_to_image",
+            "pipeline": {
+                "configuration": {
+                    "component_type": "ModularPipeline",
+                    "load_components": {
+                        "dtype": "torch.bfloat16"
+                    },
+                    "components": {
+                        "transformer": {
+                            "device": "cuda"
+                        },
+                        "text_encoder": {
+                            "device": "cuda"
+                        },
+                        "vae": {
+                            "device": "cuda"
+                        }
+                    }
+                },
+                "from_pretrained_arguments": {
+                    "model_name": "black-forest-labs/flux-3-image-klein"
+                },
+                "arguments": {
+                    "prompt": "variable:prompt",
+                    "width": "variable:width",
+                    "height": "variable:height",
+                    "num_inference_steps": 16,
+                    "output": "images"
+                }
+            },
+            "result": {
+                "content_type": "image/jpeg",
+                "embed_metadata": true,
+                "subfolder": "final"
+            }
+        }
+    ]
+}
diff --git a/workflows/templates/flux3/multi-reference.json b/workflows/templates/flux3/multi-reference.json
new file mode 100644
index 00000000..76e86780
--- /dev/null
+++ b/workflows/templates/flux3/multi-reference.json
@@ -0,0 +1,74 @@
+{
+    "id": "Flux3KleinMultiReference",
+    "description": "FLUX 3 Image Klein with several references: BFL's prompt upsampler reads every reference in order and the instruction, writes the caption, then Klein draws from the caption and the references. The upsampler sees the same references as the pipeline. In a caption written by hand, name them <ref_image_0>, <ref_image_1> and so on (zero-based); the upsampler's own wording is the first image, the second image. The first reference sets the output's aspect ratio, at 1 MP by default. BFL trained Klein on up to 10 references; the pipeline does not enforce that cap, so more than 10 references run but are outside what the model learned. Family rules (16 steps, no guidance, component placement, the gated license) are as in text-to-image.json.",
+    "summary": "FLUX 3 Klein edit from several reference pictures, expanded by BFL's upsampler first.",
+    "cost_drivers": [
+        "images"
+    ],
+    "variables": {
+        "instruction": "print the dog from the second image onto the mug",
+        "images": [
+            {
+                "location": "https://raw.githubusercontent.com/black-forest-labs/flux-3-image-klein/bbfe317dd81c825c30d76090a67d3d0db51da3cc/examples/inputs/2.png"
+            },
+            {
+                "location": "https://raw.githubusercontent.com/black-forest-labs/flux-3-image-klein/bbfe317dd81c825c30d76090a67d3d0db51da3cc/examples/inputs/3.png"
+            }
+        ],
+        "seed": 23
+    },
+    "seed": "variable:seed",
+    "steps": [
+        {
+            "name": "upsample",
+            "release_models": true,
+            "workflow": {
+                "path": "builtin:flux3_klein_upsample_edit.json",
+                "arguments": {
+                    "instruction": "variable:instruction",
+                    "images": "variable:images"
+                }
+            },
+            "result": {
+                "content_type": "text/plain",
+                "subfolder": "intermediate"
+            }
+        },
+        {
+            "name": "edit",
+            "pipeline": {
+                "configuration": {
+                    "component_type": "ModularPipeline",
+                    "load_components": {
+                        "dtype": "torch.bfloat16"
+                    },
+                    "components": {
+                        "transformer": {
+                            "device": "cuda"
+                        },
+                        "text_encoder": {
+                            "device": "cuda"
+                        },
+                        "vae": {
+                            "device": "cuda"
+                        }
+                    }
+                },
+                "from_pretrained_arguments": {
+                    "model_name": "black-forest-labs/flux-3-image-klein"
+                },
+                "arguments": {
+                    "prompt": "previous_result:upsample",
+                    "image": "variable:images",
+                    "num_inference_steps": 16,
+                    "output": "images"
+                }
+            },
+            "result": {
+                "content_type": "image/jpeg",
+                "embed_metadata": true,
+                "subfolder": "final"
+            }
+        }
+    ]
+}
diff --git a/workflows/templates/flux3/text-to-image.json b/workflows/templates/flux3/text-to-image.json
new file mode 100644
index 00000000..2498f8c4
--- /dev/null
+++ b/workflows/templates/flux3/text-to-image.json
@@ -0,0 +1,66 @@
+{
+    "id": "Flux3KleinT2I",
+    "description": "FLUX 3 Image Klein (distilled, 5.6B) text to image, the baseline of the FLUX 3 templates. The prompt here is already a full caption - BFL's own upsampled caption for their man walking a dog example - because Klein was trained on long upsampler captions and turns short prompts into generic pictures; upsample-then-generate shows how to get one from a short request. Sixteen steps with no guidance: the distilled model is a flow map, so it takes no guidance scale and no negative prompt. Width and height must be multiples of 16, which the workflow declares; BFL states sides of 64 to 4096, which is not checked. Every component is placed on the GPU explicitly, about 19 GB of bf16 weights, which fits a 24 GB card at 1024x1024 with under 2 GB to spare. The weights are gated under the FLUX Kommunity License: accept it on the model page and log in with hf auth login first.",
+    "cost_drivers": [
+        "width",
+        "height"
+    ],
+    "variables": {
+        "prompt": "prompt:flux3/man_dog",
+        "width": 1024,
+        "height": 1024,
+        "seed": 7
+    },
+    "variable_constraints": {
+        "width": {
+            "modulus": 16,
+            "remainder": 0,
+            "reason": "FLUX 3 Image Klein's pipeline refuses a width not divisible by 16 (the VAE's 8x compression times the 2x2 latent packing), and only after the weights have loaded, so it is checked here first"
+        },
+        "height": {
+            "modulus": 16,
+            "remainder": 0,
+            "reason": "FLUX 3 Image Klein's pipeline refuses a height not divisible by 16 (the VAE's 8x compression times the 2x2 latent packing), and only after the weights have loaded, so it is checked here first"
+        }
+    },
+    "seed": "variable:seed",
+    "steps": [
+        {
+            "name": "text_to_image",
+            "pipeline": {
+                "configuration": {
+                    "component_type": "ModularPipeline",
+                    "load_components": {
+                        "dtype": "torch.bfloat16"
+                    },
+                    "components": {
+                        "transformer": {
+                            "device": "cuda"
+                        },
+                        "text_encoder": {
+                            "device": "cuda"
+                        },
+                        "vae": {
+                            "device": "cuda"
+                        }
+                    }
+                },
+                "from_pretrained_arguments": {
+                    "model_name": "black-forest-labs/flux-3-image-klein"
+                },
+                "arguments": {
+                    "prompt": "variable:prompt",
+                    "width": "variable:width",
+                    "height": "variable:height",
+                    "num_inference_steps": 16,
+                    "output": "images"
+                }
+            },
+            "result": {
+                "content_type": "image/jpeg",
+                "embed_metadata": true,
+                "subfolder": "final"
+            }
+        }
+    ]
+}
diff --git a/workflows/templates/flux3/upsample-then-generate.json b/workflows/templates/flux3/upsample-then-generate.json
new file mode 100644
index 00000000..f9d8e5e8
--- /dev/null
+++ b/workflows/templates/flux3/upsample-then-generate.json
@@ -0,0 +1,81 @@
+{
+    "id": "Flux3KleinUpsampleThenGenerate",
+    "description": "FLUX 3 Image Klein from a short request, the way Black Forest Labs say to run it: their prompt upsampler first expands the request into the long caption Klein was trained on, then Klein draws from that caption. The upsampler is about 18 GB and Klein about 19 GB in bf16, which do not fit a 24 GB card together, so the upsample step sets release_models and the upsampler is freed before Klein loads. The caption is saved as an intermediate so it can be read, edited or reused as the prompt of text-to-image without paying for the upsampler again. Sixteen steps with no guidance or negative prompt, as the distilled model takes neither. Width and height must be multiples of 16, which the workflow declares; BFL states sides of 64 to 4096, which is not checked. The weights are gated under the FLUX Kommunity License: accept it on the model page and log in with hf auth login first.",
+    "summary": "FLUX 3 Klein image from a short request, expanded by BFL's upsampler first.",
+    "cost_drivers": [
+        "width",
+        "height"
+    ],
+    "variables": {
+        "request": "A man walking with his dog, afternoon sun",
+        "width": 1024,
+        "height": 1024,
+        "seed": 7
+    },
+    "variable_constraints": {
+        "width": {
+            "modulus": 16,
+            "remainder": 0,
+            "reason": "FLUX 3 Image Klein's pipeline refuses a width not divisible by 16 (the VAE's 8x compression times the 2x2 latent packing), and only after the weights have loaded, so it is checked here first"
+        },
+        "height": {
+            "modulus": 16,
+            "remainder": 0,
+            "reason": "FLUX 3 Image Klein's pipeline refuses a height not divisible by 16 (the VAE's 8x compression times the 2x2 latent packing), and only after the weights have loaded, so it is checked here first"
+        }
+    },
+    "seed": "variable:seed",
+    "steps": [
+        {
+            "name": "upsample",
+            "release_models": true,
+            "workflow": {
+                "path": "builtin:flux3_klein_upsample.json",
+                "arguments": {
+                    "prompt": "variable:request"
+                }
+            },
+            "result": {
+                "content_type": "text/plain",
+                "subfolder": "intermediate"
+            }
+        },
+        {
+            "name": "text_to_image",
+            "pipeline": {
+                "configuration": {
+                    "component_type": "ModularPipeline",
+                    "load_components": {
+                        "dtype": "torch.bfloat16"
+                    },
+                    "components": {
+                        "transformer": {
+                            "device": "cuda"
+                        },
+                        "text_encoder": {
+                            "device": "cuda"
+                        },
+                        "vae": {
+                            "device": "cuda"
+                        }
+                    }
+                },
+                "from_pretrained_arguments": {
+                    "model_name": "black-forest-labs/flux-3-image-klein"
+                },
+                "arguments": {
+                    "prompt": "previous_result:upsample",
+                    "width": "variable:width",
+                    "height": "variable:height",
+                    "num_inference_steps": 16,
+                    "output": "images"
+                }
+            },
+            "result": {
+                "content_type": "image/jpeg",
+                "embed_metadata": true,
+                "subfolder": "final"
+            }
+        }
+    ]
+}
diff --git a/workflows/templates/minimax/chain-matched-and-aligned.json b/workflows/templates/minimax/chain-matched-and-aligned.json
index 1e209abf..73956613 100644
--- a/workflows/templates/minimax/chain-matched-and-aligned.json
+++ b/workflows/templates/minimax/chain-matched-and-aligned.json
@@ -45,7 +45,9 @@
         "lora_weight_name": "minimax_h3_ref2v_turbo_8step_v1.0_768p_bf16.safetensors",
         "lora_adapter_name": "turbo",
         "seed": 12345,
-        "attention_backend": null,
+        "attention_backend": "sparse",
+        "sparse_tau": 0.5,
+        "sparse_topk": 0.15,
         "cache": null
     },
     "variable_constraints": {
@@ -136,6 +138,8 @@
                     "components": {
                         "transformer_ref": {
                             "attention_backend": "variable:attention_backend",
+                            "sparse_tau": "variable:sparse_tau",
+                            "sparse_topk": "variable:sparse_topk",
                             "group_offload": {
                                 "offload_type": "block_level",
                                 "num_blocks_per_group": 1,
diff --git a/workflows/templates/minimax/chain-matched-to-audio.json b/workflows/templates/minimax/chain-matched-to-audio.json
index 990b4f13..bd1cc527 100644
--- a/workflows/templates/minimax/chain-matched-to-audio.json
+++ b/workflows/templates/minimax/chain-matched-to-audio.json
@@ -41,7 +41,9 @@
         "weights_dtype": "{int4}",
         "hold_audio": null,
         "seed": null,
-        "attention_backend": null,
+        "attention_backend": "sparse",
+        "sparse_tau": 0.5,
+        "sparse_topk": 0.15,
         "cache": null
     },
     "variable_constraints": {
@@ -133,6 +135,8 @@
                     "components": {
                         "transformer_ref": {
                             "attention_backend": "variable:attention_backend",
+                            "sparse_tau": "variable:sparse_tau",
+                            "sparse_topk": "variable:sparse_topk",
                             "group_offload": {
                                 "offload_type": "block_level",
                                 "num_blocks_per_group": 1,
diff --git a/workflows/templates/minimax/chain-video-continuity.json b/workflows/templates/minimax/chain-video-continuity.json
index 31cbf738..6be31a4f 100644
--- a/workflows/templates/minimax/chain-video-continuity.json
+++ b/workflows/templates/minimax/chain-video-continuity.json
@@ -45,7 +45,9 @@
         "lora_adapter_name": "turbo",
         "weights_dtype": "{int4}",
         "seed": 12345,
-        "attention_backend": null,
+        "attention_backend": "sparse",
+        "sparse_tau": 0.5,
+        "sparse_topk": 0.15,
         "cache": null
     },
     "variable_constraints": {
@@ -136,6 +138,8 @@
                     "components": {
                         "transformer_ref": {
                             "attention_backend": "variable:attention_backend",
+                            "sparse_tau": "variable:sparse_tau",
+                            "sparse_topk": "variable:sparse_topk",
                             "group_offload": {
                                 "offload_type": "block_level",
                                 "num_blocks_per_group": 1,
diff --git a/workflows/templates/minimax/chained-segments.json b/workflows/templates/minimax/chained-segments.json
index 9f171f61..eb480646 100644
--- a/workflows/templates/minimax/chained-segments.json
+++ b/workflows/templates/minimax/chained-segments.json
@@ -54,7 +54,9 @@
         "lora_weight_name": "minimax_h3_fl2v_turbo_4step_v1.2_768p_bf16.safetensors",
         "lora_adapter_name": "turbo",
         "seed": null,
-        "attention_backend": null,
+        "attention_backend": "sparse",
+        "sparse_tau": 0.5,
+        "sparse_topk": 0.15,
         "cache": null
     },
     "variable_constraints": {
@@ -146,6 +148,8 @@
                     "components": {
                         "transformer": {
                             "attention_backend": "variable:attention_backend",
+                            "sparse_tau": "variable:sparse_tau",
+                            "sparse_topk": "variable:sparse_topk",
                             "group_offload": {
                                 "offload_type": "block_level",
                                 "num_blocks_per_group": 2,
diff --git a/workflows/templates/minimax/composable-references.json b/workflows/templates/minimax/composable-references.json
index c39c1559..2eb82826 100644
--- a/workflows/templates/minimax/composable-references.json
+++ b/workflows/templates/minimax/composable-references.json
@@ -41,7 +41,9 @@
         "lora_adapter_name": "turbo",
         "weights_dtype": "{int4}",
         "seed": 12345,
-        "attention_backend": null,
+        "attention_backend": "sparse",
+        "sparse_tau": 0.5,
+        "sparse_topk": 0.15,
         "cache": null
     },
     "variable_constraints": {
@@ -132,6 +134,8 @@
                     "components": {
                         "transformer_ref": {
                             "attention_backend": "variable:attention_backend",
+                            "sparse_tau": "variable:sparse_tau",
+                            "sparse_topk": "variable:sparse_topk",
                             "group_offload": {
                                 "offload_type": "block_level",
                                 "num_blocks_per_group": 1,
diff --git a/workflows/templates/minimax/dialogue-short.json b/workflows/templates/minimax/dialogue-short.json
index 2038241c..e37e0273 100644
--- a/workflows/templates/minimax/dialogue-short.json
+++ b/workflows/templates/minimax/dialogue-short.json
@@ -148,7 +148,9 @@
         "lora_weight_name": "minimax_h3_ref2v_turbo_8step_v1.0_768p_bf16.safetensors",
         "lora_adapter_name": "turbo",
         "seed": 42,
-        "attention_backend": null,
+        "attention_backend": "sparse",
+        "sparse_tau": 0.5,
+        "sparse_topk": 0.15,
         "cache": null
     },
     "variable_constraints": {
@@ -297,6 +299,8 @@
                     "components": {
                         "transformer_ref": {
                             "attention_backend": "variable:attention_backend",
+                            "sparse_tau": "variable:sparse_tau",
+                            "sparse_topk": "variable:sparse_topk",
                             "group_offload": {
                                 "offload_type": "block_level",
                                 "num_blocks_per_group": 1,
diff --git a/workflows/templates/minimax/enhance-prompt-with-image.json b/workflows/templates/minimax/enhance-prompt-with-image.json
index 3abfa59b..9aa1bdf5 100644
--- a/workflows/templates/minimax/enhance-prompt-with-image.json
+++ b/workflows/templates/minimax/enhance-prompt-with-image.json
@@ -32,7 +32,9 @@
         "lora_weight_name": "minimax_h3_fl2v_turbo_4step_v1.2_768p_bf16.safetensors",
         "lora_adapter_name": "turbo",
         "seed": null,
-        "attention_backend": null,
+        "attention_backend": "sparse",
+        "sparse_tau": 0.5,
+        "sparse_topk": 0.15,
         "cache": null
     },
     "variable_constraints": {
@@ -141,6 +143,8 @@
                     "components": {
                         "transformer": {
                             "attention_backend": "variable:attention_backend",
+                            "sparse_tau": "variable:sparse_tau",
+                            "sparse_topk": "variable:sparse_topk",
                             "group_offload": {
                                 "offload_type": "block_level",
                                 "num_blocks_per_group": 2,
diff --git a/workflows/templates/minimax/enhance-prompt.json b/workflows/templates/minimax/enhance-prompt.json
index e645985f..d64ddea5 100644
--- a/workflows/templates/minimax/enhance-prompt.json
+++ b/workflows/templates/minimax/enhance-prompt.json
@@ -48,7 +48,9 @@
         "lora_weight_name": "minimax_h3_fl2v_turbo_4step_v1.2_768p_bf16.safetensors",
         "lora_adapter_name": "turbo",
         "seed": 42,
-        "attention_backend": null,
+        "attention_backend": "sparse",
+        "sparse_tau": 0.5,
+        "sparse_topk": 0.15,
         "cache": null
     },
     "variable_constraints": {
@@ -156,6 +158,8 @@
                     "components": {
                         "transformer": {
                             "attention_backend": "variable:attention_backend",
+                            "sparse_tau": "variable:sparse_tau",
+                            "sparse_topk": "variable:sparse_topk",
                             "group_offload": {
                                 "offload_type": "block_level",
                                 "num_blocks_per_group": 2,
diff --git a/workflows/templates/minimax/first-and-last-frame.json b/workflows/templates/minimax/first-and-last-frame.json
index 05afbc10..16853e4b 100644
--- a/workflows/templates/minimax/first-and-last-frame.json
+++ b/workflows/templates/minimax/first-and-last-frame.json
@@ -33,7 +33,9 @@
         "lora_weight_name": "minimax_h3_fl2v_turbo_4step_v1.2_768p_bf16.safetensors",
         "lora_adapter_name": "turbo",
         "seed": null,
-        "attention_backend": null,
+        "attention_backend": "sparse",
+        "sparse_tau": 0.5,
+        "sparse_topk": 0.15,
         "cache": null
     },
     "variable_constraints": {
@@ -125,6 +127,8 @@
                     "components": {
                         "transformer": {
                             "attention_backend": "variable:attention_backend",
+                            "sparse_tau": "variable:sparse_tau",
+                            "sparse_topk": "variable:sparse_topk",
                             "group_offload": {
                                 "offload_type": "block_level",
                                 "num_blocks_per_group": 2,
diff --git a/workflows/templates/minimax/generated-subject-reference.json b/workflows/templates/minimax/generated-subject-reference.json
index 709f3baa..3ab04906 100644
--- a/workflows/templates/minimax/generated-subject-reference.json
+++ b/workflows/templates/minimax/generated-subject-reference.json
@@ -39,7 +39,9 @@
         "lora_adapter_name": "turbo",
         "weights_dtype": "{int4}",
         "seed": null,
-        "attention_backend": null,
+        "attention_backend": "sparse",
+        "sparse_tau": 0.5,
+        "sparse_topk": 0.15,
         "cache": null
     },
     "variable_constraints": {
@@ -158,6 +160,8 @@
                     "components": {
                         "transformer_ref": {
                             "attention_backend": "variable:attention_backend",
+                            "sparse_tau": "variable:sparse_tau",
+                            "sparse_topk": "variable:sparse_topk",
                             "group_offload": {
                                 "offload_type": "block_level",
                                 "num_blocks_per_group": 1,
diff --git a/workflows/templates/minimax/image-to-video.json b/workflows/templates/minimax/image-to-video.json
index be5a19c2..d6dd7e71 100644
--- a/workflows/templates/minimax/image-to-video.json
+++ b/workflows/templates/minimax/image-to-video.json
@@ -30,7 +30,9 @@
         "lora_weight_name": "minimax_h3_fl2v_turbo_4step_v1.2_768p_bf16.safetensors",
         "lora_adapter_name": "turbo",
         "seed": null,
-        "attention_backend": null,
+        "attention_backend": "sparse",
+        "sparse_tau": 0.5,
+        "sparse_topk": 0.15,
         "cache": null
     },
     "variable_constraints": {
@@ -122,6 +124,8 @@
                     "components": {
                         "transformer": {
                             "attention_backend": "variable:attention_backend",
+                            "sparse_tau": "variable:sparse_tau",
+                            "sparse_topk": "variable:sparse_topk",
                             "group_offload": {
                                 "offload_type": "block_level",
                                 "num_blocks_per_group": 2,
diff --git a/workflows/templates/minimax/last-frame-only.json b/workflows/templates/minimax/last-frame-only.json
index 602986d0..936da62d 100644
--- a/workflows/templates/minimax/last-frame-only.json
+++ b/workflows/templates/minimax/last-frame-only.json
@@ -30,7 +30,9 @@
         "lora_weight_name": "minimax_h3_fl2v_turbo_4step_v1.2_768p_bf16.safetensors",
         "lora_adapter_name": "turbo",
         "seed": null,
-        "attention_backend": null,
+        "attention_backend": "sparse",
+        "sparse_tau": 0.5,
+        "sparse_topk": 0.15,
         "cache": null
     },
     "variable_constraints": {
@@ -122,6 +124,8 @@
                     "components": {
                         "transformer": {
                             "attention_backend": "variable:attention_backend",
+                            "sparse_tau": "variable:sparse_tau",
+                            "sparse_topk": "variable:sparse_topk",
                             "group_offload": {
                                 "offload_type": "block_level",
                                 "num_blocks_per_group": 2,
diff --git a/workflows/templates/minimax/music-video.json b/workflows/templates/minimax/music-video.json
index dd5123ca..f5c76713 100644
--- a/workflows/templates/minimax/music-video.json
+++ b/workflows/templates/minimax/music-video.json
@@ -97,7 +97,9 @@
         "lora_weight_name": "minimax_h3_ref2v_turbo_8step_v1.0_768p_bf16.safetensors",
         "lora_adapter_name": "turbo",
         "seed": 42,
-        "attention_backend": null,
+        "attention_backend": "sparse",
+        "sparse_tau": 0.5,
+        "sparse_topk": 0.15,
         "cache": null
     },
     "variable_constraints": {
@@ -263,6 +265,8 @@
                     "components": {
                         "transformer_ref": {
                             "attention_backend": "variable:attention_backend",
+                            "sparse_tau": "variable:sparse_tau",
+                            "sparse_topk": "variable:sparse_topk",
                             "group_offload": {
                                 "offload_type": "block_level",
                                 "num_blocks_per_group": 1,
diff --git a/workflows/templates/minimax/reference-to-video.json b/workflows/templates/minimax/reference-to-video.json
index ed8760c1..a14ebb8d 100644
--- a/workflows/templates/minimax/reference-to-video.json
+++ b/workflows/templates/minimax/reference-to-video.json
@@ -48,7 +48,9 @@
         "lora_adapter_name": "turbo",
         "weights_dtype": "{int4}",
         "seed": null,
-        "attention_backend": null,
+        "attention_backend": "sparse",
+        "sparse_tau": 0.5,
+        "sparse_topk": 0.15,
         "cache": null
     },
     "variable_constraints": {
@@ -140,6 +142,8 @@
                     "components": {
                         "transformer_ref": {
                             "attention_backend": "variable:attention_backend",
+                            "sparse_tau": "variable:sparse_tau",
+                            "sparse_topk": "variable:sparse_topk",
                             "group_offload": {
                                 "offload_type": "block_level",
                                 "num_blocks_per_group": 1,
diff --git a/workflows/templates/minimax/shots-batch.json b/workflows/templates/minimax/shots-batch.json
index 619d624a..a6b500ba 100644
--- a/workflows/templates/minimax/shots-batch.json
+++ b/workflows/templates/minimax/shots-batch.json
@@ -75,7 +75,9 @@
         "lora_weight_name": "minimax_h3_fl2v_turbo_4step_v1.2_768p_bf16.safetensors",
         "lora_adapter_name": "turbo",
         "seed": null,
-        "attention_backend": null,
+        "attention_backend": "sparse",
+        "sparse_tau": 0.5,
+        "sparse_topk": 0.15,
         "cache": null
     },
     "variable_constraints": {
@@ -168,6 +170,8 @@
                     "components": {
                         "transformer": {
                             "attention_backend": "variable:attention_backend",
+                            "sparse_tau": "variable:sparse_tau",
+                            "sparse_topk": "variable:sparse_topk",
                             "group_offload": {
                                 "offload_type": "block_level",
                                 "num_blocks_per_group": 2,
diff --git a/workflows/templates/minimax/storyboard.json b/workflows/templates/minimax/storyboard.json
index 7532d214..88ea30f8 100644
--- a/workflows/templates/minimax/storyboard.json
+++ b/workflows/templates/minimax/storyboard.json
@@ -50,7 +50,9 @@
         "lora_weight_name": "minimax_h3_ref2v_turbo_8step_v1.0_768p_bf16.safetensors",
         "lora_adapter_name": "turbo",
         "seed": 42,
-        "attention_backend": null,
+        "attention_backend": "sparse",
+        "sparse_tau": 0.5,
+        "sparse_topk": 0.15,
         "cache": null
     },
     "variable_constraints": {
@@ -221,6 +223,8 @@
                     "components": {
                         "transformer_ref": {
                             "attention_backend": "variable:attention_backend",
+                            "sparse_tau": "variable:sparse_tau",
+                            "sparse_topk": "variable:sparse_topk",
                             "group_offload": {
                                 "offload_type": "block_level",
                                 "num_blocks_per_group": 1,
diff --git a/workflows/templates/minimax/video-with-audio-768p.json b/workflows/templates/minimax/video-with-audio-768p.json
index 6fd9d36c..087a485c 100644
--- a/workflows/templates/minimax/video-with-audio-768p.json
+++ b/workflows/templates/minimax/video-with-audio-768p.json
@@ -46,7 +46,9 @@
         "lora_weight_name": "minimax_h3_fl2v_turbo_4step_v1.2_768p_bf16.safetensors",
         "lora_adapter_name": "turbo",
         "seed": 42,
-        "attention_backend": null,
+        "attention_backend": "sparse",
+        "sparse_tau": 0.5,
+        "sparse_topk": 0.15,
         "cache": null
     },
     "variable_constraints": {
@@ -138,6 +140,8 @@
                     "components": {
                         "transformer": {
                             "attention_backend": "variable:attention_backend",
+                            "sparse_tau": "variable:sparse_tau",
+                            "sparse_topk": "variable:sparse_topk",
                             "group_offload": {
                                 "offload_type": "block_level",
                                 "num_blocks_per_group": 2,
diff --git a/workflows/templates/minimax/video-with-audio.json b/workflows/templates/minimax/video-with-audio.json
index 5887652c..53be7d9a 100644
--- a/workflows/templates/minimax/video-with-audio.json
+++ b/workflows/templates/minimax/video-with-audio.json
@@ -46,7 +46,9 @@
         "lora_weight_name": "minimax_h3_fl2v_turbo_4step_v1.2_768p_bf16.safetensors",
         "lora_adapter_name": "turbo",
         "seed": 42,
-        "attention_backend": null,
+        "attention_backend": "sparse",
+        "sparse_tau": 0.5,
+        "sparse_topk": 0.15,
         "cache": null
     },
     "variable_constraints": {
@@ -138,6 +140,8 @@
                     "components": {
                         "transformer": {
                             "attention_backend": "variable:attention_backend",
+                            "sparse_tau": "variable:sparse_tau",
+                            "sparse_topk": "variable:sparse_topk",
                             "group_offload": {
                                 "offload_type": "block_level",
                                 "num_blocks_per_group": 2,
diff --git a/workflows/templates/minimax/voice-timbre-reference.json b/workflows/templates/minimax/voice-timbre-reference.json
index 052a2655..76bd5228 100644
--- a/workflows/templates/minimax/voice-timbre-reference.json
+++ b/workflows/templates/minimax/voice-timbre-reference.json
@@ -41,7 +41,9 @@
         "lora_adapter_name": "turbo",
         "weights_dtype": "{int4}",
         "seed": null,
-        "attention_backend": null,
+        "attention_backend": "sparse",
+        "sparse_tau": 0.5,
+        "sparse_topk": 0.15,
         "cache": null
     },
     "variable_constraints": {
@@ -148,6 +150,8 @@
                     "components": {
                         "transformer_ref": {
                             "attention_backend": "variable:attention_backend",
+                            "sparse_tau": "variable:sparse_tau",
+                            "sparse_topk": "variable:sparse_topk",
                             "group_offload": {
                                 "offload_type": "block_level",
                                 "num_blocks_per_group": 1,