diff --git a/CLAUDE.md b/CLAUDE.md
index 1808633b..4861cd5d 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -88,7 +88,7 @@ Reserved names: `workflows`, `prompts`, `assets`, `outputs`, `exports`,
 workspace on the server (`ui/src/lib/Sidebar.svelte`) and the selected one
 named in the hash (`#/ws/<name>/...`).
 
-The web UI has a page for it: `ui/src/lib/pages/AssetsPage.svelte` (#165)
+The web UI has a page for it: `ui/src/lib/pages/AssetsPage.svelte`
 reads `GET /api/assets` and shows the library the way the gallery shows
 outputs, tagged by `origin` so a shadowed or read-only entry is visible
 before a 403 explains it.
@@ -164,8 +164,9 @@ references) are documented above in *Workflow sources* and *Type System*.
 - Values prefixed with `prompt:` load a stored prompt's `text` from the prompt library:
   `"prompt:name"` or `"prompt:folder/name"`. Resolved in `realize_args` (`dw/prompts.py`),
   rooted at the library rather than the workflow file. The library is `DW_PROMPT_DIR` /
-  `--prompt-dir`, else `./prompts` if it exists, else found by walking up from the
-  workflow file's directory
+  `--prompt-dir`, else the workspace's `prompts/` when a workspace was named, else
+  `./prompts` if it exists, else found by walking up from the workflow file's
+  directory, else the workspace's `prompts/`
 - A step's `result.subfolder` names a subfolder of the run directory for that step's
   files - by convention `final` for the deliverable and `intermediate` for the rest; any
   relative path (`shots/act-1`); `variable:`/`item:` allowed; no default. Mechanics under
@@ -204,10 +205,10 @@ change both when one changes.
 
 ### LTX-2.5 IC-LoRAs
 
-`templates/ltx2/generative-upscale` was the only IC-LoRA use in the catalog;
-three more conditioning templates join it (#151, #152), all through
-`LTX2InContextPipeline` + `LTX2ReferenceCondition`, all at
-`reference_downscale_factor: 1` (the upscaler's is 2). `reference-sheet`
+The catalog's IC-LoRA templates are `templates/ltx2/generative-upscale` and three
+conditioning templates, all through `LTX2InContextPipeline` +
+`LTX2ReferenceCondition`; the three run at `reference_downscale_factor: 1` (the
+upscaler's is 2). `reference-sheet`
 drives Ingredients — the family's only identity route, and the first two
 templates here whose reference is a file the workflow did not make; the sheet
 is a still, so a `loop_frames` step (`dw/tasks/video_utils.py`, the video
@@ -221,13 +222,13 @@ against their own convention rather than the 150-220-word paragraph rule.
 The weights are `gated: auto` on Hugging Face — per repo, so a box that pulls
 one can still 403 on another. A `loras` entry counts toward
 `plan.downloads_required` (`_collect_sources`, `dw/plan.py`): it names its repo
-under `model_name` directly rather than through `from_pretrained_arguments`, so
-the walk used to miss it and a box holding every base weight but not the
-IC-LoRA answered `[]` and then pulled it mid-run.
+under `model_name` directly rather than through `from_pretrained_arguments`, and
+a walk that skipped it would report `[]` on a box missing only the IC-LoRA,
+which then downloads mid-run.
 
 ### Quantization Support
 
-Quantization configs are defined per-component in workflow JSON and instantiated in `config_objects.py`. Supported frameworks: BitsAndBytes, TorchAO, GGUF, SDNQ, optimum-quanto. The `config_type` field is a free-form string — new quantization backends work automatically via dynamic import.
+Quantization configs are defined per-component in workflow JSON and instantiated in `dw/pipeline_processors/config_objects.py`. Supported frameworks: BitsAndBytes, TorchAO, GGUF, SDNQ, optimum-quanto. The `config_type` field is a free-form string — new quantization backends work automatically via dynamic import.
 
 SDNQ pre-quantized models use a different pattern: `pre_load_modules` imports sdnq (registers with diffusers), then the entire pipeline loads from the pre-quantized repo. Optional `sdnq_optimize` applies quantized matmul post-load (CUDA/XPU only).
 
@@ -248,7 +249,7 @@ The same translation reaches the settings that carry a device or a CUDA-only fea
 
 A `components` entry can additionally set `residency: "on_demand"`, which rests the component on the CPU and wraps its `forward`/`encode`/`decode` to move it to the device around each call (`apply_on_demand_placement` in `pipeline.py`). The wrappers use `functools.wraps` because callers introspect the signature — MiniMax H3's denoiser picks its arguments from `signature(transformer.forward)`. It is mutually exclusive with `group_offload` on the same component, and like `group_offload` it suppresses the wholesale `pipeline.to(device)` at load.
 
-Settings in `~/.diffusers_helper/settings.json`: `device`, `enable_tf32`, `cudnn_benchmark`, `cudnn_deterministic`, `log_level`, `log_filename`.
+Settings in `~/.diffusers_helper/settings.json` (`dw/settings.py`): `device`, `workspace`, `output_layout`, `public_url`, `enable_tf32`, `cudnn_benchmark`, `cudnn_deterministic`, `log_level`, `log_filename`.
 
 ## Security Rules
 
@@ -279,9 +280,9 @@ same reason - default setup cannot load a pack.
 - **`previous_result:` references are checked statically too** — once the schema
   passes, `previous_result_reference_errors` (`dw/previous_results.py`) reports any
   literal `previous_result:` or `from_previous_result` naming no *earlier* step, with
-  the JSON path it sits at. References otherwise resolve lazily per step, so a step
-  renamed in one place and not another failed only when the run reached it, after
-  every step before it had generated. The definition is substituted before the check,
+  the JSON path it sits at. References otherwise resolve lazily per step, so without
+  the check a step renamed in one place and not another would fail only when the run
+  reached it, after every step before it had generated. The definition is substituted before the check,
   so a reference spelled by a *declared* variable is checked by its value; one spelled
   by an undeclared variable is itself a validation error (below)
 - **`for_each` expands before the reference check** — `validation_errors` substitutes
@@ -294,32 +295,28 @@ same reason - default setup cannot load a pack.
   warning and not a complaint about the `for_each` list that did substitute: once a
   `variables` block exists, `replace_variables` refuses an undeclared reference, so it is
   a run that cannot start
-- **The two MiniMax cut templates take one `shots` list** — since the stage-2
-  rewrite (2026-09-11) `templates/minimax/dialogue-short` and `music-video`
-  have no `shot_N_*` variables; a scripted caller passes `shots` (entries
+- **The two MiniMax cut templates take one `shots` list** —
+  `templates/minimax/dialogue-short` and `music-video` have no per-shot
+  variables; a scripted caller passes `shots` (entries
   `{name, prompt, references, num_frames}` and `{name, prompt, start_frame}`).
-  The members are `shot@<name>` in the manifest and the gallery. This is the
-  breaking change the next release note should name. The CLI and REPL only
+  The members are `shot@<name>` in the manifest and the gallery. The CLI and REPL only
   take `name=value` strings, and a string handed to a list variable is
   comma-split - so `shots` can only be supplied over the API/MCP (a JSON
   body); `python -m dw.run` runs the templates' default list
 - **A reference name is checked for its shape before the queue, and `@` is
   part of it** — a `for_each` member is `<group>@<entry>` and the files it
-  writes carry that `@` in their base name, which `OUTPUT_REFERENCE_PATTERN`
-  and `ASSET_REFERENCE_PATTERN` refused: a whole class of files the server
-  itself named could not be named back to it, so `output:` on a shot a
-  list-driven template produced forced a re-render or an `upload_asset` round
-  trip (#162). `@` is safe in a path — not a separator, not `..`, and
-  containment is still `validate_path`'s — and a name still may not *start*
-  with one. The other half is that the refusal arrived at run time, after the
-  queue, from a message that described a *valid* name and never said which
-  character it objected to: `reference_name_errors` (`dw/reference_names.py`)
-  now checks the shape of every `asset:`/`prompt:`/`output:` reference in the
-  definition in `validation_errors`, and `_name_fault` (`dw/security.py`)
-  names the offending character and position. Shape only — *existence*
-  depends on the workspace and on what pruning has taken, so it stays where it
-  was: the validate route resolves the caller's `arguments` against the
-  workspace, and the definition's own references resolve at run time
+  writes carry that `@` in their base name, so `OUTPUT_REFERENCE_PATTERN`
+  and `ASSET_REFERENCE_PATTERN` accept it: every file the server names can be
+  named back to it. `@` is safe in a path — not a separator, not `..`, and
+  containment is still `validate_path`'s — but a name may not *start* with
+  one. `reference_name_errors` (`dw/reference_names.py`) checks the shape of
+  every `asset:`/`prompt:`/`output:` reference in the definition in
+  `validation_errors`, so a bad name is refused before the queue, and
+  `_name_fault` (`dw/security.py`) names the offending character and
+  position. Shape only — *existence* depends on the workspace and on what
+  pruning has taken: the validate route resolves the caller's `arguments`
+  against the workspace, and the definition's own references resolve at run
+  time
 - **Cartesian product explosion** — multiple `previous_result` references multiply: 4 images × 3 masks = 12 iterations
 - **Component sharing requires exact key matching** between `shared_components` and `reused_components`
 - **Built-in workflows** need explicit argument mapping: `"prompt": "variable:prompt"`
@@ -334,9 +331,9 @@ same reason - default setup cannot load a pack.
   job that fails on its first step, and `POST /api/validate` takes the same
   `arguments` (plus an `asset:`/`prompt:`/`output:` existence check against
   the workspace) so the free pre-flight covers the part the caller wrote.
-  A workflow that declares no variables takes no arguments at all - those were
-  dropped in silence, since `Workflow.run` only substitutes when a `variables`
-  block exists. A valid `POST /api/validate` answer also carries `plan`
+  A workflow that declares no variables takes no arguments at all, since
+  `Workflow.run` only substitutes when a `variables` block exists - any passed
+  would be dropped in silence. A valid `POST /api/validate` answer also carries `plan`
   (`dw/plan.py`): the fingerprint of the work, step and list counts,
   `downloads_required` and a cost `estimate` with its `basis` - the number an
   agent quotes, with `basis` saying whether it was measured for this list
@@ -362,8 +359,8 @@ same reason - default setup cannot load a pack.
   Identity is the workflow's path under a `workflows/` tree, else its file name, else its
   `id`; the run id is `<UTC timestamp>-<8 hex of the spec>`, with a `-N` counter if taken.
   A sub-workflow inherits the parent's run directory and writes no manifest of its own.
-  `--output-layout flat` / `DW_OUTPUT_LAYOUT` / the `output_layout` setting restores the
-  old layout. The gallery groups a workflow's runs under one folder by stripping the run
+  `--output-layout flat` / `DW_OUTPUT_LAYOUT` / the `output_layout` setting writes
+  straight into the output directory with no run directories. The gallery groups a workflow's runs under one folder by stripping the run
   id (`strip_run_id`). The realized workflow is written into the same directory as
   `workflow.json` (`dw/realize.py`, `write_realized_workflow`), and the manifest's
   `workflow` block carries `realized`, `prompts` (the stored prompts inlined) and
@@ -373,10 +370,9 @@ same reason - default setup cannot load a pack.
   `POST /api/jobs/{id}/export` gathers one finished job into
   `<workspace>/exports/<job id>/` and `GET /exports/<job id>.zip` streams it.
 - **A run has a number, and it is not derived from the listing** - a file's name
-  is per *step*, so four runs of one workflow write four files called
-  `AcornWarsCutAndScore-film.7-0.0.mp4` and the gallery drew four identical
-  captions: the run id told them apart but is not something anyone says out
-  loud, so an agent had no way to name one of them to a person. Every run now
+  is per *step*, so four runs of one workflow write four files with the same
+  name; the run id tells them apart but is not something anyone says out
+  loud, so the number is how an agent names one of them to a person. Every run
   takes an ordinal, `assign_run_version` (`dw/runs.py`) at the moment
   `Workflow.run` opens the run directory, recorded as `version` in
   `manifest.json` and read back by `run_versions`. Assigned once and never
@@ -429,20 +425,16 @@ same reason - default setup cannot load a pack.
   whatever the step named) (`sectionBySubfolder`, `ui/src/lib/results.ts`),
   unchanged for a run that chose none. `file_base_name` may not contain a
   separator - it is a name, not a path - and it *replaces* the derived
-  `<workflow id>-<step name>.<index>` base rather than prefixing it (#100), so
+  `<workflow id>-<step name>.<index>` base rather than prefixing it, so
   two steps in one subfolder that set the same one collide onto
   `output_file_path`'s `-2` counter.
   Every `workflows/templates/**` file with two or more saving steps
   marks each one `final`/`intermediate` (`tests/test_template_subfolders.py` pins the rule;
-  `dw/workflows/` builtins stay unmarked - a role is the parent's to assign). That moved
-  the templates' outputs into `<run>/final/` and `<run>/intermediate/`: an
-  `output:<template>/latest/x` reference keeps resolving but stops advancing past the last
-  pre-change run (`keep_output` is the stable form), and a seeded template's first run
-  after the change regenerates rather than hitting the step cache (the key includes
-  `result`). Those two, and a stray `subfolder` key becoming live, are the release-note
-  items beside the `shots` list change. Gallery names for a template's runs now read
-  `<template>/<run id>/final/<file>`, so an `output:` reference built from one carries the
-  `final/` segment
+  `dw/workflows/` builtins stay unmarked - a role is the parent's to assign). A
+  template's outputs land in `<run>/final/` and `<run>/intermediate/`, so gallery names
+  read `<template>/<run id>/final/<file>` and an `output:` reference built from one
+  carries the `final/` segment. The step-cache key includes `result`, so changing a
+  step's `subfolder` misses the cache; `keep_output` is the stable way to name an output
 - **A task argument's numeric domain is declared, not inferred** — a task
   command's argument schema is its implementation's signature, which says
   nothing about range, so `dw/task_domains.py` declares the domains that are
@@ -450,12 +442,12 @@ same reason - default setup cannot load a pack.
   and `validation_errors` reports a literal outside one at its JSON path. The
   commands check the same table at run time (`check_arguments`), which is the
   only layer that sees a value arriving from a `variable:` or an earlier step.
-  Both defects it closed were silent successes rather than failures:
-  `slice_audio(num_frames=-10)` reached Python's slice semantics and returned
-  the track minus its last ten frames (#139), and
-  `resample_audio(target_sample_rate=0)` left the samples alone and then hit
+  An out-of-domain value is a silent success rather than a failure without it:
+  `slice_audio(num_frames=-10)` would reach Python's slice semantics and return
+  the track minus its last ten frames, and
+  `resample_audio(target_sample_rate=0)` would leave the samples alone and then hit
   `DEFAULT_AUDIO_SAMPLE_RATE` at save, writing a 44100 Hz header over a 32 kHz
-  waveform (#140) — which is why `_as_track` now refuses a non-positive rate
+  waveform — which is why `_as_track` refuses a non-positive rate
   outright: relabelling a waveform changes its speed and pitch, and the save
   default makes a missing rate look like a valid one. Adding a domain means
   one entry in the table; `tests/test_task_domains.py` pins every entry to a
@@ -464,7 +456,7 @@ same reason - default setup cannot load a pack.
 - **`cost` is curated, `observed` is derived, and they are different fields** —
   `dw/workflow_schema.json` defines `cost` as *"Never derived"*, so nothing
   writes one; `dw/server/observed_cost.py` reports a sibling built from this
-  box's own `jobs.sqlite` rows (#93). Four rules, each a way the naive median
+  box's own `jobs.sqlite` rows. Four rules, each a way the naive median
   would lie: runs are bucketed by the workflow's declared `cost_drivers` (a
   list driver on its *length*, so two four-shot runs are comparable however
   different their prompts) and the bucket reported is the one the *defaults*
@@ -477,46 +469,40 @@ same reason - default setup cannot load a pack.
   job row in one query, so a figure survives a pruned run directory, and the
   aggregate caches against `JobHistory.watermark()` rather than a file mtime —
   a job landing changes every figure and changes no file. The compact listing
-  carries only `observed_minutes`/`observed_runs` (#101 budget); the full
+  carries only `observed_minutes`/`observed_runs` (the listing has a size budget); the full
   block is in the full listing and `GET /api/workflows/{name}/variables`. The
   raw `GET /api/workflows/{name}` is left verbatim, since the editor saves
   what it reads back. A `cost_drivers` entry naming no declared variable is
   dropped, and `tests/test_observed_cost.py` sweeps the catalog for one.
   `plan.estimate` quotes the observed figure ahead of the curated one
   (`basis: "observed"`, with `runs`) — `basis: "unknown"` has to mean nobody
-  has a number, not nobody curated one (#154). Only the *cold* median, only
+  has a number, not nobody curated one. Only the *cold* median, only
   when the history is this backend's, and only for the bucket the caller's
   own arguments fall in (`ObservedCosts.observed(name, definition,
   arguments)`); a resized list finds no bucket and falls back to the curated
   figure. Nothing is added for a composed child, since an observed run
   already ran it. An inline definition has no catalog name, so no history
 - **An observed figure below three runs is not the same statistical basis as
-  a dozen, and says so** — a single-run `observed_minutes` was quoted at the
-  same authority as a twelve-run one, and ran ~3x pessimistic doing it
-  (#301). Below `SMALL_N_THRESHOLD` (3) runs, `estimate()`'s `_tempered`
+  a dozen, and says so** — a single-run `observed_minutes` can be well off
+  (one ran ~3x pessimistic). Below `SMALL_N_THRESHOLD` (3) runs, `estimate()`'s `_tempered`
   (`dw/plan.py`) blends the observed minutes toward the workflow's curated
   `cost` when one exists — proportional to how thin the history is, one run
   counting for a third of the blend — rather than quoting the raw point
-  figure; where no curated figure exists to blend toward (including the
-  #268 child-rollup case, which has none by construction), the minutes are
+  figure; where no curated figure exists to blend toward (including a
+  composed child's rollup, which has none by construction), the minutes are
   left alone and `low_confidence: true` is added to the estimate instead, so
   a caller has something machine-checkable beyond having to know to inspect
-  `runs` itself. No new range/uncertainty-band math — that was considered
-  and rejected as more surface than the problem needs. A blend still
-  answered `basis: "observed"`, the same label a raw, full-authority figure
-  carries, with nothing in the estimate saying the number had been moved off
-  what `list_workflows`' own `observed_minutes` reports for the same
-  workflow (#319) — a caller reconciling the two saw them disagree with no
-  explanation. `_tempered` now marks a blend with `tempered: true` plus
-  `observed_minutes` (the raw point figure) and `curated_minutes` (what it
-  blended toward) beside `runs`, additive fields only; `basis` stays
-  `"observed"` so an existing consumer that only reads `basis`/`minutes`
-  is unaffected
+  `runs` itself. There is deliberately no range/uncertainty-band math - more
+  surface than the problem needs. `_tempered` marks a blend with `tempered:
+  true` plus `observed_minutes` (the raw point figure, which is what
+  `list_workflows` reports) and `curated_minutes` (what it blended toward)
+  beside `runs`, so a caller can reconcile the two; `basis` stays
+  `"observed"` so a consumer that only reads `basis`/`minutes` is unaffected
 - **An H3 adapter is checked against the partition its step denoises on** —
   `ref2va` loads `transformer_ref` alone, so diffusers puts whatever
   `lora_weight_name` names straight onto it: an FL2VA turbo LoRA on a
-  reference step runs, succeeds, and only retains identity worse (#149,
-  #155). `dw/adapter_compatibility.py` refuses the mispairing in
+  reference step runs, succeeds, and only retains identity worse.
+  `dw/adapter_compatibility.py` refuses the mispairing in
   `validation_errors` (so `POST /api/validate` and the pre-queue check both
   catch it, at `arguments.<name>` when the caller supplied it) and *warns*
   on a file name carrying neither `ref2v` nor `fl2v` — the name of a future
@@ -526,15 +512,14 @@ same reason - default setup cannot load a pack.
   (`MiniMaxH3Blocks._workflow_map`, pinned by `tests/test_h3_adapters.py`);
   the file-name convention is MiniMax's and is swept against the catalog's
   own defaults
-- **An elided step says whether anyone decided it** — `warn_elided` used to
-  tell every caller their reference was probably misspelled, including the
-  one who deliberately passed `singer_reference` and so bought the elision
-  `music-video` advertises (#146, #157). `overriding_variables`
+- **An elided step says whether anyone decided it** — `warn_elided` diagnoses a
+  probable misspelling only when nobody replaced the step on purpose (passing
+  `singer_reference` buys the elision `music-video` advertises). `overriding_variables`
   (`dw/elision.py`) compares the definition as *written* against the
   substituted steps: a step reached only through a variable whose value no
   longer names it was replaced on purpose, and its record carries
   `overridden_by` and drops the diagnosis. A variable no step reads is not
-  how the step was reached, so that case keeps the old wording
+  how the step was reached, so that case keeps the misspelling diagnosis
 - **A null `model_name` switches a lora off** — a template's `loras` list
   is fixed JSON, so the way a caller drops its adapter is to pass the
   variable behind `model_name` as `null` (H3: `lora_model_name`).
@@ -542,28 +527,31 @@ same reason - default setup cannot load a pack.
   keeps placement from deferring for it, and `adapter_warnings`/`warn_adapters`
   (`dw/adapter_compatibility.py`, kind `lora_disabled`) say so at the path
   the caller wrote, since a turbo lora's step count and shift no longer fit.
-  Before, nulling the variables validated clean, loaded the pipeline for
-  minutes and then died on `float(None)`. A null `scale`/`adapter_name`
+  A null `scale`/`adapter_name`
   takes its default
 - **A deliverable with no audio headroom warns** — a track at or above
   −0.5 dBFS is written anyway and said out loud (`warn_without_headroom`,
   `dw/result.py`, kind `audio_no_headroom`), for both a saved audio file and
   a muxed video: a clipped file succeeds, and a consumer that cannot listen
-  had `peak_dbfs` with no rule to read it against — `get_gallery_metadata`'s
-  hint taught the near-silent end of the range only (#158). A warning, not a
+  needs a rule to read `peak_dbfs` against. A warning, not a
   gain change: what level a deliverable sits at is the workflow's to decide,
-  and `normalize_audio` is the step that decides it. The two Music 3
-  templates decide it now (#159) - `music` and `music-video` peak-normalize
-  to -1 dBFS, the level `assemble-and-score` has always used, because the
-  warning was firing on their own defaults every run. `music-video`
-  normalizes only the track going into the mux, not the slices that condition
-  the shots, so the picture is unchanged; `music`'s deliverable moves to the
-  new `balanced` step, which renames the file an `output:` reference names
+  and `normalize_audio` is the step that decides it (the level every
+  template uses is in the next bullet). `music-video` normalizes only the
+  track going into the mux, not the slices that condition the shots, so the
+  picture is unchanged; `music`'s deliverable is its `balanced` step.
+  `normalize_audio(limit=true)` reaches a `target_lufs` a transient would
+  otherwise cap: a true-peak (4x) look-ahead limiter holds `peak_dbfs`
+  (`_normalize_limited`, constants `LIMITER_*`) while the gain is searched
+  for (`_search_gain`) until the limited track lands within 0.1 LU of the
+  target - one correction pass left dense material 2 LU short. It stops at
+  12 dB of reduction; a track left short of the target, at the cap or not,
+  warns `target_lufs_capped` with `limited: true`, past 6 dB `limiter_heavy`
+  warns, and the log's `constraint` is `"limiter"`. `compress_audio`'s
+  `limit` mode is sample-peak with no look-ahead, so it is not a ceiling
 - **A deliverable is measured as written, not as handed to the writer** —
   `warn_without_headroom` reads the waveform, and the encoder sits downstream
-  of it: a song normalized to exactly -1.0 dBFS came back out of
-  `music-video`'s AAC mux at **+0.94**, so a clean default run shipped a
-  clipped file and nothing warned (#161). `warn_if_written_above_full_scale`
+  of it: a song normalized to exactly -1.0 dBFS can come back out of an AAC
+  mux at **+0.94**. `warn_if_written_above_full_scale`
   (`dw/result.py`, kind `audio_clipped`) probes the file it just wrote and
   warns when it decodes at or above 0 dBFS — whatever the encoder did, that
   is the number a consumer's decoder sees. Only for a file that can carry a
@@ -571,11 +559,10 @@ same reason - default setup cannot load a pack.
   file, since two warnings would be two answers to one mistake. The encode's
   overshoot is material-dependent — about 0.1 dB on an mp3 and about 1.9 dB
   on the AAC mux of the same song — so no target chosen up front can be
-  *known* to be enough, which is why reading the file back is the half that
-  stops the next instance. The half that fixes this one: every template
-  whose deliverable ends in a `pair_audio` mux (`music-video`,
-  `assemble-and-score`, `dissolve-between-shots`) normalizes to **-3 dBFS**;
-  `music`, an mp3, normalizes to -3 as well (#362)
+  *known* to be enough, which is why the file is read back. The templates
+  leave room as well: every template whose deliverable ends in a `pair_audio`
+  mux (`music-video`, `assemble-and-score`, `dissolve-between-shots`)
+  normalizes to **-3 dBFS**, and so does `music`, an mp3
 - **A variable's bound is declared by the author, checked three times** — a
   model's own rule about a value (H3's `num_frames` is `17 * n + 5` from 124
   to 345) is a property of the model, so it lives in the workflow rather than
@@ -594,23 +581,57 @@ same reason - default setup cannot load a pack.
   `POST /api/validate`, `validate_workflow` and the pre-queue check all
   refuse it at `arguments.<name>` / `variables.<name>`), at run time in
   `apply_constraints` before anything loads, and reported beside the default
-  by `list_workflows` (terse) / `get_workflow(variables_only=true)` — that
-  last part is what stops the next consumer picking 61 (#96).
+  by `list_workflows` (terse) / `get_workflow(variables_only=true)`, so a
+  caller sees the rule before it picks a value.
   `tests/test_variable_constraints.py` sweeps the whole catalog and pins every
   declared number to the diffusers symbol it derives from. A constraint key is
   a plain variable name and is matched wherever a value by that name sits -
-  top-level variable *or* a field of a `for_each` entry (#145), the latter only
+  top-level variable *or* a field of a `for_each` entry, the latter only
   where a step consumes that field as `item:<name>` (`entry_constraint_fields`),
   so the bound follows the value into the pipeline argument rather than the
   name into the JSON. An entry violation is reported at
   `arguments.shots[0].num_frames`, and the rule is reported beside the field in
   the catalog's `lists` block as well as in `constraints`
+- **`vram_estimate`'s ceiling is projected per pipeline step, after
+  `for_each` expansion** — a template's declared VRAM formula
+  (`dw/vram_estimate.py`) used to read the workflow's top-level variables;
+  now it walks the definition the run actually executes (substituted,
+  every `for_each` member expanded) and projects each step that loads a
+  pipeline from *that step's own* pipeline arguments, falling back to the
+  workflow's variables only when the step doesn't name a voxel variable
+  itself — so `shot@deflect` of `dialogue-short` is projected with its own
+  `num_frames` and its own `references`, not the template's defaults. An
+  optional `gb_per_reference` adds a fixed amount per reference the step
+  will actually pass, counting an entry once its `from_file`/
+  `from_previous_result` is non-null (a null one is dropped before the
+  pipeline sees it, #478, and costs nothing). Only the *largest*
+  over-ceiling step is reported — cutting that one is the fix the caller
+  makes first — at the entry's path (`arguments.shots[1]` when the caller
+  supplied `shots`, else `variables.shots[1]`), naming the member, its
+  frames, size and reference count. Checked in `validation_errors` and
+  again in `_prepare_definition` right before a run starts, so an inline or
+  composed definition that skipped `validate_workflow` is still caught.
+  Every H3 Ref2VA template declares `base_gb` 16.0, `bytes_per_voxel`
+  28.71 and `gb_per_reference` 1.0 (`tests/test_h3_vram_ceiling.py`): at 1344x768 on a 24 GB card the ceiling on
+  H3's `17n+5` grid runs 243 frames at one reference, 209 at two, 175 at
+  three, 141 at four — a classification from the #479 field report with
+  about 0.2 GB of margin either side, not a fitted curve.
+  A workflow with no `vram_estimate` of its own inherits the catalog's
+  (`dw/vram_inheritance.py`): each pipeline step is matched by identity
+  (`component_type` + `model_name` + `workflow`) against an index built from
+  every single-identity template declaring one (`_ceiling_index` in
+  `dw/server/app.py`, cached against the listing's mtimes), projected with
+  the same code, and over the ceiling it *warns* (`vram_projection_inherited`,
+  naming the source template) at validate and pre-queue - never refuses,
+  since the hand-built config may offload or quantize differently. No
+  run-time backstop: the worker has no catalog. Templates declaring one
+  identity agree on their numbers (`tests/test_vram_inheritance.py`)
 - **A joined video records its shots, measured** — `concat_videos`,
   `dissolve_videos` and both `run_chain` returns set `AudioVideo.shots`
   (`dw/shots.py`): one `{name, start_frame, num_frames, start_sample,
   num_samples}` per input. The frames are partitioned, and the samples are
   read off the waveform the join built, never derived from the frames, so a
-  shot's overrun stays visible (#385). Every other `AudioVideo` constructor
+  shot's overrun stays visible. Every other `AudioVideo` constructor
   carries, rescales (`interpolate_frames`), re-measures (`pair_audio`) or
   drops them, and `tests/test_shots.py` enumerates the constructor sites with
   `ast`, so a new one fails until someone decides for it. `Result.save`
@@ -624,20 +645,24 @@ same reason - default setup cannot load a pack.
   *root*, never the per-run directory - a run directory is new every execution and would
   defeat the cache; disabled entirely when the workflow sets no `seed`; a hit reports the earlier run's files with `reused: true` and writes nothing new; `memory clear` drops it. This is why "Run again" on a seeded workflow finishes instantly and generates nothing - the job page says so when every step was reused, and `POST /api/jobs/{id}/rerun` with `{"new_seed": true}` (MCP `rerun_job(new_seed=True)`) draws a fresh seed into the workflow's seed variable, which is the way to get a different image
 - **Assessment probes measure a finished file and say where to look, and
-  decide nothing** (`dw/tasks/assess.py`, #387) - `analyze_shots`,
+  decide nothing** (`dw/tasks/assess.py`) - `analyze_shots`,
   `analyze_seams` and `analyze_sync_drift` each read a video streaming
   (thumbnails only, never the full frame list, so a long cut is cheap) and
   answer a JSON dict of measurements plus `findings`, the ones that crossed a
   threshold in `dw/assessment_rules.py`'s table; nothing in the engine acts
-  on a finding. These are the `returns: "json"` task kind, listed separately
-  in `list_tasks`' `assessment` (probes stay in `commands` too), and a step
+  on a finding. Membership is the declared `assessment=True` flag on
+  `register_command`, not the `returns: "json"` task kind by itself:
+  `attribute_voices` (`dw/tasks/voice_attribution.py`) answers JSON too but
+  is an analysis of a song, not a check of a cut, so it is not a probe.
+  The three probes are listed separately in `list_tasks`' `assessment`
+  (they stay in `commands` too), and a step
   on one must save `"result": {"content_type": "application/json"}` -
   anything else fails validation. Shot boundaries resolve in order: the step's `shots` argument,
   the video's own carried shots, the run manifest beside the file, else the
   whole file as one shot (`shots_source` says which). A shot's `hard_cut:
   true` field suppresses the `seam_frame_jump` rule at the seam it opens - a
   cut meant as a cut. `tests/test_assessment_rules.py` pins the rules table
-  to real probe fields, so a rename cannot leave a rule reading nothing. `GET /api/gallery/{name}/assess` (MCP `assess_output`, #388,
+  to real probe fields, so a rename cannot leave a rule reading nothing. `GET /api/gallery/{name}/assess` (MCP `assess_output`,
   `dw/server/assess.py`) runs the applicable probes in the server process on
   one decode - a sync route, so it answers beside a GPU job rather than
   queueing - with the shots the run's manifest (or an asset's keep sidecar)
diff --git a/docs/RECIPES_24GB.md b/docs/RECIPES_24GB.md
index 1318695b..5a6995d0 100644
--- a/docs/RECIPES_24GB.md
+++ b/docs/RECIPES_24GB.md
@@ -100,6 +100,14 @@ model first (Z-Image drawing a subject, Music3 writing a song) must free it with
 `release_pipeline` before H3 loads - with it, the multi-model digital-short
 workflows below fit; without it, the load is an OOM kill, not a slowdown.
 
+Ref2VA reaches 1344x768 too - the canvas isn't tied to the FL2VA 768p checkpoint, only
+the shift/alpha pairing is (above). The trade-off is frame count, not a config change:
+VAE decode memory scales with `width * height * num_frames`, so the same 24GB budget
+that holds 345 frames at 960x544 only holds 209 at 1344x768 with 2 references, and each
+reference costs about 1 GB more (175 at 3) - 175 frames with 2 references measured at
+~31 minutes on a 3090. Give up length, or a reference, before reaching for a smaller canvas;
+the model's `17n+5` ceiling (345) is reachable at 960x544, not at 1344x768.
+
 **Examples:** [reference-to-video.json](../workflows/templates/minimax/reference-to-video.json), [chain-matched-to-audio.json](../workflows/templates/minimax/chain-matched-to-audio.json), [image-to-video.json](../workflows/templates/minimax/image-to-video.json), [dialogue-short.json](../workflows/templates/minimax/dialogue-short.json) (five ref2va shots + two Z-Image portraits in ~35 minutes end to end)
 
 ## MiniMax-Music3
diff --git a/docs/RELEASING.md b/docs/RELEASING.md
index f8ba855e..9ce47f27 100644
--- a/docs/RELEASING.md
+++ b/docs/RELEASING.md
@@ -7,6 +7,123 @@ 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.5.0
+
+<!-- Drafted by the release agent, model claude-opus-5-5 via the anthropic provider, from v0.4.0..f272188 (origin/develop). -->
+
+Most of this range landed on `develop` without PRs, so the auto-generated
+notes name only the Mac PR (#470) and a deploy-script PR (#476). Paste this
+section into the GitHub release body once the tag has published (`gh release
+edit v0.5.0 --notes-file ...`).
+
+**Breaking and behaviour changes**
+
+- `templates/ltx2/two-stage` no longer has `full_width`/`full_height`. They
+  never changed the output, which is always exactly 2x `width`/`height`. A
+  call that still passes them is refused as an unknown variable (#506).
+- Every LTX-2.5 template refuses a `width` or `height` that isn't a multiple
+  of 32 at validate and at `run_workflow`, before the pipeline loads (#505).
+- The MiniMax-H3 Ref2VA VRAM ceiling is now projected per step, after
+  `for_each` expansion, and adds 1 GB for each non-null reference. At
+  1344x768 on a 24 GB card the limits are 243/209/175/141 frames with 1/2/3/4
+  references. Calls that used to pass are now refused, for example 209
+  frames with 3 references. A `for_each` refusal names the member
+  (`Member 'shot@...'`). Eight more Ref2VA templates declare the ceiling
+  (#479/#501).
+- A workflow with no `vram_estimate` gets a `vram_projection_inherited`
+  warning, not a refusal, when the catalog template that loads the same
+  pipeline would be over its ceiling (#502).
+- The VRAM ceiling is checked against the serving device's own cost entries
+  (or its measured capacity), not every CUDA card in the catalog. A 64 GB
+  Mac is no longer refused against the RTX 3090 entry (#470).
+- `asset:`, `prompt:` and `output:` references written directly into a step
+  are resolved at validate and at submission. A stored workflow with a
+  literal reference to a missing file now fails validation (#494).
+- `validate_workflow` refuses a `for_each` item's reference that resolves to
+  null, which the run already refused (#478). It also refuses a frame-size
+  mismatch between the `asset:`/`output:`/path inputs of `concat_videos` and
+  `dissolve_videos` (#504).
+- A `transcribe_audio` step with `timestamps` must set `content_type:
+  application/json` (#498).
+- A `weight_name` (a LoRA's, an IP adapter's) must be a relative file inside
+  the model repo. An absolute path, a backslash, a drive or a `.`/`..`
+  segment is refused at validate. Media path and glob refusals no longer
+  list the server's directories.
+- `previous_result:<step>.<key>` for a key that no result carries is an
+  error. It used to run zero iterations and save nothing.
+- `templates/minimax/video-with-audio-768p` runs its turbo LoRA at its
+  trained strength. It had been running at 16x, so its output changes (#468).
+- On macOS, parallel checkpoint loading is off by default, and so is SDNQ
+  quantized matmul on MPS. Group-offload CUDA streams are dropped, with a
+  warning, when the onload device isn't CUDA or XPU. An explicit
+  `HF_ENABLE_PARALLEL_LOADING` still wins (#470).
+- A `for_each` whose members produce the same shot name now warns
+  `shot_name_collision` (#508). `assess_output` has a new `shot_dead_air`
+  finding for silent gaps inside a shot, and `concat_videos` marks its joins
+  as hard cuts, so `seam_frame_jump` no longer fires on a deliberate cut
+  (#465/#466).
+
+**New**
+
+- Apple Silicon (MPS): the CUDA templates, LTX-2.5 and `minimax/music`
+  included, run unchanged. Memory figures and the chip name are real, and
+  torch's CPU-fallback warning is shown (#470).
+- The `attribute_voices` task names which reference voice sings or speaks
+  each line or window, by timbre. It uses demucs separation and ECAPA
+  embeddings, and `demucs` is now a dependency. `list_tasks` marks the
+  read-only probes with an `assessment` flag (#485/#494). The
+  `minimax-music3` skill points to it for multi-singer songs (#495).
+- `normalize_audio(limit=true)`: a true-peak look-ahead limiter that reaches
+  `target_lufs` past a loud transient. It warns `limiter_heavy` past 6 dB of
+  reduction and `target_lufs_capped` (`limited: true`) past 12 dB
+  (#474/#496).
+- `assemble-and-score` takes `target_lufs` (#467) and `limit` (#497, still
+  open). The `series-episodes` skill says to match episodes downward to one
+  series target. **Unfinished (#497):** with `limit: true` the mix holds
+  -3 dBTP, but the AAC-muxed film can land up to about 1 dB above it.
+- `transcribe_audio(timestamps="segment"|"word")` returns `{text, chunks}`.
+  Unset, it still returns plain text (#483).
+- `templates/ltx2/extend-clip` takes a `clip` to extend an existing clip.
+  The opening isn't generated when one is given (#446).
+- `save_workflow`, `delete_workflow`, `upload_asset`, `delete_asset` and
+  `list_assets` take `workspace=` for one call. Their replies name the
+  workspace they acted on (#463).
+- A LoRA with `model_name: null` is switched off and warns `lora_disabled`.
+  It used to validate clean and then fail after the model load (#469).
+- `get_guide(section=...)` reaches a `###` subsection and returns its
+  `parent_section` (#503).
+- `upload_asset`'s refusals give a working `curl` to `POST /api/uploads`
+  and state the 200 MB limit. The guide explains that `for_each`
+  item-level `from_previous_result` must name the member, as
+  `slice@<entry>` (#481/#482).
+- A running job's `manifest.json` is rewritten after each step, so finished
+  `for_each` members show up before the run ends (#480).
+- `SECURITY.md`: report vulnerabilities privately, not as issues.
+
+**Fixes**
+
+- `templates/ltx2/extend-clip` frees the opening's pipeline before the
+  extension loads, so it no longer holds two LTX-2.5 stacks on the GPU
+  (#523).
+- `concat_videos`/`dissolve_videos` load a `{"location": ...}` entry in
+  `videos` (#510).
+- A modular step whose outputs include latents no longer crashes at save
+  (#507). `pair_audio` unwraps a pipeline's batch of one video.
+- `transcribe_audio` works on clips over 30 s, and a non-Whisper model on a
+  long clip still returns text.
+- `segment` works again: the SAM2 `KeyError` is fixed, and the
+  GroundingDINO query is written the way it scores. Dead default input URLs
+  in several templates are replaced (#470).
+- `upload_asset(file_path=...)` accepts the writable shared asset library
+  (#448).
+- `host_memory_job_peak_rss_mb` is a running max (#457).
+- `dw.serve` exits on SIGTERM with an MCP client still connected (#477).
+- The `shot_dead_air` finding names the room-tone remedy. The
+  `normalize_audio` warning no longer says that gaining down always succeeds
+  (#491/#492). The docs describe `dead_air_floor_dbfs` correctly (#519).
+- The `minimax-h3` skill carries the 24-shot field report's prompting rules
+  (#484).
+
 ### 0.4.0
 
 The auto-generated notes for this range are a single merge line, since the
diff --git a/docs/TASKS.md b/docs/TASKS.md
index 3b24e0a7..5fb402dc 100644
--- a/docs/TASKS.md
+++ b/docs/TASKS.md
@@ -212,7 +212,7 @@ video generation" in the workflow guide):
 
 | Argument | Required | Description |
 | -------- | -------- | ----------- |
-| `videos` | Yes | The videos to join, in order - `previous_result` references, or the path or URL of a video file an earlier run wrote, which is read with the audio muxed into it |
+| `videos` | Yes | The videos to join, in order - `previous_result` references, or the path or URL of a video file an earlier run wrote, which is read with the audio muxed into it. Every video must be the same frame size - unlike a sample-rate mismatch, there is no reconciliation for a size mismatch, so a statically-resolvable (`asset:`/`output:`/literal path) size disagreement is refused at validate; one only known at run time still fails there (#504) |
 | `trim_frames` | No | Frames dropped from the head of every video after the first (default: 0) |
 | `crossfade_ms` | No | Equal-power crossfade at each audio seam, drawn from the trimmed material - no effect when `trim_frames` is 0, and validation warns when one is written there (default: 75) |
 | `audio_bleed_ms` | No | How long the outgoing video's tail rings on over the head of the next one, at seams with nothing trimmed to crossfade (default: 0, off) |
@@ -358,7 +358,7 @@ montage cut to a score wants:
 
 | Argument | Required | Description |
 | -------- | -------- | ----------- |
-| `videos` | Yes | The videos to join, in order - `previous_result` references, or the path or URL of a video file an earlier run wrote, one entry per video as with `concat_videos` |
+| `videos` | Yes | The videos to join, in order - `previous_result` references, or the path or URL of a video file an earlier run wrote, one entry per video as with `concat_videos`. Every video must be the same frame size - unlike a sample-rate mismatch, there is no reconciliation for a size mismatch, so a statically-resolvable (`asset:`/`output:`/literal path) size disagreement is refused at validate; one only known at run time still fails there (#504) |
 | `dissolve_frames` | No | Frames of overlap at each seam, blended linearly (default: 12). 0 is a hard cut |
 | `fade_in_frames` | No | Frames over which the first video rises out of `fade_color` (default: 0) |
 | `fade_out_frames` | No | Frames over which the last video sinks into it (default: 0) |
@@ -646,11 +646,20 @@ changes, so the dynamics survive:
 | Argument | Required | Description |
 | -------- | -------- | ----------- |
 | `audio` | Yes | Path or URL of an audio file (or of a video file, whose soundtrack is taken), a waveform from a previous step, or an earlier step's video generated with a soundtrack (which brings its sample rate along) |
-| `peak_dbfs` | No | The level the loudest sample is moved to, in dB below full scale (default: -1.0). 0 is full scale |
+| `peak_dbfs` | No | The level the loudest sample is moved to, in dB below full scale (default: -1.0). 0 is full scale. With `limit`, a true-peak (4x oversampled, BS.1770) ceiling the output never crosses |
+| `target_lufs` | No | An integrated loudness (BS.1770) to scale the track to instead, in LUFS (0 or below). Without `limit` the gain is capped so the peak stays under `peak_dbfs`, and `target_lufs_capped` warns when that cap wins. A track shorter than 400 ms (or silent throughout) cannot be measured, warns `target_lufs_unmeasurable`, and falls back to `peak_dbfs` |
+| `limit` | No | Reach `target_lufs` past a transient instead of letting it cap the gain: a true-peak look-ahead limiter (5 ms look-ahead, 20 ms hold, 150 ms release, linked across channels) holds `peak_dbfs`, and the gain is searched for until the limited track lands within 0.1 LU of `target_lufs` - limiting takes some loudness back, more on dense material. The limiter itself never adds gain, and it stops at 12 dB of reduction - past that the gain stops too, and `target_lufs_capped` warns with `limited: true` and `shortfall_lu` (as it does for any track left more than 0.1 LU short). More than 6 dB warns `limiter_heavy` (pumping can be audible). The step's log carries `constraint: "limiter"`, `gain_db`, `max_gain_reduction_db`, `limited_fraction` (0 when the limiter was not needed), `output_true_peak_dbfs` and `output_lufs` (default: false, which behaves exactly as without it) |
 | `sample_rate` | With a waveform | Sample rate of a directly passed waveform (files carry their own) |
 
 A silent track is returned unchanged.
 
+To level dialogue with a laugh or a shout on it, `limit` is the switch: a
+peak-only gain lets that one transient set the level of every line around it.
+
+```json
+"arguments": {"audio": "previous_result:dialogue", "target_lufs": -16, "peak_dbfs": -1.0, "limit": true}
+```
+
 **Example:** [dissolve-between-shots.json](../workflows/templates/dissolve-between-shots.json)
 
 **Headroom and clipping warnings.** Saving audio or a video with a muxed
@@ -839,6 +848,11 @@ covers all three through `mode`:
 
 A silent track is returned unchanged.
 
+`mode: "limit"` is a sample-peak limiter with no look-ahead: the envelope
+reacts to a transient as it arrives, so the transient's leading edge and any
+inter-sample peak get through. To hold a true-peak ceiling while reaching a
+loudness target, use `normalize_audio` with `limit: true`.
+
 ### filter_audio
 
 Run a track through a single biquad filter stage - trimming the frequencies a
@@ -902,7 +916,11 @@ sample rate, reads as `null` rather than `-inf`.
 ## Assessment Probes
 
 Three read-only commands measure a finished cut and say where to look -
-`analyze_shots`, `analyze_seams`, `analyze_sync_drift`. Each takes a video
+`analyze_shots`, `analyze_seams`, `analyze_sync_drift`. Each is registered
+with `assessment=True` (`register_command`, `dw/tasks/task.py`), which is
+what makes a command a probe - not merely answering JSON, since
+[`attribute_voices`](#voice-attribution) answers JSON too and is not one.
+Each takes a video
 (a stored file - `asset:`, `output:` or a path, read straight from disk
 rather than decoded first - or the video an earlier step returned; not a
 URL, whose download is a bare frame list with no soundtrack) and answers one JSON
@@ -952,6 +970,9 @@ Each shot's level and spectral balance, and how far apart the shots sit:
 | `shots[].crest_db` | `peak_dbfs` minus `rms_dbfs` |
 | `shots[].low_dbfs` / `mid_dbfs` / `high_dbfs` | Spectral balance (20-250 Hz / 250-4000 Hz / 4000-20000 Hz), on the same scale as `rms_dbfs` |
 | `shots[].samples` | Whether the shot's sample span was `recorded` (carried by the shot record) or `derived` (scaled from its frames) |
+| `shots[].dead_air_seconds` | The longest run of 50ms windows inside the shot at or below the `DEAD_AIR_FLOOR_DBFS` threshold (-65 dBFS) |
+| `shots[].dead_air_at` | Where that run starts, in seconds into the file |
+| `shots[].dead_air_floor_dbfs` | The quietest 50ms window measured inside that run - not the threshold. Null when the run is pure digital silence, and null when there is no run at all |
 | `rms_range_db` | The spread between the loudest and quietest voiced shot |
 | `has_audio` | Whether the file carries a soundtrack at all |
 
@@ -1002,14 +1023,20 @@ its threshold, and the severity of a crossing:
 | `seam_click` | `analyze_seams` | `click_db` | > 12.0 dB | warn |
 | `seam_hole` | `analyze_seams` | `floor_dbfs` | < -50.0 dBFS | warn |
 | `seam_frame_jump` | `analyze_seams` | `jump_ratio` | > 25.0 | info |
+| `shot_dead_air` | `analyze_shots` | `dead_air_seconds` | > 0.4 s | warn |
 | `sync_drift` | `analyze_sync_drift` | `end_offset_ms` | > 40.0 ms (magnitude) | warn |
 | `sync_length` | `analyze_sync_drift` | `length_delta_ms` | > 40.0 ms (magnitude) | warn |
 
-Two rules carry a guard beyond the threshold: `seam_hole` only fires while
+Three rules carry a guard beyond the threshold: `seam_hole` only fires while
 both sides of the seam are voiced above -30 dBFS (a quiet join between two
-quiet shots is not a hole, it's a pause the shots themselves hold), and
+quiet shots is not a hole, it's a pause the shots themselves hold);
 `seam_frame_jump` is skipped at a seam whose incoming shot is marked
-`hard_cut: true` - a cut meant as a cut.
+`hard_cut: true` - a cut meant as a cut; and `shot_dead_air` is skipped
+inside a shot whose own rms is at or below -30 dBFS - a shot that is quiet
+throughout, on purpose, rather than one holding a gap. A gap the guard lets
+through is what `slice_audio` -> `loop_audio` -> `mix_audio` is for: cut a
+room-tone bed from the take, loop it to the gap's length, and mix it under
+the line rather than leaving the drop silent.
 
 A `shots` record reaching past the file's own length is a separate finding,
 `shot_span_overrun`, on all three probes - not a threshold crossing, since
@@ -1021,7 +1048,100 @@ written is left to the finding.
 
 `list_tasks` names the probes in their own `assessment` list, alongside
 `commands`, so a caller looking for a way to check a cut can find them
-without reading every command's schema.
+without reading every command's schema. The list is exactly the commands
+declared `assessment=True`; `attribute_voices` stays in `commands` only,
+since it analyzes a song rather than checking a cut.
+
+## Voice attribution
+
+Which reference voice sings each line of a song, by timbre - staging
+lip-sync shots for a generated song needs its section-to-singer map, and a
+generation model (MiniMax Music3 included) does not hand one back. Pitch
+cannot stand in for it: a tenor and a mezzo share a range, and a pitch
+heuristic has called a tenor female.
+
+`attribute_voices` separates the vocal stem (htdemucs), reduces every line
+and every voice's reference to its voiced frames, embeds each with
+speechbrain's ECAPA speaker encoder (`spkrec-ecapa-voxceleb`), scores every
+line against every voice by cosine, and rolls lines up into named windows
+(shots, say) by the voiced seconds they overlap. It decides nothing: the
+argmax is always reported, alongside the margin and how much of the line was
+voiced, so a weak answer is visible as weak rather than silently accepted.
+
+```json
+{
+    "task": {
+        "command": "attribute_voices",
+        "arguments": {
+            "audio": "asset:song.mp3",
+            "voices": {
+                "lena": [{"start_seconds": 4.0, "duration_seconds": 6.0}],
+                "marcus": [{"start_seconds": 32.0, "duration_seconds": 6.0}]
+            },
+            "windows": [
+                {"name": "shot-1", "start": 0.0, "end": 12.0},
+                {"name": "shot-2", "start": 12.0, "end": 24.0},
+                {"name": "shot-3", "start": 24.0, "end": 40.0}
+            ]
+        }
+    },
+    "result": { "content_type": "application/json" }
+}
+```
+
+| Argument | Required | Description |
+| -------- | -------- | ----------- |
+| `audio` | Yes | The song - a path, `asset:`/`output:` reference, or an earlier step's audio or video |
+| `voices` | Yes | Each voice's name mapped to its reference: a list of `{start_seconds, duration_seconds}` (or `{start, end}`) spans into `audio`, or a path/`asset:` of a separate clip. At least 2 voices; names follow the variable-name pattern; each voice's reference must total at least `min_reference_seconds` |
+| `lines` | No | Spans to attribute, `{start, end, text?}` (a `transcribe_audio` transcript, or its `chunks` list, drops in directly) or `{start_seconds, duration_seconds, text?}`. Omitted: the song is cut into fixed windows of `window_seconds` |
+| `windows` | No | Named spans to roll lines up into, `{name, start, end}`. Omitted: mirrors the fixed windows when `lines` is also omitted, otherwise none |
+| `window_seconds` | No | Length of the fixed windows used without `lines` (default `2.0`) |
+| `min_reference_seconds` | No | Least total reference length per voice; a shorter one is refused by name (default `3.0`) |
+
+A literal `voices` is checked at validation as well as on the step: fewer
+than two voices, a bad name, a malformed span, or a span-list reference under
+`min_reference_seconds` is refused at `steps[i].task.arguments.voices`, and a
+bare path as a voice meets the same location policy as `audio`. What needs
+the song itself - a span past its end, a clip's voiced length - is the
+step's to refuse.
+| `separate` | No | Isolate the vocal stem with htdemucs before embedding (default `true`); `false` for audio that is already a dry vocal |
+| `device` | No | Where the models run |
+
+The result: `voices` (the names), `separated`, `duration_seconds`, `lines[]`
+(`start`, `end`, `text`, `scores`, `voice`, `margin`, `voiced_seconds`,
+`uncertain`, `reason`), `windows[]` (`name`, `start`, `end`, `voiced_seconds`,
+`share`, `voice`, `uncertain`, `reason`), `reference_similarity` (pairwise
+cosine between the voices' references), `voiced_floor_dbfs` (the floor this
+song's stem was read against), `warnings` and the `thresholds` compared
+against.
+
+The voiced floor is relative to the stem rather than a fixed level: a quiet
+sung verse under a loud chorus sits 20 dB or more beneath it, and a fixed
+-40 dBFS floor dropped such a verse as unvoiced and refused it as a
+reference. Separation leaves near-silence between phrases, so the floor sits
+well above that and well below the singing.
+
+| Threshold | Value | What crossing it does |
+| --------- | ----- | ---------------------- |
+| `voiced_level_percentile` | 95 | The stem's level is this percentile of its 20 ms frames' rms |
+| `voiced_floor_below_level_db` | 35.0 dB | A frame at or above the stem's level less this is voiced |
+| `voiced_floor_min_dbfs` | -60.0 dBFS | The floor never drops below this, however quiet the stem |
+| `min_voiced_seconds` | 0.5 s | A line or window under this much voiced time has no voice - `voice: null`, `uncertain: true` |
+| `uncertain_margin` | 0.05 | A line whose best score beats the runner-up by less than this is `uncertain` - the argmax is still reported |
+| `uncertain_share_margin` | 0.2 | A window whose leading voice's share beats the runner-up's by less than this is `uncertain` - a duet line, or a window straddling a hand-over |
+| `voices_too_similar` | 0.8 | Two references scoring above this against each other make every line between them a weak answer whatever its scores say |
+
+A `voices_too_similar` pair is reported in `reference_similarity`, added to
+`warnings`, and emitted onto the job's warnings (`voices_too_similar`) -
+picking better-separated reference spans is the fix, not reading past it.
+
+Both models are fixed - there is no model-name argument - and both run in
+fp32 (their STFT front ends are fp32-only in practice, and both are small
+enough that it costs nothing). Weights download on first use - htdemucs from
+Hugging Face (`adefossez/HTDemucs` via demucs 4.1), ECAPA from speechbrain -
+and are cached between calls like any other model. On MPS a `separate: true`
+run that fails in htdemucs falls back to the CPU and warns
+(`separation_cpu_fallback`) rather than failing the step.
 
 ## Data Gathering
 
@@ -1520,8 +1640,11 @@ Transcribe spoken audio to text with a local Whisper-class model. The word-corre
 | `audio` | Yes | Path or URL of an audio file (or of a video file, whose soundtrack is taken), a video with a soundtrack, or a waveform — usually a `previous_result:` reference |
 | `sample_rate` | No | Sample rate of a waveform passed directly |
 | `model_name` | No | HuggingFace model ID of a Whisper-class ASR model (default: `openai/whisper-base`) |
+| `timestamps` | No | `"segment"` or `"word"` to get chunk timings instead of plain text (see below) |
+
+Multi-channel audio is downmixed to mono and resampled to 16 kHz before transcription, since that is what a Whisper-class model is trained on; the source audio itself is untouched. By default the result is plain text, read with MCP's `get_output_text`.
 
-Multi-channel audio is downmixed to mono and resampled to 16 kHz before transcription, since that is what a Whisper-class model is trained on; the source audio itself is untouched. The result is plain text, read with MCP's `get_output_text`.
+Set `timestamps` to `"segment"` or `"word"` to get chunk timings instead — a music video cut to the lyric, or a dialogue shot checked against its line, needs the times Whisper already produces past 30 s rather than the collapsed string. The result becomes `{"text": ..., "chunks": [{"start": ..., "end": ..., "text": ...}, ...]}`, so the step's `result.content_type` must be `"application/json"` rather than `"text/plain"`, and it's read with MCP's `get_output_text` (JSON results are text). A clip under 30 s asks Whisper for timestamps explicitly when `timestamps` is set — the 30 s long-form threshold is a separate, unrelated reason to ask.
 
 **Example:** [transcribe-audio.json](../workflows/templates/transcribe-audio.json) — Transcribe an audio file to text.
 
diff --git a/docs/WORKFLOW_GUIDE.md b/docs/WORKFLOW_GUIDE.md
index 1241f579..f92e3c58 100644
--- a/docs/WORKFLOW_GUIDE.md
+++ b/docs/WORKFLOW_GUIDE.md
@@ -288,7 +288,22 @@ for existence.
   One name, three places it can sit: a bare string (`"image": "asset:x.png"`),
   an element of a list, or the `location` of a media dict
   (`{"location": "asset:x.png"}`, with or without `media_type`) - all resolve
-  to the same file.
+  to the same file. When the file is on neither the MCP session's machine nor
+  reachable as `content=` (over 4MB, or the agent has no filesystem access to
+  read it into the call), curl it straight into the library the same way the
+  web UI's file picker does — `POST /api/uploads`, body is the raw bytes, up to
+  200MB:
+  ```
+  curl -H "Authorization: Bearer $DW_API_TOKEN" --data-binary @portrait.jpg \
+    "http://<host>:8765/api/uploads?filename=portrait.jpg&asset_name=cast/portrait.jpg&workspace=<ws>"
+  ```
+  It answers 201 with `path` - the `asset:` reference to use in a workflow
+  argument (the bearer token only when the server requires one). The same
+  route is also how a file assembled entirely on the client - a finished cut
+  stitched locally rather than by a workflow step - gets onto the server at
+  all: it never lands in the gallery and `export_job` has no run to bundle it
+  from, so uploading it as an asset is the only way to hand it back to the
+  engine or to a teammate reading the workspace.
 - `output:` — `output:<workflow identity>/<run id>/<file>` is a file an earlier
   run wrote, under the output root and confined to it. `latest` in the run-id position
   picks the newest run that holds that file; `v<N>` picks the run the gallery labels
@@ -441,6 +456,25 @@ All of it is reported by `validate_workflow`, before anything is queued, so
 a draft that names a file the server may not read costs nothing to find out.
 `get_server_info`'s `trust_workflows` says which posture is in force.
 
+### A workflow you wrote inherits the catalog's VRAM ceiling
+
+A template can declare a `vram_estimate`, and a workflow over it that
+projects past the card is refused before anything is queued. A workflow you
+wrote declares none, so `validate_workflow` (and `run_workflow`'s pre-queue
+check) match each of its pipeline steps to the catalog by *pipeline
+identity* - the step's `component_type`, `from_pretrained_arguments.model_name`
+and `from_pretrained_arguments.workflow` - and project it against the
+ceiling a catalog template declared for that same pipeline. Past it, the
+answer stays `valid: true` and carries a warning of kind
+`vram_projection_inherited` that names the source template and the heaviest
+step (for a `for_each`, the heaviest member). It warns rather than
+refuses: your offload and quantization config may differ from the
+template's. Cut frames, size or references until it goes quiet, or declare
+your own `vram_estimate`, which always wins and is judged exactly as a
+template's. A pipeline the catalog declares no ceiling for gets no warning -
+silence there is not a clearance - and H3's `t2va` and `ref2va` are
+different identities with different ceilings.
+
 ### Remote code is refused by default
 
 A server started without `--trust-workflows` refuses any
@@ -536,6 +570,16 @@ slice cut for it when slicing and generating are two steps. It is the one
 pairing the engine has; `for_each` runs over exactly one list, and there is
 no zip and no loop index.
 
+That auto-pairing is at the *step* level only, where `from_previous_result`
+(or `previous_result:`) sits directly in the `for_each` step's own
+arguments. Inside an **item** — an entry field the step reads with
+`item:`, such as a `references` entry — nothing pairs it for you, because the
+entry is data the caller wrote and the engine does not know which list it
+came from. Spell the member out: `{"reference_type": "…",
+"from_previous_result": "slice@closeup"}`, not `"slice"`. Getting this wrong
+fails the run with a precise error naming the members that do exist, but the
+guide says it here first.
+
 Limits: a list has at most 32 entries, and an empty list is a validation
 error — the step would run nothing. Validation realizes a `constant:`
 default before checking it, so a list defaulted to a constant validates the
@@ -857,6 +901,7 @@ The thresholds live in one table, `dw/assessment_rules.py`:
 | `seam_click` | `analyze_seams` | the join peaks more than 12 dB above the audio either side |
 | `seam_hole` | `analyze_seams` | the join's floor drops below -50 dBFS while both sides are voiced (above -30 dBFS) |
 | `seam_frame_jump` | `analyze_seams` | the picture changes more than 25x as much across the seam as inside either shot (`info`, and skipped at a shot marked `hard_cut: true`) |
+| `shot_dead_air` | `analyze_shots` | the shot holds a gap more than 0.4 seconds long below its dead-air floor (skipped inside a shot that is quiet throughout) |
 | `sync_drift` | `analyze_sync_drift` | by a shot's end, the audio sits more than 40 ms off the picture |
 | `sync_length` | `analyze_sync_drift` | the soundtrack and the picture differ in length by more than 40 ms |
 
@@ -888,6 +933,7 @@ already made: each entry in `videos` is `output:` + the run's
 | `seam_click` | a longer `crossfade_ms` on the join | recut |
 | `seam_hole` | `audio_bleed_ms` on the join, so the outgoing tail rings on across the seam | recut |
 | `seam_frame_jump` | a `dissolve_videos` join, or regenerate the incoming shot from the outgoing shot's last frame. If the cut was meant, leave it alone | recut, or regenerate |
+| `shot_dead_air` | cut a room-tone bed from the take with `slice_audio`, `loop_audio` it to the gap's length, and `mix_audio` it under the line rather than leaving the drop silent | recut |
 | `sync_drift` | regenerate the shot. Drift inside a shot is the model's, not the join's | regenerate |
 | `sync_length` | rerun the mux through `pair_audio` with `fit: "video"`, which cuts or pads the track to the picture | recut |
 
@@ -907,8 +953,8 @@ Supported content types: `image/jpeg`, `image/png`, `image/webp`, `image/gif`, `
 A task command's implementation declares what it hands back - most answer an
 `artifact` (a file `result` saves in one of the media content types above),
 some (`judge`) answer a bare `scalar` that cannot be saved at all, and some
-(the assessment probes in [TASKS.md](TASKS.md)) answer a `json` document -
-every measurement taken, in one dict. A step on a `json` command must set
+(the assessment probes in [TASKS.md](TASKS.md), and `attribute_voices`) answer
+a `json` document - every measurement taken, in one dict. A step on a `json` command must set
 `content_type` to `application/json`, which saves it as one document; a step on a `scalar` command
 may not carry a `result` at all. Both are checked in validation, by the
 command's own declared kind rather than a name match.
diff --git a/docs/proposals/complete/attribute-voices-complete.md b/docs/proposals/complete/attribute-voices-complete.md
new file mode 100644
index 00000000..22ae50fa
--- /dev/null
+++ b/docs/proposals/complete/attribute-voices-complete.md
@@ -0,0 +1,104 @@
+# `attribute_voices`: which reference singer sings each line, by timbre (#485)
+
+Written by model `claude-opus-5-5` via provider `anthropic` (close-out,
+2026-09-27). Plan v1 approved by Don as "build smaller" on 2026-09-27;
+stages #494 (A) and #495 (B), both verified.
+
+## The report
+
+A field report from an Opus 5.5 session on lem (2026-09-25/26): a 3:12
+musical short, 18 lip-synced song shots from one Music 3 take. Music 3
+ignores "Singer X sings section Y" (all three seeds), so the session had to
+find out who sings what before staging lip-sync. Its pitch-based map
+(demucs vocal stem, median pYIN per lyric line) called the choruses female:
+the tenor melody sits at 220-293 Hz, which a mezzo also reaches, and the
+phrases open on shouted ensemble attacks that pull the median up. Six chorus
+shots were staged with the wrong singer and re-rendered (~3 GPU-hours).
+
+What worked, done by hand outside dw (`who_sings.py`): separate the vocal
+stem, embed a known stretch of each singer, score every line by cosine
+similarity, roll lines up per shot by time overlap. It got all six right.
+
+## Decisions (plan v1, approved as written)
+
+- **Build smaller.** One task and a skill note. No template field wired to
+  the attribution (it would break the pinned entry shapes in
+  `tests/test_plugin_skills.py`; the agent writes the shot list from the
+  JSON anyway). No reference-free diarization.
+- **Q1: demucs is a hard dependency.** Separation is the default path; an
+  optional extra would make the default fail on a plain install.
+- **Q2: speechbrain ECAPA, not Resemblyzer.** speechbrain was already a
+  dependency. The risk was that ECAPA is trained on speech, not singing;
+  the stage-A known-answer case was the check, and it passed (held-out
+  margins 0.36-0.74, reference cosine 0.053), so Q2 stands.
+- **Q3: an explicit `assessment` flag on `register_command`.** A second
+  `returns: "json"` command would otherwise have been filed under
+  `list_tasks`' `assessment` bucket. The three probes set
+  `assessment=True`; the bucket reads the flag.
+- **#483 (timestamped transcribe) is not a dependency.** `lines` takes
+  spans directly, in #483's proposed `{start, end, text}` chunk shape (or
+  `start_seconds`/`duration_seconds`), so its output drops in via
+  `previous_result:` when it lands.
+
+## What was built
+
+**Stage A, #494** (server): `dw/tasks/voice_attribution.py`, the
+`assessment` flag (`dw/tasks/task.py`, `dw/introspection.py`), `demucs` in
+`pyproject.toml`, and the `docs/TASKS.md` section (*Voice attribution*).
+
+- Arguments: `audio`, `voices` (name -> span list into `audio`, or a clip
+  path / `asset:`), `lines`, `windows`, `window_seconds` (2.0),
+  `min_reference_seconds` (3.0), `separate` (true), `device`. No
+  model-name argument, so nothing free-form reaches `torch.hub.load`.
+- Returns per-line `scores`, `voice`, `margin`, `voiced_seconds`,
+  `uncertain` (with `voice: null` and a reason when too little is voiced),
+  per-window `share` rolled up by voiced overlap, and
+  `reference_similarity` with a `voices_too_similar` warning.
+- A step on it must save `content_type: application/json`, the rule the
+  probes already follow.
+- Found in verification and fixed:
+  - bounce 1: a bare-path voice clip passed validation (the boundary held
+    at run time; it was refused too late). Voice clips now go through the
+    same location policy as `audio` (`dw/locations.py`). A literal `voices`
+    is checked statically by `voices_errors`. `asset:`/`prompt:`/`output:`
+    literals written straight into a step are now existence-checked at
+    validation and submission, as caller arguments already were. The
+    voiced floor became relative to the stem (95th-percentile frame rms
+    less 35 dB, never below -60 dBFS) so a quiet sung section counts.
+  - bounce 2: no code change. The failing line (Priya's opening, inside
+    her reference span) holds ~0.44 s of voice, under the declared
+    `MIN_VOICED_SECONDS` of 0.5, so `voice: null` was the specified answer.
+    Filed as suite defects harnest#21 (that line and the 0-2 s window) and
+    harnest#20 (`shot_join`).
+
+**Stage B, #495** (plugin-only): one *Hard rules* bullet in the
+`minimax-music3` skill (279 B, skill now 12,207 of 12,288 B): Music 3
+ignores per-section singers, so run `attribute_voices` with a reference
+span per singer before staging lip-sync, and never infer the singer from
+pitch.
+
+## Bounces per stage
+
+| Stage | Bounces | Cause |
+|---|---|---|
+| A, #494 | 2 | 1: SE-F038 refused too late, voiced floor, direct literal existence check. 2: a case defect (harnest#20, #21), no code change. |
+| B, #495 | 0 | |
+
+No stage comment names `usage:` figures, so per-stage cost is not recorded.
+The plan estimated ~$7-10 total.
+
+## Deferred
+
+- **Template wiring** (a per-shot `singer` chosen automatically). Back if a
+  second report shows a session mis-wiring the output into a shot list.
+- **Resemblyzer.** Back only if ECAPA fails on a real duet where
+  Resemblyzer would not.
+- **`plan.downloads_required` does not report the demucs weights** (from
+  Meta's CDN via torch.hub), the same gap `transcribe_audio`'s Whisper and
+  speechbrain already have. The fix is a per-task default-model table in
+  `_collect_sources` (`dw/plan.py`), a separate follow-up.
+- **demucs on MPS** is unverified; separation falls back to CPU with a
+  warning.
+- **Ensemble lines** (both singers at once) score between the two; `share`
+  and `margin` show it, but `voice` names one.
+- A `lines: "previous_result:transcribe"` case, once #483 lands.
diff --git a/docs/proposals/complete/h3-vram-ceiling-references-complete.md b/docs/proposals/complete/h3-vram-ceiling-references-complete.md
new file mode 100644
index 00000000..536136cc
--- /dev/null
+++ b/docs/proposals/complete/h3-vram-ceiling-references-complete.md
@@ -0,0 +1,151 @@
+# H3 Ref2VA VRAM ceiling: references, `for_each` members and hand-built workflows (#479)
+
+Written by model `claude-opus-5-5` via provider `anthropic` (close-out session,
+2026-09-27). Plan v1 was designed on #479 and approved with its defaults. It was
+built as stages #501 (A) and #502 (B).
+
+## The report
+
+This was a field report from about 7 h of H3 Ref2VA shots on lem (RTX 3090,
+24 GB, 64 GB host). Two CUDA OOMs and one host SIGKILL all got past
+`validate_workflow`. At 1344x768, int4, with the 768p turbo LoRA and 9 steps:
+
+| frames | refs | result |
+|---|---|---|
+| 175 | 2 | ok |
+| 209 | 2 | ok |
+| 175 | 3 | ok |
+| 209 | 3 | OOM in reference encode (+5.1 GB refused) |
+| 260 | 1 | OOM at denoise step 1 (+4.8 GB refused) |
+
+Two gaps let these through:
+- The old formula (`16.3 GB + 28.71 B x w x h x frames`) had no reference term.
+- The check ran only on the raw top-level definition. A `for_each` list made
+  `required_gb` return `None`, so the check was skipped silently. A workflow
+  that declared no `vram_estimate` (the report's inline shots) was never
+  checked at all.
+
+## Verdict: build smaller
+
+The design went ahead with the per-reference term, a per-step check after
+expansion, and inheritance by pipeline identity. The host-memory half was cut.
+
+There were two corrections to the triage:
+- **No engine registry.** An engine-side registry of pipeline costs would have
+  put model knowledge in engine code. Instead, the index is derived from the
+  catalog's own declarations, and the engine holds no numbers.
+- **~29 GB is a lower bound, not a measured peak.** The report's "+5.1 GB" is
+  the size of the allocation that was refused.
+
+## What was built
+
+### Stage A (#501): a per-step, post-expansion ceiling with a reference term
+
+- **Where the check runs.** `vram_estimate_errors` runs on the expanded
+  definition in `validation_errors`. The run-time backstop `apply_vram_estimate`
+  runs after `expand_for_each` in `_prepare_definition`, including for a
+  workflow with no `variables` block.
+- **Voxel values** are read from each pipeline step's own arguments first, then
+  from the workflow's variables (the caller's arguments over the defaults).
+- **New optional schema field `vram_estimate.gb_per_reference`.** The term
+  counts each `references` entry whose `from_file`/`from_previous_result` is
+  non-null (#478's null rule). Every kind of reference counts once.
+- **One error per exceeded cost entry, for the largest step only.** For a
+  `for_each` member, the error sits at `arguments.shots[i]` when the caller
+  supplied `shots`, `variables.shots[i]` otherwise, and `steps[k].for_each[i]`
+  for a literal list. The message names the member (`Member 'shot@<name>':`)
+  and its reference count.
+- **Calibration** of every Ref2VA template: `base_gb` 16.0,
+  `bytes_per_voxel` 28.71, `gb_per_reference` 1.0, against the 24 GB entry.
+  At 1344x768:
+
+  | shot | projected | verdict |
+  |---|---|---|
+  | 209x2 | 23.77 GB | valid |
+  | 175x3 | 23.83 GB | valid |
+  | 209x3 | 24.77 GB | refused |
+  | 260x1 | 24.18 GB | refused |
+
+  This puts the 1344x768 ceiling at 243/209/175/141 frames for 1/2/3/4
+  references. `minimax-h3` SKILL.md states these figures, pinned from the
+  template block in `tests/test_plugin_skills.py`.
+- **Templates.**
+  - Recalibrated: `reference-to-video` and `storyboard`.
+  - Newly declared: `dialogue-short`, `music-video`, `composable-references`,
+    `generated-subject-reference`, `voice-timbre-reference` and the three
+    `chain-*` Ref2VA templates.
+  - Unchanged: T2VA and FL2VA.
+- **Tests:** `tests/test_vram_estimate.py` and `tests/test_h3_vram_ceiling.py`.
+- **Docs:**
+  - the minimax README;
+  - the SKILL;
+  - the CLAUDE.md gotcha;
+  - `docs/RECIPES_24GB.md`.
+
+### Stage B (#502): inherit the ceiling by pipeline identity, as a warning
+
+- **The index.** `dw/vram_inheritance.py` `build_index` maps
+  `(component_type, model_name, workflow)` to
+  `{vram_estimate, cost, template}`. The server's `_ceiling_index(ws)` caches
+  it against the listing's mtimes. `POST /api/validate` and pre-queue
+  (`POST /api/jobs`) use it.
+- **Matching.** A workflow with no `vram_estimate` has each expanded pipeline
+  step matched by identity and projected with stage A's code. Over the ceiling,
+  it gets a `vram_projection_inherited` warning that names the source template
+  and says the offload/quantization config may differ. It is never a refusal.
+  A workflow's own declaration always wins.
+- **Sources today:**
+  - `ref2va`: `templates/minimax/reference-to-video`;
+  - `t2va`: `templates/minimax/shots-batch`;
+  - LTX-2.5: `templates/ltx2/text-to-video`.
+- **Agreement test.** `tests/test_vram_inheritance.py` pins every template
+  declaring one identity to the same numbers.
+- **Docs:**
+  - the MCP instructions (now naming the inherited source and that config may
+    differ);
+  - `docs/WORKFLOW_GUIDE.md`'s authoring section;
+  - CLAUDE.md.
+
+## Deviations from the plan
+
+- The `reason` strings cite the report's table rather than job ids, since the
+  report carried none.
+- Six Ref2VA templates declare `vram_estimate` but have no `cost` entry, so
+  their block is inert: the three `chain-*` templates,
+  `composable-references`, `generated-subject-reference` and
+  `voice-timbre-reference`. `cost` is never derived.
+- Validation projects an off-grid frame count at its raw value, before
+  `snap: "up"` rounding.
+- Only single-identity templates with a non-empty `cost` feed the index. Ties
+  go to the fewest steps, then the name.
+- The warning kind is embedded in the warning string.
+- `POST /api/jobs/{id}/rerun` is not wired to inheritance, since a rerun
+  re-submits a job that already passed pre-queue.
+
+## Deferred
+
+- **The host-memory half** (the 311x3 SIGKILL at 960x544). #243's host
+  projection is observed-only and keyed on the catalog name, so an inline
+  workflow has no history to read.
+  - **Reopen trigger:** a second host SIGKILL on an inline workflow, or #243
+    gaining a pipeline-keyed source.
+- **Re-checking a composed child** at the composing step's arguments. This is
+  a separate gap and was not filed.
+- **Calibration** rests on one box and four points, with about 0.2 GB of
+  margin either side. Measurement runs that bracket the line would sharpen it.
+  A video reference may cost more than 1.0 GB, but nothing measured it.
+- **MPS:** the numbers stay CUDA-measured.
+
+## Stages, cost and bounces
+
+| stage | shipped | bounces |
+|---|---|---|
+| A #501 | `develop` @ `bb23147` | 0 (M-F043 to M-F048 passed first time) |
+| B #502 | `develop` @ `1a94551`, fix @ `156a948` | 1: M-F054, the MCP instructions sentence named neither the source template nor that config may differ; docs-only fix |
+
+The stage comments name no `usage:` figures, so cost is not recorded. The
+plan estimated $9 to $13.
+
+Acceptance cases: M-F043 to M-F054 in `regression-suite-model-specific.md`.
+The tester found an arithmetic error in M-F049's 260-frame step (the text said
+1 ref, but the inline copy carries 3) and filed an amendment on harnest.
diff --git a/docs/proposals/todo.md b/docs/proposals/todo.md
index 4d18b217..7984c436 100644
--- a/docs/proposals/todo.md
+++ b/docs/proposals/todo.md
@@ -47,6 +47,14 @@ remaining deferred fix is recorded in
 - **Closing the xfail security tests** (#407, stages #409-#413), shipped
   2026-09-24. Record, including what was deferred (a UI Content-Security-Policy,
   Playwright in CI): `complete/xfail-security-tests-complete.md`.
+- **`attribute_voices`, which reference singer sings each line** (#485,
+  stages #494-#495), shipped 2026-09-27. Record, including what was
+  deferred (template wiring, demucs weights in `downloads_required`):
+  `complete/attribute-voices-complete.md`.
+- **H3 Ref2VA VRAM ceiling: references, `for_each` members, hand-built
+  workflows** (#479, stages #501-#502), shipped 2026-09-27. Record, including
+  what was deferred (the host-memory half, measured calibration):
+  `complete/h3-vram-ceiling-references-complete.md`.
 
 ## Declined
 
diff --git a/dw/assessment_rules.py b/dw/assessment_rules.py
index 7b8c75b4..f8a6acca 100644
--- a/dw/assessment_rules.py
+++ b/dw/assessment_rules.py
@@ -19,11 +19,13 @@
 `LEVEL_SPREAD_WARN_DB`, so the join-time warning and the after-the-fact
 probe cannot disagree about the same cut.
 
-Two rules carry a guard the table alone cannot express, applied by the
+Three rules carry a guard the table alone cannot express, applied by the
 probe and named here in `unless` so it is written down beside the number:
-`seam_hole` holds only while both sides of the seam are voiced, and
+`seam_hole` holds only while both sides of the seam are voiced,
 `seam_frame_jump` does not fire at a seam whose incoming shot is marked
-`hard_cut: true` - a cut meant as a cut.
+`hard_cut: true` - a cut meant as a cut - and `shot_dead_air` does not fire
+inside a shot whose own level is already at or below `HOLE_VOICED_DBFS` - a
+shot that is quiet throughout, on purpose, rather than one holding a gap.
 
 The thresholds were settled against real runs on the server in stage D
 (#386); `docs/WORKFLOW_GUIDE.md` and `docs/TASKS.md` quote every one, and
@@ -38,6 +40,12 @@
 # rather than a pause the shots themselves hold
 HOLE_VOICED_DBFS = -30.0
 
+# Below this, a 50ms window inside a shot counts toward a dead-air run - low
+# enough that ordinary room tone under a line (well above this) never
+# qualifies, high enough to catch the -70 to -84 dBFS gaps an H3 dialogue
+# take leaves between lines (#465)
+DEAD_AIR_FLOOR_DBFS = -65.0
+
 COMPARATORS = {
     ">": lambda value, threshold: value > threshold,
     ">=": lambda value, threshold: value >= threshold,
@@ -95,6 +103,21 @@
         "says": "the picture changes this many times more across the seam than inside either shot",
         "unless": "the incoming shot is marked hard_cut: true",
     },
+    {
+        "name": "shot_dead_air",
+        "probe": "analyze_shots",
+        "field": "dead_air_seconds",
+        "comparator": ">",
+        "threshold": 0.4,
+        "severity": "warn",
+        "says": (
+            "the shot holds a gap this long, well below the floor a line's own room"
+            " tone sits at - cut a room-tone bed from the take with slice_audio, loop"
+            " it to the gap's length with loop_audio, and mix it under the line with"
+            " mix_audio rather than leaving the drop silent"
+        ),
+        "unless": f"the shot's own rms is at or below {HOLE_VOICED_DBFS} dBFS",
+    },
     {
         "name": "sync_drift",
         "probe": "analyze_sync_drift",
@@ -148,7 +171,16 @@ def finding(rule, value, at):
     }
 
 
+def sort_findings(findings):
+    """Findings with every `info` moved after the `warn`s, order otherwise
+    unchanged - a real problem (`seam_hole`, `shot_dead_air`, ...) never
+    sits behind an informational one (`seam_frame_jump`) a reader skims
+    past first (#466)."""
+    return sorted(findings, key=lambda found: found.get("severity") == "info")
+
+
 __all__ = [
+    "DEAD_AIR_FLOOR_DBFS",
     "HOLE_VOICED_DBFS",
     "RULES",
     "RULES_BY_NAME",
@@ -156,4 +188,5 @@ def finding(rule, value, at):
     "crosses",
     "finding",
     "rules_for",
+    "sort_findings",
 ]
diff --git a/dw/introspection.py b/dw/introspection.py
index 261aabd1..cc78d0cf 100644
--- a/dw/introspection.py
+++ b/dw/introspection.py
@@ -396,10 +396,12 @@ def list_tasks():
     """Every task command a workflow's task step can name.
 
     `assessment` names the probes among the commands (#387) - the ones that
-    answer a JSON document of measurements about a finished file rather than
-    make one - so a caller looking for a way to check a cut finds them
-    without reading every command's schema. They stay in `commands` too,
-    since a step still names one as its `command`.
+    measure a finished cut and say where to look rather than make one - so a
+    caller looking for a way to check a cut finds them without reading every
+    command's schema. They stay in `commands` too, since a step still names
+    one as its `command`. Membership is the `assessment` flag the command
+    registered with, not its JSON return: `attribute_voices` answers JSON
+    and is not a check of a cut (#485).
     """
     from .tasks.task import (
         _COMMAND_INFO,
@@ -413,9 +415,7 @@ def list_tasks():
         "image_processors": sorted(available_processors()),
         "video_processors": list(_VIDEO_PROCESSOR_COMMANDS),
         "assessment": sorted(
-            name
-            for name, info in _COMMAND_INFO.items()
-            if info.get("returns") == "json"
+            name for name, info in _COMMAND_INFO.items() if info.get("assessment")
         ),
     }
 
diff --git a/dw/locations.py b/dw/locations.py
index 32606f82..deac8dec 100644
--- a/dw/locations.py
+++ b/dw/locations.py
@@ -151,7 +151,8 @@ def validate_media_path(
             raise PathTraversalError(
                 f"Refusing to read {what} at '{location}': it resolves "
                 f"outside every directory this workflow may read "
-                f"({', '.join(roots) or 'none configured'}). This includes "
+                f"(its own directory, the asset libraries and the output "
+                f"root). This includes "
                 f"another workspace's own directories - each workspace is "
                 f"isolated by design, not just a generic path-traversal "
                 f"refusal, so a bare path into one is refused the same way "
@@ -208,9 +209,9 @@ def validate_media_glob(pattern, base_dir=None, what="a glob argument"):
     roots = media_roots(base_dir)
     if not any(_within(resolved, root) for root in roots):
         raise PathTraversalError(
-            f"Refusing {what} '{pattern}': it expands under {resolved}, "
-            f"outside every directory this workflow may read "
-            f"({', '.join(roots) or 'none configured'}). Glob inside the "
+            f"Refusing {what} '{pattern}': it expands outside every "
+            f"directory this workflow may read (its own directory, the asset "
+            f"libraries and the output root). Glob inside the "
             f"asset library, or pass --trust-workflows if you trust this "
             f"workflow's source."
         )
@@ -449,6 +450,61 @@ def validate_model_name(name, base_dir=None):
     )
 
 
+# The key a Hub file inside a model repo is named by - a lora's, an IP
+# adapter's, a task's weights. It names a file *within* a repo, so it is a
+# relative path and nothing else
+WEIGHT_NAME_KEY = "weight_name"
+
+# Tasks that read their weights with safetensors and nothing else. A pickle
+# format is refused by name rather than left to fail in the loader: the
+# refusal is the documented contract, not an accident of which loader runs
+SAFETENSORS_ONLY_COMMANDS = ()
+SAFETENSORS_SUFFIX = ".safetensors"
+
+
+def validate_weight_name(name, suffixes=None, what="weight_name"):
+    """A file name inside a Hub repo: relative, and never climbing out of it.
+
+    `hf_hub_download(filename=...)` joins the name onto the local cache
+    directory, so a name shaped like a path is a path on this machine. A
+    subfolder is legitimate (the H3 upscaler's default lives under one);
+    an absolute path, a backslash, a drive, an empty segment or a '.'/'..'
+    segment is not. The refusal names only what the caller wrote, never a
+    directory on the server.
+
+    Args:
+        name: The file name the workflow supplied
+        suffixes: The file endings allowed, or None for any
+        what: Short phrase naming the argument, for the error message
+
+    Raises:
+        PathTraversalError: On a name that is not a plain relative path
+        InvalidInputError: On an empty name, or one with a refused ending
+    """
+    if not isinstance(name, str) or not name.strip():
+        raise InvalidInputError(f"Refusing an empty {what}.")
+    if "\x00" in name:
+        raise InvalidInputError(f"Refusing a {what} containing a null byte.")
+    if name.startswith(("/", "~")) or "\\" in name or ":" in name:
+        raise PathTraversalError(
+            f"Refusing a {what} of '{name}': it names a file inside the model "
+            f"repo, so it must be a relative path - no leading '/' or '~', no "
+            f"backslash, no drive."
+        )
+    if any(segment in ("", ".", "..") for segment in name.split("/")):
+        raise PathTraversalError(
+            f"Refusing a {what} of '{name}': it has an empty, '.' or '..' "
+            f"path segment, so it does not name a file inside the model repo."
+        )
+    if suffixes and not name.lower().endswith(tuple(suffixes)):
+        raise InvalidInputError(
+            f"Refusing a {what} of '{name}': only "
+            f"{', '.join(repr(suffix) for suffix in suffixes)} weights are "
+            f"read here."
+        )
+    return name
+
+
 # ------------------------------------------------------------- validation
 
 
@@ -529,11 +585,20 @@ def location_errors(definition, source_indices=None, base_dir=None):
             if source_indices and index < len(source_indices)
             else index
         )
-        _walk(step, f"steps[{source}]", base_dir, errors)
+        _walk(step, f"steps[{source}]", base_dir, errors, _weight_suffixes(step))
     return errors
 
 
-def _walk(node, path, base_dir, errors):
+def _weight_suffixes(step):
+    """The weight file endings a step's task reads, or None for any."""
+    task = step.get("task")
+    command = task.get("command") if isinstance(task, dict) else None
+    if command in SAFETENSORS_ONLY_COMMANDS:
+        return (SAFETENSORS_SUFFIX,)
+    return None
+
+
+def _walk(node, path, base_dir, errors, weight_suffixes=None):
     if isinstance(node, dict):
         for key, value in node.items():
             here = f"{path}.{key}"
@@ -542,6 +607,12 @@ def _walk(node, path, base_dir, errors):
                 if message:
                     errors.append({"path": here, "message": message})
                 continue
+            if key == WEIGHT_NAME_KEY and isinstance(value, str):
+                if not _deferred(value):
+                    message = _refusal(validate_weight_name, value, weight_suffixes)
+                    if message:
+                        errors.append({"path": here, "message": message})
+                continue
             if key == "remote_text_encoder" and isinstance(value, dict):
                 url = value.get("url")
                 if isinstance(url, str) and not _deferred(url):
@@ -559,15 +630,24 @@ def _walk(node, path, base_dir, errors):
                     message = _check(item, base_dir, f"'{key}'")
                     if message:
                         errors.append({"path": sub_path, "message": message})
+            if key == "voices" and isinstance(value, dict):
+                # attribute_voices maps a voice's name to its reference, and
+                # a string reference is a clip it reads - the key is the
+                # voice's name, not a media key, so it is checked here or
+                # only when the run reaches it (#494)
+                for name, item in value.items():
+                    message = _check(item, base_dir, f"voice '{name}'")
+                    if message:
+                        errors.append({"path": f"{here}.{name}", "message": message})
             if key == "urls" and isinstance(value, list):
                 for sub_path, item in _each(value, here):
                     message = _check(item, base_dir, f"'{key}'")
                     if message:
                         errors.append({"path": sub_path, "message": message})
-            _walk(value, here, base_dir, errors)
+            _walk(value, here, base_dir, errors, weight_suffixes)
     elif isinstance(node, list):
         for index, item in enumerate(node):
-            _walk(item, f"{path}[{index}]", base_dir, errors)
+            _walk(item, f"{path}[{index}]", base_dir, errors, weight_suffixes)
 
 
 def _each(value, path):
diff --git a/dw/null_media.py b/dw/null_media.py
new file mode 100644
index 00000000..55f27d08
--- /dev/null
+++ b/dw/null_media.py
@@ -0,0 +1,99 @@
+"""Catch, at validation time, an object description whose media resolved null.
+
+`realize_args` builds a pipeline argument that names a type and where its media
+comes from - MiniMax-H3's references are the catalog's example. When that media
+source resolves to null (typically a `variable:` left unset), the object is
+`OMITTED`: dropped silently when it sits in a list, since that is how a
+template makes a reference optional (`dw/arguments.py`'s list branch). But the
+*same* dict sitting directly under a key, not in a list, has nothing to leave
+it out of - `realize_args` raises there, at run time, after the checkpoint is
+already loaded (#478).
+
+This mirrors that raise, not the silent drop: only a bare object description
+in "dict context" is an error here, exactly the shapes `realize_args`' own
+dict branch would refuse. One found inside a list is left alone, since a
+template author relies on that being silently dropped rather than reported.
+"""
+
+from .arguments import (
+    FROM_ARGUMENTS_KEY,
+    FROM_FILE_KEY,
+    FROM_PREVIOUS_RESULT_KEY,
+    _names_no_media,
+)
+from .for_each import MEMBER_SEPARATOR, render_path
+
+_FROM_KEYS = (FROM_FILE_KEY, FROM_PREVIOUS_RESULT_KEY, FROM_ARGUMENTS_KEY)
+
+
+def _walk(value, path, in_list, errors):
+    if isinstance(value, dict):
+        if not in_list and _names_no_media(value):
+            from_key = next(k for k in _FROM_KEYS if value.get(k, False) is None)
+            errors.append(
+                {
+                    "path": render_path(path + (from_key,)),
+                    "message": (
+                        f"'{path[-1]}' names an object to build but the media "
+                        f"it would be built from is null. An optional one "
+                        f"belongs in a list, where it can be left out; on its "
+                        f"own there is nothing to leave it out of"
+                    ),
+                }
+            )
+            return
+        for key, item in value.items():
+            _walk(item, path + (key,), False, errors)
+    elif isinstance(value, list):
+        for index, item in enumerate(value):
+            _walk(item, path + (index,), True, errors)
+
+
+def null_media_errors(workflow_definition, source_indices=None):
+    """Every bare object description whose media is null, as [{path, message}].
+
+    The definition handed here has already been substituted and expanded, so a
+    `for_each` member's own arguments are checked as they will run;
+    `source_indices` maps each expanded step back to the step the author
+    wrote, and the member is named in the message - the same convention
+    reference_limit_errors uses.
+    """
+    steps = workflow_definition.get("steps")
+    if not isinstance(steps, list):
+        return []
+
+    errors = []
+    for index, step in enumerate(steps):
+        if not isinstance(step, dict):
+            continue
+        pipeline = step.get("pipeline")
+        arguments = pipeline.get("arguments") if isinstance(pipeline, dict) else None
+        if not isinstance(arguments, dict):
+            continue
+        source = (
+            source_indices[index]
+            if source_indices is not None and index < len(source_indices)
+            else index
+        )
+        name = step.get("name")
+        where = (
+            f" in member '{name}'"
+            if isinstance(name, str) and MEMBER_SEPARATOR in name
+            else ""
+        )
+        step_errors = []
+        for key, value in arguments.items():
+            _walk(
+                value,
+                ("steps", source, "pipeline", "arguments", key),
+                False,
+                step_errors,
+            )
+        for error in step_errors:
+            errors.append(
+                {
+                    "path": error["path"],
+                    "message": f"{error['message']}{where}.",
+                }
+            )
+    return errors
diff --git a/dw/result.py b/dw/result.py
index 23e3400d..3cc06e92 100644
--- a/dw/result.py
+++ b/dw/result.py
@@ -668,21 +668,39 @@ def get_artifact_properties(self, property_name):
                 lookup) would silently drop data or raise a confusing TypeError.
         """
         values = []
+        missing = None
         for result in self.result_list:
             if isinstance(result, Mapping):
                 if property_name in result:
                     values.append(result[property_name])
+                else:
+                    missing = missing or result
                 continue
 
             value = getattr(result, property_name, _NO_PROPERTY)
             # A string's every 'property' is a method, and so is most of a list's -
             # the original loud failure for those is the useful answer
             if value is _NO_PROPERTY or callable(value):
+                missing = missing or result
+                continue
+            values.append(value)
+
+        # Only when no result carries the property is the missing one an error
+        # (#499). An empty list is not "nothing to do": the step reading it gets
+        # zero iterations and succeeds having written nothing - a modular step's
+        # raw output dict holds 'sampling_rate', and asking it for 'sample_rate'
+        # silently skipped the mux that depended on it
+        if missing is not None and not values:
+            if isinstance(missing, Mapping):
+                keys = ", ".join(sorted(str(key) for key in missing)) or "none"
                 raise ValueError(
                     f"result has no property '{property_name}' "
-                    f"(it is a {type(result).__name__}, not a dict)"
+                    f"(it is a dict with keys: {keys})"
                 )
-            values.append(value)
+            raise ValueError(
+                f"result has no property '{property_name}' "
+                f"(it is a {type(missing).__name__}, not a dict)"
+            )
 
         logger.debug(f"Retrieved {len(values)} values for property: {property_name}")
         return values
@@ -830,6 +848,26 @@ def save_artifact(
             )
             saved_files = []
             for k, v in artifact.items():
+                if isinstance(v, torch.Tensor) and not content_type.startswith("audio"):
+                    # A modular pipeline's leftover output not part of the
+                    # video/audio pairing (dw's own 'latents', from an H3
+                    # upscale step's output: [..., "latents"]) is raw model
+                    # state, not media - it has no video/image/json rendering
+                    # under the step's declared content_type, and trying one
+                    # crashed the exporter deep inside its own error (#507).
+                    # It stays reachable as previous_result:<step>.<key>
+                    # straight off the in-memory result; only the file write
+                    # here is skipped.
+                    emit_warning(
+                        f"'{k}' in '{file_base_name}' is a raw tensor, not "
+                        f"media - skipped saving it under content_type "
+                        f"{content_type!r}. It is still available as "
+                        f"previous_result:<step>.{k}.",
+                        kind="non_media_artifact_skipped",
+                        key=k,
+                        content_type=content_type,
+                    )
+                    continue
                 saved_files.extend(
                     self.save_artifact(
                         output_dir,
@@ -931,6 +969,22 @@ def save_artifact(
                 with open(output_path, "w") as file:
                     file.write(json.dumps(artifact, indent=4))
             elif content_type.startswith("text"):
+                if not isinstance(artifact, str):
+                    # Static validation (dw/scalar_result_validation.py, #498)
+                    # catches a literal transcribe_audio(timestamps=...)
+                    # against the wrong content_type before the queue, but a
+                    # 'timestamps' reached through a 'variable:' is literal
+                    # only at run time - this names the same mismatch for
+                    # the one path that can still get here (a
+                    # transcribe_audio 'chunks' list, in practice), instead
+                    # of a bare write() TypeError after the step already ran
+                    raise ValueError(
+                        f"'{file_base_name}' is a {type(artifact).__name__}, not "
+                        "text - a command whose result is JSON-shaped (for "
+                        "example transcribe_audio with timestamps set) needs "
+                        "'result.content_type' set to 'application/json', not "
+                        f"{content_type!r}"
+                    )
                 with open(output_path, "w") as file:
                     file.write(artifact)
             elif hasattr(artifact, "save"):
diff --git a/dw/scalar_result_validation.py b/dw/scalar_result_validation.py
index 0faf482d..8fa5473d 100644
--- a/dw/scalar_result_validation.py
+++ b/dw/scalar_result_validation.py
@@ -16,6 +16,17 @@
 `application/json`; any other content type explodes the dict key by key
 into files, or dies on a number. So a `result` on one is allowed and must
 say `application/json`.
+
+`transcribe_audio` (#498) is a third shape: its `returns` is declared
+"artifact" because that is what it answers by default (plain text), but a
+literal `timestamps` of "segment"/"word" switches its return value to a
+{text, chunks} dict - chunks being a list, which explodes fine under
+`application/json` but dies with a bare `write() argument must be str, not
+list` under `text/plain`. Checked here as a special case keyed on the
+command name and the literal argument value, because unlike `judge`'s or
+the probes' `returns`, the shape is not a property of the command alone -
+`timestamps` reached through a `variable:` is invisible here and is instead
+named at save time (`Result.save_artifact`).
 """
 
 from .for_each import MEMBER_SEPARATOR, render_path
@@ -23,6 +34,25 @@
 
 RESULT_KEY = "result"
 JSON_CONTENT_TYPE = "application/json"
+_TIMESTAMPED_TRANSCRIPTION_COMMAND = "transcribe_audio"
+
+
+def _literal_timestamps(arguments):
+    """True when `arguments` sets a literal `timestamps` of "segment"/"word"
+    - the one shape that switches `transcribe_audio`'s return value to a
+    {text, chunks} dict. A `variable:`-supplied value is not literal here and
+    is left to `Result.save_artifact` to name at run time.
+
+    Imports `dw.tasks.audio_transcription` lazily - that module imports
+    transformers at module scope (deliberately, per its own docstring, to
+    keep the heavy import out of workflows that never transcribe), and this
+    module is on the path of every `validate_workflow` call.
+    """
+    if not isinstance(arguments, dict):
+        return False
+    from .tasks.audio_transcription import TIMESTAMP_KINDS
+
+    return arguments.get("timestamps") in TIMESTAMP_KINDS
 
 
 def scalar_result_errors(workflow_definition, source_indices=None):
@@ -58,14 +88,26 @@ def scalar_result_errors(workflow_definition, source_indices=None):
         except ValueError:
             continue
         returns = info.get("returns")
-        if returns == "json":
+        timestamped = (
+            command == _TIMESTAMPED_TRANSCRIPTION_COMMAND
+            and _literal_timestamps(task.get("arguments"))
+        )
+        if returns == "json" or timestamped:
             if result.get("content_type") == JSON_CONTENT_TYPE:
                 continue
-            message = (
-                f"{command} answers a JSON document - 'result' must set "
-                f"content_type '{JSON_CONTENT_TYPE}', not "
-                f"{result.get('content_type')!r}"
-            )
+            if timestamped:
+                message = (
+                    f"{command} with timestamps={task['arguments']['timestamps']!r} "
+                    f"answers a {{text, chunks}} document, not plain text - "
+                    f"'result' must set content_type '{JSON_CONTENT_TYPE}', not "
+                    f"{result.get('content_type')!r}"
+                )
+            else:
+                message = (
+                    f"{command} answers a JSON document - 'result' must set "
+                    f"content_type '{JSON_CONTENT_TYPE}', not "
+                    f"{result.get('content_type')!r}"
+                )
         elif returns == "scalar":
             message = (
                 f"{command} returns a number, not an artifact - "
diff --git a/dw/serve.py b/dw/serve.py
index 8c471eac..e83da281 100644
--- a/dw/serve.py
+++ b/dw/serve.py
@@ -270,7 +270,15 @@ def main():
         # would otherwise hold this line back until shutdown
         flush=True,
     )
-    uvicorn.run(app, host=args.host, port=args.port, log_level=args.log_level.lower())
+    uvicorn.run(
+        app,
+        host=args.host,
+        port=args.port,
+        log_level=args.log_level.lower(),
+        # a streamable-HTTP MCP client left connected otherwise holds SIGTERM
+        # off indefinitely (#477); a few seconds still lets lifespan cleanup run
+        timeout_graceful_shutdown=5,
+    )
 
 
 if __name__ == "__main__":
diff --git a/dw/server/app.py b/dw/server/app.py
index c9849805..71cd4454 100644
--- a/dw/server/app.py
+++ b/dw/server/app.py
@@ -158,6 +158,7 @@
 from .updater import DiffusersUpdater
 from .sysinfo import runtime_info
 from .catalog_shape import derive_catalog_metadata, project_listing
+from ..vram_inheritance import build_index
 from . import guides
 from .guides import GuideError
 from .. import settings
@@ -1035,6 +1036,36 @@ def _sources_for(ws):
         first, then the same read-only roots every workspace shares."""
         return workflow_sources(ws.workflows, examples_dirs)
 
+    # One index per distinct listing - keyed by every file's path and mtime,
+    # so an edited, added or removed template rebuilds it and nothing else does
+    ceiling_indexes = {}
+
+    def _ceiling_index(ws):
+        """The catalog's VRAM ceilings by pipeline identity, as this
+        workspace's search path lists them (`dw/vram_inheritance.py`, #502).
+        A file that cannot be read contributes nothing."""
+        paths = []
+        for name, source in sorted(listing(_sources_for(ws)).items()):
+            path = os.path.join(source.root, f"{name}.json")
+            try:
+                paths.append((name, path, os.path.getmtime(path)))
+            except OSError:
+                continue
+        signature = tuple(paths)
+        cached = ceiling_indexes.get(ws.name)
+        if cached and cached[0] == signature:
+            return cached[1]
+        catalog = []
+        for name, path, _ in paths:
+            try:
+                with open(path, "r") as file:
+                    catalog.append((name, json.load(file)))
+            except (OSError, ValueError):
+                continue
+        index = build_index(catalog)
+        ceiling_indexes[ws.name] = (signature, index)
+        return index
+
     # ------------------------------------------------------------------ jobs
 
     def _acknowledgement_form(value):
@@ -1220,6 +1251,11 @@ def submit_job(request: JobRequest, ws: Workspace = Depends(selected_workspace))
                     if form == ACK_BOUND
                     else None
                 ),
+                # A ceiling inherited from the catalog warns and never
+                # refuses, so it rides on the job the caller got (#502)
+                warnings=candidate.inherited_vram_warnings(
+                    request.arguments, _ceiling_index(workspace)
+                ),
             )
         except HTTPException:
             raise
@@ -1609,8 +1645,10 @@ def list_guides():
     def get_guide(name: str, section: Optional[str] = None):
         """One guide from /api/guides, whole or one section of it. A
         section name is matched loosely - case and punctuation dropped -
-        so a heading copied approximately still resolves. An unknown name
-        or section is a 404 whose detail lists what exists."""
+        so a heading copied approximately still resolves, and also reaches
+        a `###` subsection not listed at the top level, by its own heading
+        or by a term inside it. An unknown name or section is a 404 whose
+        detail lists what exists."""
         try:
             return guides.get_guide(name, section=section)
         except GuideError as e:
@@ -1619,8 +1657,8 @@ def get_guide(name: str, section: Optional[str] = None):
     def _argument_reference_errors(definition, arguments, ws):
         """The 'asset:', 'prompt:' and 'output:' references that name nothing
         this workspace can reach, in the values a run would actually use -
-        the caller's `arguments`, plus every declared `variables` default
-        the caller did not override.
+        the caller's `arguments`, every declared `variables` default the
+        caller did not override, and the literals written into the steps.
 
         A stored default is exactly as much a promise as a caller's value:
         `validate_workflow(name="templates/ltx2/reference-sheet")` with no
@@ -1686,6 +1724,14 @@ def _string_leaves(value, path):
                     effective.append((f"variables.{name}", value))
         for name, value in supplied.items():
             effective.append((f"arguments.{name}", value))
+        # A reference written straight into a step is as much a promise as
+        # one in a variable: `asset:cast/no-such-voice.wav` as a literal
+        # attribute_voices voice validated clean and died on the step
+        # (#494). Walked as written, so the path is the author's
+        steps = definition.get("steps") if isinstance(definition, dict) else None
+        if isinstance(steps, list):
+            for index, step in enumerate(steps):
+                effective.append((f"steps[{index}]", step))
 
         errors = []
         for base_path, value in effective:
@@ -1897,7 +1943,14 @@ def validate_workflow(
             # statically-knowable video's real frame count - silently
             # clipped rather than refused, but previously said only by the
             # run itself (#425)
-            + candidate.shot_span_warnings(request.arguments),
+            + candidate.shot_span_warnings(request.arguments)
+            # A step loading a pipeline the catalog declares a VRAM ceiling
+            # for, in a workflow that declares none, projected past it - a
+            # warning, since this workflow's offload/quantization may be
+            # leaner than the template's (#502)
+            + candidate.inherited_vram_warnings(
+                request.arguments, _ceiling_index(workspace)
+            ),
         }
         if request.arguments:
             # Naming what was checked is the difference between 'the stored
@@ -2229,6 +2282,7 @@ def save_workflow(
             )
         return {
             "name": name,
+            "workspace": ws.name,
             "path": path,
             "warnings": warnings,
             "shape": metadata["shape"],
@@ -2259,7 +2313,12 @@ def delete_workflow(name: str, ws: Workspace = Depends(selected_workspace)):
         # deletes and recreates the same workflow, would inherit the deleted
         # copy's observed figures and host-memory history
         manager.history.orphan_workflow_history(ws.name, name)
-        return {"name": name, "deleted": True}
+        return {
+            "name": name,
+            "workspace": ws.name,
+            "origin": source.origin,
+            "deleted": True,
+        }
 
     @app.get("/api/workflows/{name:path}/download")
     @query_token_ok
@@ -3861,6 +3920,7 @@ async def upload_media(
             path = f"/inputs/{UPLOADS_SUBDIR}/{quote(name)}"
             result = {
                 "path": f"asset:{UPLOADS_SUBDIR}/{name}",
+                "workspace": ws.name,
                 "url": _served_url(path, ws),
                 "shared": shared,
             }
@@ -3871,6 +3931,7 @@ async def upload_media(
         path = f"/outputs/{UPLOADS_SUBDIR}/{quote(name)}"
         result = {
             "path": dest,
+            "workspace": ws.name,
             "url": _served_url(path, ws),
         }
         absolute_url = _absolute_served_url(path, ws)
@@ -4167,7 +4228,13 @@ def delete_asset(name: str, ws: Workspace = Depends(selected_workspace)):
             os.remove(path)
             logger.info(f"Deleted asset:{relative} ({path})")
             forget_workspace_usage()
-            return {"name": relative, "deleted": True, "origin": origin}
+            return {
+                "name": relative,
+                "workspace": ws.name,
+                "reference": f"asset:{relative}",
+                "deleted": True,
+                "origin": origin,
+            }
 
         raise HTTPException(status_code=404, detail=f"No such asset: {relative}")
 
diff --git a/dw/server/assess.py b/dw/server/assess.py
index 6aada932..50cc23b5 100644
--- a/dw/server/assess.py
+++ b/dw/server/assess.py
@@ -17,6 +17,7 @@
 
 import json
 
+from ..assessment_rules import sort_findings
 from ..tasks.assess import (
     read_media,
     seams_answer,
@@ -111,8 +112,10 @@ def assess(path, kind, shots, probe=None, detail=False):
     }
     body = {
         "shots_source": source,
-        "findings": _dedupe_findings(
-            found for answer in answers.values() for found in answer["findings"]
+        "findings": sort_findings(
+            _dedupe_findings(
+                found for answer in answers.values() for found in answer["findings"]
+            )
         ),
         "rules_applied": [
             rule for answer in answers.values() for rule in answer["rules_applied"]
diff --git a/dw/server/guides.py b/dw/server/guides.py
index 50e7ad04..9bfa8b7c 100644
--- a/dw/server/guides.py
+++ b/dw/server/guides.py
@@ -80,6 +80,11 @@
 # better reached by reading the section they sit in
 SECTION_PATTERN = re.compile(r"^## (.+)$", re.M)
 
+# Not indexed (see above), but `section=` still has to reach one: a `###`
+# subsection is real content a caller can name exactly, and refusing that
+# because it isn't in the listing is the gap #503 reported.
+SUBSECTION_PATTERN = re.compile(r"^### (.+)$", re.M)
+
 # A doc's link to an example is a repo-relative path, which resolves for a
 # reader with a checkout and dead-ends for the one these guides are served
 # to: an agent holding the MCP and nothing else. Said once, on a payload
@@ -168,6 +173,41 @@ def _extract_section(text, section):
     return None
 
 
+def _extract_subsection(text, section):
+    """One `###` subsection's text, heading included, plus the `##` section
+    it sits under - or None if no subsection matches.
+
+    Matched on containment rather than equality (unlike `_extract_section`):
+    a subsection heading is usually a full sentence ("One step per entry:
+    for_each"), and the term a caller actually has in hand is the concept
+    inside it ("for_each"), not the sentence.
+    """
+    wanted = _normalized(section)
+    if not wanted:
+        return None
+    section_matches = list(SECTION_PATTERN.finditer(text))
+    for index, section_match in enumerate(section_matches):
+        section_end = (
+            section_matches[index + 1].start()
+            if index + 1 < len(section_matches)
+            else len(text)
+        )
+        section_text = text[section_match.start() : section_end]
+        sub_matches = list(SUBSECTION_PATTERN.finditer(section_text))
+        for sub_index, sub_match in enumerate(sub_matches):
+            normalized_heading = _normalized(sub_match.group(1))
+            if wanted != normalized_heading and wanted not in normalized_heading:
+                continue
+            sub_end = (
+                sub_matches[sub_index + 1].start()
+                if sub_index + 1 < len(sub_matches)
+                else len(section_text)
+            )
+            content = section_text[sub_match.start() : sub_end].rstrip() + "\n"
+            return sub_match.group(1), content, section_match.group(1)
+    return None
+
+
 def _noted(body):
     """The payload, with the repo-path rule attached when it holds one.
 
@@ -210,13 +250,26 @@ def get_guide(name, section=None):
         return _noted(_index(name, text))
 
     found = _extract_section(text, section)
-    if found is None:
-        raise GuideError(
-            f"The '{name}' guide has no section '{section}'. Its sections are: "
-            f"{', '.join(_sections(text))}."
+    if found is not None:
+        heading, content = found
+        return _noted({"name": name, "section": heading, "content": content})
+
+    sub_found = _extract_subsection(text, section)
+    if sub_found is not None:
+        heading, content, parent = sub_found
+        return _noted(
+            {
+                "name": name,
+                "section": heading,
+                "parent_section": parent,
+                "content": content,
+            }
         )
-    heading, content = found
-    return _noted({"name": name, "section": heading, "content": content})
+
+    raise GuideError(
+        f"The '{name}' guide has no section '{section}'. Its sections are: "
+        f"{', '.join(_sections(text))}."
+    )
 
 
 def _index(name, text):
diff --git a/dw/server/jobs.py b/dw/server/jobs.py
index 5708ebdc..5a9f9dcc 100644
--- a/dw/server/jobs.py
+++ b/dw/server/jobs.py
@@ -781,6 +781,7 @@ def submit(
         catalog_name=None,
         acknowledged=ACK_NONE,
         acknowledged_cost=None,
+        warnings=None,
     ):
         """Validate a job request and queue it. Raises ValueError on a bad
         request so the HTTP layer can answer 400 before anything runs.
@@ -802,6 +803,10 @@ def submit(
         `acknowledged` is the form of cost acknowledgement the caller gave
         (none/boolean/bound) and `acknowledged_cost` the bound object - both
         recorded, neither checked here; the route checks (#85).
+
+        `warnings` are the caller's own, added to the job's - the route's
+        inherited VRAM ceiling (#502), which needs the catalog this manager
+        does not hold.
         """
         arguments = arguments or {}
         if (workflow_path is None) == (workflow is None):
@@ -888,6 +893,9 @@ def submit(
         spec["warnings"] = workflow_argument_warnings(
             loaded.workflow_definition, arguments
         )
+        # What the caller worked out and this manager cannot - a VRAM ceiling
+        # inherited from the catalog needs the workspace's search path (#502)
+        spec["warnings"] += list(warnings or [])
 
         job = Job(spec)
         with self._lock:
diff --git a/dw/shots.py b/dw/shots.py
index 60e9aa0f..10ee8df7 100644
--- a/dw/shots.py
+++ b/dw/shots.py
@@ -21,6 +21,11 @@
   not build shot by shot (a chain's `match_audio`)
 - `overlap_frames` - a dissolve's head: the frames at its start that are
   blended with the shot before it
+- `hard_cut` - `concat_videos` marks it `True` on the shot it starts at every
+  seam it itself draws (never the first shot, which has no seam before it) -
+  a cut meant as a cut, which `seam_frame_jump` (`dw/assessment_rules.py`)
+  reads to stay quiet there. A chained pipeline's inner segments leave it
+  unset, since continuity is expected between them
 
 Every other `AudioVideo` constructor either carries the list (same frames),
 rescales it (`interpolate_frames`), re-measures the sample side for a new
@@ -341,6 +346,34 @@ def step_shots(saved_shots, saved_files, references=None):
     ]
 
 
+def duplicate_shot_names(shots):
+    """Names that collide within one file's shot map, or None.
+
+    Two joined inputs whose inner `for_each` used the same entry names
+    (`shot@accuse` from one episode and `shot@accuse` from another, #508)
+    leave the joined map unable to tell them apart by name - `start_frame`
+    still disambiguates, but a `shots=` argument or a finding that addresses
+    a shot by name cannot. Checked per `file` (a multi-file manifest entry
+    keeps each file's names independent), and returns the duplicated names
+    for each file that has any, in file order, so the caller can name them
+    in one warning rather than emitting one per shot.
+    """
+    if not shots:
+        return None
+    groups = {}
+    for shot in shots:
+        groups.setdefault(shot.get("file"), []).append(shot["name"])
+    duplicates = {}
+    for file, names in groups.items():
+        counts = {}
+        for name in names:
+            counts[name] = counts.get(name, 0) + 1
+        dups = [name for name in dict.fromkeys(names) if counts[name] > 1]
+        if dups:
+            duplicates[file] = dups
+    return duplicates or None
+
+
 def shots_for_file(shots, path, step_files):
     """The shots of one file out of a manifest entry's `shots`, or None.
 
diff --git a/dw/task_domains.py b/dw/task_domains.py
index 94c1b130..e61bc7bc 100644
--- a/dw/task_domains.py
+++ b/dw/task_domains.py
@@ -147,6 +147,10 @@
         "sample_rate": POSITIVE,
     },
     "analyze_audio": {"sample_rate": POSITIVE},
+    "attribute_voices": {
+        "window_seconds": POSITIVE,
+        "min_reference_seconds": POSITIVE,
+    },
     "grade": {
         "contrast": NON_NEGATIVE,
         "saturation": NON_NEGATIVE,
diff --git a/dw/tasks/assess.py b/dw/tasks/assess.py
index 288ae045..0a6c2ced 100644
--- a/dw/tasks/assess.py
+++ b/dw/tasks/assess.py
@@ -28,7 +28,14 @@
 
 import numpy
 
-from ..assessment_rules import HOLE_VOICED_DBFS, crosses, finding, rules_for
+from ..assessment_rules import (
+    DEAD_AIR_FLOOR_DBFS,
+    HOLE_VOICED_DBFS,
+    crosses,
+    finding,
+    rules_for,
+    sort_findings,
+)
 from ..events import emit_warning
 
 logger = logging.getLogger("dw")
@@ -52,6 +59,12 @@
 # dividing a seam's change by it would call any change at all a jump.
 # Grey levels on the 0-255 scale.
 TYPICAL_DELTA_FLOOR = 2.0
+
+# The window a dead-air run inside a shot is measured in, seconds - fine
+# enough that a half-second gap the rule cares about still spans several
+# windows, coarse enough that ordinary syllable-to-syllable dips don't read
+# as a run on their own (#465)
+DEAD_AIR_WINDOW = 0.05
 TYPICAL_DELTA_PERCENTILE = 90
 
 # A ratio against a zero neighbour has no size; report it capped
@@ -323,6 +336,56 @@ def _round(value, places=2):
     return None if value is None else round(float(value), places)
 
 
+def _dead_air(media, start, count):
+    """The longest run of consecutive `DEAD_AIR_WINDOW`-second windows inside
+    a shot's audio span that sit at or below `DEAD_AIR_FLOOR_DBFS` - a gap in
+    the middle of the take, not the shot's own overall level (`_findings`'s
+    `unless` guard reads that separately). A window whose RMS is digital
+    silence (`_db` answers None) counts as below the floor too - it is
+    quieter than the floor, not un-measurable.
+
+    Returns (seconds, at, floor_dbfs): `at` is seconds into the *file*
+    (matching the seams probe's own seconds fields), so a caller does not
+    have to add the shot's own start back on. All three are None when the
+    span holds fewer than two windows; `seconds` is 0.0 with no run found.
+    """
+    rate = media.sample_rate
+    if start is None or not rate:
+        return None, None, None
+    window_samples = max(1, int(round(DEAD_AIR_WINDOW * rate)))
+    total = media.audio.shape[1]
+    end = min(total, start + count)
+    if end - start < window_samples * 2:
+        return None, None, None
+    levels = [
+        _db(_rms(media.audio[:, offset : offset + window_samples]))
+        for offset in range(start, end - window_samples + 1, window_samples)
+    ]
+    best_len, best_start, best_levels = 0, None, []
+    run_start, run_levels = None, []
+    for index, level in enumerate(levels):
+        if level is None or level <= DEAD_AIR_FLOOR_DBFS:
+            if run_start is None:
+                run_start = index
+            run_levels.append(level)
+            continue
+        if len(run_levels) > best_len:
+            best_len, best_start, best_levels = len(run_levels), run_start, run_levels
+        run_start, run_levels = None, []
+    if len(run_levels) > best_len:
+        best_len, best_start, best_levels = len(run_levels), run_start, run_levels
+    if best_len == 0:
+        return 0.0, None, None
+    floor_values = [level for level in best_levels if level is not None]
+    seconds = best_len * window_samples / rate
+    at = (start + best_start * window_samples) / rate
+    return (
+        _round(seconds, 2),
+        _round(at, 2),
+        _round(min(floor_values)) if floor_values else None,
+    )
+
+
 def _findings(probe, record, at, skip=()):
     found = []
     for rule in rules_for(probe):
@@ -433,7 +496,7 @@ def _answer(probe, measurements, findings, shots_source, shot_dependent=()):
         )
     return {
         **measurements,
-        "findings": findings,
+        "findings": sort_findings(findings),
         "rules_applied": applied,
         "rules_skipped": skipped,
         "shots_source": shots_source,
@@ -450,8 +513,8 @@ def analyze_shots(video, shots=None):
 
     Returns:
         {shots: [{name, start_frame, num_frames, peak_dbfs, rms_dbfs, crest_db, low_dbfs, mid_dbfs,
-        high_dbfs, samples}], rms_range_db, findings, rules_applied,
-        rules_skipped, shots_source}
+        high_dbfs, dead_air_seconds, dead_air_at, dead_air_floor_dbfs, samples}], rms_range_db,
+        findings, rules_applied, rules_skipped, shots_source}
     """
     media = media_from(video)
     return shots_answer(media, *resolve_shots(video, media, shots))
@@ -483,6 +546,9 @@ def shots_answer(media, records, source):
             if window is not None and window.size
             else {"low_dbfs": None, "mid_dbfs": None, "high_dbfs": None}
         )
+        dead_air_seconds, dead_air_at, dead_air_floor_dbfs = (
+            _dead_air(media, start, count) if start is not None else (None, None, None)
+        )
         measured.append(
             {
                 "name": shot.get("name"),
@@ -492,6 +558,9 @@ def shots_answer(media, records, source):
                 "rms_dbfs": _round(rms),
                 "crest_db": _round(None if peak is None or rms is None else peak - rms),
                 **{key: _round(value) for key, value in balance.items()},
+                "dead_air_seconds": dead_air_seconds,
+                "dead_air_at": dead_air_at,
+                "dead_air_floor_dbfs": dead_air_floor_dbfs,
                 "samples": samples_source,
             }
         )
@@ -507,10 +576,25 @@ def shots_answer(media, records, source):
     elif voiced:
         rms_range = 0.0
     answer = {"shots": measured, "rms_range_db": rms_range, "has_audio": True}
+    dead_air_findings = []
+    for shot in measured:
+        # A shot that is quiet throughout, on purpose, holds no gap to find -
+        # the same guard seam_hole applies to a seam's two sides (#465)
+        quiet = shot["rms_dbfs"] is not None and shot["rms_dbfs"] <= HOLE_VOICED_DBFS
+        dead_air_findings.extend(
+            _findings(
+                "analyze_shots",
+                shot,
+                {"shot": shot["name"], "seconds": shot["dead_air_at"]},
+                skip={"shot_dead_air"} if quiet else (),
+            )
+        )
     return _answer(
         "analyze_shots",
         answer,
-        overrun_findings + (_findings("analyze_shots", answer, at) if at else []),
+        overrun_findings
+        + (_findings("analyze_shots", answer, at) if at else [])
+        + dead_air_findings,
         source,
         shot_dependent={"shot_level_spread"},
     )
diff --git a/dw/tasks/audio_transcription.py b/dw/tasks/audio_transcription.py
index 5aa87d23..7aa455de 100644
--- a/dw/tasks/audio_transcription.py
+++ b/dw/tasks/audio_transcription.py
@@ -27,6 +27,11 @@
 _DEFAULT_ASR_MODEL = "openai/whisper-base"
 _ASR_SAMPLE_RATE = 16000
 _WHISPER_WINDOW_SECONDS = 30
+# Public: dw/scalar_result_validation.py checks a literal `timestamps`
+# argument against this same tuple to catch a `result.content_type` that
+# does not match the {text, chunks} dict shape timestamps switches the
+# return value to (#498).
+TIMESTAMP_KINDS = ("segment", "word")
 
 
 def _downmixed_mono(waveform):
@@ -53,10 +58,21 @@ def transcribe_audio(audio, device="cpu", sample_rate=None, **kwargs):
         **kwargs:
             model_name: HuggingFace model ID of a Whisper-class ASR model
                 (default: openai/whisper-base).
+            timestamps: Unset (default) returns plain text. "segment" or
+                "word" instead returns a dict of {text, chunks}, chunks
+                being a list of {start, end, text} - the step's result
+                content_type must then be "application/json" rather than
+                "text/plain", since the return shape follows the argument.
 
     Returns:
-        Transcribed text string.
+        Transcribed text string, or (with timestamps set) a
+        {text, chunks} dict of {start, end, text} chunks.
     """
+    timestamps = kwargs.get("timestamps")
+    if timestamps is not None and timestamps not in TIMESTAMP_KINDS:
+        raise ValueError(
+            f"timestamps must be one of {TIMESTAMP_KINDS}, got {timestamps!r}"
+        )
     waveform, waveform_rate = _waveform_and_rate(audio, sample_rate, "transcribe_audio")
     mono = _downmixed_mono(waveform)
     if waveform_rate != _ASR_SAMPLE_RATE:
@@ -86,11 +102,14 @@ def load_pipe():
     # long-form mode stitches windows. Asked for only of Whisper and only past
     # 30 s: transformers raises for a CTC model unless the value is "char" or
     # "word", and for any other seq2seq model at all
+    is_whisper = getattr(pipe, "type", None) == "seq2seq_whisper"
     options = {}
-    if (
-        getattr(pipe, "type", None) == "seq2seq_whisper"
-        and len(mono) > _WHISPER_WINDOW_SECONDS * _ASR_SAMPLE_RATE
-    ):
+    if timestamps == "word":
+        # "word" is accepted by both a seq2seq Whisper model and a CTC model
+        options["return_timestamps"] = "word"
+    elif timestamps == "segment":
+        options["return_timestamps"] = True
+    elif is_whisper and len(mono) > _WHISPER_WINDOW_SECONDS * _ASR_SAMPLE_RATE:
         options["return_timestamps"] = True
     result = pipe(
         {"raw": mono.astype(numpy.float32), "sampling_rate": _ASR_SAMPLE_RATE},
@@ -98,4 +117,15 @@ def load_pipe():
     )
     text = result["text"].strip()
     logger.info(f"Transcript: {text[:100]}{'...' if len(text) > 100 else ''}")
-    return text
+    if timestamps is None:
+        return text
+
+    chunks = [
+        {
+            "start": chunk.get("timestamp", (None, None))[0],
+            "end": chunk.get("timestamp", (None, None))[1],
+            "text": chunk.get("text", "").strip(),
+        }
+        for chunk in result.get("chunks", [])
+    ]
+    return {"text": text, "chunks": chunks}
diff --git a/dw/tasks/audio_utils.py b/dw/tasks/audio_utils.py
index 1d844bed..a4722893 100644
--- a/dw/tasks/audio_utils.py
+++ b/dw/tasks/audio_utils.py
@@ -11,11 +11,13 @@
 from fractions import Fraction
 
 import numpy
+import scipy.ndimage
+import scipy.signal
 import soundfile
 import torch
 
 from ..events import emit_log, emit_warning
-from ..loudness import integrated_lufs
+from ..loudness import TRUE_PEAK_OVERSAMPLE, integrated_lufs
 from ..task_domains import as_number, check_arguments
 from ..security import (
     validate_file_extension,
@@ -1394,7 +1396,9 @@ def fade_audio(audio, fade_in_ms=0, fade_out_ms=0, sample_rate=None):
     return _as_track(faded, sample_rate, "fade_audio")
 
 
-def normalize_audio(audio, peak_dbfs=-1.0, target_lufs=None, sample_rate=None):
+def normalize_audio(
+    audio, peak_dbfs=-1.0, target_lufs=None, limit=False, sample_rate=None
+):
     """Task command: scale a track so its loudest sample sits at a level.
 
     Generated music comes out at whatever level the model happened to land
@@ -1417,6 +1421,13 @@ def normalize_audio(audio, peak_dbfs=-1.0, target_lufs=None, sample_rate=None):
             and if reaching target_lufs would cross it the gain stops at the
             ceiling and a warning names the shortfall in LU. None (the
             default) leaves behavior exactly as peak-only
+        limit: Hold peak_dbfs with a look-ahead limiter instead of capping the
+            gain, so target_lufs can be reached past a transient that sets
+            the peak. peak_dbfs becomes a true-peak (4x oversampled, BS.1770)
+            ceiling; the gain is target_lufs's alone (the limiter never adds
+            any), and limiting stops at 12 dB of reduction, past which
+            target_lufs is warned as capped. False (the default) leaves
+            behavior exactly as without it
         sample_rate: Sample rate of a waveform passed directly
 
     Returns:
@@ -1424,6 +1435,10 @@ def normalize_audio(audio, peak_dbfs=-1.0, target_lufs=None, sample_rate=None):
         track is returned unchanged
     """
     check_arguments("normalize_audio", sample_rate=sample_rate, target_lufs=target_lufs)
+    if not isinstance(limit, (bool, numpy.bool_)):
+        raise ValueError(
+            f"normalize_audio 'limit' must be true or false, got {limit!r}"
+        )
     waveform, sample_rate = _waveform_and_rate(audio, sample_rate, "normalize_audio")
     if peak_dbfs > 0:
         raise ValueError("normalize_audio 'peak_dbfs' cannot be above full scale (0)")
@@ -1431,6 +1446,12 @@ def normalize_audio(audio, peak_dbfs=-1.0, target_lufs=None, sample_rate=None):
     if peak == 0.0:
         logger.warning("normalize_audio: the track is silent - left unchanged")
         return _as_track(waveform, sample_rate, "normalize_audio")
+    if limit:
+        return _as_track(
+            _normalize_limited(waveform, sample_rate, peak_dbfs, target_lufs),
+            sample_rate,
+            "normalize_audio",
+        )
 
     peak_db = 20 * numpy.log10(peak)
     measured_lufs = None
@@ -1461,8 +1482,8 @@ def normalize_audio(audio, peak_dbfs=-1.0, target_lufs=None, sample_rate=None):
                 emit_warning(
                     f"normalize_audio: target_lufs={target_lufs} would need "
                     f"{target_gain_db:+.1f} dB of gain, but peak_dbfs={peak_dbfs} "
-                    f"caps it at {gain_db:+.1f} dB - "
-                    f"{target_gain_db - gain_db:.1f} LU short of the target.",
+                    f"caps the gain at {gain_db:+.1f} dB - lands "
+                    f"{target_gain_db - gain_db:.1f} LU below the target.",
                     kind="target_lufs_capped",
                     command="normalize_audio",
                     target_lufs=target_lufs,
@@ -1485,6 +1506,275 @@ def normalize_audio(audio, peak_dbfs=-1.0, target_lufs=None, sample_rate=None):
     )
 
 
+# The limiter normalize_audio(limit=True) runs. Fixed rather than exposed
+# (#474): long enough not to pump on a laugh, short enough not to duck the
+# line after it. The look-ahead ramps the gain down before a transient; the
+# hold keeps it down across the transient's own cycles; the release then
+# recovers linearly in dB
+LIMITER_LOOKAHEAD_MS = 5.0
+LIMITER_HOLD_MS = 20.0
+LIMITER_RELEASE_MS = 150.0
+LIMITER_RELEASE_DB = 6.0
+# Past this much reduction a target is squashing the track rather than
+# levelling it, so the gain stops and target_lufs_capped says so
+LIMITER_MAX_REDUCTION_DB = 12.0
+# Past this much reduction pumping becomes audible - limiter_heavy
+LIMITER_HEAVY_DB = 6.0
+# Limiting lowers loudness by an amount that depends on how dense the
+# material is, so the gain is searched for rather than corrected once (one
+# pass left a dense track 2 LU short, #496). The search stops within this much
+# of the target, after at most this many limiting passes; a track still
+# further short than the tolerance is warned target_lufs_capped
+LIMITER_TOLERANCE_LU = 0.1
+LIMITER_SEARCH_PASSES = 8
+# Oversampling runs in blocks so a long track never holds 4x of itself; the
+# polyphase filter reaches about ten input samples each side, so this much
+# overlap makes each block's interior exact
+_TRUE_PEAK_BLOCK = 1 << 18
+_TRUE_PEAK_OVERLAP = 32
+# A gain this close to unity is floating-point noise, not reduction
+_UNITY_TOLERANCE = 1e-6
+
+
+def _true_peak_envelope(waveform):
+    """The per-sample true peak of a (channels, samples) waveform, linked
+    across channels so the loudest one drives them all and the stereo image
+    does not shift. Each sample carries the largest oversampled value on
+    either side of it, so an inter-sample peak is owed by both neighbours."""
+    total = waveform.shape[1]
+    envelope = numpy.zeros(total, dtype=numpy.float32)
+    for start in range(0, total, _TRUE_PEAK_BLOCK):
+        stop = min(total, start + _TRUE_PEAK_BLOCK)
+        low = max(0, start - _TRUE_PEAK_OVERLAP)
+        high = min(total, stop + _TRUE_PEAK_OVERLAP)
+        block = scipy.signal.resample_poly(
+            waveform[:, low:high].astype(numpy.float32),
+            TRUE_PEAK_OVERSAMPLE,
+            1,
+            axis=1,
+        )
+        linked = numpy.abs(block).max(axis=0)
+        per_sample = linked.reshape(high - low, TRUE_PEAK_OVERSAMPLE).max(axis=1)
+        envelope[start:stop] = per_sample[start - low : stop - low]
+    envelope[1:] = numpy.maximum(envelope[1:], envelope[:-1])
+    return envelope
+
+
+def _limiter_curve(envelope, ceiling, sample_rate):
+    """The per-sample gain (<= 1) that holds `envelope` under `ceiling`, or
+    None when nothing crosses it.
+
+    Vectorised end to end: the required gain goes through a forward sliding
+    minimum over the look-ahead, a backward one over the hold, a linear-in-dB
+    release (a cumulative minimum), and a boxcar as long as the look-ahead.
+    Every value the boxcar averages is the minimum of a window that contains
+    the sample it lands on, so the curve never exceeds the required gain -
+    it ramps down before a transient rather than delaying the signal.
+    """
+    required = numpy.minimum(
+        1.0, ceiling / numpy.maximum(envelope.astype(numpy.float64), 1e-12)
+    )
+    if required.min() >= 1.0 - _UNITY_TOLERANCE:
+        return None
+    total = required.size
+    half = max(1, int(round(LIMITER_LOOKAHEAD_MS / 2000.0 * sample_rate)))
+    lookahead = 2 * half
+    centred = scipy.ndimage.minimum_filter1d(required, lookahead + 1, mode="nearest")
+    ahead = numpy.concatenate([centred[half:], numpy.full(half, centred[-1])])[:total]
+
+    hold = max(1, int(round(LIMITER_HOLD_MS / 1000.0 * sample_rate)))
+    centred = scipy.ndimage.minimum_filter1d(ahead, 2 * hold + 1, mode="nearest")
+    held = numpy.empty_like(ahead)
+    head = min(hold, total)
+    held[:head] = numpy.minimum.accumulate(ahead[:head])
+    held[head:] = centred[: total - head]
+
+    rate = LIMITER_RELEASE_DB / (LIMITER_RELEASE_MS / 1000.0 * sample_rate)
+    ramp = rate * numpy.arange(total, dtype=numpy.float64)
+    held_db = 20.0 * numpy.log10(held)
+    released = 10.0 ** ((numpy.minimum.accumulate(held_db - ramp) + ramp) / 20.0)
+
+    padded = numpy.concatenate([numpy.full(lookahead, released[0]), released])
+    sums = numpy.concatenate([[0.0], numpy.cumsum(padded)])
+    curve = (sums[lookahead + 1 :] - sums[: -lookahead - 1]) / (lookahead + 1)
+    return numpy.minimum(curve, required)
+
+
+def _limit_at(waveform, envelope, gain_db, ceiling, sample_rate):
+    """One limiting pass at a static gain: the output, the limiter's curve
+    (None when it touched nothing), the static trim a reconstruction
+    overshoot needed, and the output's true peak (linear)."""
+    gain = 10 ** (gain_db / 20)
+    curve = _limiter_curve(envelope * gain, ceiling, sample_rate)
+    if curve is None:
+        output = (waveform * gain).astype(numpy.float32)
+    else:
+        output = (waveform * (gain * curve)[numpy.newaxis, :]).astype(numpy.float32)
+    output_peak = float(_true_peak_envelope(output).max())
+    trim = 1.0
+    if output_peak > ceiling * (1.0 + 1e-4):
+        trim = ceiling / output_peak
+        output = (output * trim).astype(numpy.float32)
+        output_peak *= trim
+    return output, curve, trim, output_peak
+
+
+def _search_gain(
+    waveform, envelope, ceiling, sample_rate, target_lufs, low_db, high_db
+):
+    """The static gain in [low_db, high_db] whose limited output lands within
+    LIMITER_TOLERANCE_LU of target_lufs: (gain_db, _limit_at's result, output
+    LUFS). Loudness rises with the gain, but by less than the gain once the
+    limiter acts, so this starts at the target's own gain (exact while the
+    limiter is idle), tries the cap when that falls short, and closes the
+    bracket between the two by regula falsi. Where even the cap falls short
+    the cap is the answer, and the caller warns the shortfall."""
+
+    def attempt(gain_db):
+        limited = _limit_at(waveform, envelope, gain_db, ceiling, sample_rate)
+        return gain_db, limited, integrated_lufs(limited[0].T, sample_rate)
+
+    def miss(result):
+        return None if result[2] is None else target_lufs - result[2]
+
+    low = attempt(low_db)
+    if miss(low) is None or miss(low) <= LIMITER_TOLERANCE_LU or low_db >= high_db:
+        return low
+    high = attempt(high_db)
+    if miss(high) is None or miss(high) >= -LIMITER_TOLERANCE_LU:
+        return high
+    best = min((low, high), key=lambda result: abs(miss(result)))
+    for _ in range(LIMITER_SEARCH_PASSES - 2):
+        low_miss, high_miss = miss(low), miss(high)
+        span = high[0] - low[0]
+        gain_db = low[0] + span * low_miss / (low_miss - high_miss)
+        # Stay off the bracket's ends, so a curved response cannot stall
+        # regula falsi against one side of it
+        gain_db = min(max(gain_db, low[0] + 0.1 * span), high[0] - 0.1 * span)
+        probe = attempt(gain_db)
+        if miss(probe) is None:
+            break
+        if abs(miss(probe)) < abs(miss(best)):
+            best = probe
+        if abs(miss(probe)) <= LIMITER_TOLERANCE_LU:
+            break
+        if miss(probe) > 0:
+            low = probe
+        else:
+            high = probe
+    return best
+
+
+def _normalize_limited(waveform, sample_rate, peak_dbfs, target_lufs):
+    """normalize_audio(limit=True): the target's gain, applied uncapped, with
+    a true-peak limiter holding peak_dbfs. The limiter is never a gain stage
+    - makeup comes from target_lufs alone - and it stops at
+    LIMITER_MAX_REDUCTION_DB, past which the gain is what stops instead."""
+    ceiling = 10 ** (peak_dbfs / 20)
+    envelope = _true_peak_envelope(waveform)
+    input_peak_db = 20 * numpy.log10(float(envelope.max()))
+    peak_gain_db = peak_dbfs - input_peak_db
+    most_gain_db = peak_gain_db + LIMITER_MAX_REDUCTION_DB
+
+    measured_lufs = None
+    target_gain_db = None
+    if target_lufs is not None:
+        measured_lufs = integrated_lufs(waveform.T, sample_rate)
+        if measured_lufs is None:
+            emit_warning(
+                f"normalize_audio: target_lufs={target_lufs} was given, but the "
+                "track's loudness could not be measured (shorter than the 400 ms "
+                "gating block, or silent throughout) - falling back to peak_dbfs "
+                "alone.",
+                kind="target_lufs_unmeasurable",
+                command="normalize_audio",
+                target_lufs=target_lufs,
+            )
+        else:
+            target_gain_db = target_lufs - measured_lufs
+
+    if target_gain_db is None:
+        gain_db = peak_gain_db
+        output, curve, trim, output_peak = _limit_at(
+            waveform, envelope, gain_db, ceiling, sample_rate
+        )
+        output_lufs = integrated_lufs(output.T, sample_rate)
+    else:
+        gain_db, (output, curve, trim, output_peak), output_lufs = _search_gain(
+            waveform,
+            envelope,
+            ceiling,
+            sample_rate,
+            target_lufs,
+            min(target_gain_db, most_gain_db),
+            most_gain_db,
+        )
+
+    lowest = (1.0 if curve is None else float(curve.min())) * trim
+    max_reduction_db = max(0.0, -20 * numpy.log10(lowest))
+    if curve is None:
+        limited_fraction = 1.0 if trim < 1.0 else 0.0
+    else:
+        limited_fraction = float(
+            numpy.count_nonzero(curve * trim < 1.0 - _UNITY_TOLERANCE) / curve.size
+        )
+    output_peak_db = 20 * numpy.log10(output_peak)
+
+    shortfall = None
+    if target_gain_db is not None:
+        if output_lufs is not None:
+            shortfall = target_lufs - output_lufs
+        elif gain_db < target_gain_db:
+            shortfall = target_gain_db - gain_db
+    if shortfall is not None and shortfall > LIMITER_TOLERANCE_LU:
+        reason = (
+            f"would need more than {LIMITER_MAX_REDUCTION_DB:.0f} dB of limiting "
+            f"under peak_dbfs={peak_dbfs}, so the gain stops at {gain_db:+.1f} dB"
+            if gain_db >= most_gain_db - 1e-9
+            else f"was not reached under peak_dbfs={peak_dbfs} at "
+            f"{gain_db:+.1f} dB of gain"
+        )
+        emit_warning(
+            f"normalize_audio: target_lufs={target_lufs} {reason} - lands "
+            f"{shortfall:.1f} LU below the target.",
+            kind="target_lufs_capped",
+            command="normalize_audio",
+            target_lufs=target_lufs,
+            peak_dbfs=peak_dbfs,
+            shortfall_lu=round(shortfall, 2),
+            limited=True,
+        )
+    if max_reduction_db > LIMITER_HEAVY_DB:
+        emit_warning(
+            f"normalize_audio: the limiter reduced the loudest moments by "
+            f"{max_reduction_db:.1f} dB to hold peak_dbfs={peak_dbfs} - past "
+            f"{LIMITER_HEAVY_DB:.0f} dB, pumping can be audible. A lower "
+            "target_lufs asks less of it.",
+            kind="limiter_heavy",
+            command="normalize_audio",
+            max_gain_reduction_db=round(max_reduction_db, 1),
+            peak_dbfs=peak_dbfs,
+            target_lufs=target_lufs,
+        )
+    emit_log(
+        f"normalize_audio: measured {input_peak_db:.1f} dBTP"
+        + ("" if measured_lufs is None else f", {measured_lufs:.1f} LUFS")
+        + f" -> gain {gain_db:+.1f} dB, limiter up to {max_reduction_db:.1f} dB "
+        f"on {limited_fraction:.1%} of samples -> {output_peak_db:.1f} dBTP"
+        + ("" if output_lufs is None else f", {output_lufs:.1f} LUFS"),
+        command="normalize_audio",
+        measured_true_peak_dbfs=round(input_peak_db, 1),
+        measured_lufs=round(measured_lufs, 1) if measured_lufs is not None else None,
+        gain_db=round(gain_db, 1),
+        constraint="limiter",
+        max_gain_reduction_db=round(max_reduction_db, 2),
+        limited_fraction=round(limited_fraction, 4),
+        output_true_peak_dbfs=round(output_peak_db, 2),
+        output_lufs=round(output_lufs, 1) if output_lufs is not None else None,
+    )
+    return output
+
+
 def _fade_curve(window):
     """A cosine fall from full level to exact silence, both ends included -
     unlike the seam ramps, which stop short of the endpoint so two of them
diff --git a/dw/tasks/concat_videos.py b/dw/tasks/concat_videos.py
index 450a7147..c0a7f8e6 100644
--- a/dw/tasks/concat_videos.py
+++ b/dw/tasks/concat_videos.py
@@ -24,7 +24,12 @@
     resample_waveform,
     warn_on_level_spread,
 )
-from .video_utils import check_same_frame_size, frames_as_pil_list, load_audio_video
+from .video_utils import (
+    check_same_frame_size,
+    frames_as_pil_list,
+    is_video_location,
+    load_audio_video,
+)
 
 logger = logging.getLogger("dw")
 
@@ -65,11 +70,19 @@ def concat_videos(
 
     Args:
         videos: The videos to join, in order - frame lists, frame arrays,
-            AudioVideos (from previous_result references), or the path or URL
-            of a video file, which is read with the audio muxed into it. Give
+            AudioVideos (from previous_result references), the path or URL
+            of a video file, or a {"location": ...} dict wrapping either -
+            the same idiom get_last_frame(video=...) and a pipeline's
+            'image' argument accept (#510) - each read with the audio muxed
+            into it. Give
             each video its own entry: one previous_result reference naming a
             step that produced several videos fans this step out over them,
-            one concatenation per video, rather than joining them
+            one concatenation per video, rather than joining them. Every
+            video must be the same frame size - unlike a sample-rate
+            mismatch, there is no reconciliation for a size mismatch, so a
+            statically-resolvable (asset:/output:/literal path) size
+            disagreement is refused at validate; one only known at run time
+            still fails there (#504)
         trim_frames: Frames dropped from the head of every video after the
             first - the trim used when each video was generated from the
             previous one's last frame
@@ -128,7 +141,7 @@ def concat_videos(
     names = video_names(videos)
     # A shot an earlier run already wrote is loaded here rather than by
     # gather_videos, which reads frames only and would join it silent
-    videos = [load_audio_video(v) if isinstance(v, str) else v for v in videos]
+    videos = [load_audio_video(v) if is_video_location(v) else v for v in videos]
     clips = [frames_as_pil_list(v) for v in videos]
     check_same_frame_size(clips, "concat_videos")
 
@@ -229,6 +242,11 @@ def concat_videos(
                     names[index], start_frame, len(frames) - start_frame, start_sample
                 )
             ]
+        if index and video_shots:
+            # Every seam this step draws is a cut it chose to make, unlike a
+            # chain's inner segments (continuity is expected there) - marking
+            # it lets analyze_seams tell the two apart (#466)
+            video_shots[0]["hard_cut"] = True
         # Which input this shot came from - named_shots (dw/shots.py) uses
         # it to place a step's override name on the right shot once an
         # earlier input has nested more than one of its own (#432)
diff --git a/dw/tasks/dissolve_videos.py b/dw/tasks/dissolve_videos.py
index 527ab5bc..46e64a15 100644
--- a/dw/tasks/dissolve_videos.py
+++ b/dw/tasks/dissolve_videos.py
@@ -30,7 +30,12 @@
     warn_on_level_spread,
 )
 from .concat_videos import video_names
-from .video_utils import check_same_frame_size, frames_as_array, load_audio_video
+from .video_utils import (
+    check_same_frame_size,
+    frames_as_array,
+    is_video_location,
+    load_audio_video,
+)
 
 logger = logging.getLogger("dw")
 
@@ -50,9 +55,15 @@ def dissolve_videos(
 
     Args:
         videos: The videos to join, in order - frame lists, frame arrays,
-            AudioVideos, or the path or URL of a video file. Give each video
-            its own entry, as with concat_videos. Soundtracks at different
-            sample rates are not a constraint - see `sample_rate` below
+            AudioVideos, the path or URL of a video file, or a
+            {"location": ...} dict wrapping either (#510). Give each video
+            its own entry, as with concat_videos. Every video must be the
+            same frame size - unlike a sample-rate mismatch, there is no
+            reconciliation for a size mismatch, so a statically-resolvable
+            (asset:/output:/literal path) size disagreement is refused at
+            validate; one only known at run time still fails there (#504).
+            Soundtracks at different sample rates are not a constraint - see
+            `sample_rate` below
         dissolve_frames: Frames of overlap at each seam. 0 is a hard cut
         fade_in_frames: Frames over which the first video rises out of
             `fade_color`
@@ -88,7 +99,7 @@ def dissolve_videos(
     if dissolve_frames < 0 or fade_in_frames < 0 or fade_out_frames < 0:
         raise ValueError("dissolve_videos frame counts cannot be negative")
 
-    loaded = [load_audio_video(v) if isinstance(v, str) else v for v in videos]
+    loaded = [load_audio_video(v) if is_video_location(v) else v for v in videos]
     clips = [frames_as_array(v).astype(numpy.float32) for v in loaded]
     check_same_frame_size(clips, "dissolve_videos")
 
diff --git a/dw/tasks/pair_audio.py b/dw/tasks/pair_audio.py
index a213bbfe..44579d4f 100644
--- a/dw/tasks/pair_audio.py
+++ b/dw/tasks/pair_audio.py
@@ -25,6 +25,41 @@
 LENGTH_WARN_MS = 100.0
 
 
+def _one_video(frames):
+    """The frames of one video, unwrapping a batch of one.
+
+    A pipeline's `videos` output is batched - one entry per generation - and
+    a modular step hands that batch on as it is, so
+    `previous_result:base.videos` arrives as a list holding one frame list (or
+    a 5-D array). Passed through, the encoder took the batch for a frame list
+    and failed at save (#499); the waveform beside it already had its batch of
+    one unwrapped by `as_channels_samples`. A batch of several is refused
+    rather than guessed at: which generation the track belongs under is not
+    this function's to pick.
+    """
+    ndim = getattr(frames, "ndim", None)
+    if ndim == 5:
+        count = frames.shape[0]
+    elif (
+        isinstance(frames, (list, tuple))
+        and frames
+        and (
+            isinstance(frames[0], (list, tuple))
+            or getattr(frames[0], "ndim", None) == 4
+        )
+    ):
+        count = len(frames)
+    else:
+        return frames
+    if count != 1:
+        raise ValueError(
+            f"pair_audio: 'video' is a batch of {count} videos, and one track "
+            f"goes under one video. Generate one video per step, or pair each "
+            f"from its own step"
+        )
+    return frames[0]
+
+
 class _Loaded:
     """A waveform read from a file, shaped like the artifact pair_audio expects."""
 
@@ -178,7 +213,8 @@ def pair_audio(video, audio, sample_rate=None, fps=None, fit=None):
     """Pair a video's frames with an audio track.
 
     Args:
-        video: The frames - a frame list, a frame array or tensor, or an
+        video: The frames - a frame list, a frame array or tensor (or a
+            pipeline's batch of one of those, unwrapped), or an
             AudioVideo whose own soundtrack is replaced by this one; the
             frames' own rate is carried through to the output, so set
             `result.fps` only to override it (a loaded file brings its rate
@@ -249,7 +285,7 @@ def pair_audio(video, audio, sample_rate=None, fps=None, fit=None):
     # Frames are left in whatever shape they arrived in - the result saves a frame
     # list, an array and a tensor alike, and converting a long video here would
     # cost a copy of the whole thing for nothing
-    frames = video.frames if isinstance(video, AudioVideo) else video
+    frames = _one_video(video.frames if isinstance(video, AudioVideo) else video)
     frame_rate = fps if fps is not None else getattr(video, "fps", None)
     logger.debug(f"Pairing frames with audio at {rate} Hz")
     waveform = _fit_to_video(
diff --git a/dw/tasks/task.py b/dw/tasks/task.py
index 674e5ec0..4ab15892 100644
--- a/dw/tasks/task.py
+++ b/dw/tasks/task.py
@@ -41,6 +41,7 @@ def register_command(
     returns="artifact",
     summary=None,
     parameter_descriptions=None,
+    assessment=False,
 ):
     """
     Decorator to register a command handler function.
@@ -67,10 +68,10 @@ def register_command(
             `validation_errors` (dw/scalar_result_validation.py, #212) rather
             than reaching `save_artifact` at run time, where a float has
             nothing left identifying which command produced it
-            - or "json" for a command answering a JSON-safe dict of
-            measurements (the assessment probes, `dw/tasks/assess.py`): its
-            `result` may only be `application/json`, since any other content
-            type would explode the dict key by key into files
+            - or "json" for a command answering a JSON-safe dict (the
+            assessment probes, `attribute_voices`): its `result` may only be
+            `application/json`, since any other content type would explode
+            the dict key by key into files
         summary: Overrides the command's `get_task` summary, which otherwise
             reads the implementation function's docstring. For a command
             whose handler dispatches its implementation per video frame
@@ -81,6 +82,11 @@ def register_command(
         parameter_descriptions: Overrides one or more of the implementation's
             per-parameter `get_task` descriptions by name, for the same
             single-frame-vs-command reason as `summary`
+        assessment: True for an assessment probe (`dw/tasks/assess.py`) - a
+            command that measures a finished cut and says where to look,
+            listed in `list_tasks`' `assessment`. Declared, not inferred from
+            `returns="json"`: `attribute_voices` answers JSON too and is an
+            analysis of a song, not a check of a cut (#485)
 
     Returns:
         Decorator function
@@ -103,6 +109,8 @@ def handler(task, arguments, previous_pipelines, _func=func):
             "provided": tuple(provided),
             "returns": returns,
         }
+        if assessment:
+            info["assessment"] = True
         if summary:
             info["summary"] = summary
         if parameter_descriptions:
@@ -341,7 +349,10 @@ def _handle_analyze_audio(task, arguments, previous_pipelines):
 
 
 @register_command(
-    "analyze_shots", implementation="dw.tasks.assess.analyze_shots", returns="json"
+    "analyze_shots",
+    implementation="dw.tasks.assess.analyze_shots",
+    returns="json",
+    assessment=True,
 )
 def _handle_analyze_shots(task, arguments, previous_pipelines):
     """Measure each shot of a cut's soundtrack and how far apart they sit"""
@@ -351,7 +362,10 @@ def _handle_analyze_shots(task, arguments, previous_pipelines):
 
 
 @register_command(
-    "analyze_seams", implementation="dw.tasks.assess.analyze_seams", returns="json"
+    "analyze_seams",
+    implementation="dw.tasks.assess.analyze_seams",
+    returns="json",
+    assessment=True,
 )
 def _handle_analyze_seams(task, arguments, previous_pipelines):
     """Measure every seam of a cut - level step, hole, click, frame jump"""
@@ -364,6 +378,7 @@ def _handle_analyze_seams(task, arguments, previous_pipelines):
     "analyze_sync_drift",
     implementation="dw.tasks.assess.analyze_sync_drift",
     returns="json",
+    assessment=True,
 )
 def _handle_analyze_sync_drift(task, arguments, previous_pipelines):
     """Measure how far a cut's soundtrack sits from its picture"""
@@ -372,6 +387,19 @@ def _handle_analyze_sync_drift(task, arguments, previous_pipelines):
     return analyze_sync_drift(**arguments)
 
 
+@register_command(
+    "attribute_voices",
+    implementation="dw.tasks.voice_attribution.attribute_voices",
+    consumes_device=True,
+    returns="json",
+)
+def _handle_attribute_voices(task, arguments, previous_pipelines):
+    """Say which reference voice sings each line of a song, by timbre"""
+    from .voice_attribution import attribute_voices
+
+    return attribute_voices(device=task.device_for(arguments), **arguments)
+
+
 @register_command("compose_text", implementation="dw.tasks.compose_text.compose_text")
 def _handle_compose_text(task, arguments, previous_pipelines):
     """Join parts written once into one block of text"""
diff --git a/dw/tasks/video_utils.py b/dw/tasks/video_utils.py
index c27c5198..c8c6cfbb 100644
--- a/dw/tasks/video_utils.py
+++ b/dw/tasks/video_utils.py
@@ -478,7 +478,10 @@ def load_audio_video(location, base_dir=None):
     without dropping the audio those runs generated alongside them.
 
     Args:
-        location: Local path, or an http(s) URL, of a video file
+        location: Local path, or an http(s) URL, of a video file, or a
+            {"location": ...} dict wrapping either - the same idiom
+            `get_last_frame(video=...)` and a pipeline's `image` argument
+            already accept (#510)
         base_dir: Directory a relative path is resolved against
 
     Returns:
@@ -492,6 +495,9 @@ def load_audio_video(location, base_dir=None):
     from ..security import ALLOWED_VIDEO_EXTENSIONS, validate_file_extension
     from ..locations import safe_get, validate_media_path
 
+    if isinstance(location, dict):
+        location = location["location"]
+
     if _URL_SCHEME.match(location):
         import io
 
@@ -514,6 +520,14 @@ def load_audio_video(location, base_dir=None):
     return video
 
 
+def is_video_location(value):
+    """Whether value is something load_audio_video can load: a path/URL
+    string, or a {"location": ...} dict wrapping one - the form validation
+    lets through unresolved inside a list argument (#510), since arguments.py's
+    key conventions only fire for a scalar 'video' argument, never a list entry."""
+    return isinstance(value, str) or (isinstance(value, dict) and "location" in value)
+
+
 def _decode_audio_video(handle):
     """Decode a path or file object's video and audio streams in one pass."""
     import av
diff --git a/dw/tasks/voice_attribution.py b/dw/tasks/voice_attribution.py
new file mode 100644
index 00000000..524d3010
--- /dev/null
+++ b/dw/tasks/voice_attribution.py
@@ -0,0 +1,781 @@
+"""Which reference voice sings each line of a song, by timbre (#485).
+
+A generated song's section-to-singer map is unknown - MiniMax Music3 ignores
+per-section singer directions - and staging lip-sync shots needs it. Pitch
+cannot tell a tenor from a mezzo in the range they share: a pitch heuristic
+called a tenor female and six chorus shots were re-rendered for it
+(2026-09-25). What worked was a speaker embedding of each line's isolated
+vocal compared against a reference span per singer, and that is this task:
+
+1. the vocal stem is separated from the accompaniment with htdemucs (the
+   accompaniment otherwise dominates a full mix's embedding) - `separate:
+   false` skips it for a stem that is already dry;
+2. every line, and every voice's reference, is reduced to its voiced frames
+   and embedded with speechbrain's ECAPA speaker encoder;
+3. each line scores the cosine against each voice, and lines roll up into
+   named windows (shots, say) by the voiced seconds they overlap.
+
+It decides nothing. Like the assessment probes it answers measurements - the
+scores, the margin, how much of a line was voiced - and names the thresholds
+it compared them to, so a caller can see a weak answer as weak. Every
+threshold is a constant below, named in docs/TASKS.md.
+
+Both models are fixed: nothing the caller writes reaches a model loader.
+"""
+
+import logging
+import math
+
+import numpy
+import torch
+
+from ..events import emit_warning
+from ..for_each import MEMBER_SEPARATOR, render_path
+from ..security import InvalidInputError, validate_variable_name
+from ..task_domains import check_arguments
+from .audio_utils import _waveform_and_rate, load_audio, resample_waveform
+from .model_cache import cached_model
+
+logger = logging.getLogger("dw")
+
+COMMAND = "attribute_voices"
+
+# The separator: Hybrid Transformer Demucs, four stems of which only
+# 'vocals' is kept - the other three sum to the accompaniment it discards
+_SEPARATOR_MODEL = "htdemucs"
+# The speaker encoder: ECAPA-TDNN trained on VoxCeleb. speechbrain is already
+# a dependency (generate_speech's speaker_embedding), so this adds none
+_EMBEDDER_MODEL = "speechbrain/spkrec-ecapa-voxceleb"
+# What the encoder was trained on - resampling to it is part of the embedding
+_EMBEDDER_SAMPLE_RATE = 16000
+
+# Voiced-frame detection on the (separated) vocal stem: 20 ms frames, voiced
+# when the frame's rms reaches a floor set from the stem's own level - its
+# VOICED_LEVEL_PERCENTILE frame rms - less VOICED_FLOOR_BELOW_LEVEL_DB, and
+# never below VOICED_FLOOR_MIN_DBFS. Relative, because a song's sections sit
+# at very different levels: an absolute -40 dBFS floor threw away a quiet
+# verse that was clearly sung while its loud chorus sat 20 dB above it
+# (#494). Separation leaves a residue under an instrumental passage well
+# below the floor either way
+FRAME_SECONDS = 0.02
+VOICED_LEVEL_PERCENTILE = 95.0
+VOICED_FLOOR_BELOW_LEVEL_DB = 35.0
+VOICED_FLOOR_MIN_DBFS = -60.0
+# Below this many voiced seconds a line has too little voice to embed, and
+# its `voice` is null with the reason; a window below it has no voice either
+MIN_VOICED_SECONDS = 0.5
+# Default least total length of a voice's reference, in seconds
+MIN_REFERENCE_SECONDS = 3.0
+# A line whose best score beats the runner-up by less than this is
+# `uncertain` - the argmax is still reported, but it is a coin toss
+UNCERTAIN_MARGIN = 0.05
+# A window whose leading voice's share beats the runner-up's by less than
+# this is `uncertain` - two singers split it (a duet line, or a window
+# straddling a hand-over)
+UNCERTAIN_SHARE_MARGIN = 0.2
+# Two references more alike than this make every answer between them weak,
+# whatever the scores say: `voices_too_similar`
+VOICES_TOO_SIMILAR = 0.8
+# How far past the end of the audio a line or window may reach and be
+# clipped rather than refused - a transcript's last chunk commonly ends a
+# hair past the file
+END_TOLERANCE_SECONDS = 0.1
+# Default length of the fixed windows the song is cut into without `lines`
+WINDOW_SECONDS = 2.0
+
+THRESHOLDS = {
+    "voiced_level_percentile": VOICED_LEVEL_PERCENTILE,
+    "voiced_floor_below_level_db": VOICED_FLOOR_BELOW_LEVEL_DB,
+    "voiced_floor_min_dbfs": VOICED_FLOOR_MIN_DBFS,
+    "min_voiced_seconds": MIN_VOICED_SECONDS,
+    "uncertain_margin": UNCERTAIN_MARGIN,
+    "uncertain_share_margin": UNCERTAIN_SHARE_MARGIN,
+    "voices_too_similar": VOICES_TOO_SIMILAR,
+}
+
+
+def _missing(package, error):
+    return RuntimeError(
+        f"{COMMAND} needs the '{package}' package, which is not installed "
+        f"({error}). It is a dependency of diffusers-workflow: reinstall with "
+        f"`pip install -e .` or `pip install {package}`"
+    )
+
+
+def _round(value, places=4):
+    return None if value is None else round(float(value), places)
+
+
+# --- arguments -------------------------------------------------------------
+
+
+def _span(entry, where, duration):
+    """A {start, end} span in seconds from either accepted shape.
+
+    `{start, end}` is transcribe_audio's chunk shape (#483), so its output
+    drops in as `lines`; `{start_seconds, duration_seconds}` is slice_audio's.
+    """
+    if not isinstance(entry, dict):
+        raise ValueError(
+            f"{COMMAND}: {where} must be an object with 'start'/'end' or "
+            f"'start_seconds'/'duration_seconds', got {entry!r}"
+        )
+    has_end = "start" in entry or "end" in entry
+    has_duration = "start_seconds" in entry or "duration_seconds" in entry
+    if has_end == has_duration:
+        raise ValueError(
+            f"{COMMAND}: {where} needs exactly one of 'start'/'end' or "
+            f"'start_seconds'/'duration_seconds', got keys {sorted(entry)}"
+        )
+    try:
+        if has_end:
+            start, end = float(entry["start"]), float(entry["end"])
+        else:
+            start = float(entry["start_seconds"])
+            end = start + float(entry["duration_seconds"])
+    except (KeyError, TypeError, ValueError) as error:
+        raise ValueError(
+            f"{COMMAND}: {where} needs both numbers of its shape ({error})"
+        ) from error
+    if not (math.isfinite(start) and math.isfinite(end)):
+        raise ValueError(f"{COMMAND}: {where} is not a finite span")
+    if start < 0:
+        raise ValueError(f"{COMMAND}: {where} starts before the audio ({start} s)")
+    if end <= start:
+        raise ValueError(f"{COMMAND}: {where} ends at {end} s, not after its start")
+    if duration is not None and start >= duration:
+        raise ValueError(
+            f"{COMMAND}: {where} starts at {start:.3f} s, past the end of the "
+            f"{duration:.3f} s audio"
+        )
+    if duration is not None and end > duration + END_TOLERANCE_SECONDS:
+        raise ValueError(
+            f"{COMMAND}: {where} ends at {end:.3f} s, past the end of the "
+            f"{duration:.3f} s audio"
+        )
+    return start, min(end, duration) if duration is not None else end
+
+
+def parse_voices(voices, duration, min_reference_seconds, clip_duration=None):
+    """The voices argument as {name: spans | clip path}, checked.
+
+    A reference is a list of spans into the audio itself (one span may be
+    given bare), or a path to a separate clip. Refuses fewer than two
+    voices, a name outside validate_variable_name's pattern, a span outside
+    the audio, and a reference shorter than min_reference_seconds - naming
+    the voice. clip_duration(path) measures a clip; it is only called for one.
+    """
+    if not isinstance(voices, dict):
+        raise ValueError(
+            f"{COMMAND}: 'voices' must map each voice's name to its reference, "
+            f"got {type(voices).__name__}"
+        )
+    if len(voices) < 2:
+        raise ValueError(
+            f"{COMMAND} needs at least 2 voices to choose between, got "
+            f"{len(voices)} ({', '.join(voices) or 'none'})"
+        )
+    parsed = {}
+    for name, reference in voices.items():
+        try:
+            validate_variable_name(name)
+        except InvalidInputError as error:
+            raise ValueError(
+                f"{COMMAND}: voice name {name!r} is not allowed - letters, "
+                f"digits, '_' and '-', starting with a letter or '_' ({error})"
+            ) from error
+        if isinstance(reference, str):
+            length = clip_duration(reference) if clip_duration else None
+            parsed[name] = reference
+        else:
+            spans = [reference] if isinstance(reference, dict) else reference
+            if not isinstance(spans, list) or not spans:
+                raise ValueError(
+                    f"{COMMAND}: voice '{name}' needs a clip path or a list of "
+                    f"spans into the audio, got {reference!r}"
+                )
+            spans = [
+                _span(span, f"voice '{name}' span {index}", duration)
+                for index, span in enumerate(spans)
+            ]
+            length = sum(end - start for start, end in spans)
+            parsed[name] = spans
+        if length is not None and length < min_reference_seconds:
+            raise ValueError(
+                f"{COMMAND}: voice '{name}' has {length:.2f} s of reference, "
+                f"under the {min_reference_seconds:g} s minimum "
+                "(min_reference_seconds) - give it a longer span or more of them"
+            )
+    return parsed
+
+
+def voices_errors(workflow_definition, source_indices=None):
+    """Every attribute_voices step whose literal `voices` parse_voices would
+    refuse, as [{path, message}] - fewer than two, a bad name, a malformed
+    span, a reference under min_reference_seconds.
+
+    The definition is substituted and expanded, so a `voices` a caller
+    passed is checked as it will run. What needs the audio - a span past its
+    end, a clip's length - stays the run's: the duration is not known here.
+    A `voices` still spelled as a reference, or with a span holding one, is
+    left to the run too.
+    """
+    steps = workflow_definition.get("steps")
+    if not isinstance(steps, list):
+        return []
+    errors = []
+    for index, step in enumerate(steps):
+        task = step.get("task") if isinstance(step, dict) else None
+        if not isinstance(task, dict) or task.get("command") != COMMAND:
+            continue
+        arguments = task.get("arguments")
+        if not isinstance(arguments, dict) or "voices" not in arguments:
+            continue
+        voices = arguments["voices"]
+        if isinstance(voices, str) or _holds_reference(voices):
+            continue
+        minimum = arguments.get("min_reference_seconds", MIN_REFERENCE_SECONDS)
+        if isinstance(minimum, bool) or not isinstance(minimum, (int, float)):
+            minimum = MIN_REFERENCE_SECONDS
+        try:
+            parse_voices(voices, None, minimum)
+        except ValueError as error:
+            source = (
+                source_indices[index]
+                if source_indices is not None and index < len(source_indices)
+                else index
+            )
+            name = step.get("name")
+            where = (
+                f" in member '{name}'"
+                if isinstance(name, str) and MEMBER_SEPARATOR in name
+                else ""
+            )
+            path = ("steps", source, "task", "arguments", "voices")
+            errors.append({"path": render_path(path), "message": f"{error}{where}"})
+    return errors
+
+
+def _holds_reference(voices):
+    """Whether any span in `voices` carries a string - a reference the run
+    resolves - so its numbers are not known yet. A clip path in place of a
+    voice's spans is not a span and does not count."""
+    if not isinstance(voices, dict):
+        return False
+    for reference in voices.values():
+        spans = [reference] if isinstance(reference, dict) else reference
+        if not isinstance(spans, list):
+            continue
+        for span in spans:
+            values = span.values() if isinstance(span, dict) else [span]
+            if any(isinstance(value, str) for value in values):
+                return True
+    return False
+
+
+def parse_lines(lines, duration, window_seconds):
+    """The lines to attribute, as [{start, end, text}].
+
+    Without `lines`, the song is cut into fixed windows of window_seconds,
+    the last one whatever is left.
+    """
+    if lines is None:
+        count = max(1, math.ceil(duration / window_seconds - 1e-9))
+        return [
+            {
+                "start": index * window_seconds,
+                "end": min((index + 1) * window_seconds, duration),
+                "text": None,
+            }
+            for index in range(count)
+        ]
+    if isinstance(lines, dict) and isinstance(lines.get("chunks"), list):
+        # A whole transcript rather than its chunk list
+        lines = lines["chunks"]
+    if not isinstance(lines, list) or not lines:
+        raise ValueError(f"{COMMAND}: 'lines' must be a non-empty list of spans")
+    parsed = []
+    for index, line in enumerate(lines):
+        start, end = _span(line, f"lines[{index}]", duration)
+        parsed.append({"start": start, "end": end, "text": line.get("text")})
+    return parsed
+
+
+def parse_windows(windows, duration):
+    """The named windows lines roll up into, as [{name, start, end}]."""
+    if not isinstance(windows, list) or not windows:
+        raise ValueError(f"{COMMAND}: 'windows' must be a non-empty list")
+    parsed = []
+    for index, window in enumerate(windows):
+        start, end = _span(window, f"windows[{index}]", duration)
+        name = window.get("name")
+        parsed.append(
+            {
+                "name": str(name) if name is not None else str(index),
+                "start": start,
+                "end": end,
+            }
+        )
+    return parsed
+
+
+# --- measurement -----------------------------------------------------------
+
+
+def _dbfs(amplitude):
+    return 20 * math.log10(amplitude) if amplitude > 0 else -math.inf
+
+
+def voiced_floor_dbfs(rms):
+    """The voiced floor for a stem whose frames have these rms values: its
+    VOICED_LEVEL_PERCENTILE level less VOICED_FLOOR_BELOW_LEVEL_DB, never
+    below VOICED_FLOOR_MIN_DBFS."""
+    if len(rms) == 0:
+        return VOICED_FLOOR_MIN_DBFS
+    level = _dbfs(float(numpy.percentile(rms, VOICED_LEVEL_PERCENTILE)))
+    return max(VOICED_FLOOR_MIN_DBFS, level - VOICED_FLOOR_BELOW_LEVEL_DB)
+
+
+def voiced_mask(waveform, sample_rate):
+    """Per-frame voiced flags for a mono waveform, the frame length in
+    samples and the floor used: FRAME_SECONDS frames whose rms reaches
+    voiced_floor_dbfs."""
+    frame = max(1, int(round(FRAME_SECONDS * sample_rate)))
+    count = len(waveform) // frame
+    if count == 0:
+        return numpy.zeros(0, dtype=bool), frame, VOICED_FLOOR_MIN_DBFS
+    frames = waveform[: count * frame].reshape(count, frame)
+    rms = numpy.sqrt(numpy.mean(frames.astype(numpy.float64) ** 2, axis=1))
+    floor_dbfs = voiced_floor_dbfs(rms)
+    return rms >= 10 ** (floor_dbfs / 20), frame, floor_dbfs
+
+
+class _Voicing:
+    """The voiced frames of the vocal stem, answering spans in seconds."""
+
+    def __init__(self, waveform, sample_rate):
+        self.waveform = waveform
+        self.sample_rate = sample_rate
+        self.mask, self.frame, self.floor_dbfs = voiced_mask(waveform, sample_rate)
+        self.frame_seconds = self.frame / sample_rate
+
+    def _frames(self, start, end):
+        first = int(math.floor(start / self.frame_seconds + 1e-9))
+        last = int(math.ceil(end / self.frame_seconds - 1e-9))
+        return max(0, first), min(len(self.mask), last)
+
+    def seconds(self, start, end):
+        first, last = self._frames(start, end)
+        return float(self.mask[first:last].sum()) * self.frame_seconds
+
+    def samples(self, spans):
+        """The voiced samples of every span, concatenated."""
+        pieces = []
+        for start, end in spans:
+            first, last = self._frames(start, end)
+            for index in numpy.nonzero(self.mask[first:last])[0] + first:
+                pieces.append(
+                    self.waveform[index * self.frame : (index + 1) * self.frame]
+                )
+        if not pieces:
+            return numpy.zeros(0, dtype=numpy.float32)
+        return numpy.concatenate(pieces)
+
+
+def cosine(a, b):
+    a = numpy.asarray(a, dtype=numpy.float64)
+    b = numpy.asarray(b, dtype=numpy.float64)
+    denominator = numpy.linalg.norm(a) * numpy.linalg.norm(b)
+    return float(a @ b / denominator) if denominator else 0.0
+
+
+def reference_similarity(embeddings):
+    """Pairwise cosine between the voices' references, and the pairs above
+    VOICES_TOO_SIMILAR."""
+    names = list(embeddings)
+    pairs = []
+    for i, first in enumerate(names):
+        for second in names[i + 1 :]:
+            value = cosine(embeddings[first], embeddings[second])
+            pairs.append(
+                {
+                    "voices": [first, second],
+                    "cosine": _round(value),
+                    "too_similar": value > VOICES_TOO_SIMILAR,
+                }
+            )
+    return pairs
+
+
+def score_line(
+    embedding, references, voiced_seconds, too_similar_pairs=(), separated=True
+):
+    """One line's scores against every reference, its argmax and margin.
+
+    A line under MIN_VOICED_SECONDS is not embedded (embedding None) and has
+    no voice. A line whose best two voices are a too-similar pair is
+    uncertain whatever its margin. `separated` only words the reason: a
+    stem that was never separated is not "after separation".
+    """
+    if embedding is None or voiced_seconds < MIN_VOICED_SECONDS:
+        return {
+            "scores": {},
+            "voice": None,
+            "margin": None,
+            "voiced_seconds": _round(voiced_seconds, 3),
+            "uncertain": True,
+            "reason": (
+                f"only {voiced_seconds:.2f} s voiced"
+                f"{' after separation' if separated else ''} "
+                f"(needs {MIN_VOICED_SECONDS} s) - instrumental, or too short "
+                "to embed"
+            ),
+        }
+    scores = {name: cosine(embedding, ref) for name, ref in references.items()}
+    ranked = sorted(scores, key=scores.get, reverse=True)
+    margin = scores[ranked[0]] - scores[ranked[1]]
+    reason = None
+    if frozenset(ranked[:2]) in {frozenset(pair) for pair in too_similar_pairs}:
+        reason = (
+            f"'{ranked[0]}' and '{ranked[1]}' have references too similar to "
+            "tell apart (voices_too_similar)"
+        )
+    elif margin < UNCERTAIN_MARGIN:
+        reason = f"margin {margin:.3f} is under {UNCERTAIN_MARGIN}"
+    return {
+        "scores": {name: _round(value) for name, value in scores.items()},
+        "voice": ranked[0],
+        "margin": _round(margin),
+        "voiced_seconds": _round(voiced_seconds, 3),
+        "uncertain": reason is not None,
+        "reason": reason,
+    }
+
+
+def roll_up(windows, lines, voiced_seconds, voices):
+    """Each window's share of voiced time by voice.
+
+    A line counts toward a window by the voiced seconds of the stretch the
+    two overlap, credited to the line's voice; a line with no voice counts
+    for nothing. voiced_seconds(start, end) measures a stretch.
+    """
+    rolled = []
+    for window in windows:
+        weights = dict.fromkeys(voices, 0.0)
+        for line in lines:
+            if line["voice"] is None:
+                continue
+            start = max(window["start"], line["start"])
+            end = min(window["end"], line["end"])
+            if end > start:
+                weights[line["voice"]] += voiced_seconds(start, end)
+        total = sum(weights.values())
+        entry = {
+            "name": window["name"],
+            "start": _round(window["start"], 3),
+            "end": _round(window["end"], 3),
+            "voiced_seconds": _round(total, 3),
+        }
+        if total < MIN_VOICED_SECONDS:
+            entry.update(
+                share={},
+                voice=None,
+                uncertain=True,
+                reason=(
+                    f"only {total:.2f} s of attributed voice in the window "
+                    f"(needs {MIN_VOICED_SECONDS} s)"
+                ),
+            )
+        else:
+            share = {name: weight / total for name, weight in weights.items()}
+            ranked = sorted(share, key=share.get, reverse=True)
+            lead = share[ranked[0]] - share[ranked[1]]
+            uncertain = lead < UNCERTAIN_SHARE_MARGIN
+            entry.update(
+                share={name: _round(value) for name, value in share.items()},
+                voice=ranked[0],
+                uncertain=uncertain,
+                reason=(
+                    f"'{ranked[0]}' leads '{ranked[1]}' by {lead:.2f} of the "
+                    f"window, under {UNCERTAIN_SHARE_MARGIN}"
+                    if uncertain
+                    else None
+                ),
+            )
+        rolled.append(entry)
+    return rolled
+
+
+# --- models ----------------------------------------------------------------
+
+
+def _load_separator(device, dtype):
+    try:
+        from demucs.pretrained import get_model
+    except ImportError as error:
+        raise _missing("demucs", error) from error
+
+    def load():
+        model = get_model(_SEPARATOR_MODEL)
+        model.eval()
+        return model.to(device=device, dtype=dtype)
+
+    return cached_model((COMMAND, _SEPARATOR_MODEL, str(device), str(dtype)), load)
+
+
+def _load_embedder(device, dtype):
+    try:
+        from speechbrain.inference.speaker import EncoderClassifier
+    except ImportError as error:
+        raise _missing("speechbrain", error) from error
+
+    def load():
+        return EncoderClassifier.from_hparams(
+            source=_EMBEDDER_MODEL, run_opts={"device": str(device)}
+        )
+
+    return cached_model((COMMAND, _EMBEDDER_MODEL, str(device), str(dtype)), load)
+
+
+def _run_separator(waveform, sample_rate, device, dtype):
+    from demucs.apply import apply_model
+
+    model = _load_separator(device, dtype)
+    rate = model.samplerate
+    mix = resample_waveform(waveform, sample_rate, rate)
+    if mix.shape[0] == 1:
+        mix = numpy.repeat(mix, model.audio_channels, axis=0)
+    mix = torch.as_tensor(mix[: model.audio_channels], dtype=dtype)
+    # demucs' own separate.py normalizes the mix and undoes it on the stems
+    reference = mix.mean(0)
+    mean, std = reference.mean(), reference.std()
+    std = std if float(std) > 0 else torch.tensor(1.0)
+    with torch.no_grad():
+        stems = apply_model(
+            model, ((mix - mean) / std)[None], device=device, split=True
+        )[0]
+    vocals = stems[model.sources.index("vocals")] * std + mean
+    return vocals.float().cpu().numpy(), rate
+
+
+def separate_vocals(waveform, sample_rate, device, dtype):
+    """The vocal stem of a (channels, samples) mix, as a mono 16 kHz array.
+
+    demucs on MPS is unverified; if it fails there, separation is retried on
+    the CPU with a warning rather than failing the step.
+    """
+    from .. import get_device_type
+
+    try:
+        vocals, rate = _run_separator(waveform, sample_rate, device, dtype)
+    except Exception as error:
+        if get_device_type(device) != "mps":
+            raise
+        emit_warning(
+            f"{COMMAND}: htdemucs failed on {device} ({error}); separating on "
+            "the CPU instead, which is slower",
+            kind="separation_cpu_fallback",
+            command=COMMAND,
+        )
+        vocals, rate = _run_separator(waveform, sample_rate, "cpu", torch.float32)
+    return _mono_16k(vocals, rate)
+
+
+def _mono_16k(waveform, sample_rate):
+    waveform = resample_waveform(
+        numpy.ascontiguousarray(waveform, dtype=numpy.float32),
+        sample_rate,
+        _EMBEDDER_SAMPLE_RATE,
+    )
+    return waveform.mean(axis=0).astype(numpy.float32)
+
+
+def embed(encoder, samples):
+    """An ECAPA embedding of mono 16 kHz samples, as a unit numpy vector."""
+    with torch.no_grad():
+        embedding = encoder.encode_batch(
+            torch.as_tensor(samples, dtype=torch.float32).unsqueeze(0)
+        )
+    vector = embedding.detach().float().cpu().numpy().reshape(-1)
+    norm = numpy.linalg.norm(vector)
+    return vector / norm if norm else vector
+
+
+# --- the task --------------------------------------------------------------
+
+
+def attribute_voices(
+    audio,
+    voices,
+    lines=None,
+    windows=None,
+    window_seconds=WINDOW_SECONDS,
+    min_reference_seconds=MIN_REFERENCE_SECONDS,
+    separate=True,
+    device="cpu",
+):
+    """Say which reference voice sings each line of a song, by timbre.
+
+    Separates the vocal stem (htdemucs), embeds each line's voiced audio and
+    each voice's reference with speechbrain's ECAPA speaker encoder, and
+    scores every line against every voice by cosine. Decides nothing: it
+    reports scores, the margin between the best two, and how much of each
+    line was voiced, and flags a weak answer as `uncertain`. Pitch is not
+    used - it cannot separate a tenor from a mezzo in their shared range.
+
+    Args:
+        audio: The song - a path, 'asset:'/'output:' reference, or an
+            earlier step's audio or video.
+        voices: Each voice's name mapped to its reference: a list of
+            {start_seconds, duration_seconds} (or {start, end}) spans into
+            'audio' itself, or a path/'asset:' of a separate clip of that
+            voice. At least 2 voices; names follow the variable-name pattern
+            (letters, digits, '_', '-').
+        lines: The spans to attribute, in seconds - a list of {start, end,
+            text?} (transcribe_audio's chunk shape) or {start_seconds,
+            duration_seconds, text?}. Omitted: the song is cut into fixed
+            windows of window_seconds.
+        windows: Named spans to roll the lines up into, e.g. shots - a list
+            of {name, start, end}. Each reports every voice's share of its
+            voiced time. Omitted: the fixed windows when 'lines' is omitted
+            too, else none.
+        window_seconds: Length of the fixed windows used without 'lines'.
+            Default 2.0.
+        min_reference_seconds: Least total reference length per voice; a
+            voice under it is refused by name. Default 3.0.
+        separate: Isolate the vocal stem with htdemucs before embedding
+            (default true). False for audio that is already a dry vocal.
+        device: Where to run the models.
+
+    Returns:
+        A JSON document: 'voices', 'separated', 'lines' (start, end, text,
+        scores, voice, margin, voiced_seconds, uncertain, reason), 'windows'
+        (name, start, end, share, voice, uncertain, reason),
+        'reference_similarity' (pairwise cosine between references),
+        'warnings' ('voices_too_similar') and the 'thresholds' used.
+    """
+    check_arguments(
+        COMMAND,
+        window_seconds=window_seconds,
+        min_reference_seconds=min_reference_seconds,
+    )
+    waveform, sample_rate = _waveform_and_rate(audio, None, COMMAND)
+    duration = waveform.shape[1] / sample_rate
+
+    clips = {}
+
+    def clip_duration(path):
+        clip, rate = load_audio(path)
+        clips[path] = (clip, rate)
+        return clip.shape[1] / rate
+
+    references = parse_voices(voices, duration, min_reference_seconds, clip_duration)
+    parsed_lines = parse_lines(lines, duration, window_seconds)
+    parsed_windows = None
+    if windows is not None:
+        parsed_windows = parse_windows(windows, duration)
+    elif lines is None:
+        parsed_windows = [
+            {"name": f"window-{index + 1}", "start": line["start"], "end": line["end"]}
+            for index, line in enumerate(parsed_lines)
+        ]
+
+    # Both models' STFT front ends are fp32-only in practice (cuFFT's half
+    # path needs a power-of-two size, and ECAPA's 400-sample window is not),
+    # and both are small, so they run in fp32 on every device
+    dtype = torch.float32
+    separate = bool(separate)
+
+    def stem(mix, rate):
+        if separate:
+            return separate_vocals(mix, rate, device, dtype)
+        return _mono_16k(mix, rate)
+
+    song = _Voicing(stem(waveform, sample_rate), _EMBEDDER_SAMPLE_RATE)
+    encoder = _load_embedder(device, dtype)
+
+    embeddings = {}
+    for name, reference in references.items():
+        if isinstance(reference, str):
+            clip = _Voicing(stem(*clips[reference]), _EMBEDDER_SAMPLE_RATE)
+            samples = clip.samples([(0.0, len(clip.waveform) / clip.sample_rate)])
+        else:
+            samples = song.samples(reference)
+        voiced = len(samples) / _EMBEDDER_SAMPLE_RATE
+        if voiced < MIN_VOICED_SECONDS:
+            raise ValueError(
+                f"{COMMAND}: voice '{name}''s reference holds only {voiced:.2f} s "
+                f"of voice{' after separation' if separate else ''} (needs "
+                f"{MIN_VOICED_SECONDS} s) - point it at a stretch where that "
+                "voice sings"
+            )
+        embeddings[name] = embed(encoder, samples)
+
+    similarity = reference_similarity(embeddings)
+    too_similar = [pair["voices"] for pair in similarity if pair["too_similar"]]
+    warnings = []
+    for pair in similarity:
+        if pair["too_similar"]:
+            message = (
+                f"{COMMAND}: the references for '{pair['voices'][0]}' and "
+                f"'{pair['voices'][1]}' score {pair['cosine']} against each "
+                f"other, above {VOICES_TOO_SIMILAR} - any line between them "
+                "is a weak answer whatever its scores say"
+            )
+            warnings.append(
+                {
+                    "kind": "voices_too_similar",
+                    "voices": pair["voices"],
+                    "cosine": pair["cosine"],
+                    "threshold": VOICES_TOO_SIMILAR,
+                    "message": message,
+                }
+            )
+            emit_warning(
+                message,
+                kind="voices_too_similar",
+                command=COMMAND,
+                voices=pair["voices"],
+                cosine=pair["cosine"],
+            )
+
+    attributed = []
+    for line in parsed_lines:
+        voiced = song.seconds(line["start"], line["end"])
+        embedding = None
+        if voiced >= MIN_VOICED_SECONDS:
+            embedding = embed(encoder, song.samples([(line["start"], line["end"])]))
+        attributed.append(
+            {
+                "start": _round(line["start"], 3),
+                "end": _round(line["end"], 3),
+                "text": line["text"],
+                **score_line(
+                    embedding, embeddings, voiced, too_similar, separated=separate
+                ),
+            }
+        )
+
+    rolled = []
+    if parsed_windows is not None:
+        rolled = roll_up(
+            parsed_windows,
+            [
+                {"start": line["start"], "end": line["end"], "voice": result["voice"]}
+                for line, result in zip(parsed_lines, attributed)
+            ],
+            song.seconds,
+            list(references),
+        )
+
+    return {
+        "voices": list(references),
+        "separated": separate,
+        "duration_seconds": _round(duration, 3),
+        "voiced_floor_dbfs": _round(song.floor_dbfs, 2),
+        "lines": attributed,
+        "windows": rolled,
+        "reference_similarity": similarity,
+        "warnings": warnings,
+        "thresholds": dict(THRESHOLDS),
+    }
diff --git a/dw/video_size_errors.py b/dw/video_size_errors.py
new file mode 100644
index 00000000..3910807a
--- /dev/null
+++ b/dw/video_size_errors.py
@@ -0,0 +1,107 @@
+"""A `dissolve_videos`/`concat_videos` input whose frame size disagrees with
+its siblings, refused before the run when the sizes are already knowable.
+
+Both tasks join clips frame-by-frame (`check_same_frame_size`,
+`dw/tasks/video_utils.py`) and raise once every input has been decoded: "video
+N is WxH, video M is WxH". Unlike a sample-rate mismatch (#108/#287), which is
+auto-resampled with a warning, there is no reconciliation for a size mismatch
+- Don declined a resize/fit argument on the join tasks (#504, #512) - so the
+only thing to move earlier is the refusal itself.
+
+Moved here, into `validation_errors`, for exactly the cases a size is
+knowable without running anything: an `asset:`/`output:` reference, or a
+literal file path inside the directories the run may read
+(`dw/probe_paths.py`). A `previous_result:` (or any reference `expand_for_each`
+left unresolved), a `variable:`/`item:`/`gather:` reference, or a
+`{"location": ...}` dict, names no size yet and is left to the existing
+run-time check - silence there is correct, not a gap, since the size is not
+known until the step that produces it runs.
+"""
+
+from .for_each import MEMBER_SEPARATOR, render_path
+from .media_info import probe_media
+from .probe_paths import resolve_probe_path
+
+_CHECKED_COMMANDS = ("dissolve_videos", "concat_videos")
+
+
+def _frame_size(path):
+    """The (width, height) `dissolve_videos`/`concat_videos` would see for
+    this file, or None when it cannot be probed or carries no video stream."""
+    info = probe_media(path)
+    if info is None or info.get("kind") != "video":
+        return None
+    width, height = info.get("width"), info.get("height")
+    return (width, height) if width and height else None
+
+
+def video_size_errors(workflow_definition, source_indices=None, base_dir=None):
+    """Every `dissolve_videos`/`concat_videos` step whose statically-resolvable
+    inputs already disagree in frame size, as [{path, message}].
+
+    Walks the substituted, expanded definition, the same convention
+    `dissolve_frame_errors` and `task_argument_errors` follow: `source_indices`
+    maps an expanded step back to the one the author wrote, and a path inside
+    a `for_each` member names the member.
+    """
+    steps = workflow_definition.get("steps")
+    if not isinstance(steps, list):
+        return []
+
+    errors = []
+    for index, step in enumerate(steps):
+        if not isinstance(step, dict):
+            continue
+        task = step.get("task")
+        if not isinstance(task, dict) or task.get("command") not in _CHECKED_COMMANDS:
+            continue
+        command = task["command"]
+        arguments = task.get("arguments")
+        if not isinstance(arguments, dict):
+            continue
+        videos = arguments.get("videos")
+        if not isinstance(videos, list) or len(videos) < 2:
+            continue
+
+        sizes = {}
+        for video_index, video in enumerate(videos):
+            path = resolve_probe_path(video, base_dir, "a video argument")
+            if path is None:
+                continue
+            size = _frame_size(path)
+            if size is None:
+                continue
+            sizes[video_index] = size
+        if len(set(sizes.values())) < 2:
+            continue
+
+        first_index = next(iter(sizes))
+        first_size = sizes[first_index]
+        problems = [f"video {first_index} is {first_size[0]}x{first_size[1]}"]
+        for video_index, size in sizes.items():
+            if video_index == first_index or size == first_size:
+                continue
+            problems.append(f"video {video_index} is {size[0]}x{size[1]}")
+
+        source = (
+            source_indices[index]
+            if source_indices is not None and index < len(source_indices)
+            else index
+        )
+        name = step.get("name")
+        where = (
+            f" in member '{name}'"
+            if isinstance(name, str) and MEMBER_SEPARATOR in name
+            else ""
+        )
+        errors.append(
+            {
+                "path": render_path(("steps", source, "task", "arguments", "videos")),
+                "message": f"{command} needs every video at one size: "
+                f"{', '.join(problems)}{where}",
+            }
+        )
+    return errors
+
+
+__all__ = ["video_size_errors"]
diff --git a/dw/vram_estimate.py b/dw/vram_estimate.py
index 95c59160..8fdb9772 100644
--- a/dw/vram_estimate.py
+++ b/dw/vram_estimate.py
@@ -17,6 +17,15 @@
 than assumed to be `num_frames` alone - an image template's width and
 height matter here just as much as a video template's frame count does.
 
+The projection is per step, over the definition the run executes -
+substituted and expanded - so a `for_each` member is projected with its own
+`num_frames` and its own reference list rather than with the workflow's
+top-level variables (#479). A reference-conditioned pipeline holds every
+reference's encoding resident beside the video latents, so an optional
+`gb_per_reference` adds a fixed amount per reference the step will actually
+pass; one whose media resolved null is dropped before the pipeline sees it
+(#478) and costs nothing.
+
 The entries checked are the serving device's own (see `_entries_for`);
 `bytes_per_voxel` was calibrated on CUDA, so a check against a Mac's capacity
 is an estimate of an estimate.
@@ -24,7 +33,13 @@
 
 import numbers
 
+from .arguments import FROM_FILE_KEY, FROM_PREVIOUS_RESULT_KEY
+from .for_each import FOR_EACH_KEY, MEMBER_SEPARATOR, render_path
+
 KEY = "vram_estimate"
+REFERENCES_KEY = "references"
+_SOURCE_KEYS = (FROM_FILE_KEY, FROM_PREVIOUS_RESULT_KEY)
+_VARIABLE_PREFIX = "variable:"
 
 
 def _as_number(value):
@@ -45,10 +60,31 @@ def declared_estimate(definition):
     return estimate if isinstance(estimate, dict) else None
 
 
-def required_gb(estimate, values):
-    """The projected requirement for `values`, or None when a voxel
-    variable's value is not a number this pass can compute with - an
-    undeclared reference or a for_each list is somebody else's error."""
+def reference_count(arguments):
+    """How many of a step's `references` the pipeline will receive.
+
+    An entry whose `from_file`/`from_previous_result` is null is dropped from
+    the list before the pipeline sees it (#478, `realize_object`), so it
+    costs nothing and is not counted; neither is a null entry. Every kind
+    counts once - nothing measured says an audio reference costs less than
+    an image one (#479).
+    """
+    references = arguments.get(REFERENCES_KEY) if isinstance(arguments, dict) else None
+    if not isinstance(references, list):
+        return 0
+    count = 0
+    for entry in references:
+        if not isinstance(entry, dict):
+            continue
+        if any(entry.get(key) is not None for key in _SOURCE_KEYS):
+            count += 1
+    return count
+
+
+def required_gb(estimate, values, references=0):
+    """The projected requirement for `values` with `references` counted, or
+    None when a voxel variable's value is not a number this pass can compute
+    with - an undeclared reference or a list is somebody else's error."""
     product = 1.0
     for name in estimate.get("voxel_variables", []):
         number = _as_number(values.get(name))
@@ -57,7 +93,8 @@ def required_gb(estimate, values):
         product *= number
     base = estimate.get("base_gb", 0)
     per_voxel = estimate.get("bytes_per_voxel", 0)
-    return base + per_voxel * product / (1024**3)
+    per_reference = estimate.get("gb_per_reference", 0)
+    return base + per_voxel * product / (1024**3) + per_reference * references
 
 
 def _entries_for(cost, device_type, capacity_gb):
@@ -87,32 +124,172 @@ def _entries_for(cost, device_type, capacity_gb):
     return entries
 
 
+def _projections(definition, estimate, arguments):
+    """(step index, step, values, references, projected GB) for every step
+    the estimate can project.
+
+    Only a step that loads a pipeline is projected, since the ceiling is the
+    pipeline's. Each voxel variable is read from that step's own arguments -
+    substituted, so a for_each member carries its entry's `num_frames` -
+    and from the workflow's variables (the caller's arguments over them) when
+    the step does not name it. A definition with no steps at all is projected
+    from its variables alone, as a single step.
+    """
+    variables = {**(definition.get("variables") or {}), **(arguments or {})}
+    steps = definition.get("steps")
+    if not isinstance(steps, list):
+        projected = required_gb(estimate, variables)
+        if projected is not None:
+            yield None, None, variables, 0, projected
+        return
+    names = estimate.get("voxel_variables", [])
+    for index, step in enumerate(steps):
+        pipeline = step.get("pipeline") if isinstance(step, dict) else None
+        if not isinstance(pipeline, dict):
+            continue
+        step_arguments = pipeline.get("arguments")
+        if not isinstance(step_arguments, dict):
+            step_arguments = {}
+        values = {
+            name: step_arguments[name]
+            if name in step_arguments
+            else variables.get(name)
+            for name in names
+        }
+        references = reference_count(step_arguments)
+        projected = required_gb(estimate, values, references)
+        if projected is not None:
+            yield index, step, values, references, projected
+
+
+def _variable_names(value):
+    """Every name a `variable:` reference inside `value` spells."""
+    if isinstance(value, str):
+        if value.startswith(_VARIABLE_PREFIX):
+            yield value[len(_VARIABLE_PREFIX) :]
+    elif isinstance(value, dict):
+        for item in value.values():
+            yield from _variable_names(item)
+    elif isinstance(value, list):
+        for item in value:
+            yield from _variable_names(item)
+
+
+def _entry_position(source_indices, index):
+    """Which member of its group expanded step `index` is - its entry's
+    index in the for_each list, since members are emitted in list order."""
+    source = source_indices[index]
+    return sum(1 for s in source_indices[:index] if s == source)
+
+
+def _where(estimate, index, step, supplied, source_indices, written):
+    """The path an error sits at: the for_each entry a member came from, when
+    one did, else `arguments` when the caller supplied anything the
+    projection read and `variables` when every value was a default."""
+    supplied = set(supplied or ())
+    written_steps = written.get("steps") if isinstance(written, dict) else None
+    source = (
+        source_indices[index]
+        if source_indices is not None
+        and index is not None
+        and index < len(source_indices)
+        else index
+    )
+    written_step = (
+        written_steps[source]
+        if isinstance(written_steps, list)
+        and isinstance(source, int)
+        and source < len(written_steps)
+        else None
+    )
+    if isinstance(written_step, dict) and FOR_EACH_KEY in written_step:
+        position = (
+            _entry_position(source_indices, index) if source_indices is not None else 0
+        )
+        entries = written_step[FOR_EACH_KEY]
+        if isinstance(entries, str) and entries.startswith(_VARIABLE_PREFIX):
+            name = entries[len(_VARIABLE_PREFIX) :]
+            root = "arguments" if name in supplied else "variables"
+            return f"{root}.{name}[{position}]"
+        return render_path(("steps", source, FOR_EACH_KEY, position))
+    read = set(estimate.get("voxel_variables", []))
+    if isinstance(written_step, dict):
+        pipeline = written_step.get("pipeline")
+        if isinstance(pipeline, dict):
+            read.update(_variable_names(pipeline.get("arguments")))
+    return "arguments" if read & supplied else "variables"
+
+
+def _formula(estimate):
+    voxel_variables = estimate.get("voxel_variables", [])
+    formula = (
+        f"Declared ceiling: {estimate.get('base_gb', 0)} GB base plus "
+        f"{estimate.get('bytes_per_voxel', 0):.4g} bytes per unit of "
+        f"{' * '.join(voxel_variables)}"
+    )
+    if "gb_per_reference" in estimate:
+        formula += f" plus {estimate['gb_per_reference']} GB per reference"
+    return formula
+
+
 def vram_estimate_errors(
-    definition, arguments=None, supplied=(), device_type=None, capacity_gb=None
+    definition,
+    arguments=None,
+    supplied=(),
+    device_type=None,
+    capacity_gb=None,
+    source_indices=None,
+    written=None,
 ):
-    """Every `cost` entry a declared vram_estimate projects to exceed, as
+    """The step a declared vram_estimate projects past a `cost` entry, as
     [{path, message}] - refused, not warned, since the failure this guards
-    is an OOM partway through a run that already spent minutes loading."""
+    is an OOM partway through a run that already spent minutes loading.
+
+    `definition` is the one the run will execute: substituted and expanded,
+    so every for_each member is projected with its own frames and references
+    (#479). `source_indices` and `written` (the definition as written) map
+    a member back to the list entry it came from. One step is reported - the
+    largest - rather than one error per shot: cutting that one is the fix
+    the caller has to make first, and the rest follow from the same formula.
+    """
     estimate = declared_estimate(definition)
     if estimate is None:
         return []
-    voxel_variables = estimate.get("voxel_variables", [])
-    values = {**(definition.get("variables") or {}), **(arguments or {})}
-    projected = required_gb(estimate, values)
-    if projected is None:
-        return []
     cost = definition.get("cost")
     if not isinstance(cost, list):
         return []
+    entries = _entries_for(cost, device_type, capacity_gb)
+    capacities = [
+        entry.get("vram_gb") for entry in entries if entry.get("vram_gb") is not None
+    ]
+    if not capacities:
+        return []
+    over = [
+        projection
+        for projection in _projections(definition, estimate, arguments)
+        if projection[4] > min(capacities)
+    ]
+    if not over:
+        return []
+    index, step, values, references, projected = max(over, key=lambda p: p[4])
+
+    voxel_variables = estimate.get("voxel_variables", [])
     reason = estimate.get("reason")
     because = f" - {reason}" if reason else ""
-    where = (
-        "arguments"
-        if any(v in (supplied or ()) for v in voxel_variables)
-        else "variables"
+    name = step.get("name") if isinstance(step, dict) else None
+    member = (
+        f"Member '{name}': "
+        if isinstance(name, str) and MEMBER_SEPARATOR in name
+        else ""
     )
+    with_references = (
+        f" with {references} reference{'s' if references != 1 else ''}"
+        if "gb_per_reference" in estimate or references
+        else ""
+    )
+    where = _where(estimate, index, step, supplied, source_indices, written)
     errors = []
-    for entry in _entries_for(cost, device_type, capacity_gb):
+    for entry in entries:
         capacity = entry.get("vram_gb")
         if capacity is None or projected <= capacity:
             continue
@@ -121,13 +298,11 @@ def vram_estimate_errors(
             {
                 "path": where,
                 "message": (
-                    f"{'*'.join(voxel_variables)} = "
-                    f"{'*'.join(str(values.get(v)) for v in voxel_variables)} "
-                    f"projects to {projected:.2f} GB VRAM, above the "
-                    f"{capacity} GB declared for {device_label}{because}. "
-                    f"Declared ceiling: {estimate.get('base_gb', 0)} GB base plus "
-                    f"{estimate.get('bytes_per_voxel', 0):.4g} bytes per unit of "
-                    f"{' * '.join(voxel_variables)}"
+                    f"{member}{'*'.join(voxel_variables)} = "
+                    f"{'*'.join(str(values.get(v)) for v in voxel_variables)}"
+                    f"{with_references} projects to {projected:.2f} GB VRAM, "
+                    f"above the {capacity} GB declared for {device_label}"
+                    f"{because}. {_formula(estimate)}"
                 ),
             }
         )
@@ -137,13 +312,15 @@ def vram_estimate_errors(
 def apply_vram_estimate(definition, variables, device_type=None, capacity_gb=None):
     """The run-time half of the check above - the backstop for a caller
     that skips validate_workflow (or an inline/composed workflow static
-    validation never saw). Raises ValueError for the same projection
-    vram_estimate_errors refuses, so run() cannot start a job the decode
-    step was always going to OOM on (#265)."""
-    if not isinstance(variables, dict):
-        return
+    validation never saw). `definition` is the expanded one the run
+    executes. Raises ValueError for the same projection vram_estimate_errors
+    refuses, so run() cannot start a job the pipeline was always going to
+    OOM on (#265, #479)."""
     errors = vram_estimate_errors(
-        definition, variables, device_type=device_type, capacity_gb=capacity_gb
+        definition,
+        variables if isinstance(variables, dict) else None,
+        device_type=device_type,
+        capacity_gb=capacity_gb,
     )
     if errors:
         raise ValueError(errors[0]["message"])
diff --git a/dw/vram_inheritance.py b/dw/vram_inheritance.py
new file mode 100644
index 00000000..1ff11cd9
--- /dev/null
+++ b/dw/vram_inheritance.py
@@ -0,0 +1,195 @@
+"""A VRAM ceiling a hand-built workflow inherits from the catalog.
+
+`vram_estimate` is declared by a template, so a workflow an agent writes by
+hand - the same pipeline, the same checkpoint, its own shots - declares none
+and was never checked. Both OOMs in #479's report were inline Ref2VA
+workflows that `validate_workflow` passed.
+
+The ceiling belongs to the pipeline, not to the file that declared it, so a
+step is matched to the catalog by *pipeline identity*: the step's
+`component_type`, its `from_pretrained_arguments.model_name` and its
+`from_pretrained_arguments.workflow` (the fields `adapter_compatibility`
+reads - H3's `ref2va` and `t2va` load different partitions and declare
+different numbers). The index is derived from the catalog's own
+declarations; this module holds no numbers and names no model.
+
+A template contributes only when every pipeline step it holds shares one
+identity: a workflow-level `vram_estimate` on a template that also loads an
+image model and a music model says nothing about which of the three it was
+measured for, so attributing it to all of them would be a guess. It also has
+to declare `cost` entries, since those carry the card the ceiling is checked
+against.
+
+An inherited ceiling warns and never refuses (#479, Q3): the hand-built
+workflow may offload or quantize differently from the template, and the
+escape hatch for a leaner config is declaring its own `vram_estimate`, which
+always wins. There is no run-time backstop - the worker has no catalog, and
+the pre-queue check covers every server submission.
+"""
+
+from .vram_estimate import KEY as ESTIMATE_KEY
+from .vram_estimate import vram_estimate_errors
+
+KIND = "vram_projection_inherited"
+_VARIABLE_PREFIX = "variable:"
+
+
+def _resolved(value, variables):
+    """A `variable:` reference resolved against a template's own defaults -
+    the index reads templates as written, not substituted."""
+    if isinstance(value, str) and value.startswith(_VARIABLE_PREFIX):
+        return variables.get(value[len(_VARIABLE_PREFIX) :])
+    return value
+
+
+def pipeline_identity(step, variables=None):
+    """(component_type, model_name, workflow) for a step that loads a
+    pipeline, or None for a step that does not."""
+    pipeline = step.get("pipeline") if isinstance(step, dict) else None
+    if not isinstance(pipeline, dict):
+        return None
+    variables = variables or {}
+    configuration = pipeline.get("configuration")
+    from_pretrained = pipeline.get("from_pretrained_arguments")
+    configuration = configuration if isinstance(configuration, dict) else {}
+    from_pretrained = from_pretrained if isinstance(from_pretrained, dict) else {}
+    identity = tuple(
+        _resolved(value, variables)
+        for value in (
+            configuration.get("component_type"),
+            from_pretrained.get("model_name"),
+            from_pretrained.get("workflow"),
+        )
+    )
+    if not all(isinstance(part, (str, type(None))) for part in identity):
+        return None
+    if identity[1] is None:
+        # No checkpoint named - nothing to match a catalog entry on
+        return None
+    return identity
+
+
+def template_identity(definition):
+    """The one pipeline identity every pipeline step of `definition` shares,
+    or None when it holds none or more than one."""
+    variables = definition.get("variables")
+    variables = variables if isinstance(variables, dict) else {}
+    steps = definition.get("steps")
+    identities = {
+        pipeline_identity(step, variables)
+        for step in (steps if isinstance(steps, list) else [])
+        if isinstance(step, dict) and isinstance(step.get("pipeline"), dict)
+    }
+    if len(identities) != 1 or None in identities:
+        return None
+    return identities.pop()
+
+
+def declarations(catalog):
+    """Every (identity, name, definition) a catalog of (name, definition)
+    pairs offers the index: a declared `vram_estimate` on a single-identity
+    template. Cost is not required here - the agreement test reads the
+    numbers of a template that declares no card too."""
+    for name, definition in catalog:
+        if not isinstance(definition, dict):
+            continue
+        if not isinstance(definition.get(ESTIMATE_KEY), dict):
+            continue
+        identity = template_identity(definition)
+        if identity is not None:
+            yield identity, name, definition
+
+
+def _preference(entry):
+    # Fewest steps first - the plainest statement of the pipeline's ceiling -
+    # then by name, so the source a warning names never depends on listing
+    # order
+    _, name, definition = entry
+    return (len(definition.get("steps") or []), name)
+
+
+def build_index(catalog):
+    """identity -> {vram_estimate, cost, template} from a catalog of
+    (name, definition) pairs. Only a template that declares `cost` entries
+    to check against contributes; where several declare the same identity,
+    the one with the fewest steps is the named source (the agreement test
+    pins that their numbers are the same)."""
+    found = {}
+    for entry in sorted(declarations(catalog), key=_preference):
+        identity, name, definition = entry
+        cost = definition.get("cost")
+        if identity in found or not isinstance(cost, list) or not cost:
+            continue
+        found[identity] = {
+            "vram_estimate": definition[ESTIMATE_KEY],
+            "cost": cost,
+            "template": name,
+        }
+    return found
+
+
+def inherited_vram_warnings(
+    definition,
+    index,
+    arguments=None,
+    supplied=(),
+    device_type=None,
+    capacity_gb=None,
+    source_indices=None,
+    written=None,
+):
+    """Every catalog ceiling `definition` (expanded, as the run executes it)
+    projects past, as warning strings - one per matched identity, naming the
+    largest step. Nothing when the definition declares its own
+    `vram_estimate`, which always wins."""
+    if not index or not isinstance(definition, dict):
+        return []
+    if isinstance(definition.get(ESTIMATE_KEY), dict):
+        return []
+    steps = definition.get("steps")
+    if not isinstance(steps, list):
+        return []
+    variables = definition.get("variables")
+    variables = variables if isinstance(variables, dict) else {}
+    identities = [pipeline_identity(step, variables) for step in steps]
+    warnings = []
+    for identity in dict.fromkeys(i for i in identities if i in index):
+        entry = index[identity]
+        # Only this identity's steps, at their own indices so a member's
+        # path still maps back through source_indices
+        matched = {
+            **definition,
+            "steps": [
+                step if step_identity == identity else {}
+                for step, step_identity in zip(steps, identities)
+            ],
+            # The template's reason is its own calibration story; the
+            # warning names the template, which is where to read it
+            ESTIMATE_KEY: {
+                key: value
+                for key, value in entry["vram_estimate"].items()
+                if key != "reason"
+            },
+            "cost": entry["cost"],
+        }
+        errors = vram_estimate_errors(
+            matched,
+            arguments,
+            supplied=supplied,
+            device_type=device_type,
+            capacity_gb=capacity_gb,
+            source_indices=source_indices,
+            written=written,
+        )
+        if not errors:
+            continue
+        error = errors[0]
+        warnings.append(
+            f"{error['path']}: {KIND}: {error['message'].rstrip('.')}. The "
+            f"ceiling is inherited from '{entry['template']}', which loads "
+            f"the same pipeline; this workflow declares no vram_estimate and "
+            f"its offload and quantization config may differ from the "
+            f"template's, so this warns rather than refuses - declare a "
+            f"vram_estimate to be judged by your own numbers"
+        )
+    return warnings
diff --git a/dw/worker.py b/dw/worker.py
index 6ce163f9..a189d8e4 100644
--- a/dw/worker.py
+++ b/dw/worker.py
@@ -35,8 +35,9 @@ def _mb(value):
     return f"{value:.0f} MB" if value is not None else "unknown"
 
 
-def _job_scoped_peak_rss_mb(info, baseline_peak_mb):
-    """This job's own contribution to the process-lifetime peak (#272).
+def _job_scoped_peak_rss_mb(info, baseline_peak_mb, running_max_mb):
+    """This job's own contribution to the process-lifetime peak (#272),
+    held as a running max across the job's readings (#457).
 
     `host_memory_peak_rss_mb` is `ru_maxrss` - process-lifetime, never reset -
     so in the persistent worker a small job run right after a heavy one
@@ -46,15 +47,22 @@ def _job_scoped_peak_rss_mb(info, baseline_peak_mb):
     then is unambiguously this job's doing. A job that caused no growth at
     all (it rode an earlier, larger peak) has no meaningful "job peak" to
     report as a delta, so this floors at the job's current rss instead of
-    reporting a number that undersells what is resident right now.
+    reporting a number that undersells what is resident right now - but the
+    current rss can *fall* between readings (cleanup, GC), and a peak must
+    not: `running_max_mb` is the highest value this function has returned
+    for this job so far, and the candidate for this reading is folded into
+    it rather than replacing it outright.
     """
     peak = info.get("host_memory_peak_rss_mb")
     if peak is None or baseline_peak_mb is None:
-        return None
+        return running_max_mb
     growth = peak - baseline_peak_mb
-    if growth > 0:
-        return growth
-    return info.get("host_memory_rss_mb")
+    candidate = growth if growth > 0 else info.get("host_memory_rss_mb")
+    if candidate is None:
+        return running_max_mb
+    if running_max_mb is None or candidate > running_max_mb:
+        return candidate
+    return running_max_mb
 
 
 logger = logging.getLogger("dw.worker")
@@ -264,7 +272,7 @@ def _handle_execute(self, command: Dict[str, Any]):
             # of refusing with job_running for the run's whole duration; the
             # first such reading is this job's baseline for the job-scoped
             # peak field carried on every memory_info from here on (#272)
-            job_baseline = {"peak_rss_mb": None}
+            job_baseline = {"peak_rss_mb": None, "job_peak_rss_mb": None}
 
             def _on_event(event):
                 self.result_queue.put({"type": "progress", **event})
@@ -274,11 +282,14 @@ def _on_event(event):
                         job_baseline["peak_rss_mb"] = memory_info.get(
                             "host_memory_peak_rss_mb"
                         )
-                    memory_info["host_memory_job_peak_rss_mb"] = (
-                        _job_scoped_peak_rss_mb(
-                            memory_info, job_baseline["peak_rss_mb"]
-                        )
+                    job_baseline["job_peak_rss_mb"] = _job_scoped_peak_rss_mb(
+                        memory_info,
+                        job_baseline["peak_rss_mb"],
+                        job_baseline["job_peak_rss_mb"],
                     )
+                    memory_info["host_memory_job_peak_rss_mb"] = job_baseline[
+                        "job_peak_rss_mb"
+                    ]
                     self.result_queue.put({"type": "memory_info", "info": memory_info})
 
             context = RunContext(on_event=_on_event)
@@ -319,7 +330,9 @@ def _on_event(event):
             # guessing a baseline after the fact.
             memory_info = self._get_memory_info()
             memory_info["host_memory_job_peak_rss_mb"] = _job_scoped_peak_rss_mb(
-                memory_info, job_baseline["peak_rss_mb"]
+                memory_info,
+                job_baseline["peak_rss_mb"],
+                job_baseline["job_peak_rss_mb"],
             )
             self.result_queue.put({"type": "memory_info", "info": memory_info})
 
diff --git a/dw/workflow.py b/dw/workflow.py
index c0e7d0d6..eda455d6 100644
--- a/dw/workflow.py
+++ b/dw/workflow.py
@@ -18,6 +18,7 @@
 from .events import (
     RunContext,
     emit_phase,
+    emit_warning,
     WorkflowCancelled,
     get_context,
     current_context,
@@ -30,6 +31,7 @@
 )
 from .locations import location_errors
 from .reference_limits import reference_limit_errors
+from .null_media import null_media_errors
 from .adapter_compatibility import adapter_errors, warn_adapters
 from .elision import elide_definition, warn_elided
 from .introspection import (
@@ -38,6 +40,7 @@
     component_name_errors,
 )
 from .dissolve_frame_errors import dissolve_frame_errors
+from .video_size_errors import video_size_errors
 from .task_domains import task_argument_errors
 from .select_validation import select_errors
 from .variable_constraints import (
@@ -47,7 +50,7 @@
     resolve_constraint_references,
 )
 from .result_fps import fps_errors
-from .shots import step_shots
+from .shots import duplicate_shot_names, step_shots
 from .subfolders import step_subfolder, subfolder_errors
 from .reference_names import reference_name_errors
 from .video_extensions import video_extension_errors
@@ -91,6 +94,7 @@
 from .pipeline_processors.pipeline import Pipeline
 from .tasks.model_cache import clear_model_cache
 from .tasks.task import Task
+from .tasks.voice_attribution import voices_errors
 from . import (
     get_device,
     get_device_type,
@@ -726,6 +730,26 @@ def validation_errors(self, arguments=None, composing=None):
             # A reference set the pipeline would refuse costs a checkpoint
             # load to find out about otherwise (dw/reference_limits.py, #136)
             + reference_limit_errors(expanded, source_indices)
+            # A step a declared vram_estimate projects past the card 'cost'
+            # was measured on - per step, after expansion, so a for_each
+            # member is projected with its own frames and references, and
+            # refused here rather than found 90+ seconds into denoising on
+            # an OOM the caller had no way to see coming
+            # (dw/vram_estimate.py, #265, #479)
+            + vram_estimate_errors(
+                expanded,
+                arguments,
+                supplied=set(arguments or {}),
+                device_type=get_device_type(),
+                capacity_gb=device_capacity_gb(),
+                source_indices=source_indices,
+                written=self.workflow_definition,
+            )
+            # A for_each item's bare reference (not in a list, so nothing to
+            # silently drop it from) whose media resolved null - realize_args
+            # already refuses this at run time, a few seconds into the job
+            # (dw/null_media.py, #478)
+            + null_media_errors(expanded, source_indices)
             # An adapter trained for the other checkpoint partition, which
             # the pipeline loads without complaint and answers worse for -
             # the one H3 mistake that never shows in the output
@@ -742,6 +766,10 @@ def validation_errors(self, arguments=None, composing=None):
             # sample rate a silent fallback to 44100 (dw/task_domains.py,
             # #139, #140)
             + task_argument_errors(expanded, source_indices)
+            # An attribute_voices `voices` it would refuse - one voice, a bad
+            # name, a reference too short - is knowable from the literal and
+            # was refused only on the step, a queued job in (#494)
+            + voices_errors(expanded, source_indices)
             # A dissolve_videos overlap wider than a statically-resolvable
             # input's real frame count decoded clean past the queue and
             # failed only after every upstream step had already generated -
@@ -749,6 +777,11 @@ def validation_errors(self, arguments=None, composing=None):
             # output:/literal-path video, the cases the frame count is
             # already knowable (dw/dissolve_frame_errors.py, #400)
             + dissolve_frame_errors(expanded, source_indices, base_dir)
+            # A dissolve_videos/concat_videos size mismatch decoded clean
+            # past the queue and failed only after every upstream step had
+            # already generated - refused here for the cases the sizes are
+            # already knowable (dw/video_size_errors.py, #504)
+            + video_size_errors(expanded, source_indices, base_dir)
             # A select step whose rule is misspelled, or whose
             # threshold/index does not match its rule, validated clean and
             # died on select's own run-time ValueError after the fan-out
@@ -784,18 +817,6 @@ def validation_errors(self, arguments=None, composing=None):
                 self.workflow_definition, arguments, supplied=set(arguments or {})
             )
             + constraint_reference_errors(self.workflow_definition)
-            # A (width, height, num_frames)-shaped combination a declared
-            # vram_estimate projects past the card 'cost' was measured on -
-            # refused here rather than found 90+ seconds into denoising on
-            # an OOM the caller had no way to see coming (dw/vram_estimate.py,
-            # #265)
-            + vram_estimate_errors(
-                self.workflow_definition,
-                arguments,
-                supplied=set(arguments or {}),
-                device_type=get_device_type(),
-                capacity_gb=device_capacity_gb(),
-            )
             # An 'attn_processor_type' whose Hub kernel this machine has no
             # build variant for - validated clean and then died 88s into
             # loading, naming a torch/natten mismatch the construction alone
@@ -828,6 +849,36 @@ def adapter_warnings(self, arguments=None):
             supplied=set(arguments or {}),
         )
 
+    def inherited_vram_warnings(self, arguments=None, index=None):
+        """Every catalog VRAM ceiling this workflow's expanded steps project
+        past, matched by pipeline identity (`dw/vram_inheritance.py`) - for a
+        workflow that declares no `vram_estimate` of its own. A warning, not
+        an error: the catalog's numbers were measured on the catalog's
+        offload and quantization config (#479).
+
+        Best effort, like `adapter_warnings`.
+        """
+        from .vram_inheritance import inherited_vram_warnings
+
+        if not index:
+            return []
+        try:
+            source_indices = []
+            expanded = self.expanded_definition(arguments, source_indices)
+        except Exception:
+            logger.debug("No inherited VRAM warnings available", exc_info=True)
+            return []
+        return inherited_vram_warnings(
+            expanded,
+            index,
+            arguments,
+            supplied=set(arguments or {}),
+            device_type=get_device_type(),
+            capacity_gb=device_capacity_gb(),
+            source_indices=source_indices,
+            written=self.workflow_definition,
+        )
+
     def slice_past_end_warnings(self, arguments=None):
         """Every `slice_audio` step whose source's real duration is already
         knowable and whose requested slice reaches past it - valid, padded
@@ -998,18 +1049,6 @@ def _prepare_definition(self, workflow_def, arguments, base_dir):
             # before anything loads, and before substitution puts the value
             # everywhere it is referenced (dw/variable_constraints.py, #96)
             apply_constraints(workflow_def, variables)
-            # A (width, height, num_frames)-shaped combination a declared
-            # vram_estimate projects past the card 'cost' was measured on -
-            # the run-time backstop for a caller that skips
-            # validate_workflow, so this raises the same refusal rather
-            # than starting a job the decode step was always going to OOM
-            # on (dw/vram_estimate.py, #265)
-            apply_vram_estimate(
-                workflow_def,
-                variables,
-                device_type=get_device_type(),
-                capacity_gb=device_capacity_gb(),
-            )
             # realize the variables - explicit references only (asset:,
             # output:, constant:, prompt:, a {media_type, location} dict).
             # Key-name conventions (an 'image'/'video'/'_type' argument) are
@@ -1035,6 +1074,19 @@ def _prepare_definition(self, workflow_def, arguments, base_dir):
 
         workflow_def = expand_for_each(workflow_def)
 
+        # A step a declared vram_estimate projects past the card 'cost' was
+        # measured on - the run-time backstop for a caller that skips
+        # validate_workflow, so this raises the same refusal rather than
+        # starting a job the decode step was always going to OOM on. After
+        # expansion, so a for_each member is projected with its own frames
+        # and references (dw/vram_estimate.py, #265, #479)
+        apply_vram_estimate(
+            workflow_def,
+            variables,
+            device_type=get_device_type(),
+            capacity_gb=device_capacity_gb(),
+        )
+
         # A step nothing after it reads, and which saves no file, does not
         # run - after expansion, so a for_each member is judged like any
         # other step, and before the seed and the run id, so everything
@@ -1596,6 +1648,23 @@ def run(
                 )
                 if shots:
                     manifest_entry["shots"] = shots
+                    duplicates = duplicate_shot_names(shots)
+                    if duplicates:
+                        # Frames and samples stay exact either way - only a
+                        # name-based lookup (a `shots=` argument, a finding)
+                        # can no longer tell the collided shots apart (#508)
+                        for file, names in duplicates.items():
+                            extra = {"file": file} if file is not None else {}
+                            emit_warning(
+                                f"{step.name}: joined shots share a name ("
+                                + ", ".join(names)
+                                + ") and can no longer be told apart by "
+                                "name - start_frame still disambiguates.",
+                                kind="shot_name_collision",
+                                command=step.name,
+                                names=names,
+                                **extra,
+                            )
                 # No entry at all for a step the parent saves for: the
                 # parent's own entry names the same files, under the step
                 # name the caller wrote (#92)
@@ -1622,6 +1691,24 @@ def run(
                 )
                 logger.debug(f"Step {step.name} completed with result: {result}")
 
+                # Rewritten after every step, not only at the end (#480): a
+                # for_each member that just landed is otherwise invisible to
+                # anything reading manifest.json until the whole job finishes
+                # or dies, leaving a killed worker's finished shots
+                # unrecorded. Best effort, like the run-open and final
+                # writes - a step that saved its files has succeeded whether
+                # or not this lands
+                if self._run_dir and not self._run_dir_inherited:
+                    self._write_run_manifest(
+                        run_id,
+                        "running",
+                        started_at,
+                        arguments,
+                        resolved_seed,
+                        realized_name,
+                        annotations,
+                    )
+
                 # Release results no later step references - saved to disk
                 # already, and last_result keeps the workflow's return value
                 release_unreferenced_results(results, remaining_refs)
diff --git a/dw/workflow_schema.json b/dw/workflow_schema.json
index 6da2916f..ef81e252 100644
--- a/dw/workflow_schema.json
+++ b/dw/workflow_schema.json
@@ -69,7 +69,7 @@
             "$ref": "#/$defs/arguments"
         },
         "vram_estimate": {
-            "description": "A declared VRAM ceiling over this workflow's cost_drivers, checked against each 'cost' entry's 'vram_gb' in validate_workflow. Never derived from a profiler - a maintainer's own reading of what a stage needs, the same way 'cost' itself is. required_gb = base_gb + bytes_per_voxel * (product of voxel_variables' values) / 2^30; a combination projecting above any cost entry's vram_gb for that entry's device is refused, not warned, since the failure this guards is an OOM partway through a run that already spent minutes loading. 'voxel_variables' names the cost_drivers whose product drives the estimate - typically width, height and num_frames for a video template.",
+            "description": "A declared VRAM ceiling over this workflow's cost_drivers, checked against each 'cost' entry's 'vram_gb' in validate_workflow and again before a run starts. Never derived from a profiler - a maintainer's own reading of what a stage needs, the same way 'cost' itself is. Projected per pipeline step of the definition as it will run - variables substituted and every for_each expanded, so each member is projected with its own values: required_gb = base_gb + bytes_per_voxel * (product of voxel_variables' values) / 2^30 + gb_per_reference * (the step's 'references' entries whose from_file/from_previous_result is not null); a step projecting above any cost entry's vram_gb for that entry's device is refused, not warned, since the failure this guards is an OOM partway through a run that already spent minutes loading. Only the largest step past the ceiling is reported - for a for_each member, at the list entry it came from. 'voxel_variables' names the cost_drivers whose product drives the estimate - typically width, height and num_frames for a video template.",
             "type": "object",
             "required": ["base_gb", "bytes_per_voxel", "voxel_variables"],
             "properties": {
@@ -80,8 +80,9 @@
                     "items": {"type": "string"},
                     "minItems": 1,
                     "uniqueItems": true,
-                    "description": "Variable names whose product is the voxel count the formula scales with. Each must be a declared variable."
+                    "description": "Names whose product is the voxel count the formula scales with. Each is read from the step's own pipeline arguments, else from the workflow's variables; a step where one is not a number is not projected."
                 },
+                "gb_per_reference": {"type": "number", "minimum": 0, "description": "GB of additional VRAM per reference the step passes - a reference-conditioned pipeline holds each one's encoding resident beside the latents. Every kind counts once; an entry whose media is null is dropped before the pipeline sees it and is not counted. Absent means references are not in the formula."},
                 "reason": {"type": "string"}
             },
             "additionalProperties": false
diff --git a/dw_mcp/CLAUDE.md b/dw_mcp/CLAUDE.md
index 46e87ccc..7e32d580 100644
--- a/dw_mcp/CLAUDE.md
+++ b/dw_mcp/CLAUDE.md
@@ -42,11 +42,12 @@ routing table, with `get_prompt` for the one body that was chosen. It also
 forwards `tag` and `intended_model`, because the library is where the
 trained caption format for a family is already written out and the reason to
 read it is to find that one.
-`run_workflow` and `validate_workflow` are the other two handlers that carry
-one: each takes an
-optional per-call `workspace` that `_scoped`'s `setdefault` lets win over the
-session's, so one call can be pinned to a workspace other than the session's
-without switching it.
+`run_workflow`, `validate_workflow` and the gallery and output tools
+(`list_gallery`, `get_output_*`, `get_gallery_metadata`, `keep_output`,
+`download_output`, `delete_output`, `assess_output`) also take an optional
+per-call `workspace` that `_scoped`'s `setdefault` lets win over the session's,
+so one call can be pinned to a workspace other than the session's without
+switching it.
 `get_server_info`
 (`/api/server`) is the capability call: the device a run will use, the dw
 version, the workspace and the workflow/output/prompt/asset directories, which is what tells an
@@ -58,7 +59,7 @@ because a request names a subject and the catalog is written in shapes, and an
 agent with nowhere to look up the shape authors a fresh workflow instead of
 composing one. Only `dw_mcp/server.py` imports the MCP SDK; the
 handlers in `catalog.py`, `authoring.py`, `prompts.py`, `diagnose.py`,
-`media.py`, `assets.py`, `models.py` and `workspaces.py` are plain `(client, **kwargs)` functions, which is what makes
+`media.py`, `assets.py`, `models.py`, `exports.py` and `workspaces.py` are plain `(client, **kwargs)` functions, which is what makes
 them testable without an MCP session. It is a top-level package rather than
 `dw.mcp` on purpose: importing any `dw.*` submodule runs `dw/__init__.py`
 and pulls in torch, which a pure HTTP client has no use for — a test guards
diff --git a/dw_mcp/assets.py b/dw_mcp/assets.py
index e7dbadd6..73d8dfe4 100644
--- a/dw_mcp/assets.py
+++ b/dw_mcp/assets.py
@@ -11,6 +11,7 @@
 
 import base64
 import os
+from urllib.parse import urlsplit
 
 from dw_mcp.client import DwApiError, api_path
 
@@ -58,6 +59,14 @@ def _remote_roots(client):
     file read plus a path-existence oracle (#138). A stdio `dw-mcp` returns
     None and keeps reading whatever the user can, because there "local file"
     is genuinely their own.
+
+    `/api/server`'s `directories` names only the four workspace-scoped
+    folders plus the shared prompt library, not the shared asset library
+    ('common/assets') every workspace's own asset search path already
+    includes - that one is only visible via `/api/assets`'s `libraries`
+    (#448). A writable library there (the workspace's own, already covered
+    above, and the shared one) is as legal a source as the four directories;
+    a read-only examples library is not, so it is left out.
     """
     if not getattr(client, "mounted", False):
         return None
@@ -73,6 +82,23 @@ def _remote_roots(client):
         )
         if resolved not in roots:
             roots.append(resolved)
+
+    try:
+        libraries = client.get_json("/api/assets").get("libraries") or []
+    except DwApiError:
+        libraries = []
+    for library in libraries:
+        if not isinstance(library, dict) or not library.get("writable"):
+            continue
+        value = library.get("dir")
+        if not value:
+            continue
+        resolved = os.path.normpath(
+            os.path.realpath(os.path.abspath(os.path.expanduser(str(value))))
+        )
+        if resolved not in roots:
+            roots.append(resolved)
+
     if not roots:
         raise DwApiError(
             "This server cannot say which directories it works in, so it "
@@ -84,7 +110,58 @@ def _remote_roots(client):
     return roots
 
 
-def _confine_source(path, roots, named):
+# Hosts a URL cannot be handed to another machine with: each one names
+# whichever machine reads it. A `dw.serve --mcp` endpoint reaches its own
+# server at 127.0.0.1 (dw/server/mcp_mount.py's client_base_url), which is
+# exactly the address that is wrong for the remote caller an upload refusal
+# is written for (#481)
+LOCAL_ONLY_HOSTS = frozenset(("localhost", "::1", "0.0.0.0", "::"))
+
+
+def _upload_origin(client):
+    """The origin to print in a curl command meant for the caller's machine:
+    the client's own base URL when another machine can use it, else the
+    same URL with `<host>` in place of the loopback address."""
+    parsed = urlsplit(client.base_url)
+    host = (parsed.hostname or "").lower()
+    if host and host not in LOCAL_ONLY_HOSTS and not host.startswith("127."):
+        return client.base_url.rstrip("/")
+    port = f":{parsed.port}" if parsed.port else ""
+    return f"{parsed.scheme or 'http'}://<host>{port}"
+
+
+def _upload_route_hint(client, workspace=None):
+    """The `POST /api/uploads` curl command both upload_asset refusals end
+    in - the one route that takes a file no MCP call can carry (#481). The
+    workspace is filled from the call or the session, since an upload to the
+    wrong one yields an 'asset:' reference that resolves to nothing where
+    the caller is working."""
+    origin = _upload_origin(client)
+    ws = workspace or client.workspace
+    text = (
+        f"curl the bytes straight to the upload route dw.serve exposes for "
+        f"this - the one the web UI's file picker uses, up to "
+        f"{MAX_UPLOAD_BYTES // (1024 * 1024)}MB, the body the raw file rather than JSON: "
+        f'curl -H "Authorization: Bearer $DW_API_TOKEN" --data-binary '
+        f'@<file> "{origin}/api/uploads?filename=<name>'
+        f'&asset_name=<folder/name>&workspace={ws}" (the bearer token only '
+        f"when the server requires one). "
+    )
+    if "<host>" in origin:
+        text += (
+            "<host> is this server's address as your machine reaches it - "
+            "the host of the MCP endpoint you are connected to - not "
+            "127.0.0.1, which on your machine is your machine. "
+        )
+    return text + (
+        "It answers 201 with 'path', the 'asset:' reference to use in a "
+        "workflow argument; the guide's References section "
+        '(get_guide("workflows", section="Authoring a workflow from an '
+        'agent")) has the same command.'
+    )
+
+
+def _confine_source(path, roots, named, client, workspace=None):
     """Refuse a source outside `roots`, before anything looks at the file.
 
     Ordered ahead of the existence and extension checks on purpose: a
@@ -108,9 +185,9 @@ def _confine_source(path, roots, named):
         f"({', '.join(roots)}). A file that is already there is reachable "
         f"as an 'asset:' reference; to put a new one there when it exists "
         f"only on your own machine, call upload_asset with content= (its "
-        f"bytes, base64-encoded) instead of file_path, upload it through "
-        f"the web UI's file picker, or promote a generated file with "
-        f"keep_output."
+        f"bytes, base64-encoded, capped at {MAX_INLINE_UPLOAD_BYTES} bytes) "
+        f"instead of file_path, or {_upload_route_hint(client, workspace)} "
+        f"Or promote a generated file with keep_output."
     )
 
 
@@ -127,10 +204,14 @@ def _summarised_asset_entries(entries):
     ]
 
 
-def list_assets(client, detail=False):
+def list_assets(client, detail=False, workspace=None):
     """The input media on the server, each with the 'asset:' reference a
     workflow argument carries.
 
+    `workspace` pins this one call to another workspace without switching
+    the session (#463) - the same selector `run_workflow` and the output
+    tools take.
+
     Spans the whole search path: each entry's 'origin' says whether it is
     this workspace's own ('workspace'), the library every workspace shares
     ('common'), or one a read-only examples tree brought with it.
@@ -147,7 +228,7 @@ def list_assets(client, detail=False):
     under what name" (#249). Pass `detail=True` for each entry's `folder`,
     `mtime` and `url` too.
     """
-    result = client.get_json("/api/assets")
+    result = client.get_json("/api/assets", workspace=workspace)
     if detail:
         return result
     assets = result.get("assets")
@@ -167,14 +248,18 @@ def list_assets(client, detail=False):
     }
 
 
-def delete_asset(client, name):
+def delete_asset(client, name, workspace=None):
     """Remove one file from the asset library.
 
     Deletes from whichever library holds it - the workspace's own before
     the shared one, the order 'asset:' resolves in. An asset from a
     read-only examples library answers 403.
+
+    `workspace` pins this one call to another workspace without switching
+    the session (#463) - without it a delete follows the session's shared
+    pin, which another connection on a mounted transport can move.
     """
-    return client.delete_json(api_path("api", "assets", name))
+    return client.delete_json(api_path("api", "assets", name), workspace=workspace)
 
 
 def keep_output(
@@ -207,7 +292,14 @@ def keep_output(
     )
 
 
-def upload_asset(client, file_path=None, content=None, asset_name=None, shared=False):
+def upload_asset(
+    client,
+    file_path=None,
+    content=None,
+    asset_name=None,
+    shared=False,
+    workspace=None,
+):
     """Put an image, video or audio file into the server's asset library and
     get back the reference a workflow can use.
 
@@ -244,17 +336,23 @@ def upload_asset(client, file_path=None, content=None, asset_name=None, shared=F
     the session's own, which is what a recurring cast needs: assets are
     per workspace, so a cast uploaded while making episode one was
     invisible from the workspace episode four was made in.
+
+    `workspace` pins this one call to another workspace without switching
+    the session (#463) - the same selector `run_workflow` and the output
+    tools take.
     """
     if (file_path is None) == (content is None):
         raise DwApiError("Pass exactly one of file_path or content.")
 
     if content is not None:
-        return _upload_inline(client, content, asset_name=asset_name, shared=shared)
+        return _upload_inline(
+            client, content, asset_name=asset_name, shared=shared, workspace=workspace
+        )
 
     path = os.path.abspath(os.path.expanduser(str(file_path)))
     roots = _remote_roots(client)
     if roots is not None:
-        _confine_source(path, roots, file_path)
+        _confine_source(path, roots, file_path, client, workspace)
     if not os.path.isfile(path):
         raise DwApiError(f"No such file: {file_path}")
 
@@ -283,19 +381,20 @@ def upload_asset(client, file_path=None, content=None, asset_name=None, shared=F
         params["asset_name"] = asset_name
     if shared:
         params["shared"] = "true"
-    result = client.post_bytes("/api/uploads", body, params=params)
+    result = client.post_bytes("/api/uploads", body, params=params, workspace=workspace)
     # 'path' from a server with no asset library is an absolute path on that
     # machine; from one with a library it is already the reference. Report
     # whichever it gave, named for what it is
     return {
         "reference": result.get("path"),
+        "workspace": result.get("workspace"),
         "url": result.get("url"),
         "uploaded": os.path.basename(path),
         "size": size,
     }
 
 
-def _upload_inline(client, content, asset_name=None, shared=False):
+def _upload_inline(client, content, asset_name=None, shared=False, workspace=None):
     """The `content=` path of upload_asset - bytes with no path behind
     them, so nothing here is confined or read off any disk (#203)."""
     if not asset_name:
@@ -321,15 +420,18 @@ def _upload_inline(client, content, asset_name=None, shared=False):
             f"content is {len(body)} bytes, over the "
             f"{MAX_INLINE_UPLOAD_BYTES} byte limit for an inline upload. A "
             f"file this large should be reached by file_path instead, from "
-            f"a machine that has it on disk."
+            f"a machine that has it on disk. If neither machine has it - a "
+            f"remote dw.serve --mcp endpoint with nothing in common with the "
+            f"caller's own disk - {_upload_route_hint(client, workspace)}"
         )
 
     params = {"filename": asset_name, "asset_name": asset_name}
     if shared:
         params["shared"] = "true"
-    result = client.post_bytes("/api/uploads", body, params=params)
+    result = client.post_bytes("/api/uploads", body, params=params, workspace=workspace)
     return {
         "reference": result.get("path"),
+        "workspace": result.get("workspace"),
         "url": result.get("url"),
         "uploaded": asset_name,
         "size": len(body),
diff --git a/dw_mcp/authoring.py b/dw_mcp/authoring.py
index 9aed52b8..5a7fb3ae 100644
--- a/dw_mcp/authoring.py
+++ b/dw_mcp/authoring.py
@@ -66,7 +66,7 @@ def validate_workflow(
     return client.post_json("/api/validate", payload, params=params)
 
 
-def save_workflow(client, name, workflow=None, patch=None):
+def save_workflow(client, name, workflow=None, patch=None, workspace=None):
     """Write a workflow into the server's writable workflow directory,
     overwriting any file already under that name there. A name that resolves
     to one of the server's read-only sources (an examples directory) is not
@@ -80,7 +80,12 @@ def save_workflow(client, name, workflow=None, patch=None):
     argument rather than the whole document. A key set to `null` deletes it.
     A list replaces the stored list whole - a merge patch has no notion of
     list position, so changing one entry of a `for_each` list still means
-    sending that whole list."""
+    sending that whole list.
+
+    `workspace` pins this one call to another workspace without switching
+    the session - the same selector `run_workflow` and the output tools
+    take, so a save cannot be misdirected by a pin another connection on a
+    shared mount changed underneath it (#463)."""
     if (workflow is None) == (patch is None):
         raise DwApiError(
             "Provide exactly one of `workflow` (a full replacement) or "
@@ -89,9 +94,13 @@ def save_workflow(client, name, workflow=None, patch=None):
     workflow = coerce_json_object(workflow, "workflow")
     patch = coerce_json_object(patch, "patch")
     if patch is not None:
-        current = client.get_json(api_path("api", "workflows", name))
+        current = client.get_json(
+            api_path("api", "workflows", name), workspace=workspace
+        )
         workflow = _merge_patch(current, patch)
-    return client.put_json(api_path("api", "workflows", name), {"workflow": workflow})
+    return client.put_json(
+        api_path("api", "workflows", name), {"workflow": workflow}, workspace=workspace
+    )
 
 
 def _merge_patch(target, patch):
@@ -109,6 +118,10 @@ def _merge_patch(target, patch):
     return result
 
 
-def delete_workflow(client, name):
-    """Remove a workflow from the server's workflow directory."""
-    return client.delete_json(api_path("api", "workflows", name))
+def delete_workflow(client, name, workspace=None):
+    """Remove a workflow from the server's workflow directory.
+
+    `workspace` pins this one call to another workspace without switching
+    the session (#463) - without it a delete follows the session's shared
+    pin, which another connection on a mounted transport can move."""
+    return client.delete_json(api_path("api", "workflows", name), workspace=workspace)
diff --git a/dw_mcp/guides.py b/dw_mcp/guides.py
index 977e709f..f5f6b126 100644
--- a/dw_mcp/guides.py
+++ b/dw_mcp/guides.py
@@ -24,7 +24,9 @@ def list_guides(client):
 
 def get_guide(client, name, section=None):
     """One guide, or one section of it. A section name is matched loosely
-    on the server, so a heading copied approximately resolves.
+    on the server, so a heading copied approximately resolves; this also
+    reaches a `###` subsection not listed in `sections` (e.g. "for_each"),
+    by name or by a term inside it.
 
     Without a section the answer is the guide's index - its opening, its
     first section, and `sections`/`withheld` naming the rest - not the
diff --git a/dw_mcp/server.py b/dw_mcp/server.py
index 370acf85..800f71d4 100644
--- a/dw_mcp/server.py
+++ b/dw_mcp/server.py
@@ -70,8 +70,7 @@ def build_server(client):
             "Generate images, video and audio on a real GPU: author, run "
             "and diagnose diffusers-workflow jobs against a running "
             "dw.serve. A workflow is a JSON document of named steps, each a "
-            "diffusers pipeline or a utility task; the engine runs one job "
-            "at a time.\n"
+            "diffusers pipeline or a utility task.\n"
             "\n"
             "Start from `list_workflows(shape=...)` and run what the catalog "
             "already holds, with `arguments` overriding its variables. "
@@ -84,7 +83,7 @@ def build_server(client):
             "author new JSON only when neither the catalog nor a "
             "composition covers the request.\n"
             "\n"
-            "`get_server_info` reports the accelerator, directories and this "
+            "`get_server_info` reports the accelerator and this "
             "session's workspace; a CUDA-only choice is unavailable on an "
             "mps or cpu server.\n"
             "\n"
@@ -93,21 +92,23 @@ def build_server(client):
             "`validate_workflow` (free; repeat until clean) -> quote its "
             "`plan.estimate` and get the user's go-ahead -> `run_workflow` "
             "-> `wait_for_job` -> `get_job` -> `get_output_image`, "
-            "`get_output_frames`, `get_output_audio` to look at and listen "
-            "to the result and judge it against the request. Tools that "
-            "spend GPU time or disk, or delete for good, refuse until "
+            "`get_output_frames`, `get_output_audio` to judge the result "
+            "against the ask. Tools that spend GPU time or disk, or "
+            "delete, refuse until "
             "`acknowledged_cost` is set. A workflow you wrote has no "
-            "measured cost: quote the `models/` entry that loads the same "
-            "pipeline (`list_workflows(include_models=true)`) times the "
-            "number of images.\n"
+            "cost: quote the `models/` entry for its pipeline "
+            "(`list_workflows(include_models=true)`) times the number of "
+            "images. Validate warns (never refuses) past the VRAM ceiling "
+            "inherited from the catalog template with the same pipeline; "
+            "your offload or quantization may differ.\n"
             "\n"
             "Arguments carry references rather than literals: `variable:`, "
             "`previous_result:`, `prompt:` (the stored prompt library), "
             "`asset:` (input media on the server - `upload_asset`, "
             "`keep_output`) and `output:` (an earlier run's file). The "
-            "guide's References section defines each; prefer them to a "
-            "local path, which means nothing to the server. "
-            "`use_workspace` picks the workspace this session works in."
+            "guide's References section defines each; a local path means "
+            "nothing to the server. "
+            "`use_workspace` picks this session's workspace."
         ),
     )
 
@@ -461,7 +462,8 @@ def get_guide(name: str, section: str | None = None) -> dict:
         section - a guide runs to thousands of lines, and the headings in
         the listing are there so the right part can be asked for by name. A
         section name is matched loosely, so a heading copied approximately
-        still resolves. Called without one, the answer is the guide's index
+        still resolves, including a `###` subsection not in `sections`
+        (e.g. "for_each"). Called without one, the answer is the guide's index
         (its opening and first section, with `sections` and `withheld`
         naming the rest), not the whole file."""
         return guides.get_guide(client, name, section=section)
@@ -753,60 +755,60 @@ def download_output(
 
     # ---------------------------------------------------------------- assets
 
-    def list_assets(detail: bool = False) -> dict:
+    def list_assets(detail: bool = False, workspace: str | None = None) -> dict:
         """List 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. Entries carry
-        name, reference, kind, size and origin only - for one asset's
-        duration, frame count, fps, sample rate or channels, pass its
-        reference to `get_gallery_metadata`, which reads inputs as well as
-        outputs. Pass detail=true for each entry's folder, mtime and url
-        too, needed before naming a shared library's writable/read-only
-        roots or opening the file's preview URL."""
-        return assets.list_assets(client, detail=detail)
+        name, reference, kind, size and origin only - for duration, frame
+        count, fps, sample rate or channels, pass the reference to
+        `get_gallery_metadata`, which reads inputs as well as outputs. Pass
+        detail=true for each entry's folder, mtime and url too, needed
+        before naming a shared library's writable/read-only roots or
+        opening the file's preview URL.
+
+        `workspace` scopes this one call without changing the session pin."""
+        return assets.list_assets(client, detail=detail, workspace=workspace)
 
     def upload_asset(
         file_path: str | None = None,
         content: str | None = None,
         asset_name: str | None = None,
         shared: bool = False,
+        workspace: str | None = None,
     ) -> dict:
         """Put an image, video or audio file into the server's asset
         library and get back the "asset:" reference to use in a workflow.
         Pass exactly one of `file_path` or `content`.
 
         `file_path` is read from the machine this MCP server runs on and
-        pushed to the engine, so it is how an input reaches a dw.serve
-        running somewhere else. When this MCP surface is served by
-        dw.serve itself, "this machine" is the engine's own box, so
-        `file_path` is confined to the directories it works in - a file
-        that exists only on your own machine cannot be named this way.
-
-        `content` is for exactly that case: the file's bytes, base64-encoded,
-        sent inline in the call rather than read off any disk. Use it for a
-        voice sample or small image that lives only on the machine you are
-        running on, against a remote `dw.serve --mcp` endpoint with no
-        filesystem in common with you. Capped at 4MB, well under
-        `file_path`'s 200MB, because these bytes ride in the call itself.
-        `asset_name` is required with `content`, since there is no file to
-        take a name or extension from.
-
-        Accepts the usual image, video and audio extensions. Reference the
-        result rather than a path: a path on this machine means nothing to
-        the server. Pass `asset_name` to store it under a readable name
-        ("cast/priya-voice.wav", folders allowed) - without one (when using
-        `file_path`) the stored name is random, and a set of related inputs
-        cannot be told apart in the workflows that carry them. Pass
-        `shared=true` to put it in the library every workspace shares
-        rather than this session's own - where a recurring cast belongs,
-        since a workspace's own assets are invisible from the next
-        workspace."""
+        pushed to the engine - how an input reaches a dw.serve running
+        elsewhere. When this MCP surface is served by dw.serve itself,
+        "this machine" is the engine's own box, so `file_path` is confined
+        to the directories it works in - a file that exists only on your
+        own machine cannot be named this way.
+
+        `content` is for that case: the file's bytes, base64-encoded, sent
+        inline rather than read off disk. Use it for a file that lives
+        only on the machine you're running on, against a remote
+        `dw.serve --mcp` endpoint with no filesystem in common with you.
+        Capped at 4MB, well under `file_path`'s 200MB. `asset_name` is
+        required with `content`, since there is no file to name it from.
+
+        Accepts the usual image, video and audio extensions; reference the
+        result, not a path. Pass `asset_name` for a readable stored name
+        ("cast/priya-voice.wav", folders allowed) - otherwise (with
+        `file_path`) the name is random. Pass `shared=true` to put it in
+        the library every workspace shares - where a recurring cast
+        belongs, since a workspace's own assets are invisible from the next.
+
+        `workspace` scopes this one call without changing the session pin."""
         return assets.upload_asset(
             client,
             file_path=file_path,
             content=content,
             asset_name=asset_name,
             shared=shared,
+            workspace=workspace,
         )
 
     def keep_output(
@@ -818,18 +820,13 @@ def keep_output(
     ) -> dict:
         """Keep a generated file as an input asset under a stable "asset:"
         name, so later workflows can rely on it - a run's own name moves
-        ("latest") or breaks when outputs are pruned. This is the step
-        between a render you liked and the next stage that conditions on
-        it. `name` is a gallery name; `asset_name` defaults to the file's
-        own. The copy happens on the server, inside the workspace: nothing
-        is downloaded or re-uploaded. Pass `shared=true` to keep it in the
-        library every workspace shares instead - where something a later
-        piece in its own workspace has to reach belongs.
+        ("latest") or breaks when outputs are pruned. `name` is a gallery
+        name; `asset_name` defaults to the file's own. The copy happens on
+        the server, inside the workspace: nothing is downloaded or
+        re-uploaded. Pass `shared=true` to keep it in the library every
+        workspace shares instead.
 
-        `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 is reachable from
-        here without leaving this one."""
+        `workspace` scopes this one call without changing the session pin."""
         return assets.keep_output(
             client,
             name,
@@ -839,15 +836,18 @@ def keep_output(
             workspace=workspace,
         )
 
-    def delete_asset(name: str) -> dict:
+    def delete_asset(name: str, workspace: str | None = None) -> dict:
         """Permanently remove one file from the asset library, by the name
         `list_assets` reports (without the "asset:" prefix). Not
         recoverable, and any workflow still carrying that reference stops
         loading. Deletes from whichever library holds it - this
         workspace's own before the shared one, the order an "asset:"
         reference resolves in; one from a read-only examples library is
-        refused."""
-        return assets.delete_asset(client, name)
+        refused.
+
+        `workspace` scopes this one call without changing the session pin,
+        movable by another connection on a mounted transport."""
+        return assets.delete_asset(client, name, workspace=workspace)
 
     tool(list_assets, READ_ONLY)
     tool(upload_asset, WRITES)
@@ -951,40 +951,41 @@ def save_workflow(
         name: str,
         workflow: dict | str | None = None,
         patch: dict | str | None = None,
+        workspace: str | None = None,
     ) -> dict:
         """Save a workflow to the server's writable workflow directory,
         overwriting any existing workflow of that name there. Validate it
-        first. A name that currently resolves to a read-only source (an
-        examples directory) is not overwritten - the copy lands in the
-        writable directory and shadows it from then on, which is how an
-        example gets adapted without being damaged. `name` may include
-        folders.
-
-        Give exactly one of `workflow` (the full document) or `patch` for a
-        small, targeted edit: a JSON Merge Patch (RFC 7396) merged onto the
-        currently stored definition, so bumping one argument means sending
-        just that argument rather than the whole document -
+        first. A name resolving to a read-only source (an examples
+        directory) is not overwritten - the copy lands in the writable
+        directory and shadows it, adapting the example without damaging it.
+        `name` may include folders.
+
+        Give exactly one of `workflow` (the full document) or `patch`: a
+        JSON Merge Patch (RFC 7396) merged onto the stored definition, so
+        bumping one argument means sending just that argument -
         `{"variables": {"num_images_per_prompt": 4}}` rather than the whole
-        workflow. A patch key set to `null` deletes that key from the
-        stored document. A list is replaced whole, never merged - a merge
-        patch has no notion of list position, so changing one `shots` entry
-        still means sending the whole `shots` list. Either may also be
-        given as a JSON-encoded string, which is parsed before saving; a
-        string that fails to parse is reported as invalid JSON rather than
-        as a type mismatch.
-
-        A workflow stored for reuse should mark each saving step's
-        `result.subfolder` - `final` for the step whose output the user will
-        be shown, `intermediate` for the rest - so a later consumer can tell
-        the deliverable from the scratch files without knowing the workflow."""
-        return authoring.save_workflow(client, name, workflow=workflow, patch=patch)
-
-    def delete_workflow(name: str) -> dict:
+        workflow. A patch key set to `null` deletes that key; a list is
+        replaced whole, never merged. Either may be a JSON-encoded string,
+        parsed before saving; a parse failure is reported as invalid JSON.
+
+        Mark each saving step's `result.subfolder` (`final`/`intermediate`)
+        so a later consumer can tell the deliverable from scratch files.
+
+        `workspace` scopes this one call without changing the session pin,
+        so a save cannot be misdirected by another connection's pin change."""
+        return authoring.save_workflow(
+            client, name, workflow=workflow, patch=patch, workspace=workspace
+        )
+
+    def delete_workflow(name: str, workspace: str | None = None) -> dict:
         """Permanently delete a stored workflow from this workspace. A
         workflow from a read-only examples directory is refused rather than
         deleted - `list_workflows` reports which those are as
-        `writable: false`."""
-        return authoring.delete_workflow(client, name)
+        `writable: false`.
+
+        `workspace` scopes this one call without changing the session pin,
+        movable by another connection on a mounted transport."""
+        return authoring.delete_workflow(client, name, workspace=workspace)
 
     tool(validate_workflow, READ_ONLY)
     tool(save_workflow, OVERWRITES)
diff --git a/plugins/dw/skills/ltx-2.5/SKILL.md b/plugins/dw/skills/ltx-2.5/SKILL.md
index fe81f608..7756cea9 100644
--- a/plugins/dw/skills/ltx-2.5/SKILL.md
+++ b/plugins/dw/skills/ltx-2.5/SKILL.md
@@ -25,11 +25,10 @@ caption spec below.
    `info: null` means nothing is resident, and a `live: false` reading is
    cached from another moment. A non-trivial idle figure is an earlier run's
    leftover and comes off what this one has. With the server idle,
-   `clear_memory` clears it (refused while a job is queued or running) - it
-   also drops the step cache, so the next run, including a seeded rerun, is
-   cold and regenerates. Re-read `get_memory` to confirm. Don't
-   retry into a failed attempt without clearing first - a failed attempt is
-   itself what leaves weight resident.
+   `clear_memory` clears it (refused while queued or running) - it also
+   drops the step cache, so the next run, including a seeded rerun, is cold
+   and regenerates. Re-read `get_memory` to confirm; don't retry into a
+   failed attempt without clearing first.
 
 ## Which shape is the request
 
@@ -61,7 +60,8 @@ caption spec below.
   removes motion blur or grain - so say which defect you think it is and let
   the user correct you.
 - **Longer**: `templates/ltx2/extend-clip` continues an opening conditioned
-  on all of it, not one frame;
+  on all of it, not one frame; `clip` extends an existing clip (matching
+  `width`/`height`/`clip_frames`) instead of generating one.
   `templates/ltx2/chained-segments` re-runs per segment on the previous last
   frame and stitches. Neither is a Lightricks recipe; both are dw's, and a
   single 481-frame pass reaches 20 seconds before either is needed.
@@ -140,8 +140,8 @@ AESTHETIC QUALITY (in addition to the above, without breaking the objective capt
    included) and name any `downloads_required` - an IC-LoRA template pulls a
    gated weight the box may not have. Only `text-to-video` and `two-stage`
    carry a `cost`; for the rest give the shape - a 121-frame clip at 960x544
-   is under two minutes cold on a 24 GB card, a minute of it loading, the
-   two-stage flow about eight, and extend and chain multiply by their passes.
+   is under two minutes cold on a 24 GB card, a minute of it loading; extend
+   and chain multiply by their passes.
    Get the go-ahead before `run_workflow` with `acknowledged_cost` set to the
    plan's `{fingerprint, minutes, downloads}`.
 3. `wait_for_job`, then `get_job` for the manifest.
diff --git a/plugins/dw/skills/minimax-h3/SKILL.md b/plugins/dw/skills/minimax-h3/SKILL.md
index e025fb4f..3c32e5fa 100644
--- a/plugins/dw/skills/minimax-h3/SKILL.md
+++ b/plugins/dw/skills/minimax-h3/SKILL.md
@@ -37,53 +37,35 @@ arguments; the prompt format is MiniMax's, from their text not here.
   `templates/minimax/voice-timbre-reference` fixes a voice from a Bark line.
 - **Several boards in one generation, one unbroken score**:
   `templates/minimax/storyboard` - H3 cuts between the boards inside a single
-  generation, which no concat can match. One beat with fixed cut points, not
-  a building block; past one beat with a recurring cast, use the cuts
-  pattern below.
+  generation, which no concat can match. One beat only; past that, use the
+  cuts pattern below.
 - **Longer than 14.4 seconds**: chain when one action or line of speech
   crosses the seam, cut when the scene changes (each cut its own generation).
   Six distinct scenes are a cuts piece, not a chain.
 - **As one take (a chain)**: `templates/minimax/chained-segments`
-  (last-frame continuity), `templates/minimax/chain-video-continuity` (the
-  previous segment's tail rides as a video reference - motion, camera and
-  voice carry across the seam), `templates/minimax/chain-matched-to-audio` (a
-  supplied track sets the length, muxed back seamless),
-  `templates/minimax/chain-matched-and-aligned` (all of it, per-segment
-  prompts). Drift compounds per seam: reference the subject picture every
-  segment, prefer `last_segment` continuity, use the longest segments memory
-  allows.
+  (last-frame continuity), `templates/minimax/chain-video-continuity`
+  (previous segment's tail rides as a video reference - motion, camera and
+  voice carry the seam), `templates/minimax/chain-matched-to-audio` (a track
+  sets the length, muxed back seamless), `templates/minimax/chain-matched-and-aligned`
+  (per-segment prompts). Drift compounds per seam: reference the subject
+  picture each segment, prefer `last_segment` continuity, use the longest
+  segments memory allows.
 - **A piece with cuts**: fresh shots from shared portraits, then a concat.
   `templates/minimax/dialogue-short` (Z-Image draws the cast, one shot per
-  `shots` entry on one loaded model, `concat_videos` splices) and
-  `templates/minimax/music-video` (a song, one slice and one lip-synced shot
-  per entry; its singer is `singer_reference` - a `from_file` reference uses
-  an existing cast portrait and elides the drawing).
-  `shots` is one list argument: a dialogue entry is `name`, `prompt`,
-  `references` (portraits and voices: `from_previous_result` for one drawn
-  here, `from_file` for an `asset:` cast) and `num_frames`; a music-video
-  entry is `name`, `prompt`, `start_frame`.
-  A six-shot piece is one more entry, not a new file. The listing's
-  `lists` block says what an entry carries; its `cost` carries `per_entry`
-  when one shot was measured: quote
-  `minutes - per_entry.minutes × per_entry.entries + per_entry.minutes × N`
-  for N entries. Without `per_entry`, quote the total for the default list.
-  A cut erases drift: the last shot is as clean as the first. Each shot makes
-  its own audio, so write `non_diegetic_music: N/A` in every shot and lay one
-  score under the concat afterwards: `templates/minimax/music` writes the
-  track and `templates/assemble-and-score` shows the `pair_audio` step that
-  mixes it under the world sound; `shots` is a list, so a six-shot reel is
-  one more entry, not a new file. A character speaking in several shots keeps
-  one voice by passing the same clip as an audio reference each time (the
-  `voice-timbre-reference` pattern) - a repeated description alone drifts.
-  Each entry's `num_frames` paces the cut.
-  A score burying voice-over is not a `world_gain` fix: the world track
-  carries narration and action together (narration ~24 dB over its own
-  ambience, score 6-15 dB over that), so raising it lifts both. Duck the
-  *score* instead, before passing it as `score`: one `gain_audio` (#187)
-  step per voice-over shot, chained, `start_frame` = running sum of
-  preceding shots' `num_frames`, `num_frames` that shot's length, `fps`
-  the cut's rate, negative `gain_db` (-6 to -10). `dissolve-between-shots`
-  eats `dissolve_frames` per seam, so its sum isn't plain.
+  `shots` entry, `concat_videos` splices) and `templates/minimax/music-video`
+  (a song, one slice and one lip-synced shot per entry - `from_file` reuses
+  an existing cast portrait and skips the drawing).
+  `shots` is one list: a dialogue entry is `name`, `prompt`, `references`
+  and `num_frames`; a music-video entry is `name`, `prompt`, `start_frame`.
+  A six-shot piece is one more entry, not a new file. The listing's `lists`
+  block says what an entry carries; its `cost` carries `per_entry` when one
+  shot was measured - scale from that, else quote the default list's total.
+  A cut erases drift, and each shot makes its own audio: score with
+  `templates/minimax/music` and `templates/assemble-and-score`'s `pair_audio`
+  mix under the world sound. Keep one voice across shots with a repeated
+  audio reference, not a repeated description. Duck a score burying
+  voice-over rather than raising the world track - a `gain_audio` step per
+  shot, negative `gain_db`.
 - **Unrelated shots, no cut**: `templates/minimax/shots-batch` - one H3
   step per `shots` entry, no shared cast, no concat. `keep_output` each
   clip, then `templates/assemble-and-score` cuts and scores.
@@ -112,6 +94,25 @@ read the `workflows` guide's authoring section first.
   `transformer_ref` alone, so whatever is handed there only degrades the
   output. `validate_workflow` refuses it and warns on a `weight_name`
   naming neither path.
+- Fit a crowd's action to what it holds: a candle-holding crowd asked to
+  clap rendered three-handed people. State an action the prop allows.
+- A directed crowd move needs its landmark in frame - "the town marches up
+  to the house" put the house behind camera. Track from the side with the
+  landmark ahead, in the direction of travel.
+- Two people in frame can lip-sync the wrong one, seemingly by whichever
+  voice enters first: credit a shout to the crowd, spell the sung line in
+  `<d>` tags, and frame the singer face-on at medium close-up.
+- State the crowd's age range - an unstated crowd skews young.
+- A three-reference shot can open on the reference portraits' own backdrop
+  for ~1.5s (about 1 in 25): check a shot's first frames, and say in
+  `subject_definitions` that the portrait's backdrop, pose and framing are
+  not reused.
+- Ref2VA reaches 1344x768 too, not only the FL2VA 768p template - see the
+  `recipes` guide's MiniMax-H3 section for the trade-off. At that canvas the
+  24 GB ceiling on the `17n+5` grid drops with each reference: 243 frames at
+  one, 209 at two, 175 at three, 141 at four. `validate_workflow` projects
+  every `for_each` shot on its own frames and references and refuses the
+  largest one over budget, at that shot's path.
 - Nine steps for an eight-step LoRA: the scheduler counts sigma grid points,
   terminal zero included, so `denoise_total_steps` reports 8. A null
   `lora_model_name` drops the LoRA; raise steps and shifts too.
@@ -125,22 +126,19 @@ read the `workflows` guide's authoring section first.
   SIGKILL near the end where a fresh one would not.
 - Ref2VA limits: at most 9 images, 3 videos, 3 audio clips, 12 files; audio can
   never be the only reference. References are labelled in order.
-- Music3 reads `audio_duration` as a ceiling, not a target: ask for more than
-  needed and trim with `templates/audio-trim-fade`.
+- Music3's `audio_duration` is a ceiling: ask for more than needed and trim
+  with `templates/audio-trim-fade`.
 - Write the prompt for the length generated: timestamps should span the
-  duration, or a five-second script tells a five-second story whatever the
-  frame count.
+  duration.
 
 ## Prompts
 
 H3 wants Context-IR, MiniMax's own format. `get_prompt` shows the shape;
 the rules come from MiniMax, not from paraphrasing one:
 
-1. If the `h3-prompt-writing` skill is installed (MiniMax ships it in
-   https://github.com/MiniMax-AI/MiniMax-H3 under `skills/`), use it. If not,
-   say once that
-   `npx skills add MiniMax-AI/MiniMax-H3 --skill h3-prompt-writing` installs
-   it - only that one; the rest are style packs - and go on without it.
+1. If the `h3-prompt-writing` skill is installed, use it. If not, say once
+   that `npx skills add MiniMax-AI/MiniMax-H3 --skill h3-prompt-writing`
+   installs it, and go on without it.
 2. Else read the guides on the model card:
    https://huggingface.co/MiniMaxAI/MiniMax-H3/raw/main/docs/VIDEO_PROMPT_WRITING_GUIDE_base_en.md
    for text and frame conditioning, and
@@ -184,6 +182,8 @@ itself - or every shot inherits the portrait's composition.
    (`validate_workflow` on `templates/transcribe-audio`, `run_workflow` with
    `acknowledged_cost` bound, `get_output_text`, `delete_output`) - `basis:
    "unknown"`, quote seconds not minutes.
+   A `shot_dead_air` finding: bed with `slice_audio`->`loop_audio`->`mix_audio`
+   room tone, not silence.
    Then `get_gallery_metadata` for duration/audio presence,
    and hand the user the gallery `url`
    (`list_gallery`). `get_output_image` works only on image steps - the
@@ -196,7 +196,6 @@ itself - or every shot inherits the portrait's composition.
 
 ## Sources
 
-MiniMax-H3 model card and prompt guides (huggingface.co/MiniMaxAI/MiniMax-H3),
-`h3-prompt-writing` (github.com/MiniMax-AI/MiniMax-H3), the diffusers
+MiniMax-H3 model card and prompt guides, `h3-prompt-writing`, the diffusers
 MiniMax-H3 modular pipeline, `lightx2v/Minimax-h3-Turbo` LoRA notes; read
 2026-09-07; audit `docs/proposals/audits/2026-09-07-minimax-h3-audit.md`.
diff --git a/plugins/dw/skills/minimax-music3/SKILL.md b/plugins/dw/skills/minimax-music3/SKILL.md
index 9f28af78..ca0ea1b8 100644
--- a/plugins/dw/skills/minimax-music3/SKILL.md
+++ b/plugins/dw/skills/minimax-music3/SKILL.md
@@ -102,6 +102,10 @@ If none fits, compose from `list_tasks` (`slice_audio`, `fade_audio`,
 - Section tags and the caption are generative control, not guarantees: the
   vendor says tempo, key, structure and lyrics may not match every detail.
   Iterate at 30-60 seconds before asking for a long track.
+- Music 3 ignores per-section singer directions. Before staging lip-sync on
+  a song with two or more singers, run `attribute_voices` with a reference
+  span per singer and cast each shot from its answer. Never infer the singer
+  from pitch: a tenor and a mezzo share the range.
 
 ## Prompts
 
@@ -120,7 +124,9 @@ from the templates' examples:
    Arrangement - in 250-450 English words, with no title, no reasoning, and
    no lyric line copied into the caption. The pipeline strips markdown
    headings and emphasis on the way in, so the vendor's caption pastes
-   straight into `prompt`.
+   straight into `prompt`. This is the recommended route: a 24-shot field
+   report's three-heading caption produced a correct, complete song on its
+   first seed (#484).
 3. The concise one-paragraph form the templates' stored prompts use (genre,
    BPM, key, emotional progression, listening scenario, production profile,
    vocals, arrangement) is the model card's own example and works; the
@@ -157,9 +163,10 @@ Control" section.
    ceiling cut the track (raise it and rerun); well short of it means the
    song finished on its own. Its `peak_dbfs` is a single sample and does not
    say how loud the song reads end to end - `integrated_lufs` (BS.1770,
-   whole-track) is the field for that, and what `normalize_audio`'s optional
-   `target_lufs` targets when a score or a music-video mix needs to match
-   another track by ear rather than by peak alone. Then listen with
+   whole-track) is the field for that, and what `normalize_audio`'s
+   `target_lufs` targets when a mix must match another track by ear, not
+   by peak. A master louder than its peak allows (-16 streaming): add
+   `limit: true`; `limiter_heavy` means lower the target. Then listen with
    `get_output_audio` (a long
    track in `start`/`duration` excerpts) for the family's failure modes: a
    song that went instrumental (name the vocals in the caption), an ending
diff --git a/plugins/dw/skills/series-episodes/SKILL.md b/plugins/dw/skills/series-episodes/SKILL.md
index fa120c4a..4f4092fb 100644
--- a/plugins/dw/skills/series-episodes/SKILL.md
+++ b/plugins/dw/skills/series-episodes/SKILL.md
@@ -92,13 +92,28 @@ composes into, not something to re-derive:
   recipe: `gain_audio` regions on the score, one per voice-over shot,
   applied before the score is passed in.
 - **normalize**: the mixed world sound and score are normalized together
-  (`assemble-and-score`'s `balanced` step, -3 dBFS) so one episode is not
-  louder than the next. A shared peak ceiling does not mean a shared
-  loudness - a sparse, dialogue-only episode and a dense, score-heavy one
-  can both sit at -3 dBFS peak and still read as very different volumes;
-  `normalize_audio`'s optional `target_lufs` gains to a measured loudness
-  first, with `peak_dbfs` still holding as a ceiling, when episodes need to
-  match by ear rather than by sample.
+  (`assemble-and-score`'s `balanced` step, -3 dBFS peak ceiling, always
+  enforced) so one episode is not louder than the next. A shared peak
+  ceiling does not mean a shared loudness - a sparse, dialogue-only episode
+  and a dense, score-heavy one can both sit at -3 dBFS peak and still read
+  as very different volumes. `assemble-and-score`'s `target_lufs` variable
+  (passed through to `normalize_audio`) gains the mix toward a measured
+  loudness before the ceiling is applied - but gain down succeeds only
+  while the mix's own peak is below the ceiling; a single loud peak (a
+  laugh track, a sting) caps gain up the same way, and can pull a gain-down
+  episode lower still. Match episodes **downward** anyway: pick one series `target_lufs`
+  that every episode can reach - in practice, about the quietest episode
+  the ceiling holds back - and pass that same value on every episode's
+  `assemble-and-score` run. Don't pick the loudest episode's loudness and
+  ask the others to climb to it. A `target_lufs_capped` warning on an
+  episode means that episode's own peak sets the series' ceiling; lower the
+  series `target_lufs` rather than accepting the mismatch. Only when the
+  series should sit louder than its most dynamic episode allows (e.g. -16
+  for streaming) pass `limit: true` beside the same `target_lufs` on every
+  episode: -3 dBFS becomes a true-peak ceiling a look-ahead limiter holds,
+  so the laugh is limited rather than setting the gain. A `limiter_heavy`
+  warning on an episode means the series target is squashing it audibly -
+  lower the series `target_lufs` rather than living with it.
 - **pair**: the normalized track is muxed onto the cut - the episode's
   deliverable.
 
@@ -109,6 +124,10 @@ One `assemble-and-score` run per episode; each episode's `total_frames` and
 
 Judge a finished episode with `assess_output(name)` before listening end
 to end: it measures every seam and the shots' levels, and says where to look.
+A `shot_dead_air` finding is an H3 dialogue gap (0.5-2s of near-silence
+between lines) inside one shot, not a seam problem - see `minimax-h3`'s
+room-tone bed recipe (`slice_audio` -> `loop_audio` -> `mix_audio`) rather
+than treating it as a cut to fix.
 
 `output:` a shot straight from its generation run rather than downloading
 and re-uploading it as an asset - only the cast portraits from step 0 need
@@ -131,7 +150,13 @@ on each episode's final file for duration and loudness, so a level
 mismatch between episodes shows up before a viewer notices it - its
 `peak_dbfs` is a single sample and does not say how loud the episode reads
 as a whole; `integrated_lufs` (BS.1770, whole-track) is the field that
-answers that, and is what to compare across episodes. To confirm a
+answers that, and is what to compare across episodes. A peak-normalized
+episode with one loud outlier (a studio-audience laugh, a sting) can sit
+1-2 LU quieter than its neighbors even at the same -3 dBFS peak ceiling -
+that gap is `target_lufs`'s to close, matched downward to a series-wide
+value every episode's ceiling allows (see the **normalize** bullet above);
+`target_lufs` alone cannot raise a capped episode to meet a louder one -
+`limit: true` can, for a series that must sit louder (same bullet). To confirm a
 line actually rendered rather than judging it by ear, `get_output_audio`
 returns sound, not text: `validate_workflow(name="templates/transcribe-audio",
 arguments={"input_audio": "output:<name>"})` first (free; it takes the
diff --git a/pyproject.toml b/pyproject.toml
index 77a05448..28f38bc1 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -87,12 +87,23 @@ dependencies = [
     "matplotlib>=3.11.1",
     # BS.1770 integrated loudness / true-peak metering (dw/loudness.py, #361)
     "pyloudnorm>=0.2.0",
+    # normalize_audio(limit=true)'s 4x true-peak detection (resample_poly) and
+    # look-ahead minimum (minimum_filter1d) - imported directly, so declared
+    # rather than left to controlnet-aux (#474)
+    "scipy>=1.18.1",
     # speaker_embedding preprocessing arg for generate_speech: reduces a
     # reference clip to the x-vector a SpeechT5 model conditions its voice
     # on (spkrec-xvect-voxceleb). Imported lazily in speech_generation.py,
     # so it's only exercised - and its model only downloaded - by a call
     # that actually passes speaker_embedding.
     "speechbrain>=1.0.3",
+    # attribute_voices (dw/tasks/voice_attribution.py, #485): htdemucs
+    # separates a song's vocal stem before speechbrain's ECAPA encoder
+    # embeds it - on a full mix the accompaniment dominates the embedding
+    # and the voices score alike. A hard dependency rather than an extra so
+    # the task answers the same on every box; imported lazily, and its
+    # weights download only when the task runs with separate=true.
+    "demucs>=4.1.0",
     # Utilities
     "qrcode>=8.2",
     "requests>=2.34.2",
diff --git a/tests/test_assemble_and_score_target_lufs.py b/tests/test_assemble_and_score_target_lufs.py
new file mode 100644
index 00000000..060a6735
--- /dev/null
+++ b/tests/test_assemble_and_score_target_lufs.py
@@ -0,0 +1,117 @@
+"""#467: assemble-and-score hardcoded peak_dbfs and exposed no way for a
+caller to pass target_lufs to the 'balanced' normalize_audio step, so two
+peak-normalized episodes with different crest factors (a studio-audience
+laugh setting one episode's peak) could not be loudness-matched - target_lufs
+alone can gain a mix down to a shared loudness, but the template gave it
+nowhere to land."""
+
+import json
+import os
+
+import pytest
+
+TEMPLATE_PATH = os.path.normpath(
+    os.path.join(
+        os.path.dirname(__file__),
+        "..",
+        "workflows",
+        "templates",
+        "assemble-and-score.json",
+    )
+)
+
+
+def load_definition():
+    with open(TEMPLATE_PATH) as f:
+        return json.load(f)
+
+
+def steps_by_name(definition):
+    return {s["name"]: s for s in definition["steps"]}
+
+
+def balanced_arguments(variables):
+    from dw.variables import replace_variables, resolve_variable_values
+
+    definition = load_definition()
+    merged = {**definition["variables"], **variables}
+    merged = resolve_variable_values(merged)
+    substituted = replace_variables(definition, merged)
+    return steps_by_name(substituted)["balanced"]["task"]["arguments"]
+
+
+def test_target_lufs_declared_and_defaults_to_null():
+    definition = load_definition()
+    assert definition["variables"]["target_lufs"] is None
+
+
+def test_target_lufs_reaches_the_balanced_step():
+    arguments = balanced_arguments({"target_lufs": -21})
+    assert arguments["target_lufs"] == -21
+
+
+def test_peak_dbfs_ceiling_is_unchanged_by_target_lufs():
+    arguments = balanced_arguments({"target_lufs": -21})
+    assert arguments["peak_dbfs"] == -3.0
+
+
+def test_omitting_target_lufs_keeps_the_old_peak_only_result():
+    # An unset (null) variable: reference is dropped from the arguments
+    # entirely (dw/variables.py replace_variables), so normalize_audio falls
+    # back to its own target_lufs=None default - unchanged, peak-only
+    # behavior for a caller that never mentions target_lufs.
+    arguments = balanced_arguments({})
+    assert "target_lufs" not in arguments
+    assert arguments["peak_dbfs"] == -3.0
+
+
+# #497 (#474 stage 2): 'limit' is exposed beside target_lufs, so a cut can
+# reach a target past the transient that would otherwise cap its gain.
+
+
+def test_limit_declared_and_defaults_to_false():
+    definition = load_definition()
+    assert definition["variables"]["limit"] is False
+
+
+def test_limit_reaches_the_balanced_step():
+    arguments = balanced_arguments({"target_lufs": -16, "limit": True})
+    assert arguments["limit"] is True
+    assert arguments["target_lufs"] == -16
+    assert arguments["peak_dbfs"] == -3.0
+
+
+def test_the_default_leaves_the_balanced_step_unlimited():
+    assert balanced_arguments({})["limit"] is False
+
+
+def test_the_balanced_step_limits_a_laugh_track_to_the_target():
+    # The real path: the arguments the template hands 'balanced', applied
+    # by normalize_audio to a quiet bed with one burst 20 dB above it (the
+    # laugh that capped #467's episodes). Without limit it caps; with it
+    # the mix lands on -16 LUFS under a -3 dBTP ceiling.
+    import numpy
+    import scipy.signal
+
+    from dw.loudness import integrated_lufs
+    from dw.tasks.audio_utils import normalize_audio
+
+    rate = 48000
+    t = numpy.arange(rate * 4) / rate
+    wave = 0.05 * numpy.sin(2 * numpy.pi * 1000 * t)
+    wave[rate * 2 : rate * 2 + rate // 50] *= 10
+    wave = numpy.tile(wave.astype(numpy.float32), (2, 1))
+
+    def balanced(variables):
+        arguments = balanced_arguments(variables)
+        arguments.update(audio=wave, sample_rate=rate)
+        return numpy.atleast_2d(numpy.asarray(normalize_audio(**arguments).audio))
+
+    capped = balanced({"target_lufs": -16})
+    assert integrated_lufs(capped.T, rate) < -17
+
+    limited = balanced({"target_lufs": -16, "limit": True})
+    assert integrated_lufs(limited.T, rate) == pytest.approx(-16, abs=0.5)
+    true_peak = numpy.abs(scipy.signal.resample_poly(limited, 4, 1, axis=1)).max()
+    assert 20 * numpy.log10(true_peak) <= -3.0 + 0.05
+    assert limited.shape == wave.shape
diff --git a/tests/test_assess.py b/tests/test_assess.py
index bcae7d76..a1a8190a 100644
--- a/tests/test_assess.py
+++ b/tests/test_assess.py
@@ -7,6 +7,7 @@
 """
 
 import json
+import math
 
 import numpy
 import pytest
@@ -25,6 +26,7 @@
     read_media,
     resolve_shots,
 )
+from dw.tasks.concat_videos import concat_videos
 from dw.tasks.dissolve_videos import dissolve_videos
 
 
@@ -200,6 +202,55 @@ def test_shots_echo_their_frame_range(self):
         ]
 
 
+# ---------------------------------------------------------------------------
+# 1b. A voiced shot's in-shot gap flags shot_dead_air only when the gap sits
+# below the floor and the shot itself is not quiet throughout (#465)
+# ---------------------------------------------------------------------------
+
+
+class TestShotDeadAir:
+    @staticmethod
+    def _shot(gap_dbfs, tone_dbfs=-17.0, sample_rate=48000, seg_seconds=1.0):
+        """One shot, three one-second segments: tone, gap, tone. `tone_dbfs`
+        and `gap_dbfs` are each realized as a sine amplitude via
+        amplitude = sqrt(2) * 10**(dbfs/20), matching make_tone's own RMS."""
+        seg_samples = int(sample_rate * seg_seconds)
+        tone_amp = math.sqrt(2) * 10 ** (tone_dbfs / 20)
+        gap_amp = math.sqrt(2) * 10 ** (gap_dbfs / 20)
+        tone = make_tone(seg_samples, sample_rate, amplitude=tone_amp)
+        gap = make_tone(seg_samples, sample_rate, amplitude=gap_amp)
+        audio = numpy.concatenate([tone, gap, tone], axis=1)
+        frames = make_frames(3 * 24, base_grey=120, noise=3.0, seed=0)
+        shots = [shot_record("s0", 0, len(frames), 0, audio.shape[1])]
+        return AudioVideo(frames, audio, sample_rate, fps=24, shots=shots)
+
+    def test_a_deep_gap_fires_at_the_right_position(self):
+        answer = analyze_shots(self._shot(gap_dbfs=-80.0))
+        shot = answer["shots"][0]
+        assert shot["dead_air_seconds"] == pytest.approx(1.0, abs=0.1)
+        assert shot["dead_air_at"] == pytest.approx(1.0, abs=0.1)
+        findings = [f for f in answer["findings"] if f["rule"] == "shot_dead_air"]
+        assert len(findings) == 1
+        assert findings[0]["at"]["shot"] == "s0"
+
+    def test_a_shallow_gap_does_not_fire(self):
+        # -58 dBFS sits above DEAD_AIR_FLOOR_DBFS (-65) - a dip, not a hole
+        answer = analyze_shots(self._shot(gap_dbfs=-58.0))
+        shot = answer["shots"][0]
+        assert shot["dead_air_seconds"] == 0.0
+        assert not [f for f in answer["findings"] if f["rule"] == "shot_dead_air"]
+
+    def test_a_shot_quiet_throughout_does_not_fire(self):
+        # The shot's own rms sits at or below HOLE_VOICED_DBFS (-30), so the
+        # deep gap it still measures is the shot being quiet on purpose,
+        # not a hole inside a voiced take
+        answer = analyze_shots(self._shot(gap_dbfs=-80.0, tone_dbfs=-40.0))
+        shot = answer["shots"][0]
+        assert shot["rms_dbfs"] <= -30.0
+        assert shot["dead_air_seconds"] > 0.4
+        assert not [f for f in answer["findings"] if f["rule"] == "shot_dead_air"]
+
+
 # ---------------------------------------------------------------------------
 # 2. A dissolve does not flag a level step, click, hole or frame jump
 # ---------------------------------------------------------------------------
@@ -281,6 +332,57 @@ def test_without_hard_cut_the_jump_fires(self):
         assert jump_findings[0]["at"]["seam"] == 1
 
 
+# ---------------------------------------------------------------------------
+# 3b. concat_videos marks its own seam hard_cut, so a real join's jump is
+# suppressed while the same magnitude reached by a chain-style join (which
+# never sets hard_cut) still fires (#466)
+# ---------------------------------------------------------------------------
+
+
+class TestConcatVideosMarksHardCut:
+    @staticmethod
+    def _clips(fps, frames_per_shot):
+        frames_a = make_frames(frames_per_shot, base_grey=0.3 * 255, noise=2.0, seed=1)
+        frames_b = make_frames(frames_per_shot, base_grey=0.8 * 255, noise=2.0, seed=2)
+        return (
+            AudioVideo(frames_a, None, None, fps=fps),
+            AudioVideo(frames_b, None, None, fps=fps),
+        )
+
+    def test_concat_videos_seam_is_not_flagged(self):
+        fps, frames_per_shot = 24, 24
+        clip_a, clip_b = self._clips(fps, frames_per_shot)
+
+        joined = concat_videos([clip_a, clip_b], fps=fps)
+        assert joined.shots[1]["hard_cut"] is True
+
+        answer = analyze_seams(joined)
+        assert answer["seams"][0]["hard_cut"] is True
+        jump_findings = [
+            f for f in answer["findings"] if f["rule"] == "seam_frame_jump"
+        ]
+        assert jump_findings == []
+
+    def test_the_same_jump_without_a_concat_seam_still_fires(self):
+        # A chain never marks hard_cut on its inner segments (dw/pipeline_processors/chain.py) -
+        # the same picture jump, built the same way but joined by hand rather
+        # than through concat_videos, is still checked
+        fps, frames_per_shot = 24, 24
+        clip_a, clip_b = self._clips(fps, frames_per_shot)
+        video = AudioVideo(clip_a.frames + clip_b.frames, None, None, fps=fps)
+        shots = [
+            shot_record("s0", 0, frames_per_shot),
+            shot_record("s1", frames_per_shot, frames_per_shot),
+        ]
+
+        answer = analyze_seams(video, shots=shots)
+        assert answer["seams"][0]["hard_cut"] is False
+        jump_findings = [
+            f for f in answer["findings"] if f["rule"] == "seam_frame_jump"
+        ]
+        assert len(jump_findings) == 1
+
+
 # ---------------------------------------------------------------------------
 # 4. A static shot into a modest cut does not flag seam_frame_jump
 # ---------------------------------------------------------------------------
diff --git a/tests/test_assessment_rules.py b/tests/test_assessment_rules.py
index 2c7f3eba..a06fafdc 100644
--- a/tests/test_assessment_rules.py
+++ b/tests/test_assessment_rules.py
@@ -273,3 +273,19 @@ def test_both_docs_quote_the_voiced_guard(self):
         assert guard in _section(
             DOCS / "WORKFLOW_GUIDE.md", "## Assessing a run's output"
         )
+
+
+class TestFindingSaysTheRemedy:
+    def test_shot_dead_air_names_the_room_tone_recipe(self):
+        """#491: the finding an agent actually reads, not just the docs, has
+        to carry the remedy - lay a room-tone bed with slice_audio ->
+        loop_audio -> mix_audio, using the take's own quiet stretch."""
+        says = RULES_BY_NAME["shot_dead_air"]["says"]
+        assert says == (
+            "the shot holds a gap this long, well below the floor a line's own room"
+            " tone sits at - cut a room-tone bed from the take with slice_audio, loop"
+            " it to the gap's length with loop_audio, and mix it under the line with"
+            " mix_audio rather than leaving the drop silent"
+        )
+        for command in ("slice_audio", "loop_audio", "mix_audio"):
+            assert command in says
diff --git a/tests/test_audio_utils.py b/tests/test_audio_utils.py
index 70ee39f2..59ccec6b 100644
--- a/tests/test_audio_utils.py
+++ b/tests/test_audio_utils.py
@@ -777,6 +777,243 @@ def test_logs_peak_ceiling_constraint_when_it_caps_the_target(self):
         assert logs[0]["constraint"] == "peak_ceiling"
 
 
+class TestNormalizeAudioLimit:
+    """normalize_audio(limit=True): the target's gain under a true-peak
+    look-ahead limiter rather than a gain the loudest transient caps (#474)."""
+
+    RATE = 48000
+
+    def _bursty(self, seconds=4.0, bed=0.05, burst=0.5, channels=1):
+        # A quiet 1 kHz bed with one 20 ms burst 20 dB above it - the shape of
+        # a dialogue track with a laugh on it, whose peak caps a peak-only gain
+        t = numpy.arange(int(self.RATE * seconds)) / self.RATE
+        wave = bed * numpy.sin(2 * numpy.pi * 1000 * t)
+        start, length = int(self.RATE * seconds / 2), int(0.02 * self.RATE)
+        wave[start : start + length] *= burst / bed
+        return numpy.tile(wave.astype(numpy.float32), (channels, 1))
+
+    def _run(self, waveform, **kwargs):
+        from dw.events import RunContext, activate_context, deactivate_context
+        from dw.tasks.audio_utils import normalize_audio
+
+        events = []
+        token = activate_context(RunContext(on_event=events.append))
+        try:
+            track = normalize_audio(
+                waveform, sample_rate=self.RATE, limit=True, **kwargs
+            )
+        finally:
+            deactivate_context(token)
+        logs = [e for e in events if e.get("event") == "log"]
+        warnings = {e.get("kind"): e for e in events if e.get("event") == "warning"}
+        return track, logs, warnings
+
+    @staticmethod
+    def _true_peak_dbfs(track):
+        import scipy.signal
+
+        up = scipy.signal.resample_poly(
+            numpy.atleast_2d(numpy.asarray(track.audio)), 4, 1, axis=1
+        )
+        return 20 * numpy.log10(numpy.abs(up).max())
+
+    def _lufs(self, track):
+        from dw.loudness import integrated_lufs
+
+        return integrated_lufs(samples(track), self.RATE)
+
+    def test_reaches_the_target_under_a_true_peak_ceiling(self):
+        track, logs, warnings = self._run(
+            self._bursty(), peak_dbfs=-3.0, target_lufs=-16.0
+        )
+
+        assert self._true_peak_dbfs(track) <= -3.0 + 0.05
+        assert self._lufs(track) == pytest.approx(-16.0, abs=0.5)
+        assert "target_lufs_capped" not in warnings
+        (log,) = logs
+        assert log["constraint"] == "limiter"
+        assert 0 < log["limited_fraction"] < 0.2
+        assert log["max_gain_reduction_db"] > 0
+        assert log["output_true_peak_dbfs"] <= -3.0 + 0.05
+        assert log["output_lufs"] == pytest.approx(-16.0, abs=0.5)
+        for field in ("gain_db", "measured_lufs", "measured_true_peak_dbfs"):
+            assert log[field] is not None
+
+    def test_the_peak_only_path_could_not_reach_that_target(self):
+        # The case the limiter exists for: without it the burst caps the gain
+        from dw.events import RunContext, activate_context, deactivate_context
+        from dw.tasks.audio_utils import normalize_audio
+
+        events = []
+        token = activate_context(RunContext(on_event=events.append))
+        try:
+            normalize_audio(
+                self._bursty(), peak_dbfs=-3.0, target_lufs=-16.0, sample_rate=self.RATE
+            )
+        finally:
+            deactivate_context(token)
+        assert any(e.get("kind") == "target_lufs_capped" for e in events)
+
+    def test_past_twelve_db_of_reduction_the_target_is_capped(self):
+        track, logs, warnings = self._run(
+            self._bursty(), peak_dbfs=-3.0, target_lufs=-8.0
+        )
+
+        capped = warnings["target_lufs_capped"]
+        assert capped["limited"] is True
+        assert capped["shortfall_lu"] > 0
+        assert "limiter_heavy" in warnings
+        assert logs[0]["max_gain_reduction_db"] <= 12.0 + 0.1
+        assert self._true_peak_dbfs(track) <= -3.0 + 0.05
+
+    def _dense(self, seconds=6.0):
+        # A burst every 120 ms, 6-20 dB over the bed - laughter under a line
+        # rather than one laugh, so the limiter acts on half the track and
+        # takes loudness with it wherever the gain goes (#496's bounce)
+        t = numpy.arange(int(self.RATE * seconds)) / self.RATE
+        rng = numpy.random.default_rng(0)
+        level = numpy.full(t.size, 0.05)
+        for start in range(0, t.size, int(0.12 * self.RATE)):
+            level[start : start + int(0.05 * self.RATE)] = 0.05 * 10 ** (
+                rng.uniform(6, 20) / 20
+            )
+        wave = level * numpy.sin(2 * numpy.pi * 700 * t)
+        return wave.astype(numpy.float32)[numpy.newaxis, :]
+
+    def test_dense_material_still_reaches_a_target_inside_the_cap(self):
+        # One correction pass left this 0.4 LU short, and a real laugh-track
+        # episode 2 LU short; the gain is searched for instead
+        from dw.tasks.audio_utils import LIMITER_TOLERANCE_LU
+
+        track, logs, warnings = self._run(
+            self._dense(), peak_dbfs=-3.0, target_lufs=-12.0
+        )
+
+        assert self._lufs(track) == pytest.approx(
+            -12.0, abs=LIMITER_TOLERANCE_LU + 0.05
+        )
+        assert self._true_peak_dbfs(track) <= -3.0 + 0.05
+        assert "target_lufs_capped" not in warnings
+        assert 0 < logs[0]["max_gain_reduction_db"] < 12.0
+        assert logs[0]["limited_fraction"] > 0.3
+
+    def test_a_target_the_cap_stops_short_of_says_by_how_much(self):
+        # Past the cap the track lands short; the warning's shortfall is the
+        # one the output actually has, not the gain's
+        track, logs, warnings = self._run(
+            self._dense(), peak_dbfs=-3.0, target_lufs=-10.0
+        )
+
+        capped = warnings["target_lufs_capped"]
+        assert capped["limited"] is True
+        assert capped["shortfall_lu"] == pytest.approx(
+            -10.0 - self._lufs(track), abs=0.05
+        )
+        assert logs[0]["max_gain_reduction_db"] == pytest.approx(12.0, abs=0.1)
+        assert self._true_peak_dbfs(track) <= -3.0 + 0.05
+
+    def test_heavy_limiting_warns(self):
+        _, logs, warnings = self._run(self._bursty(), peak_dbfs=-3.0, target_lufs=-16.0)
+
+        assert logs[0]["max_gain_reduction_db"] > 6.0
+        assert warnings["limiter_heavy"]["max_gain_reduction_db"] > 6.0
+
+    def test_a_target_the_ceiling_allows_leaves_the_limiter_idle(self):
+        from dw.tasks.audio_utils import normalize_audio
+
+        track, logs, warnings = self._run(
+            self._bursty(), peak_dbfs=-3.0, target_lufs=-30.0
+        )
+        plain = normalize_audio(
+            self._bursty(), peak_dbfs=-3.0, target_lufs=-30.0, sample_rate=self.RATE
+        )
+
+        assert logs[0]["limited_fraction"] == 0
+        assert logs[0]["max_gain_reduction_db"] == 0
+        assert "limiter_heavy" not in warnings
+        numpy.testing.assert_array_equal(
+            numpy.asarray(track.audio), numpy.asarray(plain.audio)
+        )
+
+    def test_without_a_target_the_ceiling_is_a_true_peak_one(self):
+        # A pure tone just under Nyquist/4 peaks between samples; limit=True
+        # holds the reconstructed peak, not the sample peak
+        t = numpy.arange(self.RATE) / self.RATE
+        tone = (0.5 * numpy.sin(2 * numpy.pi * 11025 * t + 0.25 * numpy.pi)).astype(
+            numpy.float32
+        )[numpy.newaxis, :]
+
+        track, logs, _ = self._run(tone, peak_dbfs=-1.0)
+
+        assert self._true_peak_dbfs(track) <= -1.0 + 0.05
+        assert logs[0]["constraint"] == "limiter"
+
+    def test_keeps_length_and_channels(self):
+        waveform = self._bursty(channels=2)
+
+        track, _, _ = self._run(waveform, peak_dbfs=-1.0, target_lufs=-14.0)
+
+        assert samples(track).shape == (waveform.shape[1], 2)
+
+    def test_a_silent_track_is_returned_unchanged(self):
+        silent = numpy.zeros((2, self.RATE), dtype=numpy.float32)
+
+        track, logs, _ = self._run(silent, peak_dbfs=-1.0, target_lufs=-14.0)
+
+        numpy.testing.assert_array_equal(numpy.asarray(track.audio), silent)
+        assert logs == []
+
+    def test_three_minutes_of_stereo_is_fast(self):
+        import time
+
+        waveform = self._bursty(seconds=180.0, channels=2)
+        started = time.perf_counter()
+        self._run(waveform, peak_dbfs=-1.0, target_lufs=-14.0)
+        assert time.perf_counter() - started < 10.0
+
+    def test_limit_must_be_a_bool(self):
+        from dw.tasks.audio_utils import normalize_audio
+
+        with pytest.raises(ValueError, match="limit"):
+            normalize_audio(self._bursty(), limit="yes", sample_rate=self.RATE)
+
+    def test_limit_false_is_the_default(self):
+        import inspect
+
+        from dw.tasks.audio_utils import normalize_audio
+
+        assert inspect.signature(normalize_audio).parameters["limit"].default is False
+
+    def test_timings_are_pinned(self):
+        # The plan fixes these rather than exposing them: ~5 ms look-ahead,
+        # ~150 ms release, 12 dB most reduction, 6 dB heavy
+        from dw.tasks import audio_utils
+
+        assert audio_utils.LIMITER_LOOKAHEAD_MS == 5.0
+        assert audio_utils.LIMITER_RELEASE_MS == 150.0
+        assert audio_utils.LIMITER_HOLD_MS == 20.0
+        assert audio_utils.LIMITER_MAX_REDUCTION_DB == 12.0
+        assert audio_utils.LIMITER_HEAVY_DB == 6.0
+        assert audio_utils.LIMITER_TOLERANCE_LU == 0.1
+        assert audio_utils.LIMITER_SEARCH_PASSES == 8
+
+    def test_the_curve_ramps_down_before_the_transient(self):
+        # Look-ahead: the gain is already down when the burst arrives
+        from dw.tasks.audio_utils import _limiter_curve, _true_peak_envelope
+
+        waveform = self._bursty()
+        envelope = _true_peak_envelope(waveform) * 10 ** (12 / 20)
+        curve = _limiter_curve(envelope, 10 ** (-3 / 20), self.RATE)
+        start = waveform.shape[1] // 2
+        assert curve[start] < 1.0
+        assert curve[start - int(0.004 * self.RATE)] < 1.0
+        assert curve[start - int(0.05 * self.RATE)] == pytest.approx(1.0)
+        required = numpy.minimum(
+            1.0, 10 ** (-3 / 20) / numpy.maximum(envelope.astype(numpy.float64), 1e-12)
+        )
+        assert numpy.all(curve <= required + 1e-9)
+
+
 class TestAudioTasksTakeAnAudioVideo:
     """Every audio task accepts the video an earlier step generated with its
     soundtrack, and takes the sample rate that video carries."""
diff --git a/tests/test_catalog_structure.py b/tests/test_catalog_structure.py
index 770fb30a..37c02693 100644
--- a/tests/test_catalog_structure.py
+++ b/tests/test_catalog_structure.py
@@ -402,7 +402,13 @@ def test_no_stale_entry_in_the_allowlist():
 # Then to 8_450 for the catalog-wide seed convention (#351): every generative
 # entry now declares `seed` in `variables`, which is a compact field
 # (`variable_names`), measured at 8_424.
-COMPACT_BUDGET = 8_650
+# Then to 8_850 for the LTX-2.5 width/height divisibility rule (#505):
+# `constraints` is a compact field, and the twelve LTX-2.5 templates that take
+# a `width`/`height` pair each now carry a `32*n+0` entry for both, measured
+# at 8_762 - the cost of a real diffusers refusal (not a floor like
+# `num_frames`) being checked before the pipeline loads rather than 80s
+# after it.
+COMPACT_BUDGET = 8_850
 FILTERED_BUDGET = 1_500
 
 
diff --git a/tests/test_concat_videos.py b/tests/test_concat_videos.py
index 5028b84a..6c70889a 100644
--- a/tests/test_concat_videos.py
+++ b/tests/test_concat_videos.py
@@ -404,6 +404,18 @@ def test_a_path_joins_a_video_passed_in_directly(self, tmp_path):
         assert len(result.frames) == 8
         assert result.audio.shape[1] == 8 / 4 * 8000
 
+    def test_a_location_dict_is_loaded_with_its_audio(self, tmp_path):
+        """The {"location": ...} idiom get_last_frame(video=...) already
+        accepts, unwrapped inside the videos list too (#510)."""
+        first = self.write_shot(tmp_path / "shot_1.mp4", 40)
+        second = self.write_shot(tmp_path / "shot_2.mp4", 200)
+
+        result = concat_videos([{"location": first}, second], fps=4)
+
+        assert len(result.frames) == 8
+        assert result.sample_rate == 8000
+        assert result.audio.shape == (2, 8 / 4 * 8000)
+
 
 class TestLevelMatching:
     """Independently generated shots land at whatever level the model chose,
diff --git a/tests/test_dissolve_videos.py b/tests/test_dissolve_videos.py
index f4abb171..7366eb4a 100644
--- a/tests/test_dissolve_videos.py
+++ b/tests/test_dissolve_videos.py
@@ -76,6 +76,18 @@ def test_an_empty_list_is_refused(self):
         with pytest.raises(ValueError):
             dissolve_videos([])
 
+    def test_a_location_dict_is_loaded_from_disk(self, tmp_path):
+        """The {"location": ...} idiom get_last_frame(video=...) already
+        accepts, unwrapped inside the videos list too (#510)."""
+        from diffusers.utils.export_utils import encode_video
+
+        path = tmp_path / "shot.mp4"
+        encode_video(frames(4, 0), fps=4, output_path=str(path))
+
+        result = dissolve_videos([{"location": str(path)}, frames(4, 200)], 0)
+
+        assert levels(result) == [0, 0, 0, 0, 200, 200, 200, 200]
+
     def test_audio_is_crossfaded_over_the_seam_span(self):
         first, second = audio_video(8, 0, 1.0), audio_video(8, 0, 1.0)
 
diff --git a/tests/test_elision.py b/tests/test_elision.py
index 98dd8146..b96eced1 100644
--- a/tests/test_elision.py
+++ b/tests/test_elision.py
@@ -474,3 +474,61 @@ def test_the_portrait_saves_nothing(self):
         otherwise keep the step a cast episode has no use for."""
         steps = {s["name"]: s for s in self.definition()["steps"]}
         assert steps["draw_singer"]["result"]["save"] is False
+
+
+class TestExtendClip:
+    """#446: extending a kept clip elides the opening rather than generating
+    and discarding one, the same pattern as the music-video singer."""
+
+    PATH = str(REPO_ROOT / "workflows/templates/ltx2/extend-clip.json")
+
+    def definition(self):
+        return json.loads(pathlib.Path(self.PATH).read_text())
+
+    def test_by_default_the_opening_is_generated_and_kept(self):
+        written = self.definition()
+        expanded = Workflow(
+            copy.deepcopy(written), "outputs", self.PATH
+        ).expanded_definition()
+        assert elide_definition(expanded, written) == []
+
+    def test_a_supplied_clip_elides_the_opening(self):
+        written = self.definition()
+        definition = copy.deepcopy(written)
+        definition["variables"]["clip"] = "asset:cast/ep63-shot-ltx-priya.mp4"
+        expanded = Workflow(definition, "outputs", self.PATH).expanded_definition()
+
+        elided = elide_definition(expanded, written)
+
+        assert [e["step"] for e in elided] == ["opening"]
+        assert elided[0]["overridden_by"] == "clip"
+
+    def test_opening_frames_reads_the_clip_variable(self):
+        definition = self.definition()
+        assert definition["variables"]["clip"] == "previous_result:opening"
+        opening_frames = next(
+            s for s in definition["steps"] if s["name"] == "opening_frames"
+        )
+        assert opening_frames["task"]["arguments"]["video"] == "variable:clip"
+
+    def test_the_opening_saves_nothing(self):
+        steps = {s["name"]: s for s in self.definition()["steps"]}
+        assert steps["opening"]["result"]["save"] is False
+
+    def test_extended_resolves_components_with_opening_elided(self):
+        """#446 bounce: 'extended' declared reused_components with no
+        earlier step left to share them once 'opening' is elided, so a
+        clip-supplied run failed at load with 'no earlier step shared it'.
+        This builds the real Pipeline for 'extended' and resolves its
+        components against an empty shared_components dict - what the
+        elided run actually hands it - rather than mocking the check away."""
+        from dw.pipeline_processors.pipeline import Pipeline
+
+        steps = {s["name"]: s for s in self.definition()["steps"]}
+        extended = Pipeline(
+            steps["extended"]["pipeline"], default_seed=42, device="cpu"
+        )
+        # Would raise ValueError("Cannot reuse component ... no earlier step
+        # shared it") if 'extended' still depended on a component only
+        # 'opening' ever populated
+        assert extended.resolve_reused_components({}) == {}
diff --git a/tests/test_h3_vram_ceiling.py b/tests/test_h3_vram_ceiling.py
new file mode 100644
index 00000000..32f54846
--- /dev/null
+++ b/tests/test_h3_vram_ceiling.py
@@ -0,0 +1,250 @@
+"""Category 4/5 coverage for #479's per-step VRAM projection, against the
+real catalog rather than inline fixtures.
+
+Every real-template check here mocks the serving device the same way
+test_vram_estimate.py does (a 24 GB CUDA card), since `vram_estimate_errors`
+is only checked against the device actually serving the run.
+"""
+
+import contextlib
+import copy
+import os
+import tempfile
+from unittest.mock import patch
+
+import dw.workflow
+import dw.vram_estimate
+from dw.workflow import workflow_from_definition, workflow_from_file
+
+REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+TEMPLATES_DIR = os.path.join(REPO_ROOT, "workflows", "templates")
+MINIMAX_DIR = os.path.join(TEMPLATES_DIR, "minimax")
+
+
+@contextlib.contextmanager
+def cuda_24gb():
+    with (
+        patch.object(dw.workflow, "get_device_type", return_value="cuda"),
+        patch.object(dw.workflow, "device_capacity_gb", return_value=24.0),
+    ):
+        yield
+
+
+def _vram_errors(errors):
+    return [e for e in errors if "GB VRAM" in e["message"]]
+
+
+def _load(path):
+    return workflow_from_file(path, tempfile.mkdtemp())
+
+
+def _template_json_files(root):
+    for directory, _, files in os.walk(root):
+        for name in files:
+            if name.endswith(".json"):
+                yield os.path.join(directory, name)
+
+
+def _iter_steps(definition):
+    steps = definition.get("steps") if isinstance(definition, dict) else None
+    if isinstance(steps, list):
+        for step in steps:
+            if isinstance(step, dict):
+                yield step
+
+
+def _is_ref2va_step(step):
+    pipeline = step.get("pipeline")
+    if not isinstance(pipeline, dict):
+        return False
+    from_pretrained = pipeline.get("from_pretrained_arguments")
+    return (
+        isinstance(from_pretrained, dict)
+        and from_pretrained.get("workflow") == "ref2va"
+    )
+
+
+# --- Category 4: catalog acceptance at 1344x768 on cuda/24GB ---------------
+
+
+def test_reference_to_video_accepts_209_frames_at_1344x768():
+    with cuda_24gb():
+        workflow = _load(os.path.join(MINIMAX_DIR, "reference-to-video.json"))
+        errors = _vram_errors(
+            workflow.validation_errors(
+                arguments={"width": 1344, "height": 768, "num_frames": 209}
+            )
+        )
+        assert errors == []
+
+
+def test_reference_to_video_refuses_260_frames_at_1344x768():
+    with cuda_24gb():
+        workflow = _load(os.path.join(MINIMAX_DIR, "reference-to-video.json"))
+        errors = _vram_errors(
+            workflow.validation_errors(
+                arguments={"width": 1344, "height": 768, "num_frames": 260}
+            )
+        )
+        assert len(errors) == 1
+
+
+def _ref2va_definition(num_frames, num_references, width=1344, height=768):
+    references = [
+        {
+            "reference_type": "diffusers.modular_pipelines.minimax_h3.MiniMaxH3ImageReference",
+            "from_file": f"https://example.com/reference-{i}.png",
+        }
+        for i in range(num_references)
+    ]
+    return {
+        "id": "inline-ref2va-vram",
+        "cost": [
+            {"device": "cuda", "name": "RTX 3090", "vram_gb": 24, "minutes": 7.88}
+        ],
+        "vram_estimate": {
+            "base_gb": 16.0,
+            "bytes_per_voxel": 28.71,
+            "gb_per_reference": 1.0,
+            "voxel_variables": ["width", "height", "num_frames"],
+        },
+        "steps": [
+            {
+                "name": "shot",
+                "pipeline": {
+                    "configuration": {"component_type": "ModularPipeline"},
+                    "from_pretrained_arguments": {
+                        "model_name": "MiniMaxAI/MiniMax-H3",
+                        "workflow": "ref2va",
+                    },
+                    "arguments": {
+                        "prompt": "x",
+                        "references": references,
+                        "num_frames": num_frames,
+                        "width": width,
+                        "height": height,
+                    },
+                },
+                "result": {"content_type": "video/mp4"},
+            }
+        ],
+    }
+
+
+def test_inline_ref2va_refuses_three_references_at_209_frames():
+    with cuda_24gb():
+        workflow = workflow_from_definition(
+            _ref2va_definition(209, 3), tempfile.mkdtemp()
+        )
+        assert len(_vram_errors(workflow.validation_errors())) == 1
+
+
+def test_inline_ref2va_accepts_three_references_at_175_frames():
+    with cuda_24gb():
+        workflow = workflow_from_definition(
+            _ref2va_definition(175, 3), tempfile.mkdtemp()
+        )
+        assert _vram_errors(workflow.validation_errors()) == []
+
+
+def test_inline_ref2va_refuses_one_reference_at_260_frames():
+    with cuda_24gb():
+        workflow = workflow_from_definition(
+            _ref2va_definition(260, 1), tempfile.mkdtemp()
+        )
+        assert len(_vram_errors(workflow.validation_errors())) == 1
+
+
+def _dialogue_short_shots_with_three_references_on_deflect():
+    """The 'deflect' entry (shots[1]) given 'cold_open''s (shots[0]'s) first
+    three references - two subject portraits plus character_a's voice - so
+    it carries 3 counted references once character_a_voice is non-null,
+    rather than its own default single subject reference."""
+    workflow = _load(os.path.join(MINIMAX_DIR, "dialogue-short.json"))
+    default_shots = workflow.workflow_definition["variables"]["shots"]
+    shots = copy.deepcopy(default_shots)
+    assert shots[1]["name"] == "deflect"
+    shots[1]["num_frames"] = 209
+    shots[1]["references"] = copy.deepcopy(shots[0]["references"][:3])
+    return workflow, shots
+
+
+def test_dialogue_short_deflect_over_ceiling_with_a_named_voice():
+    with cuda_24gb():
+        workflow, shots = _dialogue_short_shots_with_three_references_on_deflect()
+        errors = _vram_errors(
+            workflow.validation_errors(
+                arguments={
+                    "width": 1344,
+                    "height": 768,
+                    "character_a_voice": "https://huggingface.co/datasets/Xenova/transformers.js-docs/resolve/main/jfk.wav",
+                    "shots": shots,
+                }
+            )
+        )
+        assert len(errors) == 1
+        assert errors[0]["path"] == "arguments.shots[1]"
+        assert "shot@deflect" in errors[0]["message"]
+
+
+def test_dialogue_short_deflect_under_ceiling_without_a_named_voice():
+    with cuda_24gb():
+        workflow, shots = _dialogue_short_shots_with_three_references_on_deflect()
+        errors = _vram_errors(
+            workflow.validation_errors(
+                arguments={"width": 1344, "height": 768, "shots": shots}
+            )
+        )
+        assert errors == []
+
+
+# --- Category 5: catalog sweeps ---------------------------------------------
+
+
+def test_every_ref2va_minimax_template_declares_gb_per_reference():
+    checked = 0
+    for path in _template_json_files(MINIMAX_DIR):
+        workflow = workflow_from_file(path, tempfile.mkdtemp())
+        definition = workflow.workflow_definition
+        if not any(_is_ref2va_step(step) for step in _iter_steps(definition)):
+            continue
+        checked += 1
+        estimate = definition.get("vram_estimate")
+        assert isinstance(estimate, dict), (
+            f"{path} has a ref2va step but no vram_estimate"
+        )
+        assert "gb_per_reference" in estimate, (
+            f"{path} vram_estimate has no gb_per_reference"
+        )
+    assert checked > 0, "expected at least one minimax ref2va template"
+
+
+def test_every_template_with_vram_estimate_validates_clean_at_its_defaults():
+    checked = 0
+    for path in _template_json_files(TEMPLATES_DIR):
+        workflow = workflow_from_file(path, tempfile.mkdtemp())
+        definition = workflow.workflow_definition
+        if not isinstance(definition.get("vram_estimate"), dict):
+            continue
+        checked += 1
+        with cuda_24gb():
+            errors = _vram_errors(workflow.validation_errors())
+            assert errors == [], (
+                f"{path} has a VRAM error at its own defaults: {errors}"
+            )
+
+            expanded = workflow.expanded_definition()
+            projections = list(
+                dw.vram_estimate._projections(
+                    expanded, definition["vram_estimate"], None
+                )
+            )
+            assert projections, f"{path} declares vram_estimate but projects no step"
+    assert checked > 0, "expected at least one template declaring vram_estimate"
+
+
+def test_ltx2_text_to_video_refuses_361_frames():
+    with cuda_24gb():
+        workflow = _load(os.path.join(TEMPLATES_DIR, "ltx2", "text-to-video.json"))
+        errors = _vram_errors(workflow.validation_errors(arguments={"num_frames": 361}))
+        assert len(errors) == 1
diff --git a/tests/test_ltx2_extend_clip.py b/tests/test_ltx2_extend_clip.py
new file mode 100644
index 00000000..6bebea9f
--- /dev/null
+++ b/tests/test_ltx2_extend_clip.py
@@ -0,0 +1,35 @@
+"""templates/ltx2/extend-clip's default path loads two LTX-2.5 stacks.
+
+'opening' generates the first clip and 'extended' conditions on it with a
+second, differently-keyed pipeline (LTX2ConditionPipeline vs LTX2Pipeline),
+so the engine's step-redefinition sharing does not apply and only
+`release_pipeline` frees the first stack before the second loads (#523).
+"""
+
+import json
+import os
+
+import pytest
+
+from tests.test_examples import REPO_ROOT
+
+PATH = os.path.join(REPO_ROOT, "workflows", "templates", "ltx2", "extend-clip.json")
+
+
+@pytest.fixture
+def definition():
+    with open(PATH, encoding="utf-8") as handle:
+        return json.load(handle)
+
+
+def test_opening_releases_its_pipeline_before_extended_loads(definition):
+    steps = {step["name"]: step for step in definition["steps"]}
+    assert steps["opening"]["release_pipeline"] is True
+
+
+def test_release_pipeline_does_not_disturb_the_elision_path(definition):
+    """`opening` must stay unreferenced when the caller supplies `clip`, so
+    `release_pipeline` costs nothing on the elided path (#446)."""
+    assert definition["variables"]["clip"] == "previous_result:opening"
+    opening = {s["name"]: s for s in definition["steps"]}["opening"]
+    assert "shared_components" not in opening
diff --git a/tests/test_mcp_assets.py b/tests/test_mcp_assets.py
index 6523c9c1..8b8483c2 100644
--- a/tests/test_mcp_assets.py
+++ b/tests/test_mcp_assets.py
@@ -67,6 +67,20 @@ def handler(request):
         result = list_assets(client_over(handler))
         assert result["assets"][0]["reference"] == "asset:uploads/iris.png"
 
+    def test_a_workspace_can_be_named_for_one_request(self):
+        """#463: listing another workspace's library for one call must not
+        depend on switching the session's own pin."""
+        seen = {}
+
+        def handler(request):
+            seen["params"] = dict(request.url.params)
+            return httpx.Response(
+                200, json={"asset_dir": "/w/A/assets", "assets": [], "folders": []}
+            )
+
+        list_assets(client_over(handler), workspace="A")
+        assert seen["params"]["workspace"] == "A"
+
 
 class TestUpload:
     def test_a_file_is_pushed_and_the_reference_returned(self, tmp_path):
@@ -157,6 +171,28 @@ def handler(request):
         result = upload_asset(client_over(handler), str(source))
         assert result["reference"] == "/srv/outputs/uploads/x.png"
 
+    def test_a_workspace_can_be_named_for_one_request(self, tmp_path):
+        """#463: an upload pinned to another workspace must not depend on
+        switching the session's own pin."""
+        source = tmp_path / "iris.png"
+        source.write_bytes(b"png-bytes")
+        seen = {}
+
+        def handler(request):
+            seen["params"] = dict(request.url.params)
+            return httpx.Response(
+                201,
+                json={
+                    "path": "asset:uploads/deadbeef.png",
+                    "workspace": "A",
+                    "url": "/inputs/uploads/deadbeef.png",
+                },
+            )
+
+        result = upload_asset(client_over(handler), str(source), workspace="A")
+        assert seen["params"]["workspace"] == "A"
+        assert result["workspace"] == "A"
+
 
 class TestKeeping:
     def test_keeping_sends_no_bytes(self):
@@ -227,6 +263,32 @@ def handler(request):
         with pytest.raises(DwApiError, match="read-only"):
             delete_asset(client_over(handler), "iris.png")
 
+    def test_a_workspace_can_be_named_for_one_request(self):
+        """#463: the exact incident this issue fixes - a delete pinned to the
+        workspace named on the call must not follow the session's own pin,
+        which another connection on a shared mount can move underneath it."""
+        seen = {}
+
+        def handler(request):
+            seen["params"] = dict(request.url.params)
+            return httpx.Response(
+                200,
+                json={
+                    "name": "qa-cast/priya-voice",
+                    "workspace": "A",
+                    "reference": "asset:qa-cast/priya-voice.wav",
+                    "deleted": True,
+                    "origin": "workspace",
+                },
+            )
+
+        result = delete_asset(
+            client_over(handler), "qa-cast/priya-voice", workspace="A"
+        )
+        assert seen["params"]["workspace"] == "A"
+        assert result["workspace"] == "A"
+        assert result["deleted"] is True
+
 
 class TestUploadInlineContent:
     """The content= path (#203): bytes an agent holds itself, with no path
@@ -388,3 +450,200 @@ def test_a_stdio_client_is_unconfined(self, tmp_path):
         client, _seen = recording()
 
         assert upload_asset(client, str(source))["uploaded"] == "iris.png"
+
+    def _mounted_client_with_shared_library(self, workspace, common, tmp_path):
+        """A workspace root plus the shared 'common/assets' library every
+        workspace's asset search path includes (#448) - only visible via
+        /api/assets's 'libraries', not /api/server's 'directories'."""
+
+        def handler(request):
+            if request.url.path == "/api/server":
+                return httpx.Response(
+                    200,
+                    json={
+                        "directories": {
+                            "workspace": str(workspace),
+                            "workflows": str(workspace / "workflows"),
+                            "assets": str(workspace / "assets"),
+                            "outputs": str(workspace / "outputs"),
+                            "prompts": None,
+                        }
+                    },
+                )
+            if request.url.path == "/api/assets":
+                return httpx.Response(
+                    200,
+                    json={
+                        "asset_dir": str(workspace / "assets"),
+                        "assets": [],
+                        "folders": [],
+                        "libraries": [
+                            {
+                                "origin": "workspace",
+                                "dir": str(workspace / "assets"),
+                                "writable": True,
+                            },
+                            {
+                                "origin": "common",
+                                "dir": str(common),
+                                "writable": True,
+                            },
+                            {
+                                "origin": "examples",
+                                "dir": str(tmp_path / "examples" / "assets"),
+                                "writable": False,
+                            },
+                        ],
+                        "shadowed": [],
+                    },
+                )
+            return httpx.Response(
+                201,
+                json={
+                    "path": "asset:uploads/deadbeef.png",
+                    "url": "/inputs/uploads/deadbeef.png",
+                },
+            )
+
+        client = client_over(handler)
+        client.mounted = True
+        return client
+
+    def test_a_file_in_the_shared_common_library_is_a_legal_source(self, tmp_path):
+        """SE-F027: the shared asset library is writable and on every
+        workspace's asset search path, so it must be as legal a file_path
+        source as the four directories /api/server names - not just the
+        workspace's own assets/ folder (#448)."""
+        workspace = tmp_path / "workspace"
+        (workspace / "assets").mkdir(parents=True)
+        common = tmp_path / "common" / "assets"
+        common.mkdir(parents=True)
+        source = common / "qa-cast" / "ep10-bed.wav"
+        source.parent.mkdir()
+        source.write_bytes(b"wav-bytes")
+
+        client = self._mounted_client_with_shared_library(workspace, common, tmp_path)
+        result = upload_asset(client, str(source))
+        assert result["reference"] == "asset:uploads/deadbeef.png"
+
+    def test_a_read_only_examples_library_is_still_refused(self, tmp_path):
+        """A writable library is a legal source; a read-only examples one is
+        not - only #448's shared/writable gap is closed, not confinement
+        itself."""
+        workspace = tmp_path / "workspace"
+        (workspace / "assets").mkdir(parents=True)
+        common = tmp_path / "common" / "assets"
+        common.mkdir(parents=True)
+        examples = tmp_path / "examples" / "assets"
+        examples.mkdir(parents=True)
+        source = examples / "sample.png"
+        source.write_bytes(b"png-bytes")
+
+        client = self._mounted_client_with_shared_library(workspace, common, tmp_path)
+        with pytest.raises(DwApiError, match="Refusing to read"):
+            upload_asset(client, str(source))
+
+    def test_traversal_out_of_the_shared_library_is_still_refused(self, tmp_path):
+        """#448 widens the legal roots; it must not widen containment - '..'
+        out of the shared library is still refused."""
+        workspace = tmp_path / "workspace"
+        (workspace / "assets").mkdir(parents=True)
+        common = tmp_path / "common" / "assets"
+        common.mkdir(parents=True)
+        outside = tmp_path / "elsewhere" / "secret.png"
+        outside.parent.mkdir()
+        outside.write_bytes(b"png-bytes")
+        traversal = str(common) + "/../../elsewhere/secret.png"
+
+        client = self._mounted_client_with_shared_library(workspace, common, tmp_path)
+        with pytest.raises(DwApiError, match="Refusing to read"):
+            upload_asset(client, traversal)
+
+
+class TestUploadRouteInTheRefusals:
+    """Both refusals end in a curl command for POST /api/uploads that the
+    caller can run from its own machine (#481): a mounted endpoint reaches
+    its server at 127.0.0.1, which on a remote caller's machine is that
+    machine, so a loopback origin is printed as <host>; the workspace is the
+    one the call would have uploaded to; and the ceiling is the route's real
+    one, not 'no size cap'."""
+
+    def _client(self, base_url, workspace=None, roots=None):
+        def handler(request):
+            if request.url.path == "/api/server":
+                return httpx.Response(200, json={"directories": roots or {}})
+            if request.url.path == "/api/assets":
+                return httpx.Response(200, json={"assets": []})
+            raise AssertionError(f"nothing should be sent: {request.url}")
+
+        client = DwClient(
+            base_url=base_url,
+            workspace=workspace,
+            transport=httpx.MockTransport(handler),
+        )
+        client.mounted = roots is not None
+        return client
+
+    def _file_path_refusal(self, tmp_path, base_url, **kwargs):
+        workspace = tmp_path / "workspace"
+        (workspace / "assets").mkdir(parents=True)
+        roots = {"workspace": str(workspace), "assets": str(workspace / "assets")}
+        client = self._client(
+            base_url, workspace=kwargs.pop("session", None), roots=roots
+        )
+        with pytest.raises(DwApiError) as refused:
+            upload_asset(
+                client,
+                file_path="/Users/don/Pictures/portrait.jpg",
+                asset_name="qa-cast/portrait.jpg",
+                **kwargs,
+            )
+        return str(refused.value)
+
+    def test_a_loopback_origin_is_printed_as_host(self, tmp_path):
+        # what dw/server/mcp_mount.py's client_base_url gives a mounted
+        # endpoint on a loopback or wildcard bind
+        text = self._file_path_refusal(tmp_path, "http://127.0.0.1:8765")
+        assert "127.0.0.1:8765" not in text
+        assert '"http://<host>:8765/api/uploads?filename=<name>' in text
+        assert "<host> is this server's address as your machine reaches it" in text
+
+    def test_a_reachable_origin_is_printed_verbatim(self, tmp_path):
+        text = self._file_path_refusal(tmp_path, "http://100.64.0.7:8765")
+        assert '"http://100.64.0.7:8765/api/uploads?' in text
+        assert "<host>" not in text
+
+    def test_the_command_carries_token_workspace_and_return(self, tmp_path):
+        text = self._file_path_refusal(
+            tmp_path, "http://127.0.0.1:8765", workspace="qa-series"
+        )
+        assert "Authorization: Bearer $DW_API_TOKEN" in text
+        assert "--data-binary @<file>" in text
+        assert '&asset_name=<folder/name>&workspace=qa-series"' in text
+        assert "201 with 'path', the 'asset:' reference" in text
+        assert f"up to {MAX_UPLOAD_BYTES // (1024 * 1024)}MB" in text
+        assert "no size cap" not in text
+
+    def test_the_session_workspace_fills_the_command(self, tmp_path):
+        text = self._file_path_refusal(
+            tmp_path, "http://127.0.0.1:8765", session="episode-4"
+        )
+        assert '&workspace=episode-4"' in text
+
+    def test_the_default_workspace_is_named_rather_than_left_blank(self, tmp_path):
+        text = self._file_path_refusal(tmp_path, "http://127.0.0.1:8765")
+        assert '&workspace=default"' in text
+        assert "<ws>" not in text
+
+    def test_the_inline_limit_refusal_carries_the_same_command(self):
+        client = self._client("http://127.0.0.1:8765", workspace="qa-series")
+        oversized = base64.b64encode(b"0" * (MAX_INLINE_UPLOAD_BYTES + 1)).decode(
+            "ascii"
+        )
+        with pytest.raises(DwApiError) as refused:
+            upload_asset(client, content=oversized, asset_name="cut/final.mp4")
+        text = str(refused.value)
+        assert '"http://<host>:8765/api/uploads?filename=<name>' in text
+        assert '&workspace=qa-series"' in text
+        assert "201 with 'path', the 'asset:' reference" in text
+        assert "no size cap" not in text
diff --git a/tests/test_mcp_authoring.py b/tests/test_mcp_authoring.py
index 72cd7bfb..207540af 100644
--- a/tests/test_mcp_authoring.py
+++ b/tests/test_mcp_authoring.py
@@ -220,6 +220,71 @@ def test_delete_calls_delete():
     assert seen == [("DELETE", "/api/workflows/mine")]
 
 
+def test_save_can_name_a_workspace_for_one_request():
+    """#463: a save pinned to another workspace must not depend on the
+    session's own pin, which another connection on a shared mount can move."""
+    client, seen = scripted_with_params(
+        {
+            ("PUT", "/api/workflows/mine"): (
+                200,
+                {"name": "mine", "workspace": "A", "path": "/w/mine.json"},
+            )
+        }
+    )
+
+    result = authoring.save_workflow(client, "mine", WORKFLOW, workspace="A")
+
+    assert seen[0]["params"]["workspace"] == "A"
+    assert client.workspace == DEFAULT_WORKSPACE
+    assert result["workspace"] == "A"
+
+
+def test_save_without_workspace_sends_no_workspace_param():
+    client, seen = scripted_with_params(
+        {("PUT", "/api/workflows/mine"): (200, {"name": "mine"})}
+    )
+
+    authoring.save_workflow(client, "mine", WORKFLOW)
+
+    assert "workspace" not in seen[0]["params"]
+
+
+def test_delete_can_name_a_workspace_for_one_request():
+    """#463: same guard for delete - a stray save's cleanup must land in the
+    workspace named on the call, not wherever the session happened to be
+    pinned."""
+    client, seen = scripted_with_params(
+        {
+            ("DELETE", "/api/workflows/mine"): (
+                200,
+                {
+                    "name": "mine",
+                    "workspace": "A",
+                    "origin": "workspace",
+                    "deleted": True,
+                },
+            )
+        }
+    )
+
+    result = authoring.delete_workflow(client, "mine", workspace="A")
+
+    assert seen[0]["params"]["workspace"] == "A"
+    assert client.workspace == DEFAULT_WORKSPACE
+    assert result["workspace"] == "A"
+    assert result["deleted"] is True
+
+
+def test_delete_without_workspace_sends_no_workspace_param():
+    client, seen = scripted_with_params(
+        {("DELETE", "/api/workflows/mine"): (200, {"name": "mine", "deleted": True})}
+    )
+
+    authoring.delete_workflow(client, "mine")
+
+    assert "workspace" not in seen[0]["params"]
+
+
 def body_recording_client():
     """A client that keeps the request body, for the parts of a payload the
     (method, path) recorders above cannot see."""
diff --git a/tests/test_mcp_server.py b/tests/test_mcp_server.py
index 27797fe8..5655047d 100644
--- a/tests/test_mcp_server.py
+++ b/tests/test_mcp_server.py
@@ -1154,6 +1154,7 @@ def refusing(request):
     "update_diffusers": (models, "update_diffusers"),
     "validate_workflow": (authoring, "validate_workflow"),
     "save_workflow": (authoring, "save_workflow"),
+    "delete_workflow": (authoring, "delete_workflow"),
     "run_workflow": (diagnose, "run_workflow"),
     "rerun_job": (diagnose, "rerun_job"),
     "get_output_text": (media, "get_output_text"),
@@ -1294,6 +1295,16 @@ def test_the_instructions_say_where_a_copied_workflow_gets_its_cost_from():
     assert "times the number of images" in server.instructions
 
 
+def test_the_instructions_say_a_hand_built_workflow_inherits_a_warning_ceiling():
+    """#502: a workflow with no `vram_estimate` is projected against the
+    catalog template that loads the same pipeline, and only warned. Without
+    naming the template, "its VRAM ceiling" read as the `models/` entry's."""
+    server = server_over(ok({}))
+
+    for words in ("warns (never refuses)", "catalog template", "may differ"):
+        assert words in server.instructions
+
+
 @pytest.mark.asyncio
 async def test_list_workflows_takes_shape_and_traits():
     tools = await tools_of(server_over(ok({})))
diff --git a/tests/test_modular_output_properties.py b/tests/test_modular_output_properties.py
new file mode 100644
index 00000000..5183caf0
--- /dev/null
+++ b/tests/test_modular_output_properties.py
@@ -0,0 +1,182 @@
+"""A modular step asked for several outputs (`output: [videos, audio,
+sampling_rate, latents]`) keeps the dict the pipeline returned as its result
+(step.py adds each iteration's raw output), and `previous_result:<step>.<key>`
+names a key of that dict, spelled as the pipeline spells it (#499).
+
+The pairing into an AudioVideo (`modular_artifacts`, dw/result.py) happens only
+when the result is saved or read whole, so `sample_rate` - the AudioVideo's name
+for it - is not a key the dict has. Asking for it used to come back as an empty
+list, which gave the step reading it zero iterations, succeeding having written
+nothing. A property no result carries is now an error.
+"""
+
+import numpy
+import pytest
+import torch
+from PIL import Image
+
+from dw.previous_results import get_iterations, get_previous_results
+from dw.result import AudioVideo, Result
+from dw.tasks.pair_audio import pair_audio
+
+SAMPLE_RATE = 48000
+FPS = 24
+FRAME_COUNT = 5
+
+
+def frames(width=64, height=32):
+    return [
+        Image.new("RGB", (width, height), (i * 40, 0, 0)) for i in range(FRAME_COUNT)
+    ]
+
+
+def modular_output():
+    """What a modular H3 pipeline hands back for `output: [videos, audio,
+    sampling_rate, latents]`: one dict, batched the way diffusers batches it."""
+    samples = int(FRAME_COUNT / FPS * SAMPLE_RATE)
+    return {
+        "videos": [frames()],
+        "audio": torch.zeros((1, 2, samples)),
+        "sampling_rate": SAMPLE_RATE,
+        "latents": torch.randn(1, 24, 2, 4, 8),
+    }
+
+
+def modular_result():
+    """The base step's Result exactly as Step.run leaves it."""
+    result = Result({})
+    output = modular_output()
+    result.add_result(output)
+    return result, output
+
+
+class TestAModularStepsPropertiesAreItsOutputKeys:
+    def test_the_result_list_holds_the_raw_dict(self):
+        result, output = modular_result()
+        assert result.result_list == [output]
+
+    @pytest.mark.parametrize("key", ["latents", "audio", "sampling_rate", "videos"])
+    def test_every_requested_output_is_reachable_by_its_own_name(self, key):
+        result, output = modular_result()
+        values = get_previous_results({"base": result}, f"base.{key}")
+        assert len(values) == 1
+        assert values[0] is output[key]
+
+    def test_sample_rate_is_not_a_key_and_says_what_is(self):
+        result, _ = modular_result()
+        with pytest.raises(ValueError) as raised:
+            get_previous_results({"base": result}, "base.sample_rate")
+        message = str(raised.value)
+        assert "'sample_rate'" in message
+        assert "sampling_rate" in message
+
+    def test_a_property_nobody_has_raises(self):
+        result, _ = modular_result()
+        with pytest.raises(ValueError, match="nonexistent"):
+            result.get_artifact_properties("nonexistent")
+
+    def test_a_property_one_result_has_is_found_past_one_that_lacks_it(self):
+        result = Result({})
+        latents = torch.randn(1, 2)
+        result.add_result([AudioVideo(frames(), None, None), {"latents": latents}])
+        values = result.get_artifact_properties("latents")
+        assert len(values) == 1
+        assert values[0] is latents
+
+
+def test_the_batched_audio_reaches_pair_audio_as_one_track():
+    """diffusers batches the soundtrack (1, channels, samples); pair_audio
+    takes the one-item batch as it is."""
+    output = modular_output()
+    paired = pair_audio(
+        AudioVideo(frames(), None, None, fps=FPS),
+        output["audio"],
+        sample_rate=output["sampling_rate"],
+        fit="video",
+    )
+    assert numpy.asarray(paired.audio).ndim == 2
+
+
+class TestTheBasesOwnTakeSavesBesideIt:
+    """`previous_result:base.videos` is the pipeline's batch - a list holding
+    one frame list. pair_audio unwraps it; passed through, the encoder took
+    the batch for a frame list and failed at save (#499, third bounce)."""
+
+    def reference_step(self):
+        return {
+            "task": {
+                "command": "pair_audio",
+                "arguments": {
+                    "video": "previous_result:base.videos",
+                    "audio": "previous_result:base.audio",
+                    "sample_rate": "previous_result:base.sampling_rate",
+                    "fit": "video",
+                },
+            },
+            "result": {
+                "content_type": "video/mp4",
+                "fps": FPS,
+                "subfolder": "intermediate",
+            },
+        }
+
+    def test_the_base_videos_save_as_one_mp4_with_its_frames_and_audio(self, tmp_path):
+        import av
+
+        base, _ = modular_result()
+        step = self.reference_step()
+        (arguments,) = get_iterations(step["task"]["arguments"], {"base": base})
+
+        paired = pair_audio(**arguments)
+        assert isinstance(paired.frames, list)
+        assert len(paired.frames) == FRAME_COUNT
+
+        result = Result(step["result"])
+        result.add_result(paired)
+        result.save(str(tmp_path), "reference")
+
+        (written,) = tmp_path.rglob("*.mp4")
+        with av.open(str(written)) as container:
+            assert container.streams.audio
+            decoded = sum(1 for _ in container.decode(video=0))
+        assert decoded == FRAME_COUNT
+
+    def test_a_five_dimensional_batch_of_one_is_unwrapped(self):
+        video = numpy.zeros((1, FRAME_COUNT, 32, 64, 3), dtype=numpy.float32)
+        paired = pair_audio(video, torch.zeros((1, 2, 100)), sample_rate=SAMPLE_RATE)
+        assert paired.frames.shape == (FRAME_COUNT, 32, 64, 3)
+
+    def test_a_frame_list_is_left_alone(self):
+        video = frames()
+        paired = pair_audio(video, torch.zeros((1, 2, 100)), sample_rate=SAMPLE_RATE)
+        assert paired.frames is video
+
+    def test_a_list_of_array_frames_is_not_mistaken_for_a_batch(self):
+        video = [numpy.zeros((32, 64, 3), dtype=numpy.uint8)] * FRAME_COUNT
+        paired = pair_audio(video, torch.zeros((1, 2, 100)), sample_rate=SAMPLE_RATE)
+        assert paired.frames is video
+
+    def test_fit_measures_the_unwrapped_video(self):
+        paired = pair_audio(
+            [frames()],
+            torch.zeros((1, 2, 10)),
+            sample_rate=SAMPLE_RATE,
+            fps=FPS,
+            fit="video",
+        )
+        assert paired.audio.shape[1] == int(round(FRAME_COUNT / FPS * SAMPLE_RATE))
+
+    @pytest.mark.parametrize(
+        "video",
+        [
+            [frames(), frames()],
+            numpy.zeros((2, FRAME_COUNT, 32, 64, 3), dtype=numpy.float32),
+        ],
+    )
+    def test_a_batch_of_several_is_refused(self, video):
+        with pytest.raises(ValueError, match="batch of 2 videos"):
+            pair_audio(video, torch.zeros((1, 2, 100)), sample_rate=SAMPLE_RATE)
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])
diff --git a/tests/test_null_media.py b/tests/test_null_media.py
new file mode 100644
index 00000000..8b433b1a
--- /dev/null
+++ b/tests/test_null_media.py
@@ -0,0 +1,107 @@
+"""A for_each item's null media reference, caught before the checkpoint loads.
+
+`realize_args` raises when an object description sitting directly under a key
+(not inside a list) names a type but resolves no media to build it from -
+but only at run time, after the checkpoint is already loaded. validate_workflow
+is supposed to catch what realize_args would refuse; this mirrors that dict-
+context raise so a caller finds out for free (#478). List-context entries are
+left alone: a template relies on realize_args silently dropping a null one
+there to make a reference optional (`dialogue-short.json`'s shots), so that
+shape must never be flagged.
+"""
+
+import json
+
+import pytest
+
+from dw.null_media import null_media_errors
+from dw.workflow import Workflow
+
+H3 = "diffusers.modular_pipelines.minimax_h3"
+IMAGE = f"{H3}.MiniMaxH3ImageReference"
+
+
+def reference(reference_type=IMAGE, from_file="x.jpg"):
+    return {"reference_type": reference_type, "from_file": from_file}
+
+
+def workflow_with(arguments):
+    return {
+        "id": "refs",
+        "steps": [
+            {
+                "name": "shot",
+                "pipeline": {
+                    "configuration": {"component_type": "ModularPipeline"},
+                    "from_pretrained_arguments": {
+                        "model_name": "MiniMaxAI/MiniMax-H3",
+                        "workflow": "ref2va",
+                    },
+                    "arguments": arguments,
+                },
+                "result": {"content_type": "video/mp4"},
+            }
+        ],
+    }
+
+
+def messages(arguments):
+    return [e["message"] for e in null_media_errors(workflow_with(arguments))]
+
+
+class TestDictContextIsRefused:
+    def test_a_bare_null_reference_is_an_error(self):
+        found = messages({"ref_a": reference(), "ref_b": reference(from_file=None)})
+        assert len(found) == 1
+        assert "'ref_b' names an object to build" in found[0]
+        assert "media it would be built from is null" in found[0]
+
+    def test_the_path_points_at_the_null_from_key(self):
+        errors = null_media_errors(workflow_with({"ref_b": reference(from_file=None)}))
+        assert len(errors) == 1
+        assert errors[0]["path"].endswith("pipeline.arguments.ref_b.from_file")
+
+    def test_a_fully_populated_reference_is_fine(self):
+        assert messages({"ref_a": reference()}) == []
+
+
+class TestListContextIsLeftAlone:
+    """This is the shape realize_args silently drops - the documented way a
+    template makes a reference optional. Flagging it would be a regression."""
+
+    def test_a_null_entry_in_a_list_is_not_an_error(self):
+        assert messages({"references": [reference(), reference(from_file=None)]}) == []
+
+    def test_a_list_of_only_null_entries_is_not_an_error(self):
+        assert messages({"references": [reference(from_file=None)]}) == []
+
+
+class TestUnresolvedIsLeftToAnotherPass:
+    def test_a_still_variable_reference_is_not_flagged(self):
+        assert messages({"ref_a": {"reference_type": "variable:kind"}}) == []
+        assert messages({"ref_a": "variable:references"}) == []
+
+
+class TestThroughTheTemplate:
+    """The issue's own shape: a for_each member's item: reference resolves to
+    a bare (non-list) null-media dict once expanded."""
+
+    def _workflow(self, arguments):
+        return Workflow(workflow_with(arguments), "outputs", "refs.json")
+
+    def test_validation_errors_reports_the_dict_context_null(self):
+        errors = self._workflow(
+            {"ref_a": reference(), "ref_b": reference(from_file=None)}
+        ).validation_errors()
+        messages_found = [e["message"] for e in errors]
+        assert any("'ref_b' names an object to build" in m for m in messages_found)
+
+    def test_dialogue_short_s_optional_list_references_still_validate(self):
+        path = "workflows/templates/minimax/dialogue-short.json"
+        with open(path) as handle:
+            workflow = Workflow(json.load(handle), "outputs", path)
+        assert workflow.validation_errors() == []
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])
diff --git a/tests/test_plugin_skills.py b/tests/test_plugin_skills.py
index db1eb51a..41b4d1e0 100644
--- a/tests/test_plugin_skills.py
+++ b/tests/test_plugin_skills.py
@@ -112,6 +112,25 @@ def test_every_catalog_name_a_skill_quotes_resolves(path):
         )
 
 
+# The task commands a skill sends an agent to by name. A skill cannot be
+# swept for these the way catalog names are - a backticked identifier may be
+# a tool, a field or a task - so each one is listed here.
+SKILL_TASKS = {"minimax-music3": ["attribute_voices"]}
+
+
+@pytest.mark.parametrize(
+    "skill,task",
+    [(skill, task) for skill, tasks in SKILL_TASKS.items() for task in tasks],
+)
+def test_every_task_a_skill_names_is_in_list_tasks(skill, task):
+    """A renamed task fails here rather than in a cold session."""
+    from dw.introspection import list_tasks
+
+    path = os.path.join(PLUGIN_DIR, "skills", skill, "SKILL.md")
+    assert f"`{task}`" in skill_text(path)
+    assert task in list_tasks()["commands"]
+
+
 H3_SKILL = os.path.join(PLUGIN_DIR, "skills", "minimax-h3", "SKILL.md")
 
 
@@ -303,6 +322,68 @@ def test_the_cuts_templates_are_described_as_list_driven(self):
         assert "`per_entry`" in text
         assert "`lists`" in text
 
+    def test_the_768p_ref2va_tradeoff_points_at_the_recipes_guide(self):
+        """Ref2VA reaches 1344x768 too (field report #484 item 6), but the
+        skill's byte cap can't hold the long-form trade-off - it has to
+        point at the recipes guide, and the guide has to actually say it.
+
+        No diffusers symbol enforces these figures (they're a measured
+        field report, not a library constant), so this pins the literal
+        numbers directly rather than deriving them.
+        """
+        text = skill_text(H3_SKILL)
+        assert "1344x768" in text
+        assert "`recipes` guide" in text and "MiniMax-H3" in text
+
+        from dw.server.guides import get_guide
+
+        guide = get_guide("recipes", section="MiniMax-H3")["content"]
+        assert "1344x768" in guide
+        assert "175" in guide and "17n+5" in guide
+        assert "31 minutes" in guide
+
+    def test_the_1344x768_reference_ceilings_are_the_templates_vram_estimate(self):
+        """#479: `gb_per_reference` and the per-step projection moved the
+        Ref2VA ceiling from one number (175 frames, unstated reference count)
+        to one per reference count. Derived here from
+        reference-to-video.json's own `vram_estimate`/`cost`/
+        `variable_constraints` rather than hardcoded, so a recalibration of
+        the template fails this rather than leaving the skill stale.
+        """
+        import json
+
+        from dw.vram_estimate import required_gb
+
+        path = os.path.join(
+            REPO_ROOT, "workflows", "templates", "minimax", "reference-to-video.json"
+        )
+        definition = json.load(open(path, encoding="utf-8"))
+        estimate = definition["vram_estimate"]
+        (cost_entry,) = definition["cost"]
+        capacity = cost_entry["vram_gb"]
+        constraint = definition["variable_constraints"]["num_frames"]
+        width, height = 1344, 768
+
+        def max_frames_for(references):
+            best = None
+            n = 0
+            while True:
+                frames = constraint["modulus"] * n + constraint["remainder"]
+                if frames > constraint["max_frames"]:
+                    return best
+                if frames >= constraint["min_frames"]:
+                    values = {"width": width, "height": height, "num_frames": frames}
+                    if required_gb(estimate, values, references) <= capacity:
+                        best = frames
+                n += 1
+
+        ceilings = {refs: max_frames_for(refs) for refs in (1, 2, 3, 4)}
+        assert ceilings == {1: 243, 2: 209, 3: 175, 4: 141}
+
+        text = skill_text(H3_SKILL)
+        for frames in ceilings.values():
+            assert str(frames) in text
+
 
 LTX_SKILL = os.path.join(PLUGIN_DIR, "skills", "ltx-2.5", "SKILL.md")
 
diff --git a/tests/test_result.py b/tests/test_result.py
index 41b62fc9..662a3020 100644
--- a/tests/test_result.py
+++ b/tests/test_result.py
@@ -257,6 +257,58 @@ def test_save_creates_directory(self):
             assert os.path.exists(output_file)
 
 
+class TestTranscribeAudioTimestampsAtSave:
+    """#498: static validation (test_scalar_result_validation.py) catches a
+    literal `timestamps` against the wrong content_type before the queue, but
+    a `timestamps` reached through a `variable:` is literal only at run time -
+    this is the real save_artifact path a transcribe_audio 'chunks' list (a
+    list, under content_type text/plain) reaches, which used to die with a
+    bare `write() argument must be str, not list` TypeError."""
+
+    def test_a_list_under_text_content_type_names_the_cause(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            result = Result({"content_type": "text/plain", "save": True})
+            result.add_result({"text": "hello world", "chunks": [{"start": 0.0}]})
+
+            with pytest.raises(ValueError) as excinfo:
+                result.save(temp_dir, "transcript")
+
+            message = str(excinfo.value)
+            assert "application/json" in message
+            assert "transcribe_audio" in message
+            assert not os.path.exists(
+                os.path.join(temp_dir, "transcript-0.0-chunks.txt")
+            )
+
+    def test_the_text_half_alone_still_saves(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            result = Result({"content_type": "text/plain", "save": True})
+            result.add_result("plain transcript")
+
+            result.save(temp_dir, "transcript")
+
+            output_file = os.path.join(temp_dir, "transcript-0.0.txt")
+            assert os.path.exists(output_file)
+            with open(output_file) as file:
+                assert file.read() == "plain transcript"
+
+    def test_the_same_dict_under_application_json_is_fine(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            result = Result({"content_type": "application/json", "save": True})
+            result.add_result({"text": "hello world", "chunks": [{"start": 0.0}]})
+
+            result.save(temp_dir, "transcript")
+
+            # A JSON content_type is handled by save() itself, ahead of
+            # save_artifact's own dict recursion - the whole {text, chunks}
+            # document is written to one file, not exploded key by key
+            output_file = os.path.join(temp_dir, "transcript-0.json")
+            assert os.path.exists(output_file)
+            with open(output_file) as file:
+                saved = json.load(file)
+            assert saved == {"text": "hello world", "chunks": [{"start": 0.0}]}
+
+
 @dataclass
 class _LatentOutput:
     """The shape LTX2PipelineOutput has when output_type is 'latent': two
@@ -509,6 +561,45 @@ def test_generated_audio_is_muxed_into_the_video(self):
         assert encode.call_args.kwargs["audio_sample_rate"] == 16000
         assert encode.call_args.kwargs["audio"].shape == (2, 100)
 
+    def test_latents_leftover_beside_video_is_skipped_not_crashed(self, monkeypatch):
+        # #507: a modular step asked for output: [..., "latents"] alongside
+        # video/audio put the raw latents tensor through export_to_video,
+        # which does not accept one - "append_data requires ndarray" deep in
+        # the exporter, after the run's only generation was already made.
+        # The tensor has no media rendering under this step's content_type,
+        # so it is skipped rather than crashing the whole save.
+        import dw.result as result_module
+
+        warnings = []
+        monkeypatch.setattr(
+            result_module,
+            "emit_warning",
+            lambda message, **data: warnings.append((message, data)),
+        )
+        outputs = {
+            "videos": [["frame"] * 1000],
+            "audio": torch.zeros((1, 2, 100)),
+            "sampling_rate": 16000,
+            "latents": torch.zeros((1, 24, 8, 16, 16)),
+        }
+        result = Result({"content_type": "video/mp4", "fps": 24})
+        result.add_result(outputs)
+
+        with (
+            patch("dw.result.encode_video"),
+            patch("dw.result.export_to_video") as export,
+            patch("dw.result.is_av_available", return_value=True),
+            tempfile.TemporaryDirectory() as temp_dir,
+        ):
+            saved = result.save(temp_dir, "test")
+
+        export.assert_not_called()
+        assert len(saved) == 1
+        assert warnings and warnings[0][1]["kind"] == "non_media_artifact_skipped"
+        assert warnings[0][1]["key"] == "latents"
+        # Still reachable in memory by name, unaffected by the save skip
+        assert result.get_artifact_properties("latents")[0].shape == (1, 24, 8, 16, 16)
+
     def test_outputs_are_still_available_by_name(self):
         # The outputs stay a dictionary, so a later step can reference one of them
         result = Result({"content_type": "video/mp4"})
diff --git a/tests/test_runs.py b/tests/test_runs.py
index 360355a7..6dbb6fb5 100644
--- a/tests/test_runs.py
+++ b/tests/test_runs.py
@@ -298,6 +298,80 @@ def test_the_manifest_describes_the_run(self, tmp_path, fake_pipeline):
             assert not os.path.isabs(name)
             assert (run_dir / name).exists()
 
+    def test_a_finished_step_is_in_the_manifest_before_the_run_ends(
+        self, tmp_path, fake_pipeline
+    ):
+        """#480: a finished for_each member (or any earlier step) must be
+        readable from manifest.json while a later, still-running step is
+        the one holding up the job - not only once the whole run ends or is
+        killed."""
+        from PIL import Image
+
+        from dw.pipeline_processors.pipeline import Pipeline
+        from dw.workflow import Workflow
+
+        definition = _workflow_definition()
+        second = _workflow_definition()["steps"][0]
+        second["name"] = "gen1"
+        second["pipeline"]["from_pretrained_arguments"]["model_name"] = "model-1"
+        definition["steps"].append(second)
+
+        seen = {}
+
+        class SecondStepPipeline:
+            def __call__(self, *args, **kwargs):
+                # The run directory is the only one this workflow wrote
+                run_dir = next((tmp_path / "Gyre").iterdir())
+                manifest = json.loads((run_dir / "manifest.json").read_text())
+                seen["status"] = manifest["status"]
+                seen["steps"] = [entry["step"] for entry in manifest["steps"]]
+
+                class Output:
+                    images = [Image.new("RGB", (8, 8), "green")]
+
+                return Output()
+
+            def to(self, *args, **kwargs):
+                return self
+
+            @property
+            def components(self):
+                return {}
+
+        calls = {"n": 0}
+
+        def mock_load(self, shared_components):
+            calls["n"] += 1
+            if calls["n"] == 1:
+                from PIL import Image as _Image
+
+                class FirstStepPipeline:
+                    def __call__(self, *args, **kwargs):
+                        class Output:
+                            images = [_Image.new("RGB", (8, 8), "green")]
+
+                        return Output()
+
+                    def to(self, *args, **kwargs):
+                        return self
+
+                    @property
+                    def components(self):
+                        return {}
+
+                self.pipeline = FirstStepPipeline()
+            else:
+                self.pipeline = SecondStepPipeline()
+
+        with patch.object(Pipeline, "load", mock_load):
+            with patch("dw.workflow.empty_device_cache"):
+                Workflow(definition, str(tmp_path), "/w/workflows/Gyre.json").run({})
+
+        # While gen1 was running, gen0 had already landed in the manifest,
+        # and the run was still reported as in progress
+        assert seen["status"] == "running"
+        assert seen["steps"] == ["gen0"]
+
     def test_the_manifest_records_the_seed_a_seedless_run_drew(
         self, tmp_path, fake_pipeline
     ):
diff --git a/tests/test_scalar_result_validation.py b/tests/test_scalar_result_validation.py
index d6766c78..f21830db 100644
--- a/tests/test_scalar_result_validation.py
+++ b/tests/test_scalar_result_validation.py
@@ -194,6 +194,119 @@ def test_artifact_kind_behaviour_is_unchanged(self):
         self.assertEqual(errors, [])
 
 
+class TestTranscribeAudioTimestamps(unittest.TestCase):
+    """#498: a literal `timestamps` of "segment"/"word" switches
+    transcribe_audio's return value to a {text, chunks} dict - the same
+    application/json requirement as a returns="json" command, but keyed on
+    the argument rather than on the command's declared `returns` (which
+    stays "artifact", since the no-timestamps case really is plain text)."""
+
+    def test_word_timestamps_with_text_plain_is_an_error(self):
+        definition = {
+            "steps": [
+                _step(
+                    "mm",
+                    "transcribe_audio",
+                    result={"content_type": "text/plain"},
+                    arguments={"audio": "asset:voice.wav", "timestamps": "word"},
+                )
+            ]
+        }
+
+        errors = scalar_result_errors(definition, source_indices=[0])
+
+        self.assertEqual(len(errors), 1)
+        self.assertEqual(errors[0]["path"], "steps[0].result")
+        self.assertIn("application/json", errors[0]["message"])
+        self.assertIn("transcribe_audio", errors[0]["message"])
+        self.assertIn("timestamps", errors[0]["message"])
+
+    def test_segment_timestamps_with_image_png_is_an_error(self):
+        definition = {
+            "steps": [
+                _step(
+                    "mm",
+                    "transcribe_audio",
+                    result={"content_type": "image/png"},
+                    arguments={"audio": "asset:voice.wav", "timestamps": "segment"},
+                )
+            ]
+        }
+
+        errors = scalar_result_errors(definition, source_indices=[0])
+
+        self.assertEqual(len(errors), 1)
+        self.assertIn("application/json", errors[0]["message"])
+
+    def test_word_timestamps_with_application_json_is_fine(self):
+        definition = {
+            "steps": [
+                _step(
+                    "mm",
+                    "transcribe_audio",
+                    result={"content_type": "application/json"},
+                    arguments={"audio": "asset:voice.wav", "timestamps": "word"},
+                )
+            ]
+        }
+
+        errors = scalar_result_errors(definition, source_indices=[0])
+
+        self.assertEqual(errors, [])
+
+    def test_no_timestamps_with_text_plain_is_fine(self):
+        definition = {
+            "steps": [
+                _step(
+                    "mm",
+                    "transcribe_audio",
+                    result={"content_type": "text/plain"},
+                    arguments={"audio": "asset:voice.wav"},
+                )
+            ]
+        }
+
+        errors = scalar_result_errors(definition, source_indices=[0])
+
+        self.assertEqual(errors, [])
+
+    def test_variable_timestamps_is_not_flagged_here(self):
+        # Not literal - a variable's value is unknown until run time, so
+        # this is left to Result.save_artifact to name (see test_result.py)
+        definition = {
+            "steps": [
+                _step(
+                    "mm",
+                    "transcribe_audio",
+                    result={"content_type": "text/plain"},
+                    arguments={
+                        "audio": "asset:voice.wav",
+                        "timestamps": "variable:ts_kind",
+                    },
+                )
+            ]
+        }
+
+        errors = scalar_result_errors(definition, source_indices=[0])
+
+        self.assertEqual(errors, [])
+
+    def test_no_result_block_with_timestamps_is_fine(self):
+        definition = {
+            "steps": [
+                _step(
+                    "mm",
+                    "transcribe_audio",
+                    arguments={"audio": "asset:voice.wav", "timestamps": "word"},
+                )
+            ]
+        }
+
+        errors = scalar_result_errors(definition, source_indices=[0])
+
+        self.assertEqual(errors, [])
+
+
 class TestThroughValidationErrors(unittest.TestCase):
     """The same check, exercised through the public `validation_errors` on a
     full workflow definition rather than the pre-substituted form directly."""
diff --git a/tests/test_serve_main.py b/tests/test_serve_main.py
index 6a403d8a..07c73c48 100644
--- a/tests/test_serve_main.py
+++ b/tests/test_serve_main.py
@@ -87,3 +87,10 @@ def test_a_non_loopback_bind_without_mcp_is_only_warned_about(serve):
     calls = serve("--host", "0.0.0.0")
     assert calls["create_app"]["mcp"] is False
     assert calls["uvicorn"]["host"] == "0.0.0.0"
+
+
+def test_shutdown_has_a_grace_period_so_an_open_mcp_connection_cannot_block_it(serve):
+    """#477: uvicorn otherwise waits forever on SIGTERM for a connected
+    streamable-HTTP MCP client to disconnect."""
+    calls = serve()
+    assert calls["uvicorn"]["timeout_graceful_shutdown"] == 5
diff --git a/tests/test_server_guides.py b/tests/test_server_guides.py
index 76ea607e..8638239a 100644
--- a/tests/test_server_guides.py
+++ b/tests/test_server_guides.py
@@ -32,7 +32,12 @@ def checkout(tmp_path, monkeypatch):
     (root / "docs").mkdir(parents=True)
     (root / "docs" / "TASKS.md").write_text(TASKS_TEXT)
     (root / "docs" / "WORKFLOW_GUIDE.md").write_text(
-        "## Structure\n\nsteps - as in workflows/templates/text-to-image.json\n"
+        "## Structure\n\nsteps - as in workflows/templates/text-to-image.json\n\n"
+        "## Cross-Step Data Flow\n\n"
+        "### One step per entry: for_each\n\n"
+        "for_each runs a step once per entry.\n\n"
+        "### previous_result\n\n"
+        "previous_result chains steps.\n"
     )
     monkeypatch.setattr(guides, "__file__", str(root / "dw" / "server" / "guides.py"))
     monkeypatch.setattr(
@@ -147,6 +152,34 @@ def test_a_section_name_need_not_match_case_or_spacing(self, checkout):
 
         assert guide["section"] == "Speech Generation"
 
+    def test_a_subsection_is_reachable_by_its_own_heading(self, checkout):
+        # #503: a `###` subsection isn't in the top-level index, but a
+        # caller who copied its exact heading still reaches it, not a
+        # refusal that only lists `##` headings.
+        guide = guides.get_guide("workflows", section="One step per entry: for_each")
+
+        assert guide["section"] == "One step per entry: for_each"
+        assert guide["parent_section"] == "Cross-Step Data Flow"
+        assert "for_each runs a step once per entry." in guide["content"]
+        # Just the subsection - not its sibling, not the whole ## section
+        assert "previous_result chains steps." not in guide["content"]
+
+    def test_a_subsection_is_reachable_by_a_term_inside_its_heading(self, checkout):
+        # The concept a caller has in hand ("for_each") rather than the
+        # full sentence the heading is written as.
+        guide = guides.get_guide("workflows", section="for_each")
+
+        assert guide["section"] == "One step per entry: for_each"
+        assert guide["parent_section"] == "Cross-Step Data Flow"
+
+    def test_a_section_match_wins_over_a_subsection_match(self, checkout):
+        # An exact `##` match still takes priority - subsections are a
+        # fallback for a term the top level does not otherwise resolve.
+        guide = guides.get_guide("workflows", section="Cross-Step Data Flow")
+
+        assert guide["section"] == "Cross-Step Data Flow"
+        assert "parent_section" not in guide
+
     def test_a_section_linking_an_example_says_how_to_reach_it(self, checkout):
         """A guide's link to an example is a repo path. The reader these
         guides exist for has no checkout - it has the MCP and nothing else -
@@ -217,6 +250,16 @@ def test_the_authoring_section_is_reachable_by_name(self):
 
         assert guide["section"] == "Authoring a workflow from an agent"
 
+    def test_the_for_each_subsection_is_reachable_without_its_parent(self):
+        """#503: both terms the issue's repro used reach the `###` subsection
+        directly, rather than only through its `##` parent."""
+        for section in ("for_each", "One step per entry: for_each"):
+            guide = guides.get_guide("workflows", section=section)
+
+            assert "for_each" in guide["section"]
+            assert guide["parent_section"] == "Authoring a workflow from an agent"
+            assert "for_each" in guide["content"]
+
     def test_the_authoring_section_names_every_reference_prefix(self):
         """The prefixes the engine reserves are the ones the section has to
         explain; a new prefix added to the engine fails here until it is
diff --git a/tests/test_server_workspaces.py b/tests/test_server_workspaces.py
index 872c7a2c..6c7076c3 100644
--- a/tests/test_server_workspaces.py
+++ b/tests/test_server_workspaces.py
@@ -661,11 +661,12 @@ def test_an_asset_is_deleted_and_gone_from_the_listing(
             response = client.delete("/api/assets/cast/hero.png")
             listed = client.get("/api/assets").json()["assets"]
         assert response.status_code == 200
-        assert response.json() == {
-            "name": "cast/hero.png",
-            "deleted": True,
-            "origin": "workspace",
-        }
+        body = response.json()
+        assert body["name"] == "cast/hero.png"
+        assert body["deleted"] is True
+        assert body["origin"] == "workspace"
+        assert body["workspace"] == "default"
+        assert body["reference"] == "asset:cast/hero.png"
         assert listed == []
         assert not os.path.exists(
             os.path.join(workspace_root.assets, "cast", "hero.png")
diff --git a/tests/test_shots.py b/tests/test_shots.py
index 1a0aee0d..07557e61 100644
--- a/tests/test_shots.py
+++ b/tests/test_shots.py
@@ -28,6 +28,7 @@
 from dw.runs import MANIFEST_FILE_NAME, recorded_shots
 from dw.shots import (
     carried_shots,
+    duplicate_shot_names,
     named_shots,
     remeasured_shots,
     rescaled_shots,
@@ -1014,6 +1015,35 @@ def test_no_shots_returns_none(self):
         assert shots_for_file([], "solo.mp4", ["solo.mp4"]) is None
 
 
+class TestDuplicateShotNames:
+    """#508: two joined inputs whose inner shots share names."""
+
+    def test_no_collision_returns_none(self):
+        shots = [shot_record("shot@accuse", 0, 4), shot_record("shot@deflect", 4, 4)]
+        assert duplicate_shot_names(shots) is None
+
+    def test_collision_across_two_inputs_named_by_the_same_for_each(self):
+        shots = [
+            shot_record("shot@accuse", 0, 4),
+            shot_record("shot@deflect", 4, 4),
+            shot_record("shot@accuse", 8, 5),
+            shot_record("shot@deflect", 13, 5),
+        ]
+        assert duplicate_shot_names(shots) == {None: ["shot@accuse", "shot@deflect"]}
+
+    def test_collision_is_scoped_per_file(self):
+        shots = [
+            {**shot_record("shot@accuse", 0, 4), "file": "one.mp4"},
+            {**shot_record("shot@accuse", 0, 5), "file": "one.mp4"},
+            {**shot_record("shot@accuse", 0, 6), "file": "two.mp4"},
+        ]
+        assert duplicate_shot_names(shots) == {"one.mp4": ["shot@accuse"]}
+
+    def test_no_shots_returns_none(self):
+        assert duplicate_shot_names(None) is None
+        assert duplicate_shot_names([]) is None
+
+
 # 11. Workflow.run: the manifest entry and step_end carry the shots, named by
 # the `gather:shot` the step wrote
 
@@ -1102,3 +1132,77 @@ def fake_step_run(self, previous_results, previous_pipelines, step_action):
         os.path.join(workflow._run_dir, written["files"][0]), str(tmp_path)
     ).replace(os.sep, "/")
     assert recorded_shots(str(tmp_path), relative) == entry["shots"]
+
+
+def test_workflow_run_warns_when_two_joined_inputs_share_inner_shot_names(tmp_path):
+    """#508: joining two cuts each made by its own `for_each` named `accuse`/
+    `deflect` (the normal shape for a series' episodes) collides their inner
+    shot names in the joined map - a real concat_videos join, not a stand-in,
+    since the collision comes from named_shots/nested_shots leaving a nested
+    input's own names untouched."""
+    from dw.events import RunContext
+    from dw.step import Step
+    from dw.step_cache import step_cache
+    from dw.workflow import Workflow
+
+    fps, sample_rate = 4, 100
+    episode_a = AudioVideo(
+        frames(8),
+        numpy.full((2, 200), 1.0, dtype=numpy.float32),
+        sample_rate,
+        fps=fps,
+        shots=[
+            shot_record("shot@accuse", 0, 4, start_sample=0, num_samples=100),
+            shot_record("shot@deflect", 4, 4, start_sample=100, num_samples=100),
+        ],
+    )
+    episode_b = AudioVideo(
+        frames(10),
+        numpy.full((2, 250), 1.0, dtype=numpy.float32),
+        sample_rate,
+        fps=fps,
+        shots=[
+            shot_record("shot@accuse", 0, 5, start_sample=0, num_samples=125),
+            shot_record("shot@deflect", 5, 5, start_sample=125, num_samples=125),
+        ],
+    )
+    joined = concat_videos([episode_a, episode_b], fps=fps)
+
+    definition = {
+        "id": "shots_collision",
+        "steps": [
+            {
+                "name": "cut",
+                "task": {
+                    "command": "concat_videos",
+                    "arguments": {"videos": ["episode-a.mp4", "episode-b.mp4"]},
+                },
+                "result": {"content_type": "video/mp4"},
+            }
+        ],
+    }
+
+    def fake_step_run(self, previous_results, previous_pipelines, step_action):
+        return _ShotResult(joined.shots)
+
+    step_cache.clear()
+    events = []
+    workflow = Workflow(definition, str(tmp_path), str(tmp_path / "shots.json"))
+    with patch.object(Step, "run", fake_step_run):
+        workflow.run({}, context=RunContext(on_event=events.append))
+
+    (entry,) = [e for e in workflow.manifest if e["step"] == "cut"]
+    assert [shot["name"] for shot in entry["shots"]] == [
+        "shot@accuse",
+        "shot@deflect",
+        "shot@accuse",
+        "shot@deflect",
+    ]
+
+    (warning,) = [
+        e
+        for e in events
+        if e["event"] == "warning" and e.get("kind") == "shot_name_collision"
+    ]
+    assert set(warning["names"]) == {"shot@accuse", "shot@deflect"}
+    assert "cut" in warning["message"]
diff --git a/tests/test_transcribe_audio.py b/tests/test_transcribe_audio.py
index 14940430..0d39caeb 100644
--- a/tests/test_transcribe_audio.py
+++ b/tests/test_transcribe_audio.py
@@ -24,10 +24,15 @@ def _waveform(self, channels=1, seconds=1.0, sample_rate=16000):
         tone = numpy.zeros((channels, samples), dtype=numpy.float32)
         return tone, sample_rate
 
-    def _mock_pipe(self, mock_pipeline, text="hello world", kind="seq2seq_whisper"):
+    def _mock_pipe(
+        self, mock_pipeline, text="hello world", kind="seq2seq_whisper", chunks=None
+    ):
         pipe = MagicMock()
         pipe.type = kind
-        pipe.return_value = {"text": text}
+        result = {"text": text}
+        if chunks is not None:
+            result["chunks"] = chunks
+        pipe.return_value = result
         mock_pipeline.return_value = pipe
         return pipe
 
@@ -124,6 +129,82 @@ def test_strips_whitespace(self, mock_pipeline):
 
         self.assertEqual(result, "spaced out")
 
+    @patch("dw.tasks.audio_transcription.hf_pipeline")
+    def test_timestamps_word_requests_word_level_and_returns_chunks(
+        self, mock_pipeline
+    ):
+        pipe = self._mock_pipe(
+            mock_pipeline,
+            "hello world",
+            chunks=[
+                {"text": " hello", "timestamp": (0.0, 0.5)},
+                {"text": " world", "timestamp": (0.5, 1.0)},
+            ],
+        )
+        waveform, rate = self._waveform()
+
+        result = transcribe_audio(
+            waveform, device="cpu", sample_rate=rate, timestamps="word"
+        )
+
+        self.assertEqual(pipe.call_args.kwargs.get("return_timestamps"), "word")
+        self.assertEqual(result["text"], "hello world")
+        self.assertEqual(
+            result["chunks"],
+            [
+                {"start": 0.0, "end": 0.5, "text": "hello"},
+                {"start": 0.5, "end": 1.0, "text": "world"},
+            ],
+        )
+
+    @patch("dw.tasks.audio_transcription.hf_pipeline")
+    def test_timestamps_segment_requests_true_and_returns_chunks(self, mock_pipeline):
+        pipe = self._mock_pipe(
+            mock_pipeline,
+            "hello world",
+            chunks=[{"text": "hello world", "timestamp": (0.0, 1.0)}],
+        )
+        waveform, rate = self._waveform()
+
+        result = transcribe_audio(
+            waveform, device="cpu", sample_rate=rate, timestamps="segment"
+        )
+
+        self.assertIs(pipe.call_args.kwargs.get("return_timestamps"), True)
+        self.assertEqual(
+            result["chunks"], [{"start": 0.0, "end": 1.0, "text": "hello world"}]
+        )
+
+    @patch("dw.tasks.audio_transcription.hf_pipeline")
+    def test_timestamps_requested_under_thirty_seconds_too(self, mock_pipeline):
+        # The 30 s long-form branch is a separate reason to ask for
+        # timestamps; an explicit request must not depend on clip length
+        pipe = self._mock_pipe(mock_pipeline, chunks=[])
+        waveform, rate = self._waveform(seconds=5.0)
+
+        transcribe_audio(waveform, device="cpu", sample_rate=rate, timestamps="word")
+
+        self.assertEqual(pipe.call_args.kwargs.get("return_timestamps"), "word")
+
+    @patch("dw.tasks.audio_transcription.hf_pipeline")
+    def test_timestamps_unset_still_returns_plain_text(self, mock_pipeline):
+        self._mock_pipe(mock_pipeline, "unchanged")
+        waveform, rate = self._waveform()
+
+        result = transcribe_audio(waveform, device="cpu", sample_rate=rate)
+
+        self.assertEqual(result, "unchanged")
+
+    @patch("dw.tasks.audio_transcription.hf_pipeline")
+    def test_invalid_timestamps_value_is_rejected(self, mock_pipeline):
+        self._mock_pipe(mock_pipeline)
+        waveform, rate = self._waveform()
+
+        with self.assertRaises(ValueError):
+            transcribe_audio(
+                waveform, device="cpu", sample_rate=rate, timestamps="paragraph"
+            )
+
 
 class TestTranscribeAudioRegistration(unittest.TestCase):
     """Test that transcribe_audio is registered as a task command."""
diff --git a/tests/test_validate_arguments.py b/tests/test_validate_arguments.py
index 87fa1954..e154ed62 100644
--- a/tests/test_validate_arguments.py
+++ b/tests/test_validate_arguments.py
@@ -411,6 +411,31 @@ def test_an_inline_workflow_is_checked_the_same_way(self, server):
         assert response.status_code == 400
         assert "arguments.image" in response.json()["detail"]
 
+    def test_a_missing_asset_written_into_a_step_is_refused(self, server):
+        """A literal in a step is as much a promise as a variable: a missing
+        `asset:` voice on an attribute_voices step validated clean and died
+        on the step (#494)."""
+        workflow = typed_workflow()
+        workflow["steps"][0]["pipeline"]["arguments"]["image"] = "asset:gone.png"
+        with server() as client:
+            checked = client.post("/api/validate", json={"workflow": workflow}).json()
+            response = client.post("/api/jobs", json={"workflow": workflow})
+
+            assert checked["valid"] is False
+            paths = [error["path"] for error in checked["errors"]]
+            assert "steps[0].pipeline.arguments.image" in paths
+            assert response.status_code == 400
+            assert "gone.png" in response.json()["detail"]
+            assert client.get("/api/jobs").json()["jobs"] == []
+
+    def test_an_asset_written_into_a_step_that_is_there_passes(self, server):
+        workflow = typed_workflow()
+        workflow["steps"][0]["pipeline"]["arguments"]["image"] = "asset:iris.png"
+        with server() as client:
+            checked = client.post("/api/validate", json={"workflow": workflow}).json()
+
+        assert checked["valid"] is True, checked
+
     def test_a_bad_stored_default_is_refused_before_the_job_is_queued(self, server):
         """The same gap at submission: a bare submit used to queue a job
         that could only fail on its first step (#166)."""
diff --git a/tests/test_variable_constraints.py b/tests/test_variable_constraints.py
index 2d16bf49..539fd8c1 100644
--- a/tests/test_variable_constraints.py
+++ b/tests/test_variable_constraints.py
@@ -509,6 +509,38 @@ def test_the_ltx2_frame_rule_is_the_pipelines(self):
             # pipeline chose
             assert "snap" not in rule, path
 
+    def test_the_ltx2_size_rule_is_the_pipelines(self):
+        """`check_inputs` on every LTX-2.5 pipeline refuses a `height`/`width`
+        not divisible by 32 outright (#505) - unlike `num_frames`, there is
+        no named symbol for it, so the rule is pinned by reading the source
+        of the pipeline class each constrained template actually loads."""
+        import inspect
+        import re
+
+        pipeline = pytest.importorskip(
+            "diffusers.pipelines.ltx2.pipeline_ltx2", reason="diffusers without LTX-2"
+        )
+        source = inspect.getsource(pipeline.LTX2Pipeline.check_inputs)
+        match = re.search(r"height % (\d+) != 0 or width % (\d+) != 0", source)
+        assert match, (
+            "LTX2Pipeline.check_inputs no longer refuses an odd size the way #505 pinned"
+        )
+        modulus = int(match.group(1))
+        assert modulus == int(match.group(2))
+
+        for name in ("width", "height"):
+            declared = [
+                (path, rule)
+                for path, variable, rule in declared_in_the_catalog()
+                if "ltx2" in path and variable == name
+            ]
+            assert declared, f"no LTX-2.5 template declares a {name} constraint"
+            for path, rule in declared:
+                assert rule["modulus"] == modulus, path
+                assert rule["remainder"] == 0, path
+                # A hard ValueError, not a floor like num_frames: no snap
+                assert "snap" not in rule, path
+
     def test_a_chain_step_states_the_rule_once(self):
         """Where a template declares a constraint and also snaps a chain,
         the chain names the constraint rather than repeating its numbers."""
diff --git a/tests/test_video_size_errors.py b/tests/test_video_size_errors.py
new file mode 100644
index 00000000..5381e6f7
--- /dev/null
+++ b/tests/test_video_size_errors.py
@@ -0,0 +1,136 @@
+"""A dissolve_videos/concat_videos frame-size mismatch, refused before the
+run when the sizes are already knowable - #504.
+
+Both tasks only discover a size mismatch after decoding every input
+(`check_same_frame_size`, dw/tasks/video_utils.py); these tests exercise the
+real decode path (`probe_media` against a genuine mp4) rather than a mock of
+it, so a fixture pair that disagrees in size is the same pair the run itself
+would have failed on.
+"""
+
+import os
+import tempfile
+
+from tests.test_dissolve_frame_errors import write_mp4, workflow_dir_with_asset
+
+from dw.runs import activate_output_root, deactivate_output_root
+from dw.video_size_errors import video_size_errors
+from dw.workflow import workflow_from_definition
+
+
+def join_workflow(command, videos, extra_arguments=None):
+    arguments = {"videos": videos}
+    if extra_arguments:
+        arguments.update(extra_arguments)
+    return {
+        "id": "joining",
+        "steps": [
+            {
+                "name": "join",
+                "task": {"command": command, "arguments": arguments},
+                "result": {"content_type": "video/mp4", "fps": 6},
+            }
+        ],
+    }
+
+
+class TestTheCheck:
+    def test_mismatched_asset_sizes_are_refused_for_dissolve_videos(self, monkeypatch):
+        base_dir = workflow_dir_with_asset(monkeypatch, ("a.mp4", 12), ("b.mp4", 12))
+        write_mp4(
+            os.path.join(base_dir, "assets", "b.mp4"), frames=12, width=64, height=32
+        )
+        definition = join_workflow("dissolve_videos", ["asset:a.mp4", "asset:b.mp4"])
+
+        problems = video_size_errors(definition, base_dir=base_dir)
+
+        assert len(problems) == 1
+        assert problems[0]["path"] == "steps[0].task.arguments.videos"
+        assert "32x16" in problems[0]["message"]
+        assert "64x32" in problems[0]["message"]
+
+    def test_mismatched_asset_sizes_are_refused_for_concat_videos(self, monkeypatch):
+        base_dir = workflow_dir_with_asset(monkeypatch, ("a.mp4", 12), ("b.mp4", 12))
+        write_mp4(
+            os.path.join(base_dir, "assets", "b.mp4"), frames=12, width=64, height=32
+        )
+        definition = join_workflow("concat_videos", ["asset:a.mp4", "asset:b.mp4"])
+
+        problems = video_size_errors(definition, base_dir=base_dir)
+
+        assert len(problems) == 1
+        assert "concat_videos needs every video at one size" in problems[0]["message"]
+
+    def test_matching_asset_sizes_validate_clean(self, monkeypatch):
+        base_dir = workflow_dir_with_asset(monkeypatch, ("a.mp4", 12), ("b.mp4", 12))
+        definition = join_workflow("dissolve_videos", ["asset:a.mp4", "asset:b.mp4"])
+
+        assert video_size_errors(definition, base_dir=base_dir) == []
+
+    def test_a_previous_result_video_is_left_to_the_run(self):
+        definition = join_workflow(
+            "dissolve_videos", ["previous_result:make_a", "previous_result:make_b"]
+        )
+
+        assert video_size_errors(definition) == []
+
+    def test_a_mismatch_against_an_unresolvable_entry_is_left_to_the_run(
+        self, monkeypatch
+    ):
+        base_dir = workflow_dir_with_asset(monkeypatch, ("a.mp4", 12))
+        definition = join_workflow(
+            "dissolve_videos", ["asset:a.mp4", "previous_result:make_b"]
+        )
+
+        assert video_size_errors(definition, base_dir=base_dir) == []
+
+    def test_an_output_reference_mismatch_is_refused(self):
+        output_root = tempfile.mkdtemp()
+        run_dir = os.path.join(output_root, "clip", "20260101-000000-abc")
+        os.makedirs(run_dir)
+        write_mp4(os.path.join(run_dir, "a.mp4"), frames=12, width=32, height=16)
+        write_mp4(os.path.join(run_dir, "b.mp4"), frames=12, width=64, height=32)
+        definition = join_workflow(
+            "concat_videos",
+            [
+                "output:clip/20260101-000000-abc/a.mp4",
+                "output:clip/20260101-000000-abc/b.mp4",
+            ],
+        )
+
+        token = activate_output_root(output_root)
+        try:
+            problems = video_size_errors(definition)
+        finally:
+            deactivate_output_root(token)
+
+        assert len(problems) == 1
+        assert "32x16" in problems[0]["message"]
+        assert "64x32" in problems[0]["message"]
+
+    def test_nothing_is_reported_for_a_definition_with_no_join_step(self):
+        assert video_size_errors({"steps": [{"name": "a", "task": {}}]}) == []
+
+    def test_a_single_video_needs_no_size_check(self, monkeypatch):
+        base_dir = workflow_dir_with_asset(monkeypatch, ("a.mp4", 5))
+        definition = join_workflow("dissolve_videos", ["asset:a.mp4"])
+
+        assert video_size_errors(definition, base_dir=base_dir) == []
+
+
+class TestTheValidationPass:
+    def test_wired_into_validation_errors(self, monkeypatch):
+        base_dir = workflow_dir_with_asset(monkeypatch, ("a.mp4", 12), ("b.mp4", 12))
+        write_mp4(
+            os.path.join(base_dir, "assets", "b.mp4"), frames=12, width=64, height=32
+        )
+        definition = join_workflow("concat_videos", ["asset:a.mp4", "asset:b.mp4"])
+        workflow = workflow_from_definition(
+            definition, os.path.join(base_dir, "workflow.json")
+        )
+
+        problems = workflow.validation_errors()
+
+        assert any(
+            problem["path"] == "steps[0].task.arguments.videos" for problem in problems
+        )
diff --git a/tests/test_video_utils.py b/tests/test_video_utils.py
index 587c7b0a..57e808bc 100644
--- a/tests/test_video_utils.py
+++ b/tests/test_video_utils.py
@@ -315,6 +315,18 @@ def test_frames_and_audio_come_back_together(self, tmp_path):
         assert video.sample_rate == 8000
         assert video.audio.shape[0] == 2
 
+    def test_a_location_dict_is_unwrapped(self, tmp_path):
+        """The same {"location": ...} idiom a `video` argument accepts,
+        unwrapped here too so a list entry can carry it (#510)."""
+        from dw.tasks.video_utils import load_audio_video
+
+        path = self.write_video(tmp_path / "shot.mp4")
+
+        video = load_audio_video({"location": path})
+
+        assert len(video.frames) == 8
+        assert video.sample_rate == 8000
+
     def test_the_files_own_frame_rate_comes_back_with_it(self, tmp_path):
         """A step that joins videos read from disk knows what to write them
         back at without being told - see issue #84."""
@@ -493,6 +505,27 @@ def test_a_disallowed_extension_is_refused(self, tmp_path):
             load_audio_video(str(payload))
 
 
+class TestIsVideoLocation:
+    """What a task's own list-of-videos loop should hand to load_audio_video
+    rather than pass through untouched - see #510."""
+
+    def test_a_path_and_a_location_dict_are_locations(self):
+        from dw.tasks.video_utils import is_video_location
+
+        assert is_video_location("shot.mp4")
+        assert is_video_location({"location": "shot.mp4"})
+
+    def test_an_already_loaded_video_is_not(self):
+        from PIL import Image
+
+        from dw.result import AudioVideo
+        from dw.tasks.video_utils import is_video_location
+
+        assert not is_video_location(AudioVideo([Image.new("RGB", (2, 2))], None, None))
+        assert not is_video_location([Image.new("RGB", (2, 2))])
+        assert not is_video_location({"media_type": "video"})
+
+
 class TestVideoFileReference:
     """#367. get_frame/get_first_frame/get_last_frame only need one frame; a
     VideoFileReference lets get_frame seek to it with PyAV instead of
diff --git a/tests/test_voice_attribution.py b/tests/test_voice_attribution.py
new file mode 100644
index 00000000..c872180a
--- /dev/null
+++ b/tests/test_voice_attribution.py
@@ -0,0 +1,784 @@
+"""Tests for #485: attribute_voices - which reference voice sings each line
+of a song, by timbre.
+
+No network access and no real demucs/speechbrain models: separation and
+embedding are mocked throughout, following the pattern in
+test_speech_generation.py (patch.dict("sys.modules", ...) for the "package
+missing" paths, direct patches of the module's own helpers everywhere else).
+"""
+
+import sys
+import unittest
+from unittest.mock import MagicMock, patch
+
+import numpy
+
+from dw.introspection import describe_task, list_tasks
+from dw.scalar_result_validation import scalar_result_errors
+from dw.tasks import model_cache
+from dw.tasks.task import _COMMAND_INFO
+from dw.tasks.voice_attribution import (
+    MIN_VOICED_SECONDS,
+    UNCERTAIN_MARGIN,
+    UNCERTAIN_SHARE_MARGIN,
+    VOICES_TOO_SIMILAR,
+    attribute_voices,
+    cosine,
+    reference_similarity,
+    roll_up,
+    score_line,
+    voiced_floor_dbfs,
+    voiced_mask,
+    voices_errors,
+)
+from dw.locations import location_errors
+from dw.security import TRUST_WORKFLOWS_ENV_VAR
+from dw.workflow import Workflow
+
+
+def tone(seconds, sample_rate=16000, amplitude=0.3, channels=1):
+    """A loud sine tone - counts as voiced (well above any voiced floor)."""
+    samples = int(round(seconds * sample_rate))
+    t = numpy.arange(samples, dtype=numpy.float32) / sample_rate
+    wave = (amplitude * numpy.sin(2 * numpy.pi * 220 * t)).astype(numpy.float32)
+    return numpy.tile(wave, (channels, 1))
+
+
+def silence(seconds, sample_rate=16000, channels=1):
+    samples = int(round(seconds * sample_rate))
+    return numpy.zeros((channels, samples), dtype=numpy.float32)
+
+
+class FakeAudio:
+    """Matches `_waveform_and_rate`'s `hasattr(audio, "audio")` branch, so no
+    file-path/security validation is triggered."""
+
+    def __init__(self, waveform, sample_rate=16000):
+        self.audio = waveform
+        self.sample_rate = sample_rate
+
+
+def song_audio(seconds=10.0, sample_rate=16000):
+    return FakeAudio(tone(seconds, sample_rate), sample_rate)
+
+
+def setUpModule():
+    # Guard against a mock leaking into another test through the process-wide
+    # model cache keyed on (COMMAND, model name, device, dtype)
+    model_cache.clear_model_cache()
+
+
+def tearDownModule():
+    model_cache.clear_model_cache()
+
+
+# ---------------------------------------------------------------------------
+# 1. Validation errors
+# ---------------------------------------------------------------------------
+
+
+class TestValidationErrors(unittest.TestCase):
+    def test_fewer_than_two_voices_is_an_error(self):
+        with self.assertRaisesRegex(ValueError, "at least 2 voices"):
+            attribute_voices(
+                song_audio(),
+                voices={"a": [{"start_seconds": 0, "duration_seconds": 4}]},
+            )
+
+    def test_a_voices_reference_under_the_minimum_names_the_voice(self):
+        with self.assertRaisesRegex(ValueError, "voice 'a' has"):
+            attribute_voices(
+                song_audio(),
+                voices={
+                    "a": [{"start_seconds": 0, "duration_seconds": 1}],
+                    "b": [{"start_seconds": 1, "duration_seconds": 4}],
+                },
+            )
+
+    def test_a_span_past_the_end_of_the_audio_is_an_error(self):
+        with self.assertRaisesRegex(ValueError, "past the end"):
+            attribute_voices(
+                song_audio(seconds=5.0),
+                voices={
+                    "a": [{"start_seconds": 0, "duration_seconds": 4}],
+                    "b": [{"start_seconds": 20, "duration_seconds": 4}],
+                },
+            )
+
+    def test_a_span_ending_before_it_starts_is_an_error(self):
+        with self.assertRaisesRegex(ValueError, "not after its start"):
+            attribute_voices(
+                song_audio(),
+                voices={
+                    "a": [{"start": 4, "end": 4}],
+                    "b": [{"start_seconds": 4, "duration_seconds": 4}],
+                },
+            )
+
+    def test_invalid_voice_name_is_named(self):
+        for bad in ("1bad", "a b"):
+            with self.assertRaisesRegex(ValueError, "voice name .* is not allowed"):
+                attribute_voices(
+                    song_audio(),
+                    voices={
+                        bad: [{"start_seconds": 0, "duration_seconds": 4}],
+                        "b": [{"start_seconds": 4, "duration_seconds": 4}],
+                    },
+                )
+
+    def test_a_span_dict_mixing_both_shapes_is_an_error(self):
+        with self.assertRaisesRegex(ValueError, "needs exactly one of"):
+            attribute_voices(
+                song_audio(),
+                voices={
+                    "a": [{"start": 0, "end": 4, "start_seconds": 0}],
+                    "b": [{"start_seconds": 4, "duration_seconds": 4}],
+                },
+            )
+
+    def test_window_seconds_must_be_positive(self):
+        with self.assertRaisesRegex(ValueError, "window_seconds"):
+            attribute_voices(
+                song_audio(),
+                voices={
+                    "a": [{"start_seconds": 0, "duration_seconds": 4}],
+                    "b": [{"start_seconds": 4, "duration_seconds": 4}],
+                },
+                window_seconds=0,
+            )
+
+    def test_min_reference_seconds_must_be_positive(self):
+        with self.assertRaisesRegex(ValueError, "min_reference_seconds"):
+            attribute_voices(
+                song_audio(),
+                voices={
+                    "a": [{"start_seconds": 0, "duration_seconds": 4}],
+                    "b": [{"start_seconds": 4, "duration_seconds": 4}],
+                },
+                min_reference_seconds=0,
+            )
+
+
+# ---------------------------------------------------------------------------
+# 2. Both `lines` shapes, chunks dict, text carried through
+# ---------------------------------------------------------------------------
+
+
+class TestLinesShapes(unittest.TestCase):
+    def _run(self, lines):
+        with (
+            patch("dw.tasks.voice_attribution._load_embedder") as mock_load_embedder,
+            patch("dw.tasks.voice_attribution.embed") as mock_embed,
+        ):
+            mock_load_embedder.return_value = MagicMock()
+
+            # Fixed embedding regardless of input: the line embedding matches
+            # 'a' exactly, so scoring is deterministic
+            def fake_embed(encoder, samples):
+                return numpy.array([1.0, 0.0])
+
+            mock_embed.side_effect = fake_embed
+            return attribute_voices(
+                song_audio(seconds=10.0),
+                voices={
+                    "a": [{"start_seconds": 0, "duration_seconds": 4}],
+                    "b": [{"start_seconds": 4, "duration_seconds": 4}],
+                },
+                lines=lines,
+                separate=False,
+            )
+
+    def test_start_end_shape_and_start_seconds_shape_give_identical_spans(self):
+        result_a = self._run([{"start": 1, "end": 3, "text": "hi"}])
+        result_b = self._run(
+            [{"start_seconds": 1, "duration_seconds": 2, "text": "hi"}]
+        )
+        self.assertEqual(result_a["lines"][0]["start"], result_b["lines"][0]["start"])
+        self.assertEqual(result_a["lines"][0]["end"], result_b["lines"][0]["end"])
+
+    def test_text_is_carried_through(self):
+        result = self._run([{"start": 1, "end": 3, "text": "hello there"}])
+        self.assertEqual(result["lines"][0]["text"], "hello there")
+
+    def test_transcript_dict_with_chunks_is_accepted(self):
+        transcript = {"text": "hello", "chunks": [{"start": 1, "end": 3, "text": "hi"}]}
+        result = self._run(transcript)
+        self.assertEqual(len(result["lines"]), 1)
+        self.assertEqual(result["lines"][0]["text"], "hi")
+
+
+# ---------------------------------------------------------------------------
+# 3. Scoring
+# ---------------------------------------------------------------------------
+
+
+class TestScoring(unittest.TestCase):
+    def test_cosine_of_identical_vectors_is_one(self):
+        self.assertAlmostEqual(cosine([1.0, 0.0], [1.0, 0.0]), 1.0)
+
+    def test_cosine_of_orthogonal_vectors_is_zero(self):
+        self.assertAlmostEqual(cosine([1.0, 0.0], [0.0, 1.0]), 0.0)
+
+    def test_cosine_zero_vector_is_zero_not_a_division_error(self):
+        self.assertEqual(cosine([0.0, 0.0], [1.0, 0.0]), 0.0)
+
+    def test_reference_similarity_reports_every_pair(self):
+        embeddings = {
+            "a": numpy.array([1.0, 0.0]),
+            "b": numpy.array([0.0, 1.0]),
+            "c": numpy.array([1.0, 0.0]),
+        }
+        pairs = reference_similarity(embeddings)
+        self.assertEqual(len(pairs), 3)
+        too_similar = {frozenset(p["voices"]) for p in pairs if p["too_similar"]}
+        self.assertEqual(too_similar, {frozenset(["a", "c"])})
+
+    def test_score_line_picks_the_argmax_and_reports_every_voice(self):
+        references = {
+            "a": numpy.array([1.0, 0.0]),
+            "b": numpy.array([0.0, 1.0]),
+        }
+        result = score_line(numpy.array([0.9, 0.1]), references, voiced_seconds=2.0)
+        self.assertEqual(result["voice"], "a")
+        self.assertEqual(set(result["scores"]), {"a", "b"})
+        self.assertAlmostEqual(
+            result["margin"], result["scores"]["a"] - result["scores"]["b"], places=3
+        )
+
+    def test_roll_up_shares_and_voice_directly(self):
+        windows = [{"name": "w1", "start": 0.0, "end": 4.0}]
+        lines = [
+            {"start": 0.0, "end": 2.0, "voice": "a"},
+            {"start": 2.0, "end": 4.0, "voice": "b"},
+        ]
+
+        def voiced_seconds(start, end):
+            return end - start
+
+        rolled = roll_up(windows, lines, voiced_seconds, ["a", "b"])
+        self.assertEqual(rolled[0]["share"], {"a": 0.5, "b": 0.5})
+
+    def test_attribute_voices_end_to_end_scores_each_voice(self):
+        with (
+            patch("dw.tasks.voice_attribution._load_embedder") as mock_load_embedder,
+            patch("dw.tasks.voice_attribution.embed") as mock_embed,
+        ):
+            mock_load_embedder.return_value = MagicMock()
+            mock_embed.return_value = numpy.array([1.0, 0.0])
+            result = attribute_voices(
+                song_audio(seconds=8.0),
+                voices={
+                    "a": [{"start_seconds": 0, "duration_seconds": 4}],
+                    "b": [{"start_seconds": 4, "duration_seconds": 4}],
+                },
+                lines=[{"start": 0, "end": 4, "text": None}],
+                separate=False,
+            )
+        line = result["lines"][0]
+        self.assertEqual(set(line["scores"]), {"a", "b"})
+        self.assertEqual(line["voice"], "a")
+
+
+# ---------------------------------------------------------------------------
+# 4. Uncertain paths
+# ---------------------------------------------------------------------------
+
+
+class TestUncertainPaths(unittest.TestCase):
+    def test_a_thin_margin_is_uncertain_but_still_reports_the_argmax(self):
+        references = {
+            "a": numpy.array([1.0, 0.001]),
+            "b": numpy.array([0.999, 0.0]),
+        }
+        result = score_line(numpy.array([1.0, 0.0005]), references, voiced_seconds=2.0)
+        self.assertLess(result["margin"], UNCERTAIN_MARGIN)
+        self.assertTrue(result["uncertain"])
+        self.assertIn("margin", result["reason"])
+        self.assertIsNotNone(result["voice"])
+
+    def test_a_silent_line_has_no_voice_and_empty_scores(self):
+        result = score_line(None, {"a": numpy.array([1.0, 0.0])}, voiced_seconds=0.1)
+        self.assertIsNone(result["voice"])
+        self.assertTrue(result["uncertain"])
+        self.assertIn("voiced", result["reason"])
+        self.assertEqual(result["scores"], {})
+        self.assertLess(0.1, MIN_VOICED_SECONDS)
+        self.assertIn("after separation", result["reason"])
+
+    def test_an_unseparated_silent_line_does_not_claim_separation(self):
+        result = score_line(
+            None, {"a": numpy.array([1.0, 0.0])}, voiced_seconds=0.1, separated=False
+        )
+        self.assertIsNone(result["voice"])
+        self.assertNotIn("separation", result["reason"])
+
+    def test_a_too_similar_top_two_pair_is_uncertain(self):
+        references = {
+            "a": numpy.array([1.0, 0.0]),
+            "b": numpy.array([1.0, 0.0]),
+        }
+        result = score_line(
+            numpy.array([1.0, 0.0]),
+            references,
+            voiced_seconds=2.0,
+            too_similar_pairs=[["a", "b"]],
+        )
+        self.assertTrue(result["uncertain"])
+        self.assertIn("too similar", result["reason"])
+
+
+# ---------------------------------------------------------------------------
+# 5. voices_too_similar warnings
+# ---------------------------------------------------------------------------
+
+
+class TestVoicesTooSimilarWarning(unittest.TestCase):
+    def test_too_similar_references_emit_a_warning(self):
+        with (
+            patch("dw.tasks.voice_attribution._load_embedder") as mock_load_embedder,
+            patch("dw.tasks.voice_attribution.embed") as mock_embed,
+            patch("dw.tasks.voice_attribution.emit_warning") as mock_emit_warning,
+        ):
+            mock_load_embedder.return_value = MagicMock()
+            # Both voices' references embed identically -> cosine 1.0 > 0.8
+            mock_embed.return_value = numpy.array([1.0, 0.0])
+            result = attribute_voices(
+                song_audio(seconds=8.0),
+                voices={
+                    "a": [{"start_seconds": 0, "duration_seconds": 4}],
+                    "b": [{"start_seconds": 4, "duration_seconds": 4}],
+                },
+                lines=[{"start": 0, "end": 4}],
+                separate=False,
+            )
+
+        kinds = [w["kind"] for w in result["warnings"]]
+        self.assertIn("voices_too_similar", kinds)
+        self.assertTrue(
+            any(
+                call.kwargs.get("kind") == "voices_too_similar"
+                for call in mock_emit_warning.call_args_list
+            )
+        )
+        self.assertGreater(VOICES_TOO_SIMILAR, 0)
+
+
+# ---------------------------------------------------------------------------
+# 6. Windows roll-up and defaults
+# ---------------------------------------------------------------------------
+
+
+class TestWindowsRollUp(unittest.TestCase):
+    def test_split_window_under_share_margin_is_uncertain(self):
+        windows = [{"name": "w1", "start": 0.0, "end": 4.0}]
+        lines = [
+            {"start": 0.0, "end": 2.1, "voice": "a"},
+            {"start": 2.1, "end": 4.0, "voice": "b"},
+        ]
+
+        def voiced_seconds(start, end):
+            return end - start
+
+        rolled = roll_up(windows, lines, voiced_seconds, ["a", "b"])
+        lead = abs(rolled[0]["share"]["a"] - rolled[0]["share"]["b"])
+        self.assertLess(lead, UNCERTAIN_SHARE_MARGIN)
+        self.assertTrue(rolled[0]["uncertain"])
+
+    def test_window_with_no_attributed_voice_has_voice_none(self):
+        windows = [{"name": "w1", "start": 0.0, "end": 4.0}]
+        lines = [{"start": 0.0, "end": 4.0, "voice": None}]
+
+        def voiced_seconds(start, end):
+            return end - start
+
+        rolled = roll_up(windows, lines, voiced_seconds, ["a", "b"])
+        self.assertIsNone(rolled[0]["voice"])
+        self.assertTrue(rolled[0]["uncertain"])
+
+    def test_no_lines_no_windows_mirrors_the_fixed_grid(self):
+        with (
+            patch("dw.tasks.voice_attribution._load_embedder") as mock_load_embedder,
+            patch("dw.tasks.voice_attribution.embed") as mock_embed,
+        ):
+            mock_load_embedder.return_value = MagicMock()
+            mock_embed.return_value = numpy.array([1.0, 0.0])
+            result = attribute_voices(
+                song_audio(seconds=10.0),
+                voices={
+                    "a": [{"start_seconds": 0, "duration_seconds": 4}],
+                    "b": [{"start_seconds": 4, "duration_seconds": 4}],
+                },
+                window_seconds=4.0,
+                separate=False,
+            )
+        # 10s / 4s windows -> 3 windows, the last one shorter (2s)
+        self.assertEqual(len(result["windows"]), 3)
+        self.assertEqual(len(result["lines"]), 3)
+        self.assertAlmostEqual(
+            result["windows"][-1]["end"] - result["windows"][-1]["start"], 2.0
+        )
+
+    def test_lines_given_no_windows_gives_empty_windows(self):
+        with (
+            patch("dw.tasks.voice_attribution._load_embedder") as mock_load_embedder,
+            patch("dw.tasks.voice_attribution.embed") as mock_embed,
+        ):
+            mock_load_embedder.return_value = MagicMock()
+            mock_embed.return_value = numpy.array([1.0, 0.0])
+            result = attribute_voices(
+                song_audio(seconds=8.0),
+                voices={
+                    "a": [{"start_seconds": 0, "duration_seconds": 4}],
+                    "b": [{"start_seconds": 4, "duration_seconds": 4}],
+                },
+                lines=[{"start": 0, "end": 4}],
+                separate=False,
+            )
+        self.assertEqual(result["windows"], [])
+
+
+# ---------------------------------------------------------------------------
+# 7. Clip-path reference
+# ---------------------------------------------------------------------------
+
+
+class TestClipPathReference(unittest.TestCase):
+    def test_clip_path_reference_is_loaded_and_length_checked(self):
+        with (
+            patch("dw.tasks.voice_attribution.load_audio") as mock_load_audio,
+            patch("dw.tasks.voice_attribution._load_embedder") as mock_load_embedder,
+            patch("dw.tasks.voice_attribution.embed") as mock_embed,
+        ):
+            mock_load_audio.return_value = (tone(4.0), 16000)
+            mock_load_embedder.return_value = MagicMock()
+            mock_embed.return_value = numpy.array([1.0, 0.0])
+            attribute_voices(
+                song_audio(seconds=8.0),
+                voices={
+                    "a": "asset:voices/a.wav",
+                    "b": [{"start_seconds": 4, "duration_seconds": 4}],
+                },
+                lines=[{"start": 0, "end": 4}],
+                separate=False,
+            )
+        mock_load_audio.assert_called_once_with("asset:voices/a.wav")
+
+    def test_clip_path_reference_under_minimum_is_refused(self):
+        with patch("dw.tasks.voice_attribution.load_audio") as mock_load_audio:
+            mock_load_audio.return_value = (tone(1.0), 16000)
+            with self.assertRaisesRegex(ValueError, "voice 'a' has"):
+                attribute_voices(
+                    song_audio(seconds=8.0),
+                    voices={
+                        "a": "asset:voices/a.wav",
+                        "b": [{"start_seconds": 4, "duration_seconds": 4}],
+                    },
+                    lines=[{"start": 0, "end": 4}],
+                    separate=False,
+                )
+
+
+# ---------------------------------------------------------------------------
+# 8. MPS fallback
+# ---------------------------------------------------------------------------
+
+
+class TestSeparationMpsFallback(unittest.TestCase):
+    def test_mps_retries_on_cpu_and_warns(self):
+        from dw.tasks.voice_attribution import separate_vocals
+
+        calls = []
+
+        def fake_run_separator(waveform, sample_rate, device, dtype):
+            calls.append(device)
+            if len(calls) == 1:
+                raise RuntimeError("boom")
+            return tone(1.0, sample_rate=16000)[0], 16000
+
+        with (
+            patch(
+                "dw.tasks.voice_attribution._run_separator",
+                side_effect=fake_run_separator,
+            ),
+            patch("dw.get_device_type", return_value="mps"),
+            patch("dw.tasks.voice_attribution.emit_warning") as mock_emit_warning,
+        ):
+            separate_vocals(tone(1.0, channels=2), 16000, "mps", None)
+
+        self.assertEqual(calls, ["mps", "cpu"])
+        self.assertTrue(
+            any(
+                call.kwargs.get("kind") == "separation_cpu_fallback"
+                for call in mock_emit_warning.call_args_list
+            )
+        )
+
+    def test_non_mps_device_propagates_the_error(self):
+        from dw.tasks.voice_attribution import separate_vocals
+
+        with (
+            patch(
+                "dw.tasks.voice_attribution._run_separator",
+                side_effect=RuntimeError("boom"),
+            ),
+            patch("dw.get_device_type", return_value="cuda"),
+        ):
+            with self.assertRaisesRegex(RuntimeError, "boom"):
+                separate_vocals(tone(1.0, channels=2), 16000, "cuda", None)
+
+
+# ---------------------------------------------------------------------------
+# 9. Missing package
+# ---------------------------------------------------------------------------
+
+
+class TestMissingPackages(unittest.TestCase):
+    def test_missing_demucs_raises_runtime_error_naming_it(self):
+        from dw.tasks.voice_attribution import _load_separator
+
+        with patch.dict(sys.modules, {"demucs": None, "demucs.pretrained": None}):
+            with self.assertRaisesRegex(RuntimeError, "demucs"):
+                _load_separator("cpu", None)
+
+    def test_missing_speechbrain_raises_runtime_error_naming_it(self):
+        from dw.tasks.voice_attribution import _load_embedder
+
+        with patch.dict(
+            sys.modules,
+            {
+                "speechbrain": None,
+                "speechbrain.inference": None,
+                "speechbrain.inference.speaker": None,
+            },
+        ):
+            with self.assertRaisesRegex(RuntimeError, "speechbrain"):
+                _load_embedder("cpu", None)
+
+
+# ---------------------------------------------------------------------------
+# 10. Registration
+# ---------------------------------------------------------------------------
+
+
+class TestRegistration(unittest.TestCase):
+    def test_assessment_is_still_exactly_the_three_probes(self):
+        self.assertEqual(
+            list_tasks()["assessment"],
+            sorted(["analyze_shots", "analyze_seams", "analyze_sync_drift"]),
+        )
+
+    def test_attribute_voices_is_a_command_but_not_an_assessment_probe(self):
+        tasks = list_tasks()
+        self.assertIn("attribute_voices", tasks["commands"])
+        self.assertNotIn("attribute_voices", tasks["assessment"])
+
+    def test_attribute_voices_returns_json_with_no_assessment_flag(self):
+        info = _COMMAND_INFO["attribute_voices"]
+        self.assertEqual(info["returns"], "json")
+        self.assertNotIn("assessment", info)
+
+    def test_argument_schema_lists_the_documented_arguments_only(self):
+        schema = describe_task("attribute_voices")
+        names = {p["name"] for p in schema["parameters"]}
+        for expected in (
+            "audio",
+            "voices",
+            "lines",
+            "windows",
+            "window_seconds",
+            "min_reference_seconds",
+            "separate",
+        ):
+            self.assertIn(expected, names)
+        # The models are fixed - nothing the caller writes reaches a loader
+        self.assertFalse(any("model" in name for name in names))
+
+
+# ---------------------------------------------------------------------------
+# 11. Step validation: result.content_type must be application/json
+# ---------------------------------------------------------------------------
+
+
+class TestStepValidation(unittest.TestCase):
+    def _step(self, content_type):
+        return {
+            "name": "voices",
+            "task": {
+                "command": "attribute_voices",
+                "arguments": {
+                    "audio": "asset:song.wav",
+                    "voices": {"a": "asset:a.wav", "b": "asset:b.wav"},
+                },
+            },
+            "result": {"content_type": content_type},
+        }
+
+    def test_application_json_is_fine(self):
+        definition = {"steps": [self._step("application/json")]}
+        errors = scalar_result_errors(definition, source_indices=[0])
+        self.assertEqual(errors, [])
+
+    def test_a_non_json_content_type_is_refused(self):
+        definition = {"steps": [self._step("text/plain")]}
+        errors = scalar_result_errors(definition, source_indices=[0])
+        self.assertEqual(len(errors), 1)
+        self.assertEqual(errors[0]["path"], "steps[0].result")
+        self.assertIn("application/json", errors[0]["message"])
+        self.assertIn("attribute_voices", errors[0]["message"])
+
+    def test_through_validation_errors_on_a_full_workflow(self):
+        workflow = Workflow(
+            {"id": "attribute", "steps": [self._step("image/png")]},
+            "outputs",
+            None,
+        )
+        errors = workflow.validation_errors()
+        messages = [e["message"] for e in errors if e["path"] == "steps[0].result"]
+        self.assertTrue(messages)
+        self.assertTrue(any("application/json" in m for m in messages))
+
+
+# ---------------------------------------------------------------------------
+# Bounce 1 (#494): a floor relative to the stem, voices checked statically
+# ---------------------------------------------------------------------------
+
+
+class TestRelativeVoicedFloor(unittest.TestCase):
+    """C-F138: an absolute -40 dBFS floor dropped a quiet sung section."""
+
+    def test_a_quiet_section_under_a_loud_one_is_voiced(self):
+        # -20 dBFS and ~-43 dBFS sine sections: the quiet one sat under the
+        # old absolute floor, and is 23 dB under the loud one
+        loud = tone(4.0, amplitude=0.14)
+        quiet = tone(4.0, amplitude=0.01)
+        waveform = numpy.concatenate([quiet, loud, silence(2.0)], axis=1)[0]
+
+        mask, frame, floor = voiced_mask(waveform, 16000)
+
+        quiet_frames = int(4.0 * 16000) // frame
+        self.assertTrue(mask[:quiet_frames].all())
+        self.assertFalse(mask[-(int(2.0 * 16000) // frame) :].any())
+        self.assertLess(floor, -40.0)
+
+    def test_the_floor_follows_the_stem_level(self):
+        loud = numpy.full(100, 0.5)
+        quiet = numpy.full(100, 0.005)
+        self.assertGreater(voiced_floor_dbfs(loud), voiced_floor_dbfs(quiet))
+
+    def test_the_floor_never_drops_below_its_minimum(self):
+        self.assertEqual(voiced_floor_dbfs(numpy.full(100, 1e-7)), -60.0)
+        self.assertEqual(voiced_floor_dbfs(numpy.zeros(0)), -60.0)
+
+    def test_silence_is_never_voiced(self):
+        mask, _, _ = voiced_mask(silence(2.0)[0], 16000)
+        self.assertFalse(mask.any())
+
+
+def _voices_step(voices, **extra):
+    return {
+        "name": "who",
+        "task": {
+            "command": "attribute_voices",
+            "arguments": {"audio": "asset:song.wav", "voices": voices, **extra},
+        },
+        "result": {"content_type": "application/json"},
+    }
+
+
+SPAN = {"start_seconds": 0, "duration_seconds": 4}
+
+
+class TestVoicesErrors(unittest.TestCase):
+    """C-F141: what parse_voices refuses without the audio is refused at
+    validation, at the path the author wrote."""
+
+    def errors(self, *steps, source_indices=None):
+        return voices_errors({"steps": list(steps)}, source_indices)
+
+    def test_a_good_voices_map_is_clean(self):
+        self.assertEqual(self.errors(_voices_step({"a": SPAN, "b": [SPAN]})), [])
+
+    def test_one_voice_is_refused(self):
+        errors = self.errors(_voices_step({"a": SPAN}))
+        self.assertEqual(errors[0]["path"], "steps[0].task.arguments.voices")
+        self.assertIn("at least 2 voices", errors[0]["message"])
+
+    def test_a_bad_name_is_refused(self):
+        errors = self.errors(_voices_step({"1bad": SPAN, "b": SPAN}))
+        self.assertIn("1bad", errors[0]["message"])
+
+    def test_a_short_reference_is_refused_against_the_literal_minimum(self):
+        short = {"start_seconds": 0, "duration_seconds": 2}
+        self.assertTrue(self.errors(_voices_step({"a": short, "b": SPAN})))
+        self.assertEqual(
+            self.errors(_voices_step({"a": short, "b": SPAN}, min_reference_seconds=1)),
+            [],
+        )
+
+    def test_a_span_past_the_end_is_left_to_the_run(self):
+        late = {"start_seconds": 9000, "duration_seconds": 4}
+        self.assertEqual(self.errors(_voices_step({"a": late, "b": SPAN})), [])
+
+    def test_references_are_left_to_the_run(self):
+        self.assertEqual(self.errors(_voices_step("variable:voices")), [])
+        self.assertEqual(
+            self.errors(_voices_step({"a": "asset:a.wav", "b": "asset:b.wav"})), []
+        )
+        held = {"start_seconds": "variable:start", "duration_seconds": 4}
+        self.assertEqual(self.errors(_voices_step({"a": held, "b": SPAN})), [])
+
+    def test_a_member_is_reported_at_its_source_step(self):
+        step = _voices_step({"a": SPAN})
+        step["name"] = "who@verse"
+        errors = self.errors({"name": "x", "task": {}}, step, source_indices=[0, 0])
+        self.assertEqual(errors[0]["path"], "steps[0].task.arguments.voices")
+        self.assertIn("in member 'who@verse'", errors[0]["message"])
+
+    def test_through_validation_errors(self):
+        workflow = Workflow(
+            {"id": "attribute", "steps": [_voices_step({"a": SPAN})]},
+            "outputs",
+            None,
+        )
+        paths = [e["path"] for e in workflow.validation_errors()]
+        self.assertIn("steps[0].task.arguments.voices", paths)
+
+
+class TestVoicePathsAreLocations(unittest.TestCase):
+    """SE-F038: a bare path as a voice is a location like `audio` is, in
+    the posture a server runs on (workflow files untrusted)."""
+
+    def setUp(self):
+        patcher = patch.dict("os.environ", {TRUST_WORKFLOWS_ENV_VAR: "0"})
+        patcher.start()
+        self.addCleanup(patcher.stop)
+
+    def test_an_absolute_voice_path_is_refused(self):
+        definition = {
+            "steps": [
+                _voices_step(
+                    {"a": "/usr/share/sounds/alsa/Front_Center.wav", "b": SPAN}
+                )
+            ]
+        }
+        errors = location_errors(definition, [0], base_dir="/tmp/wf")
+        self.assertEqual(
+            [e["path"] for e in errors], ["steps[0].task.arguments.voices.a"]
+        )
+
+    def test_a_traversing_voice_path_is_refused(self):
+        definition = {
+            "steps": [_voices_step({"a": "../../../../../etc/x.wav", "b": SPAN})]
+        }
+        errors = location_errors(definition, [0], base_dir="/tmp/wf")
+        self.assertEqual(
+            [e["path"] for e in errors], ["steps[0].task.arguments.voices.a"]
+        )
+
+    def test_asset_voices_and_spans_are_not_locations(self):
+        definition = {"steps": [_voices_step({"a": "asset:a.wav", "b": SPAN})]}
+        self.assertEqual(location_errors(definition, [0], base_dir="/tmp/wf"), [])
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_vram_estimate.py b/tests/test_vram_estimate.py
index c19e4f62..e538a084 100644
--- a/tests/test_vram_estimate.py
+++ b/tests/test_vram_estimate.py
@@ -5,9 +5,15 @@
 would have switched the guard off on a Mac entirely, since none match.
 """
 
+import copy
+import tempfile
+from unittest.mock import patch
+
 import pytest
 
-from dw.vram_estimate import apply_vram_estimate, vram_estimate_errors
+import dw.workflow
+from dw.vram_estimate import apply_vram_estimate, reference_count, vram_estimate_errors
+from dw.workflow import workflow_from_definition
 
 
 def definition(extra_cost=()):
@@ -70,3 +76,269 @@ def test_run_time_backstop_takes_the_device_too():
     apply_vram_estimate(d, d["variables"], device_type="mps", capacity_gb=62)
     with pytest.raises(ValueError):
         apply_vram_estimate(d, d["variables"], device_type="mps", capacity_gb=16)
+
+
+# --- Per-step projection over an expanded definition (#479) ---------------
+
+
+def per_step_definition(steps, base_gb=0, gb_per_reference=None, ceiling=24):
+    """A minimal expanded definition for exercising `_projections` directly:
+    one voxel variable `n`, scaled so `n=1` costs exactly 1 GiB, which keeps
+    the arithmetic in each test legible."""
+    estimate = {
+        "voxel_variables": ["n"],
+        "base_gb": base_gb,
+        "bytes_per_voxel": 1024**3,
+    }
+    if gb_per_reference is not None:
+        estimate["gb_per_reference"] = gb_per_reference
+    return {
+        "cost": [{"device": "cuda", "name": "Card", "vram_gb": ceiling, "minutes": 1}],
+        "vram_estimate": estimate,
+        "steps": steps,
+    }
+
+
+def test_step_arguments_override_the_workflow_variables():
+    steps = [{"name": "s1", "pipeline": {"arguments": {"n": 30}}}]
+    d = per_step_definition(steps)
+    d["variables"] = {"n": 5}
+    errors = vram_estimate_errors(d)
+    assert len(errors) == 1
+    assert "n = 30" in errors[0]["message"]
+
+
+def test_a_step_that_omits_the_value_falls_back_to_variables():
+    steps = [{"name": "s1", "pipeline": {"arguments": {}}}]
+    d = per_step_definition(steps)
+    d["variables"] = {"n": 30}
+    errors = vram_estimate_errors(d)
+    assert len(errors) == 1
+    assert "n = 30" in errors[0]["message"]
+
+
+def test_a_task_step_is_not_projected():
+    steps = [{"name": "t1", "task": {"command": "resample_audio", "arguments": {}}}]
+    d = per_step_definition(steps)
+    d["variables"] = {"n": 1000}
+    assert vram_estimate_errors(d) == []
+
+
+def test_a_non_numeric_value_is_skipped_not_erroring():
+    steps = [{"name": "s1", "pipeline": {"arguments": {"n": "not-a-number"}}}]
+    d = per_step_definition(steps, base_gb=100)
+    assert vram_estimate_errors(d) == []
+
+
+def test_reference_counting_skips_null_and_non_dict_entries():
+    references = [
+        {"from_file": "a"},
+        {"from_file": None},
+        None,
+        "not-a-dict",
+        {"from_previous_result": "step.x"},
+    ]
+    assert reference_count({"references": references}) == 2
+
+
+def test_no_gb_per_reference_means_references_add_nothing_to_the_projection():
+    steps = [
+        {
+            "name": "s1",
+            "pipeline": {
+                "arguments": {
+                    "n": 1,
+                    "references": [
+                        {"from_file": "a"},
+                        {"from_file": "b"},
+                        {"from_file": "c"},
+                    ],
+                }
+            },
+        }
+    ]
+    d = per_step_definition(steps, base_gb=0, gb_per_reference=None, ceiling=0.5)
+    errors = vram_estimate_errors(d)
+    assert len(errors) == 1
+    # 1 GB from `n` alone - the 3 references add nothing since gb_per_reference
+    # is not declared, even though the message still names the count.
+    assert "projects to 1.00 GB" in errors[0]["message"]
+
+
+def test_only_the_largest_over_ceiling_step_is_reported_once_per_cost_entry():
+    steps = [
+        {"name": "s1", "pipeline": {"arguments": {"n": 30}}},
+        {"name": "s2", "pipeline": {"arguments": {"n": 50}}},
+    ]
+    d = per_step_definition(steps, base_gb=0)
+    d["cost"] = [
+        {"device": "cuda", "name": "Card A", "vram_gb": 24, "minutes": 1},
+        {"device": "cuda", "name": "Card B", "vram_gb": 40, "minutes": 1},
+    ]
+    errors = vram_estimate_errors(d)
+    assert len(errors) == 2
+    assert all("n = 50" in e["message"] for e in errors)
+    assert not any("n = 30" in e["message"] for e in errors)
+
+
+# --- Per-for_each-member projection through Workflow.validation_errors ----
+
+
+def _reference(name):
+    return {"from_file": f"asset:{name}.png"}
+
+
+def shots_definition():
+    """Two H3-shaped shots: 'a' stays under ceiling at every scenario below,
+    'b' is the one whose num_frames/references/resolution combination is
+    pushed over 24 GB by each test. Constants mirror reference-to-video.json.
+    """
+    return {
+        "id": "shots-vram",
+        "variables": {
+            "width": 960,
+            "height": 544,
+            "shots": [
+                {
+                    "name": "a",
+                    "num_frames": 124,
+                    "references": [_reference("one"), _reference("two")],
+                },
+                {
+                    "name": "b",
+                    "num_frames": 209,
+                    "references": [
+                        _reference("three"),
+                        _reference("four"),
+                        _reference("five"),
+                    ],
+                },
+            ],
+        },
+        "cost": [
+            {"device": "cuda", "name": "RTX 3090", "vram_gb": 24, "minutes": 7.88}
+        ],
+        "vram_estimate": {
+            "base_gb": 16.0,
+            "bytes_per_voxel": 28.71,
+            "gb_per_reference": 1.0,
+            "voxel_variables": ["width", "height", "num_frames"],
+        },
+        "steps": [
+            {
+                "name": "shot",
+                "for_each": "variable:shots",
+                "pipeline": {
+                    "configuration": {"component_type": "ModularPipeline"},
+                    "from_pretrained_arguments": {
+                        "model_name": "MiniMaxAI/MiniMax-H3",
+                        "workflow": "ref2va",
+                    },
+                    "arguments": {
+                        "prompt": "x",
+                        "width": "variable:width",
+                        "height": "variable:height",
+                        "num_frames": "item:num_frames",
+                        "references": "item:references",
+                    },
+                },
+                "result": {"content_type": "video/mp4"},
+            }
+        ],
+    }
+
+
+def _vram_errors(errors):
+    return [e for e in errors if "GB VRAM" in e["message"]]
+
+
+def _build(definition):
+    return workflow_from_definition(definition, tempfile.mkdtemp())
+
+
+def test_for_each_defaults_have_no_vram_errors():
+    with (
+        patch.object(dw.workflow, "get_device_type", return_value="cuda"),
+        patch.object(dw.workflow, "device_capacity_gb", return_value=24.0),
+    ):
+        workflow = _build(shots_definition())
+        assert _vram_errors(workflow.validation_errors()) == []
+
+
+def test_for_each_member_over_ceiling_names_variables_path_when_shots_is_a_default():
+    with (
+        patch.object(dw.workflow, "get_device_type", return_value="cuda"),
+        patch.object(dw.workflow, "device_capacity_gb", return_value=24.0),
+    ):
+        workflow = _build(shots_definition())
+        errors = _vram_errors(
+            workflow.validation_errors(arguments={"width": 1344, "height": 768})
+        )
+        assert len(errors) == 1
+        assert errors[0]["path"] == "variables.shots[1]"
+        assert "shot@b" in errors[0]["message"]
+        assert "with 3 references" in errors[0]["message"]
+
+
+def test_for_each_member_over_ceiling_names_arguments_path_when_shots_is_supplied():
+    with (
+        patch.object(dw.workflow, "get_device_type", return_value="cuda"),
+        patch.object(dw.workflow, "device_capacity_gb", return_value=24.0),
+    ):
+        workflow = _build(shots_definition())
+        shots = copy.deepcopy(shots_definition()["variables"]["shots"])
+        shots[1]["num_frames"] = 500
+        errors = _vram_errors(workflow.validation_errors(arguments={"shots": shots}))
+        assert len(errors) == 1
+        assert errors[0]["path"] == "arguments.shots[1]"
+        assert "shot@b" in errors[0]["message"]
+
+
+def test_nulling_a_reference_brings_a_member_back_under_ceiling():
+    with (
+        patch.object(dw.workflow, "get_device_type", return_value="cuda"),
+        patch.object(dw.workflow, "device_capacity_gb", return_value=24.0),
+    ):
+        d = shots_definition()
+        d["variables"]["shots"][1]["references"][2]["from_file"] = None
+        workflow = _build(d)
+        errors = _vram_errors(
+            workflow.validation_errors(arguments={"width": 1344, "height": 768})
+        )
+        assert errors == []
+
+
+def test_a_literal_for_each_list_names_the_steps_path():
+    with (
+        patch.object(dw.workflow, "get_device_type", return_value="cuda"),
+        patch.object(dw.workflow, "device_capacity_gb", return_value=24.0),
+    ):
+        d = shots_definition()
+        d["steps"][0]["for_each"] = d["variables"].pop("shots")
+        workflow = _build(d)
+        errors = _vram_errors(
+            workflow.validation_errors(arguments={"width": 1344, "height": 768})
+        )
+        assert len(errors) == 1
+        assert errors[0]["path"] == "steps[0].for_each[1]"
+        assert "shot@b" in errors[0]["message"]
+
+
+# --- Run-time backstop -----------------------------------------------------
+
+
+def test_apply_vram_estimate_raises_on_an_expanded_definition():
+    d = per_step_definition(
+        [{"name": "s1", "pipeline": {"arguments": {"n": 30}}}], base_gb=0
+    )
+    with pytest.raises(ValueError):
+        apply_vram_estimate(d, None, device_type="cuda", capacity_gb=24.0)
+
+
+def test_apply_vram_estimate_raises_with_no_variables_block_at_all():
+    d = per_step_definition(
+        [{"name": "s1", "pipeline": {"arguments": {"n": 30}}}], base_gb=0
+    )
+    assert "variables" not in d
+    with pytest.raises(ValueError):
+        apply_vram_estimate(d, variables=None, device_type="cuda", capacity_gb=24.0)
diff --git a/tests/test_vram_inheritance.py b/tests/test_vram_inheritance.py
new file mode 100644
index 00000000..fddc53d1
--- /dev/null
+++ b/tests/test_vram_inheritance.py
@@ -0,0 +1,427 @@
+"""A VRAM ceiling a hand-built workflow inherits from the catalog by pipeline
+identity (#502, stage B of #479): the index, the match, the warning, and the
+agreement between templates that declare one identity.
+
+The serving device is mocked as a 24 GB CUDA card, as in
+test_h3_vram_ceiling.py, since a ceiling is only checked against the device
+actually serving the run.
+"""
+
+import contextlib
+import copy
+import json
+import os
+import tempfile
+from unittest.mock import patch
+
+import pytest
+from fastapi.testclient import TestClient
+
+import dw.workflow
+from dw.server.app import create_app
+from dw.server.jobs import JobManager
+from dw.vram_inheritance import (
+    KIND,
+    build_index,
+    declarations,
+    inherited_vram_warnings,
+    pipeline_identity,
+)
+from dw.workflow import workflow_from_definition
+from dw.workflow_sources import listing, workflow_sources
+from dw.workspace import Workspace
+
+from .test_server import ScriptedWorkerManager, success_script
+
+REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+WORKFLOWS_DIR = os.path.join(REPO_ROOT, "workflows")
+
+H3 = "MiniMaxAI/MiniMax-H3"
+REF2VA = ("ModularPipeline", H3, "ref2va")
+T2VA = ("ModularPipeline", H3, "t2va")
+
+REF2VA_ESTIMATE = {
+    "base_gb": 16.0,
+    "bytes_per_voxel": 28.71,
+    "gb_per_reference": 1.0,
+    "voxel_variables": ["width", "height", "num_frames"],
+    "reason": "the template's own calibration",
+}
+T2VA_ESTIMATE = {
+    "base_gb": 16.3,
+    "bytes_per_voxel": 28.71,
+    "voxel_variables": ["width", "height", "num_frames"],
+}
+CARD = [{"device": "cuda", "name": "RTX 3090", "vram_gb": 24, "minutes": 7.88}]
+
+
+@contextlib.contextmanager
+def cuda_24gb():
+    with (
+        patch.object(dw.workflow, "get_device_type", return_value="cuda"),
+        patch.object(dw.workflow, "device_capacity_gb", return_value=24.0),
+    ):
+        yield
+
+
+def _references(count):
+    return [
+        {
+            "reference_type": "diffusers.modular_pipelines.minimax_h3.MiniMaxH3ImageReference",
+            "from_file": f"https://example.com/reference-{i}.png",
+        }
+        for i in range(count)
+    ]
+
+
+def _h3_step(name, workflow="ref2va", model=H3, num_frames=209, references=3):
+    arguments = {
+        "prompt": "x",
+        "num_frames": num_frames,
+        "width": 1344,
+        "height": 768,
+    }
+    if references is not None:
+        arguments["references"] = _references(references)
+    return {
+        "name": name,
+        "pipeline": {
+            "configuration": {"component_type": "ModularPipeline"},
+            "from_pretrained_arguments": {"model_name": model, "workflow": workflow},
+            "arguments": arguments,
+        },
+        "result": {"content_type": "video/mp4"},
+    }
+
+
+def _template(identity_workflow, estimate, cost=CARD, steps=1):
+    """A synthetic single-identity template declaring an estimate."""
+    definition = {
+        "id": f"template-{identity_workflow}",
+        "vram_estimate": copy.deepcopy(estimate),
+        "steps": [
+            _h3_step(f"shot{i}", workflow=identity_workflow) for i in range(steps)
+        ],
+    }
+    if cost is not None:
+        definition["cost"] = copy.deepcopy(cost)
+    return definition
+
+
+def _catalog():
+    return [
+        ("templates/minimax/reference-to-video", _template("ref2va", REF2VA_ESTIMATE)),
+        ("templates/minimax/video-with-audio", _template("t2va", T2VA_ESTIMATE)),
+    ]
+
+
+def _inline(*steps, **extra):
+    return {"id": "inline-h3", "steps": list(steps), **extra}
+
+
+def _warnings(definition, index=None, arguments=None):
+    with cuda_24gb():
+        workflow = workflow_from_definition(definition, tempfile.mkdtemp())
+        return workflow.inherited_vram_warnings(
+            arguments, build_index(_catalog()) if index is None else index
+        )
+
+
+# --- the index ---------------------------------------------------------------
+
+
+class TestIndex:
+    def test_built_from_a_synthetic_catalog_by_identity(self):
+        index = build_index(_catalog())
+        assert set(index) == {REF2VA, T2VA}
+        assert index[REF2VA]["template"] == "templates/minimax/reference-to-video"
+        assert index[REF2VA]["vram_estimate"]["gb_per_reference"] == 1.0
+        assert index[T2VA]["template"] == "templates/minimax/video-with-audio"
+
+    def test_a_template_with_no_card_is_not_a_source(self):
+        catalog = [("templates/x", _template("ref2va", REF2VA_ESTIMATE, cost=None))]
+        assert build_index(catalog) == {}
+        # ...but its numbers still count for agreement
+        assert [name for _, name, _ in declarations(catalog)] == ["templates/x"]
+
+    def test_a_template_with_no_estimate_is_not_a_source(self):
+        definition = _template("ref2va", REF2VA_ESTIMATE)
+        del definition["vram_estimate"]
+        assert build_index([("templates/x", definition)]) == {}
+
+    def test_a_multi_identity_template_is_not_a_source(self):
+        definition = _template("ref2va", REF2VA_ESTIMATE)
+        definition["steps"].append(
+            {
+                "name": "still",
+                "pipeline": {
+                    "configuration": {"component_type": "ZImagePipeline"},
+                    "from_pretrained_arguments": {"model_name": "Tongyi/Z-Image"},
+                    "arguments": {"prompt": "x"},
+                },
+                "result": {"content_type": "image/png"},
+            }
+        )
+        assert build_index([("templates/x", definition)]) == {}
+
+    def test_the_plainest_template_is_the_named_source(self):
+        catalog = [
+            ("templates/a-chain", _template("ref2va", REF2VA_ESTIMATE, steps=3)),
+            ("templates/z-single", _template("ref2va", REF2VA_ESTIMATE, steps=1)),
+        ]
+        assert build_index(catalog)[REF2VA]["template"] == "templates/z-single"
+        assert (
+            build_index(list(reversed(catalog)))[REF2VA]["template"]
+            == "templates/z-single"
+        )
+
+    def test_identity_resolves_a_template_variable(self):
+        step = _h3_step("shot")
+        step["pipeline"]["from_pretrained_arguments"]["model_name"] = "variable:model"
+        assert pipeline_identity(step, {"model": H3}) == REF2VA
+
+    def test_the_real_catalog_indexes_ref2va_from_reference_to_video(self):
+        index = build_index(_real_catalog())
+        assert index[REF2VA]["template"] == "templates/minimax/reference-to-video"
+
+
+# --- matching ------------------------------------------------------------------
+
+
+class TestMatch:
+    def test_an_inline_ref2va_step_over_the_ceiling_warns(self):
+        warnings = _warnings(_inline(_h3_step("shot", references=3)))
+        assert len(warnings) == 1
+        assert KIND in warnings[0]
+        assert "templates/minimax/reference-to-video" in warnings[0]
+        assert "1344*768*209" in warnings[0]
+        assert "3 references" in warnings[0]
+        assert "above the 24 GB" in warnings[0]
+        assert "offload and quantization" in warnings[0]
+        # The template's calibration story stays in the template
+        assert "the template's own calibration" not in warnings[0]
+
+    def test_under_the_ceiling_nothing(self):
+        assert _warnings(_inline(_h3_step("shot", num_frames=124))) == []
+
+    def test_another_model_gets_nothing(self):
+        step = _h3_step("shot", model="someone/Other-H3-Finetune")
+        assert _warnings(_inline(step)) == []
+
+    def test_another_h3_workflow_gets_its_own_ceiling_not_ref2va(self):
+        # t2va at 1344x768x209 takes no references: 16.3 + 6.19 GB, under 24
+        # - ref2va's per-reference term would have put three on it
+        step = _h3_step("shot", workflow="t2va", references=None)
+        assert _warnings(_inline(step)) == []
+        step = _h3_step("shot", workflow="t2va", num_frames=345, references=None)
+        (warning,) = _warnings(_inline(step))
+        assert "templates/minimax/video-with-audio" in warning
+        assert "reference-to-video" not in warning
+
+    def test_an_identity_the_catalog_does_not_declare_gets_nothing(self):
+        step = _h3_step("shot", workflow="fl2va")
+        assert _warnings(_inline(step)) == []
+
+    def test_its_own_declaration_wins(self):
+        # A lean estimate of its own: judged by that, and nothing inherited
+        lean = {**REF2VA_ESTIMATE, "base_gb": 4.0}
+        definition = _inline(
+            _h3_step("shot", references=3), vram_estimate=lean, cost=CARD
+        )
+        assert _warnings(definition) == []
+        with cuda_24gb():
+            workflow = workflow_from_definition(definition, tempfile.mkdtemp())
+            assert [
+                e for e in workflow.validation_errors() if "GB VRAM" in e["message"]
+            ] == []
+
+    def test_its_own_declaration_refuses_as_stage_a_does(self):
+        definition = _inline(
+            _h3_step("shot", references=3),
+            vram_estimate=REF2VA_ESTIMATE,
+            cost=CARD,
+        )
+        assert _warnings(definition) == []
+        with cuda_24gb():
+            workflow = workflow_from_definition(definition, tempfile.mkdtemp())
+            errors = [
+                e for e in workflow.validation_errors() if "GB VRAM" in e["message"]
+            ]
+        assert len(errors) == 1
+
+    def test_an_inherited_ceiling_never_refuses(self):
+        definition = _inline(_h3_step("shot", references=3))
+        with cuda_24gb():
+            workflow = workflow_from_definition(definition, tempfile.mkdtemp())
+            assert workflow.validation_errors() == []
+
+    def test_for_each_names_the_largest_member(self):
+        step = _h3_step("shot", references=None)
+        arguments = step["pipeline"]["arguments"]
+        arguments["num_frames"] = "item:num_frames"
+        arguments["references"] = "item:references"
+        step["for_each"] = "variable:shots"
+        definition = _inline(
+            step,
+            variables={
+                "shots": [
+                    {"name": "light", "num_frames": 124, "references": _references(1)},
+                    {"name": "heavy", "num_frames": 209, "references": _references(3)},
+                ]
+            },
+        )
+        (warning,) = _warnings(definition)
+        assert warning.startswith("variables.shots[1]:")
+        assert "shot@heavy" in warning
+
+    def test_only_matching_steps_are_projected(self):
+        # A step of another pipeline beside the ref2va step: projected by
+        # neither ceiling, and the ref2va step keeps its own path
+        other = _h3_step("other", model="someone/Other", num_frames=999)
+        warnings = _warnings(_inline(other, _h3_step("shot", references=3)))
+        assert len(warnings) == 1
+        assert "999" not in warnings[0]
+
+    def test_an_empty_index_warns_nothing(self):
+        assert _warnings(_inline(_h3_step("shot")), index={}) == []
+
+    def test_a_definition_that_does_not_expand_warns_nothing(self):
+        step = _h3_step("shot")
+        step["for_each"] = []
+        assert _warnings(_inline(step)) == []
+
+
+def test_the_pure_function_skips_a_declared_estimate():
+    definition = _inline(_h3_step("shot"), vram_estimate=REF2VA_ESTIMATE)
+    assert (
+        inherited_vram_warnings(
+            definition, build_index(_catalog()), device_type="cuda", capacity_gb=24.0
+        )
+        == []
+    )
+
+
+# --- catalog agreement ---------------------------------------------------------
+
+
+def _real_catalog():
+    catalog = []
+    for name, source in listing(workflow_sources(WORKFLOWS_DIR, [])).items():
+        with open(os.path.join(source.root, f"{name}.json")) as file:
+            catalog.append((name, json.load(file)))
+    return catalog
+
+
+# What a ceiling is: the formula and the cards it is checked against. The
+# reason is prose and may differ; the numbers may not
+_ESTIMATE_FIELDS = ("base_gb", "bytes_per_voxel", "gb_per_reference", "voxel_variables")
+
+
+def _numbers(definition):
+    estimate = definition["vram_estimate"]
+    cards = {
+        (entry.get("device"), entry.get("vram_gb"))
+        for entry in definition.get("cost") or []
+    }
+    return tuple(estimate.get(field) for field in _ESTIMATE_FIELDS), cards
+
+
+def disagreements(catalog):
+    """Every identity two templates declare different ceilings for. A
+    template with no card agrees on the formula alone."""
+    seen = {}
+    found = []
+    for identity, name, definition in declarations(catalog):
+        formula, cards = _numbers(definition)
+        if identity not in seen:
+            seen[identity] = (name, formula)
+            continue
+        first, first_formula = seen[identity]
+        if formula != first_formula:
+            found.append((identity, first, name))
+    return found
+
+
+def test_every_template_declaring_one_identity_declares_the_same_numbers():
+    catalog = _real_catalog()
+    assert len(list(declarations(catalog))) > 1
+    assert disagreements(catalog) == []
+
+
+def test_every_card_a_shared_identity_declares_is_the_same_card():
+    by_identity = {}
+    for identity, name, definition in declarations(_real_catalog()):
+        _, cards = _numbers(definition)
+        if cards:
+            by_identity.setdefault(identity, {})[name] = cards
+    for identity, cards in by_identity.items():
+        assert len({frozenset(c) for c in cards.values()}) == 1, (identity, cards)
+
+
+def test_a_disagreement_is_caught():
+    drifted = {**REF2VA_ESTIMATE, "base_gb": 15.0}
+    catalog = [
+        ("templates/a", _template("ref2va", REF2VA_ESTIMATE)),
+        ("templates/b", _template("ref2va", drifted, cost=None)),
+    ]
+    assert disagreements(catalog) == [(REF2VA, "templates/a", "templates/b")]
+
+
+# --- over the server -----------------------------------------------------------
+
+
+@pytest.fixture
+def api(tmp_path):
+    workspace = Workspace(tmp_path / "studio", "flag").ensure()
+    template = os.path.join(workspace.workflows, "templates", "minimax")
+    os.makedirs(template)
+    with open(os.path.join(template, "reference-to-video.json"), "w") as file:
+        json.dump(_template("ref2va", REF2VA_ESTIMATE), file)
+    manager = JobManager(
+        workspace.outputs,
+        worker_manager=ScriptedWorkerManager(success_script),
+        history_path=str(tmp_path / "jobs.sqlite"),
+        workflow_dir=workspace.workflows,
+    )
+    app = create_app(
+        workflow_dir=workspace.workflows,
+        output_dir=workspace.outputs,
+        job_manager=manager,
+        workspace=workspace.root,
+    )
+    with cuda_24gb(), TestClient(app, base_url="http://localhost") as client:
+        yield client
+
+
+def _inherited(warnings):
+    return [w for w in warnings if KIND in w]
+
+
+def test_validate_answers_valid_with_the_inherited_warning(api):
+    answer = api.post(
+        "/api/validate", json={"workflow": _inline(_h3_step("shot", references=3))}
+    ).json()
+    assert answer["valid"] is True, answer
+    (warning,) = _inherited(answer["warnings"])
+    assert "templates/minimax/reference-to-video" in warning
+
+
+def test_validate_under_the_ceiling_answers_no_inherited_warning(api):
+    answer = api.post(
+        "/api/validate", json={"workflow": _inline(_h3_step("shot", num_frames=124))}
+    ).json()
+    assert answer["valid"] is True, answer
+    assert _inherited(answer["warnings"]) == []
+
+
+def test_a_job_over_an_inherited_ceiling_queues_and_carries_the_warning(api):
+    response = api.post(
+        "/api/jobs",
+        json={
+            "workflow": _inline(_h3_step("shot", references=3)),
+            "acknowledged_cost": True,
+        },
+    )
+    assert response.status_code == 201, response.text
+    (warning,) = _inherited(response.json()["warnings"])
+    assert "templates/minimax/reference-to-video" in warning
diff --git a/tests/test_worker_job_peak_rss.py b/tests/test_worker_job_peak_rss.py
new file mode 100644
index 00000000..c1728b96
--- /dev/null
+++ b/tests/test_worker_job_peak_rss.py
@@ -0,0 +1,56 @@
+"""Tests for `_job_scoped_peak_rss_mb`'s running-max behavior (#457).
+
+`host_memory_job_peak_rss_mb` is read by `get_job_events` callers as a
+job-scoped high-water mark; it must never decrease across a job's readings
+even when the process-lifetime peak stops growing and current rss falls
+(post-run cleanup, GC).
+"""
+
+import sys
+import os
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from dw.worker import _job_scoped_peak_rss_mb
+
+
+def test_running_max_holds_when_rss_drops():
+    """Reproduces #457's own repro: a light job run right after a heavy one
+    inherits the heavy job's process-lifetime peak as its baseline, and
+    never grows past it - so every reading falls to the current-rss branch,
+    exactly as job 2's readings in the issue did (host_memory_peak_rss_mb
+    flat at 62192.34 throughout)."""
+    baseline_peak_mb = 62192.34
+    running_max_mb = None
+
+    readings = [
+        {"host_memory_peak_rss_mb": 62192.34, "host_memory_rss_mb": 922.199},
+        {"host_memory_peak_rss_mb": 62192.34, "host_memory_rss_mb": 922.199},
+        {"host_memory_peak_rss_mb": 62192.34, "host_memory_rss_mb": 936.961},
+        {"host_memory_peak_rss_mb": 62192.34, "host_memory_rss_mb": 940.699},
+        {"host_memory_peak_rss_mb": 62192.34, "host_memory_rss_mb": 949.852},
+        # Final reading: post-run cleanup drops current rss well below the
+        # 949.852 max already seen - the running max must hold, not drop.
+        {"host_memory_peak_rss_mb": 62192.34, "host_memory_rss_mb": 932.563},
+    ]
+
+    reported = []
+    for info in readings:
+        running_max_mb = _job_scoped_peak_rss_mb(info, baseline_peak_mb, running_max_mb)
+        reported.append(running_max_mb)
+
+    assert reported == sorted(reported)
+    assert reported[-1] == 949.852
+
+
+def test_running_max_none_baseline_returns_previous_max():
+    assert (
+        _job_scoped_peak_rss_mb({"host_memory_peak_rss_mb": 100.0}, None, 42.0) == 42.0
+    )
+
+
+def test_running_max_first_reading_with_no_growth_uses_current_rss():
+    result = _job_scoped_peak_rss_mb(
+        {"host_memory_peak_rss_mb": 500.0, "host_memory_rss_mb": 123.0}, 500.0, None
+    )
+    assert result == 123.0
diff --git a/ui/CLAUDE.md b/ui/CLAUDE.md
index 47005503..9d360a1f 100644
--- a/ui/CLAUDE.md
+++ b/ui/CLAUDE.md
@@ -12,7 +12,7 @@ and `npx playwright test` (e2e — it starts its own server, so do not have
 Every request is scoped to the selected workspace in one place: `scoped()` in
 `lib/api.ts` reads `workspace.current` and appends `?workspace=`. The route is
 what sets it: `lib/routes.ts` parses `#/ws/<name>/<section>/...`, and
-`router.svelte.ts` calls `applyRouteWorkspace` on every change, so a `ws`
+`lib/router.svelte.ts` calls `applyRouteWorkspace` on every change, so a `ws`
 route names the workspace and a `shared`/`server` route keeps the last one
 named (localStorage `dw-workspace`, which is only ever a fallback). There is
 no picker; the sidebar (`lib/Sidebar.svelte`) is links. A page refetches on a
@@ -102,8 +102,7 @@ I not delete this" has to be answerable at a glance: an `examples` asset is
 read-only and the server answers 403, so the page offers no delete for one at
 all.
 
-"The same UX" is literal, and three things were missing from it until they
-were fixed: the detail popout is `position: sticky; bottom: 1rem` as the
+"The same UX" is literal: the detail popout is `position: sticky; bottom: 1rem` as the
 gallery's is, so it rides the viewport rather than sitting at the end of the
 document where a click above the fold scrolls it out of sight; the bulk
 actions are the gallery's - a checkbox per tile (shift-click spans a range),
@@ -118,11 +117,10 @@ The selection itself is not this page's: `picks.svelte.ts` holds it (a
 under the selection is seen rather than snapshotted), `BulkBar.svelte` is the
 sticky bar and the select-all, and the two rules that have to reach a tile
 the page lays out - `.cellwrap .pick`, `.cellwrap.picked .cell` - are in
-`app.css`. The gallery runs the same three. They were one page's code copied
-into the other first, and the copies had already drifted: the assets page's
-Escape guard knew that `ConfirmDialog` renders `alertdialog` and the
-gallery's did not, so Escape in the gallery's delete confirm closed the
-detail behind it. `dialogOpen()` is that check, once. A bulk action must
+`app.css`. The gallery runs the same three - keep it that way rather than
+copying code between the pages. `dialogOpen()` is the one Escape guard: it
+knows `ConfirmDialog` renders `alertdialog`, so Escape in a delete confirm
+closes the confirm, not the detail behind it. A bulk action must
 never touch what the user cannot see, so `Picks.size` counts only the
 visible selection - the same set `names` hands to an action - and a ticked
 name the filter is hiding is inert until the filter brings it back.
@@ -130,10 +128,7 @@ name the filter is hiding is inert until the filter brings it back.
 The search path is the page's top level and folders sit inside it: one
 section per library, in the order the server resolves them, because which
 library a name lives in is what decides whether it can be deleted, what a
-delete costs, and what it hides. It used to be one mtime-sorted grid with
-an `origin` badge per tile and a library `select` over it - folders then
-cut across libraries, and the select could be left pointing at a library
-that unmounted on the next workspace. A section header carries the label,
+delete costs, and what it hides. A section header carries the label,
 the count, the root it reads and a collapse chevron (persisted under
 `collapsed-asset-libraries`; a filter opens everything, as `FolderGroups`
 does), and an empty library still shows its header, so an empty workspace
diff --git a/workflows/templates/assemble-and-score.json b/workflows/templates/assemble-and-score.json
index 8c711285..b550a86c 100644
--- a/workflows/templates/assemble-and-score.json
+++ b/workflows/templates/assemble-and-score.json
@@ -1,6 +1,6 @@
 {
     "id": "assemble-and-score",
-    "description": "Cuts existing shots into one scored film. It is the pass you re-run while cutting, when re-generating the footage each time would cost GPU hours to change a fade. The shots go straight into concat_videos as hard cuts - nothing is stabilized or rescaled on the way, so a deliberate camera move survives the edit; they must already share one size and frame rate, and the task refuses a set that does not. 'shots' is a list, so a diptych is two entries and a reel is however many the cut needs. The shots' own recorded sound is carried up to the score's sample rate and mixed underneath it, so the room tone of each world survives the edit instead of being replaced by music. Supply the shots and the score as asset: references - 'shot_1.mp4' and friends, uploaded with upload_asset or promoted from a generated run with keep_output. Shots generated independently also drift in loudness - 10 dB between two shots of one scene is ordinary - and no seam control can hide a level jump, because it is either side of the cut rather than at it; 'match_levels' ('rms' for perceived level, 'peak' for the loudest sample) evens the shots out before they are joined, and left null, as it is by default, a wide spread is warned about in the log rather than passing in silence. 'match_levels_dbfs' sets the level match_levels moves every shot to, below its own default; a shot whose gain to that level would clip is held short of it instead, and the run says so rather than leaving the shots still apart after a match. 'audio_bleed_gain_db' ducks 'audio_bleed_ms'' full-scale bleed, left at 0 for no change. 'total_frames' is the length of the cut in frames and 'score' is a separate asset with its own length: the score is sliced to 'total_frames' from 'score_start_frame', and a score that does not reach that far is padded to it with digital silence, which leaves the rest of the film unscored under the shots' own sound (the run says so as a 'slice_past_end' warning, but the film itself sounds plausible). A score must therefore be at least as long as the cut; to stretch a short bed to reach, make a longer one with the 'loop_audio' task first and pass that as 'score'. The world track runs at a constant level through the score's own ending, so a score that decays into silence can sit 20+ dB under it there and be inaudible even though the mix's peak looks healthy; 'world_fade_out_ms', 0 by default, fades the world track out over its last N ms so the score's written ending is what is heard.",
+    "description": "Cuts existing shots into one scored film. It is the pass you re-run while cutting, when re-generating the footage each time would cost GPU hours to change a fade. The shots go straight into concat_videos as hard cuts - nothing is stabilized or rescaled on the way, so a deliberate camera move survives the edit; they must already share one size and frame rate, and the task refuses a set that does not. 'shots' is a list, so a diptych is two entries and a reel is however many the cut needs. The shots' own recorded sound is carried up to the score's sample rate and mixed underneath it, so the room tone of each world survives the edit instead of being replaced by music. Supply the shots and the score as asset: references - 'shot_1.mp4' and friends, uploaded with upload_asset or promoted from a generated run with keep_output. Shots generated independently also drift in loudness - 10 dB between two shots of one scene is ordinary - and no seam control can hide a level jump, because it is either side of the cut rather than at it; 'match_levels' ('rms' for perceived level, 'peak' for the loudest sample) evens the shots out before they are joined, and left null, as it is by default, a wide spread is warned about in the log rather than passing in silence. 'match_levels_dbfs' sets the level match_levels moves every shot to, below its own default; a shot whose gain to that level would clip is held short of it instead, and the run says so rather than leaving the shots still apart after a match. 'audio_bleed_gain_db' ducks 'audio_bleed_ms'' full-scale bleed, left at 0 for no change. 'total_frames' is the length of the cut in frames and 'score' is a separate asset with its own length: the score is sliced to 'total_frames' from 'score_start_frame', and a score that does not reach that far is padded to it with digital silence, which leaves the rest of the film unscored under the shots' own sound (the run says so as a 'slice_past_end' warning, but the film itself sounds plausible). A score must therefore be at least as long as the cut; to stretch a short bed to reach, make a longer one with the 'loop_audio' task first and pass that as 'score'. The world track runs at a constant level through the score's own ending, so a score that decays into silence can sit 20+ dB under it there and be inaudible even though the mix's peak looks healthy; 'world_fade_out_ms', 0 by default, fades the world track out over its last N ms so the score's written ending is what is heard. The final mix is normalized by 'balanced', which always holds the peak at -3 dBFS; 'target_lufs', null by default, additionally gains the mix toward that integrated loudness (BS.1770) before the -3 dBFS ceiling is enforced - gain down succeeds unless the mix itself already peaks above the ceiling, in which case the ceiling pulls it lower still; gaining up past what the peak allows is capped the same way, and either direction a 'target_lufs_capped' warning names which side of the target the result landed on. To match loudness across several cuts of a series, pass the same 'target_lufs' to each: pick it no louder than the quietest cut's own ceiling allows, since gaining a louder cut down to meet it usually works but can still be capped by that cut's own peak. 'limit', false by default, makes -3 dBFS a true-peak ceiling held by a look-ahead limiter instead of a cap on the gain, so 'target_lufs' is reached past a single loud transient (a laugh, a sting) - pass it only when the cut must sit louder than its own peak allows (e.g. -16 for streaming); a 'limiter_heavy' warning means the target is asking for audible squashing and should come down, and past 12 dB of reduction 'target_lufs_capped' fires with 'limited: true'.",
     "cost": [
         {
             "device": "cuda",
@@ -30,7 +30,9 @@
         "total_frames": 360,
         "score_gain": 1.0,
         "world_gain": 1.8,
-        "world_fade_out_ms": 0
+        "world_fade_out_ms": 0,
+        "target_lufs": null,
+        "limit": false
     },
     "steps": [
         {
@@ -115,6 +117,8 @@
                 "arguments": {
                     "audio": "previous_result:mixed",
                     "peak_dbfs": -3.0,
+                    "target_lufs": "variable:target_lufs",
+                    "limit": "variable:limit",
                     "sample_rate": "variable:sample_rate"
                 }
             }
diff --git a/workflows/templates/ltx2/README.md b/workflows/templates/ltx2/README.md
index a0902331..31d483ee 100644
--- a/workflows/templates/ltx2/README.md
+++ b/workflows/templates/ltx2/README.md
@@ -68,5 +68,5 @@ generating far above that bucket weakens the effect.
 
 | Example | What it introduces |
 | ------- | ------------------ |
-| [extend-clip.json](extend-clip.json) | Continuing a clip by conditioning on it in full, both steps sharing one loaded model |
+| [extend-clip.json](extend-clip.json) | Continuing a clip by conditioning on it in full; `clip` extends an existing clip instead of generating one |
 | [chained-segments.json](chained-segments.json) | A chain re-runs the pipeline per segment on the previous last frame and stitches frames and audio back together |
diff --git a/workflows/templates/ltx2/chained-segments.json b/workflows/templates/ltx2/chained-segments.json
index 6cf5f720..35f52314 100644
--- a/workflows/templates/ltx2/chained-segments.json
+++ b/workflows/templates/ltx2/chained-segments.json
@@ -19,6 +19,16 @@
         "seed": null
     },
     "variable_constraints": {
+        "width": {
+            "modulus": 32,
+            "remainder": 0,
+            "reason": "LTX-2.5's pipelines refuse a width not divisible by 32 outright (ValueError, not a silent floor), so it is checked here before the chain's first segment load rather than after it"
+        },
+        "height": {
+            "modulus": 32,
+            "remainder": 0,
+            "reason": "LTX-2.5's pipelines refuse a height not divisible by 32 outright (ValueError, not a silent floor), so it is checked here before the chain's first segment load rather than after it"
+        },
         "num_frames": {
             "modulus": 8,
             "remainder": 1,
diff --git a/workflows/templates/ltx2/diffusion-decode.json b/workflows/templates/ltx2/diffusion-decode.json
index 1e503739..47034382 100644
--- a/workflows/templates/ltx2/diffusion-decode.json
+++ b/workflows/templates/ltx2/diffusion-decode.json
@@ -18,6 +18,16 @@
         "seed": 42
     },
     "variable_constraints": {
+        "width": {
+            "modulus": 32,
+            "remainder": 0,
+            "reason": "The latents step is LTX2Pipeline, which refuses a width not divisible by 32 outright (ValueError, not a silent floor) - checked here before its load rather than after it, even though this template's width/height never reach the diffusion decoder itself"
+        },
+        "height": {
+            "modulus": 32,
+            "remainder": 0,
+            "reason": "The latents step is LTX2Pipeline, which refuses a height not divisible by 32 outright (ValueError, not a silent floor) - checked here before its load rather than after it, even though this template's width/height never reach the diffusion decoder itself"
+        },
         "num_frames": {
             "modulus": 8,
             "remainder": 1,
diff --git a/workflows/templates/ltx2/enhance-prompt.json b/workflows/templates/ltx2/enhance-prompt.json
index 77a15e08..ea2a7f28 100644
--- a/workflows/templates/ltx2/enhance-prompt.json
+++ b/workflows/templates/ltx2/enhance-prompt.json
@@ -19,6 +19,18 @@
         "enhancer_weights_dtype": "{uint4}",
         "seed": null
     },
+    "variable_constraints": {
+        "width": {
+            "modulus": 32,
+            "remainder": 0,
+            "reason": "LTX-2.5's pipelines refuse a width not divisible by 32 outright (ValueError, not a silent floor), so it is checked here before the full pipeline load rather than after it"
+        },
+        "height": {
+            "modulus": 32,
+            "remainder": 0,
+            "reason": "LTX-2.5's pipelines refuse a height not divisible by 32 outright (ValueError, not a silent floor), so it is checked here before the full pipeline load rather than after it"
+        }
+    },
     "seed": "variable:seed",
     "steps": [
         {
diff --git a/workflows/templates/ltx2/extend-clip.json b/workflows/templates/ltx2/extend-clip.json
index 6b8b1d10..c8e89be4 100644
--- a/workflows/templates/ltx2/extend-clip.json
+++ b/workflows/templates/ltx2/extend-clip.json
@@ -1,7 +1,7 @@
 {
     "id": "LTX2Extend",
-    "description": "Continuing a clip rather than restarting one. The opening is generated, then conditioned on in full so the second pass carries its motion and framing forward instead of inferring them from a single frame, with both steps sharing one copy of the loaded model.",
-    "summary": "A longer LTX-2.5 clip: an opening is generated, then continued conditioned on the whole clip, not one frame.",
+    "description": "Continuing a clip rather than restarting one. By default the opening is generated, then conditioned on in full so the second pass carries its motion and framing forward instead of inferring them from a single frame. Passing 'clip' (an 'asset:' or 'output:' reference to a clip already on hand - width, height and 'clip_frames' must match it exactly) skips generating the opening and conditions on that clip instead; the 'opening' step is then unreferenced and elided, so it costs nothing. Each step loads its own copy of the model rather than sharing one, because the opening step it would otherwise share from may be elided.",
+    "summary": "A longer LTX-2.5 clip: an opening is generated or supplied, then continued conditioned on the whole clip.",
     "cost_drivers": ["num_frames", "width", "height"],
     "variables": {
         "transformer_weights_dtype": "{uint4}",
@@ -12,11 +12,22 @@
         "width": 768,
         "height": 448,
         "clip_frames": 121,
+        "clip": "previous_result:opening",
         "num_frames": 241,
         "frame_rate": 24.0,
         "seed": 42
     },
     "variable_constraints": {
+        "width": {
+            "modulus": 32,
+            "remainder": 0,
+            "reason": "LTX-2.5's pipelines refuse a width not divisible by 32 outright (ValueError, not a silent floor), so it is checked here before either step's pipeline load rather than after it"
+        },
+        "height": {
+            "modulus": 32,
+            "remainder": 0,
+            "reason": "LTX-2.5's pipelines refuse a height not divisible by 32 outright (ValueError, not a silent floor), so it is checked here before either step's pipeline load rather than after it"
+        },
         "num_frames": {
             "modulus": 8,
             "remainder": 1,
@@ -28,6 +39,7 @@
     "steps": [
         {
             "name": "opening",
+            "release_pipeline": true,
             "pipeline": {
                 "configuration": {
                     "component_type": "LTX2Pipeline",
@@ -62,15 +74,7 @@
                         "duration_head": {
                             "device": "cuda"
                         }
-                    },
-                    "shared_components": [
-                        "transformer",
-                        "text_encoder",
-                        "connectors",
-                        "vae",
-                        "audio_vae",
-                        "vocoder"
-                    ]
+                    }
                 },
                 "from_pretrained_arguments": {
                     "model_name": "Lightricks/LTX-2.5-Diffusers",
@@ -154,7 +158,7 @@
             "task": {
                 "command": "video_frames",
                 "arguments": {
-                    "video": "previous_result:opening"
+                    "video": "variable:clip"
                 }
             },
             "result": {
@@ -171,14 +175,6 @@
                     "pre_load_modules": [
                         "sdnq"
                     ],
-                    "reused_components": [
-                        "transformer",
-                        "text_encoder",
-                        "connectors",
-                        "vae",
-                        "audio_vae",
-                        "vocoder"
-                    ],
                     "components": {
                         "transformer": {
                             "device": "cuda"
@@ -216,6 +212,56 @@
                     "model_name": "Lightricks/LTX-2.5-Diffusers",
                     "torch_dtype": "torch.bfloat16"
                 },
+                "transformer": {
+                    "configuration": {
+                        "component_type": "LTX2VideoTransformer3DModel",
+                        "preserve_device_placement": true
+                    },
+                    "quantization_config": {
+                        "configuration": {
+                            "config_type": "sdnq.SDNQConfig"
+                        },
+                        "arguments": {
+                            "weights_dtype": "variable:transformer_weights_dtype",
+                            "quantization_device": "cuda",
+                            "return_device": "cuda",
+                            "use_quantized_matmul": true,
+                            "dequantize_fp32": false
+                        }
+                    },
+                    "from_pretrained_arguments": {
+                        "model_name": "Lightricks/LTX-2.5-Diffusers",
+                        "subfolder": "transformer",
+                        "torch_dtype": "torch.bfloat16"
+                    }
+                },
+                "text_encoder": {
+                    "configuration": {
+                        "component_type": "transformers.Gemma4UnifiedForConditionalGeneration",
+                        "preserve_device_placement": true
+                    },
+                    "quantization_config": {
+                        "configuration": {
+                            "config_type": "sdnq.SDNQConfig"
+                        },
+                        "arguments": {
+                            "weights_dtype": "variable:text_encoder_weights_dtype",
+                            "quantization_device": "cuda",
+                            "return_device": "cpu",
+                            "dequantize_fp32": false,
+                            "modules_to_not_convert": [
+                                "embed_vision",
+                                "embed_audio",
+                                "lm_head"
+                            ]
+                        }
+                    },
+                    "from_pretrained_arguments": {
+                        "model_name": "Lightricks/LTX-2.5-Diffusers",
+                        "subfolder": "text_encoder",
+                        "torch_dtype": "torch.bfloat16"
+                    }
+                },
                 "arguments": {
                     "prompt": "variable:continuation_prompt",
                     "negative_prompt": "variable:negative_prompt",
diff --git a/workflows/templates/ltx2/generative-upscale.json b/workflows/templates/ltx2/generative-upscale.json
index 3cbc13e2..9aabf005 100644
--- a/workflows/templates/ltx2/generative-upscale.json
+++ b/workflows/templates/ltx2/generative-upscale.json
@@ -16,6 +16,26 @@
         "seed": 42
     },
     "variable_constraints": {
+        "base_width": {
+            "modulus": 32,
+            "remainder": 0,
+            "reason": "LTX-2.5's pipelines refuse a width not divisible by 32 outright (ValueError, not a silent floor), so it is checked here before the low-resolution stage's load rather than after it"
+        },
+        "base_height": {
+            "modulus": 32,
+            "remainder": 0,
+            "reason": "LTX-2.5's pipelines refuse a height not divisible by 32 outright (ValueError, not a silent floor), so it is checked here before the low-resolution stage's load rather than after it"
+        },
+        "width": {
+            "modulus": 32,
+            "remainder": 0,
+            "reason": "LTX-2.5's pipelines refuse a width not divisible by 32 outright (ValueError, not a silent floor), so it is checked here before the upscale stage's load rather than after it"
+        },
+        "height": {
+            "modulus": 32,
+            "remainder": 0,
+            "reason": "LTX-2.5's pipelines refuse a height not divisible by 32 outright (ValueError, not a silent floor), so it is checked here before the upscale stage's load rather than after it"
+        },
         "num_frames": {
             "modulus": 8,
             "remainder": 1,
diff --git a/workflows/templates/ltx2/image-to-video.json b/workflows/templates/ltx2/image-to-video.json
index 2904c847..083de682 100644
--- a/workflows/templates/ltx2/image-to-video.json
+++ b/workflows/templates/ltx2/image-to-video.json
@@ -17,6 +17,16 @@
         "seed": null
     },
     "variable_constraints": {
+        "width": {
+            "modulus": 32,
+            "remainder": 0,
+            "reason": "LTX-2.5's pipelines refuse a width not divisible by 32 outright (ValueError, not a silent floor), so it is checked here before the pipeline load rather than after it"
+        },
+        "height": {
+            "modulus": 32,
+            "remainder": 0,
+            "reason": "LTX-2.5's pipelines refuse a height not divisible by 32 outright (ValueError, not a silent floor), so it is checked here before the pipeline load rather than after it"
+        },
         "num_frames": {
             "modulus": 8,
             "remainder": 1,
diff --git a/workflows/templates/ltx2/keyframes.json b/workflows/templates/ltx2/keyframes.json
index 40e1e537..2acadee0 100644
--- a/workflows/templates/ltx2/keyframes.json
+++ b/workflows/templates/ltx2/keyframes.json
@@ -18,6 +18,16 @@
         "seed": 42
     },
     "variable_constraints": {
+        "width": {
+            "modulus": 32,
+            "remainder": 0,
+            "reason": "LTX-2.5's pipelines refuse a width not divisible by 32 outright (ValueError, not a silent floor), so it is checked here before the pipeline load rather than after it"
+        },
+        "height": {
+            "modulus": 32,
+            "remainder": 0,
+            "reason": "LTX-2.5's pipelines refuse a height not divisible by 32 outright (ValueError, not a silent floor), so it is checked here before the pipeline load rather than after it"
+        },
         "num_frames": {
             "modulus": 8,
             "remainder": 1,
diff --git a/workflows/templates/ltx2/reference-sheet.json b/workflows/templates/ltx2/reference-sheet.json
index 0824656f..3ef68e93 100644
--- a/workflows/templates/ltx2/reference-sheet.json
+++ b/workflows/templates/ltx2/reference-sheet.json
@@ -22,6 +22,16 @@
         "seed": 42
     },
     "variable_constraints": {
+        "width": {
+            "modulus": 32,
+            "remainder": 0,
+            "reason": "LTX-2.5's pipelines refuse a width not divisible by 32 outright (ValueError, not a silent floor), so it is checked here before the shot step's pipeline load rather than after it"
+        },
+        "height": {
+            "modulus": 32,
+            "remainder": 0,
+            "reason": "LTX-2.5's pipelines refuse a height not divisible by 32 outright (ValueError, not a silent floor), so it is checked here before the shot step's pipeline load rather than after it"
+        },
         "num_frames": {
             "modulus": 8,
             "remainder": 1,
diff --git a/workflows/templates/ltx2/restore-deblur.json b/workflows/templates/ltx2/restore-deblur.json
index 1278d9c7..9ea941af 100644
--- a/workflows/templates/ltx2/restore-deblur.json
+++ b/workflows/templates/ltx2/restore-deblur.json
@@ -21,6 +21,16 @@
         "seed": 42
     },
     "variable_constraints": {
+        "width": {
+            "modulus": 32,
+            "remainder": 0,
+            "reason": "LTX-2.5's pipelines refuse a width not divisible by 32 outright (ValueError, not a silent floor), so it is checked here before the pipeline load rather than after it"
+        },
+        "height": {
+            "modulus": 32,
+            "remainder": 0,
+            "reason": "LTX-2.5's pipelines refuse a height not divisible by 32 outright (ValueError, not a silent floor), so it is checked here before the pipeline load rather than after it"
+        },
         "num_frames": {
             "modulus": 8,
             "remainder": 1,
diff --git a/workflows/templates/ltx2/restore-decompression.json b/workflows/templates/ltx2/restore-decompression.json
index 8fc192f0..8355e5ac 100644
--- a/workflows/templates/ltx2/restore-decompression.json
+++ b/workflows/templates/ltx2/restore-decompression.json
@@ -21,6 +21,16 @@
         "seed": 42
     },
     "variable_constraints": {
+        "width": {
+            "modulus": 32,
+            "remainder": 0,
+            "reason": "LTX-2.5's pipelines refuse a width not divisible by 32 outright (ValueError, not a silent floor), so it is checked here before the pipeline load rather than after it"
+        },
+        "height": {
+            "modulus": 32,
+            "remainder": 0,
+            "reason": "LTX-2.5's pipelines refuse a height not divisible by 32 outright (ValueError, not a silent floor), so it is checked here before the pipeline load rather than after it"
+        },
         "num_frames": {
             "modulus": 8,
             "remainder": 1,
diff --git a/workflows/templates/ltx2/text-to-video.json b/workflows/templates/ltx2/text-to-video.json
index 6e960216..f800559d 100644
--- a/workflows/templates/ltx2/text-to-video.json
+++ b/workflows/templates/ltx2/text-to-video.json
@@ -23,6 +23,16 @@
         "seed": 42
     },
     "variable_constraints": {
+        "width": {
+            "modulus": 32,
+            "remainder": 0,
+            "reason": "LTX-2.5's pipelines refuse a width not divisible by 32 outright (ValueError, not a silent floor), so it is checked here before the pipeline load rather than after it"
+        },
+        "height": {
+            "modulus": 32,
+            "remainder": 0,
+            "reason": "LTX-2.5's pipelines refuse a height not divisible by 32 outright (ValueError, not a silent floor), so it is checked here before the pipeline load rather than after it"
+        },
         "num_frames": {
             "modulus": 8,
             "remainder": 1,
diff --git a/workflows/templates/ltx2/two-stage.json b/workflows/templates/ltx2/two-stage.json
index 0c8c87fa..8e811885 100644
--- a/workflows/templates/ltx2/two-stage.json
+++ b/workflows/templates/ltx2/two-stage.json
@@ -1,7 +1,7 @@
 {
     "id": "LTX2TwoStage",
-    "description": "LTX-2.5's distilled two-stage flow in its three moves: render at half size on the eight distilled sigmas, double the video latents with the latent upsampler, then renoise them and run the three stage-two sigmas at full size through the same pipeline. The soundtrack is generated in the base pass and its latents go through the refine pass with the video, renoised and denoised on the same three sigmas, so the finished clip has the audio the base pass made. Latents pass between the steps directly - nothing is decoded to pixels and re-encoded. The renoise scale 0.909375 is the first value of the library's STAGE_2_DISTILLED_SIGMA_VALUES, which a reference cannot name, so it is written out and a test holds it to the constant. The base pass keeps its pipeline loaded for the refine pass (identical configurations load once); the refine pass releases it. The upsampler borrows the base pass's VAE.",
-    "summary": "LTX-2.5 video with audio at 1536x896: half-size render, 2x latent upsample, three-sigma refine.",
+    "description": "LTX-2.5's distilled two-stage flow in its three moves: render at half size on the eight distilled sigmas, double the video latents with the latent upsampler, then renoise them and run the three stage-two sigmas at full size through the same pipeline. The soundtrack is generated in the base pass and its latents go through the refine pass with the video, renoised and denoised on the same three sigmas, so the finished clip has the audio the base pass made. Latents pass between the steps directly - nothing is decoded to pixels and re-encoded. The renoise scale 0.909375 is the first value of the library's STAGE_2_DISTILLED_SIGMA_VALUES, which a reference cannot name, so it is written out and a test holds it to the constant. The base pass keeps its pipeline loaded for the refine pass (identical configurations load once); the refine pass releases it. The upsampler borrows the base pass's VAE. The finished clip is always exactly 2x `width`/`height`: `upscale` doubles the base latents and `refine` reads its shape off those latents, so there is no separate 'full size' to ask for - the output size is not itself a free choice, only `width`/`height` are. `width` and `height` each have to be divisible by 32 (LTX-2.5's own pipelines refuse otherwise), which makes the delivered size always a multiple of 64. That rules out a 960x544 shot from this template - 544 is not a multiple of 64 - so a two-stage clip cannot be cut into a fixed-size sequence (an H3 episode, for instance) without a resize step downstream.",
+    "summary": "LTX-2.5 video with audio at 2x width/height: half-size render, 2x latent upsample, three-sigma refine.",
     "cost": [
         {
             "device": "cuda",
@@ -10,7 +10,7 @@
             "minutes": 8.2
         }
     ],
-    "cost_drivers": ["num_frames", "width", "height", "full_width", "full_height"],
+    "cost_drivers": ["num_frames", "width", "height"],
     "variables": {
         "transformer_weights_dtype": "{uint4}",
         "text_encoder_weights_dtype": "{int8}",
@@ -18,13 +18,21 @@
         "negative_prompt": "constant:diffusers.pipelines.ltx2.utils.DEFAULT_NEGATIVE_PROMPT",
         "width": 768,
         "height": 448,
-        "full_width": 1536,
-        "full_height": 896,
         "num_frames": 121,
         "frame_rate": 24.0,
         "seed": 42
     },
     "variable_constraints": {
+        "width": {
+            "modulus": 32,
+            "remainder": 0,
+            "reason": "LTX-2.5's pipelines refuse a width not divisible by 32 outright (ValueError, not a silent floor), so it is checked here before the ~80s base-stage load rather than after it"
+        },
+        "height": {
+            "modulus": 32,
+            "remainder": 0,
+            "reason": "LTX-2.5's pipelines refuse a height not divisible by 32 outright (ValueError, not a silent floor), so it is checked here before the ~80s base-stage load rather than after it"
+        },
         "num_frames": {
             "modulus": 8,
             "remainder": 1,
@@ -296,8 +304,8 @@
                     "audio_latents": "previous_result:base.audio",
                     "noise_scale": 0.909375,
                     "sigmas": "constant:diffusers.pipelines.ltx2.utils.STAGE_2_DISTILLED_SIGMA_VALUES",
-                    "width": "variable:full_width",
-                    "height": "variable:full_height",
+                    "width": "variable:width",
+                    "height": "variable:height",
                     "num_frames": "variable:num_frames",
                     "frame_rate": "variable:frame_rate",
                     "guidance_scale": 1.0,
diff --git a/workflows/templates/minimax/README.md b/workflows/templates/minimax/README.md
index e99c8f8e..c6661316 100644
--- a/workflows/templates/minimax/README.md
+++ b/workflows/templates/minimax/README.md
@@ -160,3 +160,55 @@ same clip as an audio reference in each shot, as
 | ------- | ------------------ |
 | [dialogue-short.json](dialogue-short.json) | A five-shot sitcom scene: Z-Image draws the cast, one `for_each` step over a `shots` list generates a shot per entry - its prompt, its references, its length - on one loaded model, and `concat_videos` gathers the episode |
 | [music-video.json](music-video.json) | A music video cut to a generated song, one `shots` list driving both `for_each` groups: `slice_audio` deals each entry its frame-exact piece, the shot lip-syncs to it, and `pair_audio` lays the unbroken track over the finished edit, cut to the length of the edit by `fit: "video"` so the soundtrack follows the list rather than a constant |
+
+## Field notes from a 24-shot musical
+
+A 24-shot Ref2VA short with a Music3 song surfaced six prompting habits, each
+caught only by a human watching the render (2026-09-25/26 field report,
+issue #484):
+
+- **Crowd actions have to fit what the crowd holds.** "The crowd claps while
+  holding candles" rendered three-handed people - a prop and an action that
+  conflict are resolved by adding a limb, not by dropping the prop. State an
+  action the held prop allows.
+- **A direction needs a landmark in the frame.** "The town marches up to the
+  house" put the house behind the camera and read as the crowd walking
+  toward the viewer. A side tracking shot naming the landmark at the top of
+  frame, in the direction of travel, is what held.
+- **Two people in one frame can lip-sync the wrong one.** It appears to
+  follow whichever vocal register opens the line first: a chorus opening on
+  a high ensemble shout before a tenor solo lip-synced onto the female lead
+  standing beside him. Three things that held together: spell the sung
+  lyric itself in `<d>` tags; credit a shouted attack to the crowd rather
+  than leaving it unattributed; frame the singer face-on at medium
+  close-up.
+- **Crowds skew young without an age note.** An Encanto-style "townspeople"
+  prompt rendered mostly children. State the crowd's age range explicitly.
+- **A three-reference shot can open on the reference itself.** About 1 in
+  25 opened on ~1.5 seconds of the reference portraits' own cream backdrop
+  before cutting to the generated scene. Stating in `subject_definitions`
+  that "the portrait's backdrop, pose and framing are not reused" reduced
+  but did not eliminate it - check a shot's first frames before trusting it;
+  an `analyze_shots` probe step for automating that check is #487.
+- **1344x768 is available to Ref2VA, not only to the FL2VA 768p template.**
+  The Ref2VA turbo LoRA's own schedule (shift 12/3) is trained at 960x544,
+  but 960x544 and 1344x768 are both legal canvases under H3's 768-pixel
+  short edge / 768x1344 ceiling (above), and running Ref2VA at 1344x768
+  turned smeared crowd faces crisp in the field report (175 frames, two
+  image references, ~31 minutes on a 3090 - not a measured `cost` entry,
+  one data point). It is a genuine trade-off, not a free upgrade: VAE decode
+  memory scales with `width * height * num_frames` regardless of which
+  transformer partition is denoising, so the same ceiling that OOM'd
+  `video-with-audio-768p` at 1344x768x345 (above) applies to a Ref2VA shot
+  at that canvas - frame count is where to give ground first, well before
+  345. A reference costs VRAM too - about 1 GB each, folded into
+  `reference-to-video.json`'s `vram_estimate` as `gb_per_reference` - so
+  dropping one buys roughly as much headroom as cutting a band of frames
+  (~34, two steps of the `17n+5` grid) at this canvas: at 1344x768 the
+  `17n+5` ceiling on 24 GB runs 243 frames at one reference, 209 at two, 175
+  at three, 141 at four. `validate_workflow` projects every shot of a
+  `for_each` list this way and names the largest one over budget, at that
+  shot's entry, so the refusal says which shot to cut.
+
+Item 7 of the field report - Music3 ignoring a per-section singer
+assignment - is a tool gap, not a prompting habit; see #485.
diff --git a/workflows/templates/minimax/chain-matched-and-aligned.json b/workflows/templates/minimax/chain-matched-and-aligned.json
index a3248930..1f90f80a 100644
--- a/workflows/templates/minimax/chain-matched-and-aligned.json
+++ b/workflows/templates/minimax/chain-matched-and-aligned.json
@@ -9,6 +9,17 @@
         "width",
         "height"
     ],
+    "vram_estimate": {
+        "base_gb": 16.0,
+        "bytes_per_voxel": 28.71,
+        "gb_per_reference": 1.0,
+        "voxel_variables": [
+            "width",
+            "height",
+            "num_frames"
+        ],
+        "reason": "Ref2VA holds every reference's encoding resident beside the video latents, so the ceiling is a fixed base, a per-voxel term for the VAE decode's conv3d activation (width * height * num_frames), and a per-reference term. Classified against the 24 GB entry from the #479 field report (lem, RTX 3090 24 GB, int4 + 768p turbo LoRA, 9 steps, 2026-09-25/26) at 1344x768: 175 frames x 2 refs, 209 x 2 and 175 x 3 ran (projected 22.83, 23.77 and 23.83 GB); 209 x 3 OOM'd in reference encode needing a further 5.1 GB and 260 x 1 OOM'd at denoise step 1 needing a further 4.8 GB (projected 24.77 and 24.18 GB). The refused allocations are lower bounds, not peaks, so this is a classification with about 0.2 GB of margin either side, not a fitted curve. bytes_per_voxel is unchanged from #324's calibration (job 282172105da1); base_gb drops 0.3 GB now the references are counted separately"
+    },
     "variables": {
         "first_segment_prompt": "subject_definitions:\n<Subject 1> is the cartoon astronaut in <Picture 1>, whose face, hair, clothing and proportions define their appearance for the whole video.\n<Audio 1> is the speech track <Subject 1> (S1) is lip-synchronised to: a single continuous recorded voiceover, even in level and unhurried in delivery.\n\nsummary:\n[reference generation + audio reuse] The target video shows <Subject 1> delivering the speech carried by <Audio 1> directly to camera in the setting of <Picture 1>, in one continuous take that runs to the end of the clip without resolving.\n\nretention_analysis:\n<Subject 1> (appears in [Shot 1]): fully_preserved - the face, hair, clothing and proportions of <Picture 1> are kept exactly, with the head, jaw and shoulders newly animated to speak.\n<Audio 1>: partially_copy - the segment of the recording covering this part of the timeline is reused as <Subject 1>'s speech, and the mouth is synchronised to it.\n\ndetailed_description:\nThe target video is in realistic photographic style. [Shot 1] A medium close-up frames <Subject 1> from the chest up, centred and facing camera in the setting of <Picture 1>, held as one continuous shot. The lighting of <Picture 1> is kept exactly as it is, steady and unchanging across the whole clip, and the background sits well behind in shallow focus. <Subject 1> (S1) speaks continuously, the jaw and lips moving in natural synchronisation with <Audio 1> and pausing only where the recording pauses. Between phrases <Subject 1> shifts weight very slightly and the head drifts a few degrees off centre and back, with the eyes staying on the lens and blinking at a natural rate. The camera holds a static shot throughout. The clip ends mid-delivery with <Subject 1> still speaking, the pose, framing and lighting unchanged from the rest of the shot.\n\noverall_soundscape:\nA quiet, close room tone at an even level from the first frame to the last, with no doors, footsteps or movement in the room, and faint clothing rustle as <Subject 1> shifts weight.\n\nnon_diegetic_music:\nN/A",
         "continuation_prompt": "subject_definitions:\n<Subject 1> is the cartoon astronaut in <Picture 1>, whose face, hair, clothing and proportions define their appearance for the whole video.\n<Audio 1> is the speech track <Subject 1> (S1) is lip-synchronised to: a single continuous recorded voiceover, even in level and unhurried in delivery.\n<Video 1> is the tail of the shot immediately preceding this one, and it is the same continuous take: it carries <Subject 1>'s pose, head angle, weight, framing, lighting and speaking rhythm at the moment this clip begins.\n\nsummary:\n[video continuation + reference generation + audio reuse] The target video continues the unbroken take of <Video 1> without a cut, picking up <Subject 1>'s exact pose, framing, lighting and speaking rhythm at the frame <Video 1> ends on, and carrying the delivery of <Audio 1> onward to the end of the clip.\n\nretention_analysis:\n<Subject 1> (appears in [Shot 1]): fully_preserved - the face, hair, clothing and proportions of <Picture 1> are kept exactly, unchanged from <Video 1>.\n<Video 1>: fully_preserved - the pose, head angle, weight distribution, framing, camera position, lighting and speaking rhythm at its final frame are continued directly into the first frame of this clip; none of its frames are reused.\n<Audio 1>: partially_copy - the segment of the recording covering this part of the timeline is reused as <Subject 1>'s speech, and the mouth is synchronised to it.\n\ndetailed_description:\nThe target video is in realistic photographic style. [Shot 1] The same medium close-up as <Video 1>, framing <Subject 1> from the chest up, centred and facing camera in the setting of <Picture 1>, held as one continuous shot. The first frame of this clip continues directly from the last frame of <Video 1>: the head angle, the weight on each foot, the position of the hands, the direction of the gaze and the state of the mouth all carry over without a jump, and the lighting and background are identical and stay unchanged across the whole clip. <Subject 1> (S1) speaks continuously, the jaw and lips moving in natural synchronisation with <Audio 1> and pausing only where the recording pauses, in the same unhurried delivery as <Video 1>. Between phrases <Subject 1> shifts weight very slightly and the head drifts a few degrees off centre and back, with the eyes staying on the lens and blinking at a natural rate. The camera holds the same static shot throughout, with no reframing, no cut and no change in scale. The clip ends mid-delivery with <Subject 1> still speaking, the pose, framing and lighting unchanged.\n\noverall_soundscape:\nA quiet, close room tone identical to <Video 1> and at the same even level from the first frame to the last, with no doors, footsteps or movement in the room, and faint clothing rustle as <Subject 1> shifts weight.\n\nnon_diegetic_music:\nN/A",
diff --git a/workflows/templates/minimax/chain-matched-to-audio.json b/workflows/templates/minimax/chain-matched-to-audio.json
index 64acdb27..cd04d689 100644
--- a/workflows/templates/minimax/chain-matched-to-audio.json
+++ b/workflows/templates/minimax/chain-matched-to-audio.json
@@ -8,6 +8,17 @@
         "width",
         "height"
     ],
+    "vram_estimate": {
+        "base_gb": 16.0,
+        "bytes_per_voxel": 28.71,
+        "gb_per_reference": 1.0,
+        "voxel_variables": [
+            "width",
+            "height",
+            "num_frames"
+        ],
+        "reason": "Ref2VA holds every reference's encoding resident beside the video latents, so the ceiling is a fixed base, a per-voxel term for the VAE decode's conv3d activation (width * height * num_frames), and a per-reference term. Classified against the 24 GB entry from the #479 field report (lem, RTX 3090 24 GB, int4 + 768p turbo LoRA, 9 steps, 2026-09-25/26) at 1344x768: 175 frames x 2 refs, 209 x 2 and 175 x 3 ran (projected 22.83, 23.77 and 23.83 GB); 209 x 3 OOM'd in reference encode needing a further 5.1 GB and 260 x 1 OOM'd at denoise step 1 needing a further 4.8 GB (projected 24.77 and 24.18 GB). The refused allocations are lower bounds, not peaks, so this is a classification with about 0.2 GB of margin either side, not a fitted curve. bytes_per_voxel is unchanged from #324's calibration (job 282172105da1); base_gb drops 0.3 GB now the references are counted separately"
+    },
     "variables": {
         "prompt": "subject_definitions:\n<Subject 1> is the astronaut in <Picture 1>, in a white hard-shell suit with a gold-mirrored visor, an orange chest harness and a soft-sided life-support pack.\n<Audio 1> is the speech track <Subject 1> (S1) is lip-synchronised to: a recorded male voiceover, mid-range in pitch, measured and formal in delivery.\n\nsummary:\n[reference generation + audio reuse] The target video shows <Subject 1> delivering the speech carried by <Audio 1> directly to camera in the setting of <Picture 1>, in one continuous take.\n\nretention_analysis:\n<Subject 1> (appears in [Shot 1]): fully_preserved - the suit, visor, harness and proportions of <Picture 1> are kept exactly, with the head and shoulders newly animated to speak.\n<Audio 1>: partially_copy - the segment of the recording covering this part of the timeline is reused as <Subject 1>'s speech, and his mouth is synchronised to it.\n\ndetailed_description:\nThe target video is in realistic photographic style. [Shot 1] A medium close-up frames <Subject 1> from the chest up, centred and facing camera, in the setting of <Picture 1>, held as one continuous shot. Warm low sunlight rakes across the left of the suit and reflects off the gold visor as a long soft highlight; the background sits well behind in shallow focus. <Subject 1> (S1) speaks continuously in a measured, formal male voice, his jaw and lips moving in natural synchronisation with <Audio 1> behind the open visor, pausing only where the recording pauses. Between phrases he shifts his weight very slightly and his head drifts a few degrees off centre and back, keeping his eyes on the lens. The camera holds a static shot throughout.\n\noverall_soundscape:\nA broad, open outdoor room tone with a steady low wind moving across the microphone. The suit fabric and harness give a dry creak as he shifts his weight, and a faint regulator hiss cycles quietly under the speech from the first frame to the last.\n\nnon_diegetic_music:\nA slow, sparse orchestral bed of sustained low strings under a single held horn note, mixed well beneath the voice at an even level throughout, with no build and no resolution.",
         "subject": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/astronaut.jpg",
diff --git a/workflows/templates/minimax/chain-video-continuity.json b/workflows/templates/minimax/chain-video-continuity.json
index 4fdce8d3..24037624 100644
--- a/workflows/templates/minimax/chain-video-continuity.json
+++ b/workflows/templates/minimax/chain-video-continuity.json
@@ -10,6 +10,17 @@
         "width",
         "height"
     ],
+    "vram_estimate": {
+        "base_gb": 16.0,
+        "bytes_per_voxel": 28.71,
+        "gb_per_reference": 1.0,
+        "voxel_variables": [
+            "width",
+            "height",
+            "num_frames"
+        ],
+        "reason": "Ref2VA holds every reference's encoding resident beside the video latents, so the ceiling is a fixed base, a per-voxel term for the VAE decode's conv3d activation (width * height * num_frames), and a per-reference term. Classified against the 24 GB entry from the #479 field report (lem, RTX 3090 24 GB, int4 + 768p turbo LoRA, 9 steps, 2026-09-25/26) at 1344x768: 175 frames x 2 refs, 209 x 2 and 175 x 3 ran (projected 22.83, 23.77 and 23.83 GB); 209 x 3 OOM'd in reference encode needing a further 5.1 GB and 260 x 1 OOM'd at denoise step 1 needing a further 4.8 GB (projected 24.77 and 24.18 GB). The refused allocations are lower bounds, not peaks, so this is a classification with about 0.2 GB of margin either side, not a fitted curve. bytes_per_voxel is unchanged from #324's calibration (job 282172105da1); base_gb drops 0.3 GB now the references are counted separately"
+    },
     "variables": {
         "prompt": "subject_definitions:\n<Subject 1> is the astronaut in <Picture 1>, in a white hard-shell suit with a gold-mirrored visor, an orange chest harness and a soft-sided life-support pack.\n<Audio 1> is the voice timbre reference for <Subject 1> (S1): a recorded male voiceover, mid-range in pitch, measured and formal in delivery.\n\nsummary:\n[video continuation + reference generation + audio reference] The target video continues an unbroken take of <Subject 1> speaking to camera in the setting of <Picture 1>, picking up from the state, framing and voice of the reference video that precedes it.\n\nretention_analysis:\n<Subject 1> (appears in [Shot 1]): fully_preserved - the suit, visor, harness and proportions of <Picture 1> are kept exactly, with the head and shoulders animated to speak.\n<Audio 1>: reference - only the timbre, pitch and measured delivery of the recorded male voice are referenced for <Subject 1>'s speech; none of its content is reused.\n\ndetailed_description:\nThe target video is in realistic photographic style. [Shot 1] A medium close-up frames <Subject 1> from the chest up, centred and facing camera in the setting of <Picture 1>, held as one continuous take. Warm low sunlight rakes across the left of the suit and reflects off the gold visor as a long soft highlight; the background sits well behind in shallow focus. <Subject 1> (S1) speaks steadily in a measured, formal male voice, his jaw and lips moving in natural synchronisation behind the open visor, pausing only briefly between phrases. Between phrases he shifts his weight very slightly and his head drifts a few degrees off centre and back, keeping his eyes on the lens. The camera holds a static shot throughout, and the pose, framing, lighting and vocal delivery continue without a break from the reference video that precedes this one.\n\noverall_soundscape:\nA broad, open outdoor room tone with a steady low wind moving across the microphone. The suit fabric and harness give a dry creak as he shifts his weight, and a faint regulator hiss cycles quietly under the speech from the first frame to the last, at an even level with no change in the room.\n\nnon_diegetic_music:\nA slow, sparse orchestral bed of sustained low strings under a single held horn note, mixed well beneath the voice at an even level throughout, with no build and no resolution.",
         "subject": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/astronaut.jpg",
diff --git a/workflows/templates/minimax/composable-references.json b/workflows/templates/minimax/composable-references.json
index 364e9484..58ecec94 100644
--- a/workflows/templates/minimax/composable-references.json
+++ b/workflows/templates/minimax/composable-references.json
@@ -9,6 +9,17 @@
         "width",
         "height"
     ],
+    "vram_estimate": {
+        "base_gb": 16.0,
+        "bytes_per_voxel": 28.71,
+        "gb_per_reference": 1.0,
+        "voxel_variables": [
+            "width",
+            "height",
+            "num_frames"
+        ],
+        "reason": "Ref2VA holds every reference's encoding resident beside the video latents, so the ceiling is a fixed base, a per-voxel term for the VAE decode's conv3d activation (width * height * num_frames), and a per-reference term. Classified against the 24 GB entry from the #479 field report (lem, RTX 3090 24 GB, int4 + 768p turbo LoRA, 9 steps, 2026-09-25/26) at 1344x768: 175 frames x 2 refs, 209 x 2 and 175 x 3 ran (projected 22.83, 23.77 and 23.83 GB); 209 x 3 OOM'd in reference encode needing a further 5.1 GB and 260 x 1 OOM'd at denoise step 1 needing a further 4.8 GB (projected 24.77 and 24.18 GB). The refused allocations are lower bounds, not peaks, so this is a classification with about 0.2 GB of margin either side, not a fitted curve. bytes_per_voxel is unchanged from #324's calibration (job 282172105da1); base_gb drops 0.3 GB now the references are counted separately"
+    },
     "variables": {
         "prompt": "subject_definitions:\n<Subject 1> is the astronaut in <Picture 1>, in a white hard-shell suit with a gold-mirrored visor, an orange chest harness and a soft-sided life-support pack.\n<Video 1> is the camera and staging reference for the target video: a wide backlit shot of a lone hiker standing in profile on a rocky outcrop above a layered mountain range at sunset, the sun low behind the ridge, the figure held in near silhouette on the right of frame with the valley falling away to the left.\n\nsummary:\n[reference generation] The target video places <Subject 1> into the shot described by <Video 1>: the astronaut stands in profile on the same clifftop at sunset, framed and lit the way <Video 1> frames and lights its hiker, and speaks one line to the horizon.\n\nretention_analysis:\n<Subject 1> (appears in [Shot 1]): fully_preserved - the suit, visor, harness and proportions of <Picture 1> are kept exactly, with the body newly posed standing in profile and the head newly animated to speak.\n<Video 1>: weak_reference - only its framing, its backlit sunset lighting, its clifftop-and-mountains setting and its slow held camera are referenced; its hiker is replaced by <Subject 1> and none of its frames are reused.\n\ndetailed_description:\nThe target video is in realistic photographic style. [Shot 1] A wide shot frames <Subject 1> standing in profile on a rocky outcrop on the right of frame, facing left toward a layered range of mountains that recedes into haze, exactly the staging of <Video 1>. The sun sits low and just behind the ridge, so the astronaut is held in near silhouette with a hard warm rim running down the back of the suit and a broad flare washing across the gold visor; the valley falls away to the left in bands of shadow and gold. <Subject 1> stands still with his weight on his back foot, then turns his head a few degrees toward the sun. <Subject 1> (S1), a measured, formal male voice, mid-range in pitch, says <d>[English] We have come a long way, and the way ahead is longer still.</d> As the line ends he lifts his chin and holds his gaze on the horizon, one gloved hand settling onto the chest harness. The camera holds a static shot with a very slight drift throughout, matching the held camera of <Video 1>.\n\noverall_soundscape:\nA broad, open, high-altitude room tone with a steady low wind moving across the microphone and gusting once as he turns his head. The suit fabric and harness give a dry creak as his glove meets his chest, and a faint regulator hiss cycles quietly under the dialogue from the first frame to the last.\n\nnon_diegetic_music:\nA slow, sparse orchestral bed of sustained low strings under a single held horn note, mixed well beneath the voice, swelling gently as he turns toward the sun and settling back into stillness at the end of the clip.",
         "subject": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/astronaut.jpg",
diff --git a/workflows/templates/minimax/dialogue-short.json b/workflows/templates/minimax/dialogue-short.json
index 66097a66..91a706d6 100644
--- a/workflows/templates/minimax/dialogue-short.json
+++ b/workflows/templates/minimax/dialogue-short.json
@@ -16,6 +16,17 @@
         "width",
         "height"
     ],
+    "vram_estimate": {
+        "base_gb": 16.0,
+        "bytes_per_voxel": 28.71,
+        "gb_per_reference": 1.0,
+        "voxel_variables": [
+            "width",
+            "height",
+            "num_frames"
+        ],
+        "reason": "Ref2VA holds every reference's encoding resident beside the video latents, so the ceiling is a fixed base, a per-voxel term for the VAE decode's conv3d activation (width * height * num_frames), and a per-reference term. Classified against the 24 GB entry from the #479 field report (lem, RTX 3090 24 GB, int4 + 768p turbo LoRA, 9 steps, 2026-09-25/26) at 1344x768: 175 frames x 2 refs, 209 x 2 and 175 x 3 ran (projected 22.83, 23.77 and 23.83 GB); 209 x 3 OOM'd in reference encode needing a further 5.1 GB and 260 x 1 OOM'd at denoise step 1 needing a further 4.8 GB (projected 24.77 and 24.18 GB). The refused allocations are lower bounds, not peaks, so this is a classification with about 0.2 GB of margin either side, not a fitted curve. bytes_per_voxel is unchanged from #324's calibration (job 282172105da1); base_gb drops 0.3 GB now the references are counted separately"
+    },
     "variables": {
         "character_a_portrait_prompt": "a 3/4-length studio portrait of a wiry man in his early 30s with short curly dark hair and expressive eyebrows, wearing a mustard-yellow sweater vest over a white button-down shirt, standing in a 1990s multi-camera sitcom apartment set with a sagging olive-green couch and a brick wall behind him, warm even studio lighting, sharp focus, photographic",
         "character_b_portrait_prompt": "a 3/4-length studio portrait of a heavyset man in his mid 40s with a shaved head and a calm, heavy-lidded expression, wearing an open gray flannel shirt over a dark t-shirt, standing in a 1990s multi-camera sitcom apartment set with a sagging olive-green couch and a brick wall behind him, warm even studio lighting, sharp focus, photographic",
diff --git a/workflows/templates/minimax/generated-subject-reference.json b/workflows/templates/minimax/generated-subject-reference.json
index 5b2dd238..eb0f93cb 100644
--- a/workflows/templates/minimax/generated-subject-reference.json
+++ b/workflows/templates/minimax/generated-subject-reference.json
@@ -8,6 +8,17 @@
         "width",
         "height"
     ],
+    "vram_estimate": {
+        "base_gb": 16.0,
+        "bytes_per_voxel": 28.71,
+        "gb_per_reference": 1.0,
+        "voxel_variables": [
+            "width",
+            "height",
+            "num_frames"
+        ],
+        "reason": "Ref2VA holds every reference's encoding resident beside the video latents, so the ceiling is a fixed base, a per-voxel term for the VAE decode's conv3d activation (width * height * num_frames), and a per-reference term. Classified against the 24 GB entry from the #479 field report (lem, RTX 3090 24 GB, int4 + 768p turbo LoRA, 9 steps, 2026-09-25/26) at 1344x768: 175 frames x 2 refs, 209 x 2 and 175 x 3 ran (projected 22.83, 23.77 and 23.83 GB); 209 x 3 OOM'd in reference encode needing a further 5.1 GB and 260 x 1 OOM'd at denoise step 1 needing a further 4.8 GB (projected 24.77 and 24.18 GB). The refused allocations are lower bounds, not peaks, so this is a classification with about 0.2 GB of margin either side, not a fitted curve. bytes_per_voxel is unchanged from #324's calibration (job 282172105da1); base_gb drops 0.3 GB now the references are counted separately"
+    },
     "variables": {
         "subject_prompt": "prompt:zimage/deep_sea_diver_portrait",
         "prompt": "subject_definitions:\n<Subject 1> is the deep-sea diver in <Picture 1>, in a heavy canvas suit and a brass helmet with the faceplate open, whose face, helmet, suit and proportions define their appearance for the whole video.\n\nsummary:\n[reference generation] The target video shows <Subject 1> speaking directly to camera in the setting of <Picture 1>, in one continuous take.\n\nretention_analysis:\n<Subject 1> (appears in [Shot 1]): fully_preserved - the face, helmet, suit and proportions of <Picture 1> are kept exactly, with the head, jaw and shoulders newly animated to speak.\n\ndetailed_description:\nThe target video is in realistic photographic style. [Shot 1] A medium close-up frames <Subject 1> from the chest up, centred and facing camera in the setting of <Picture 1>, held as one continuous shot. The lighting of <Picture 1> is kept exactly as it is, the warm rim light steady along the brass of the helmet and the background staying dark and well behind in shallow focus. <Subject 1> (S1), a low and gravelled male voice, unhurried and worn, says <d>[English] Down there the light gives out first. Everything else follows.</d> The jaw and lips move in natural synchronisation with the speech and settle closed at the end of the line. Between phrases <Subject 1> shifts weight very slightly and the head drifts a few degrees off centre and back, with the eyes staying on the lens and blinking at a natural rate. The camera holds a static shot throughout.\n\noverall_soundscape:\nA quiet, close room tone at an even level from the first frame to the last, with a faint creak of canvas as <Subject 1> shifts weight and a single soft knock of a glove against the brass collar.\n\nnon_diegetic_music:\nN/A",
diff --git a/workflows/templates/minimax/music-video.json b/workflows/templates/minimax/music-video.json
index b219a06d..93c9062e 100644
--- a/workflows/templates/minimax/music-video.json
+++ b/workflows/templates/minimax/music-video.json
@@ -17,6 +17,17 @@
         "width",
         "height"
     ],
+    "vram_estimate": {
+        "base_gb": 16.0,
+        "bytes_per_voxel": 28.71,
+        "gb_per_reference": 1.0,
+        "voxel_variables": [
+            "width",
+            "height",
+            "num_frames"
+        ],
+        "reason": "Ref2VA holds every reference's encoding resident beside the video latents, so the ceiling is a fixed base, a per-voxel term for the VAE decode's conv3d activation (width * height * num_frames), and a per-reference term. Classified against the 24 GB entry from the #479 field report (lem, RTX 3090 24 GB, int4 + 768p turbo LoRA, 9 steps, 2026-09-25/26) at 1344x768: 175 frames x 2 refs, 209 x 2 and 175 x 3 ran (projected 22.83, 23.77 and 23.83 GB); 209 x 3 OOM'd in reference encode needing a further 5.1 GB and 260 x 1 OOM'd at denoise step 1 needing a further 4.8 GB (projected 24.77 and 24.18 GB). The refused allocations are lower bounds, not peaks, so this is a classification with about 0.2 GB of margin either side, not a fitted curve. bytes_per_voxel is unchanged from #324's calibration (job 282172105da1); base_gb drops 0.3 GB now the references are counted separately"
+    },
     "variables": {
         "singer_portrait_prompt": "prompt:zimage/otter_singer_portrait",
         "song_prompt": "prompt:minimax/otter_soul_song",
diff --git a/workflows/templates/minimax/reference-to-video.json b/workflows/templates/minimax/reference-to-video.json
index 7a08cee5..2189d97a 100644
--- a/workflows/templates/minimax/reference-to-video.json
+++ b/workflows/templates/minimax/reference-to-video.json
@@ -17,14 +17,15 @@
         "height"
     ],
     "vram_estimate": {
-        "base_gb": 16.3,
+        "base_gb": 16.0,
         "bytes_per_voxel": 28.71,
+        "gb_per_reference": 1.0,
         "voxel_variables": [
             "width",
             "height",
             "num_frames"
         ],
-        "reason": "VAE decode's conv3d activation scales with the voxel count width * height * num_frames; base_gb and bytes_per_voxel are calibrated from two real runs: image-to-video's family baseline at 960x544x124 (on-demand VAE) succeeded at 18.03 GiB peak reserved (docs/WORKFLOW_GUIDE.md), and video-with-audio-768p at 1344x768x345 (the family's own num_frames ceiling) OOM'd mid-denoise needing >=25.82 GiB - 20.25 GiB already allocated plus a refused 5.57 GiB allocation, on a 23.56 GiB card (job 282172105da1, 2026-09-22) - closing the gap #265/#266 left the H3 family with nothing declared to check the engine's vram_estimate machinery against (#324)"
+        "reason": "Ref2VA holds every reference's encoding resident beside the video latents, so the ceiling is a fixed base, a per-voxel term for the VAE decode's conv3d activation (width * height * num_frames), and a per-reference term. Classified against the 24 GB entry from the #479 field report (lem, RTX 3090 24 GB, int4 + 768p turbo LoRA, 9 steps, 2026-09-25/26) at 1344x768: 175 frames x 2 refs, 209 x 2 and 175 x 3 ran (projected 22.83, 23.77 and 23.83 GB); 209 x 3 OOM'd in reference encode needing a further 5.1 GB and 260 x 1 OOM'd at denoise step 1 needing a further 4.8 GB (projected 24.77 and 24.18 GB). The refused allocations are lower bounds, not peaks, so this is a classification with about 0.2 GB of margin either side, not a fitted curve. bytes_per_voxel is unchanged from #324's calibration (job 282172105da1); base_gb drops 0.3 GB now the references are counted separately"
     },
     "variables": {
         "prompt": "subject_definitions:\n<Subject 1> is the astronaut in <Picture 1>, in a white hard-shell suit with a gold-mirrored visor, an orange chest harness and a soft-sided life-support pack.\n<Audio 1> is the voice timbre reference for <Subject 1> (S1): a recorded male voiceover, mid-range in pitch, measured and formal in delivery.\n\nsummary:\n[reference generation + audio reference] The target video shows <Subject 1> speaking directly to camera in the setting of <Picture 1>. The lip and jaw movement is synchronised to the generated dialogue, and the voice timbre references <Audio 1>.\n\nretention_analysis:\n<Subject 1> (appears in [Shot 1]): fully_preserved - the suit, visor, harness and proportions of <Picture 1> are kept exactly, with the head and shoulders newly animated to speak.\n<Audio 1>: reference - only the timbre, pitch and measured delivery of the recorded male voice are referenced for <Subject 1>'s speech; none of its content is reused.\n\ndetailed_description:\nThe target video is in realistic photographic style. [Shot 1] A medium close-up frames <Subject 1> from the chest up, centred and facing camera, in the setting of <Picture 1>. Warm low sunlight rakes across the left of the suit and reflects off the gold visor as a long soft highlight; the background sits well behind in shallow focus. <Subject 1> (S1) speaks in a measured, formal male voice, his jaw and lips moving in natural synchronisation behind the open visor, <d>[English] We have come a long way, and the way ahead is longer still.</d> As he delivers the line he lifts his chin slightly and turns a few degrees toward the light, one gloved hand rising into the lower frame to settle on the chest harness. Exactly as his voice stops his mouth closes and holds, and he looks past the lens toward the horizon. The camera pushes in with small amplitude at slow speed across the whole shot.\n\noverall_soundscape:\nA broad, open outdoor room tone with a steady low wind moving across the microphone. The suit fabric and harness give a dry creak as he turns and as his glove meets his chest, and a faint regulator hiss cycles quietly under the dialogue throughout.\n\nnon_diegetic_music:\nA slow, sparse orchestral bed of sustained low strings under a single held horn note, mixed well beneath the voice, swelling gently as he turns toward the light and settling back into stillness at the end of the clip.",
diff --git a/workflows/templates/minimax/storyboard.json b/workflows/templates/minimax/storyboard.json
index 293e08c6..d72a600d 100644
--- a/workflows/templates/minimax/storyboard.json
+++ b/workflows/templates/minimax/storyboard.json
@@ -16,14 +16,15 @@
         "height"
     ],
     "vram_estimate": {
-        "base_gb": 16.3,
+        "base_gb": 16.0,
         "bytes_per_voxel": 28.71,
+        "gb_per_reference": 1.0,
         "voxel_variables": [
             "width",
             "height",
             "num_frames"
         ],
-        "reason": "VAE decode's conv3d activation scales with the voxel count width * height * num_frames; base_gb and bytes_per_voxel are calibrated from two real runs: image-to-video's family baseline at 960x544x124 (on-demand VAE) succeeded at 18.03 GiB peak reserved (docs/WORKFLOW_GUIDE.md), and video-with-audio-768p at 1344x768x345 (the family's own num_frames ceiling) OOM'd mid-denoise needing >=25.82 GiB - 20.25 GiB already allocated plus a refused 5.57 GiB allocation, on a 23.56 GiB card (job 282172105da1, 2026-09-22) - closing the gap #265/#266 left the H3 family with nothing declared to check the engine's vram_estimate machinery against (#324)"
+        "reason": "Ref2VA holds every reference's encoding resident beside the video latents, so the ceiling is a fixed base, a per-voxel term for the VAE decode's conv3d activation (width * height * num_frames), and a per-reference term. Classified against the 24 GB entry from the #479 field report (lem, RTX 3090 24 GB, int4 + 768p turbo LoRA, 9 steps, 2026-09-25/26) at 1344x768: 175 frames x 2 refs, 209 x 2 and 175 x 3 ran (projected 22.83, 23.77 and 23.83 GB); 209 x 3 OOM'd in reference encode needing a further 5.1 GB and 260 x 1 OOM'd at denoise step 1 needing a further 4.8 GB (projected 24.77 and 24.18 GB). The refused allocations are lower bounds, not peaks, so this is a classification with about 0.2 GB of margin either side, not a fitted curve. bytes_per_voxel is unchanged from #324's calibration (job 282172105da1); base_gb drops 0.3 GB now the references are counted separately"
     },
     "variables": {
         "board_1_launch": "close-up at puddle level on a rain-wet cobblestone street: a child's small hand in a yellow raincoat sleeve setting a folded white paper boat onto a wide rain puddle, raindrops ringing the water, blurred umbrellas and shopfront lights reflected in it, overcast soft daylight, photographic, sharp focus on the boat",
diff --git a/workflows/templates/minimax/voice-timbre-reference.json b/workflows/templates/minimax/voice-timbre-reference.json
index ee3b9483..e23d5ef5 100644
--- a/workflows/templates/minimax/voice-timbre-reference.json
+++ b/workflows/templates/minimax/voice-timbre-reference.json
@@ -8,6 +8,17 @@
         "width",
         "height"
     ],
+    "vram_estimate": {
+        "base_gb": 16.0,
+        "bytes_per_voxel": 28.71,
+        "gb_per_reference": 1.0,
+        "voxel_variables": [
+            "width",
+            "height",
+            "num_frames"
+        ],
+        "reason": "Ref2VA holds every reference's encoding resident beside the video latents, so the ceiling is a fixed base, a per-voxel term for the VAE decode's conv3d activation (width * height * num_frames), and a per-reference term. Classified against the 24 GB entry from the #479 field report (lem, RTX 3090 24 GB, int4 + 768p turbo LoRA, 9 steps, 2026-09-25/26) at 1344x768: 175 frames x 2 refs, 209 x 2 and 175 x 3 ran (projected 22.83, 23.77 and 23.83 GB); 209 x 3 OOM'd in reference encode needing a further 5.1 GB and 260 x 1 OOM'd at denoise step 1 needing a further 4.8 GB (projected 24.77 and 24.18 GB). The refused allocations are lower bounds, not peaks, so this is a classification with about 0.2 GB of margin either side, not a fitted curve. bytes_per_voxel is unchanged from #324's calibration (job 282172105da1); base_gb drops 0.3 GB now the references are counted separately"
+    },
     "variables": {
         "prompt": "subject_definitions:\n<Subject 1> is the astronaut in <Picture 1>, in a white hard-shell suit with a gold-mirrored visor, an orange chest harness and a soft-sided life-support pack.\n<Audio 1> is the voice timbre reference for <Subject 1> (S1): a male voice, mid-range in pitch, measured and formal in delivery.\n\nsummary:\n[reference generation + audio reference] The target video shows <Subject 1> speaking directly to camera in the setting of <Picture 1>. The lip and jaw movement is synchronised to the generated dialogue, and the voice timbre references <Audio 1>.\n\nretention_analysis:\n<Subject 1> (appears in [Shot 1]): fully_preserved - the suit, visor, harness and proportions of <Picture 1> are kept exactly, with the head and shoulders newly animated to speak.\n<Picture 1>: carries no compositional detail - no framing, no shot size, no camera position. Only the appearance of <Subject 1> is taken from it; the framing below is what governs the shot.\n<Audio 1>: reference - only the timbre, pitch and measured delivery of the voice are referenced for <Subject 1>'s speech; none of its content is reused.\n\ndetailed_description:\nThe target video is in realistic photographic style. [Shot 1] A medium close-up frames <Subject 1> from the chest up, centred and facing camera, in the setting of <Picture 1>. Warm low sunlight rakes across the left of the suit and reflects off the gold visor as a long soft highlight; the background sits well behind in shallow focus. <Subject 1> (S1) speaks in a measured, formal male voice, his jaw and lips moving in natural synchronisation behind the open visor, <d>[English] We have come a long way, and the way ahead is longer still.</d> As he delivers the line he lifts his chin slightly and turns a few degrees toward the light, one gloved hand rising into the lower frame to settle on the chest harness. Exactly as his voice stops his mouth closes and holds, and he looks past the lens toward the horizon. The camera pushes in with small amplitude at slow speed across the whole shot.\n\noverall_soundscape:\nA broad, open outdoor room tone with a steady low wind moving across the microphone. The suit fabric and harness give a dry creak as he turns and as his glove meets his chest, and a faint regulator hiss cycles quietly under the dialogue throughout.\n\nnon_diegetic_music:\nA slow, sparse orchestral bed of sustained low strings under a single held horn note, mixed well beneath the voice, swelling gently as he turns toward the light and settling back into stillness at the end of the clip.",
         "subject": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/astronaut.jpg",