diff --git a/CLAUDE.md b/CLAUDE.md
index 470dcea..64084f7 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -73,8 +73,15 @@ unchanged. A job carries its own `output_dir`, `asset_dir` and `workflow_dir`
 (`JobManager.submit`), so it stays in its workspace whatever the manager serves
 next; the worker activates the asset root per job (`activate_asset_dir`), which
 is the one root that could not stay process-wide. `jobs.sqlite` has a
-`workspace` column, backfilled to `default`. Reserved names: `workflows`,
-`prompts`, `assets`, `outputs`.
+`workspace` column, backfilled to `default`. `common/assets` at the root is
+the one asset library every workspace shares - assets are otherwise per
+workspace, which is wrong for a recurring cast a later workspace still has to
+reach. It sits on every workspace's asset search path behind that workspace's
+own library (so a workspace name shadows a shared one), is tagged `origin:
+common` by `GET /api/assets`, and is written to only when a call says so
+(`?shared=true` on uploads, `"shared": true` on keep, `shared=True` over MCP).
+Reserved names: `workflows`, `prompts`, `assets`, `outputs`, `exports`,
+`common`.
 
 ### Workflow sources
 
@@ -207,6 +214,13 @@ same reason - default setup cannot load a pack.
 ## Critical Gotchas
 
 - **Schema validation runs before variable substitution** — variable defaults must match expected JSON types (use `25` not `"25"` for numbers)
+- **`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. A reference spelled by a `variable:` is left
+  alone - what it names is not knowable before substitution
 - **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"`
@@ -214,6 +228,20 @@ same reason - default setup cannot load a pack.
 - **`{}`-escaped strings** in JSON arguments: `"{nf4}"` stays as string `"nf4"`, without braces it would try to load as a type
 - **A stored prompt's `text` may not begin with a reference prefix** (`variable:`, `previous_result:`, `constant:`, `asset:`, `output:`, `prompt:`) — the engine rejects it to prevent double resolution or iteration expansion
 - **Audio+video muxing**: pipelines that generate audio alongside video (LTX-2) have the two muxed into one `video/mp4` file with PyAV in `result.py`
+- **A caller's `arguments` are checked before anything is queued** -
+  `argument_errors` (`dw/variables.py`) folds them into the declared variables
+  exactly as `set_variables` does at the top of a run, so an undeclared name or
+  a value that will not coerce is a 400 from `POST /api/jobs` rather than a
+  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 failed run still reports what it wrote** — the worker carries its partial
+  manifest on the error and cancelled messages as well as on success, and the
+  "Previous result not found" error names the steps that ran even after
+  `release_unreferenced_results` has dropped their results
 - **Run directories**: each execution writes `<output_dir>/<workflow identity>/<run id>/`
   with a `manifest.json` beside its files (`dw/runs.py`, `Workflow.effective_output_dir`).
   Identity is the workflow's path under a `workflows/` tree, else its file name, else its
diff --git a/README.md b/README.md
index 26f9fd9..b84de26 100644
--- a/README.md
+++ b/README.md
@@ -4,12 +4,11 @@
 
 Your GPU, as something an agent can drive.
 
-diffusers-workflow turns the [Hugging Face Diffusers library](https://github.com/huggingface/diffusers)
-into a declarative engine — image and video pipelines described as data rather
-than as Python — and then puts three front ends on it: an **MCP server** so
-Claude Code (or any MCP client) can author, run and inspect generations; a
-**web UI**; and a **CLI/REPL**. The JSON is the wire format underneath. Most
-days you don't write it by hand.
+diffusers-workflow wraps the [Hugging Face Diffusers library](https://github.com/huggingface/diffusers)
+in an engine that runs image, video and audio generation as jobs, and puts
+two front ends on it: an **MCP server**, so Claude Code (or any MCP client)
+can author, run and inspect generations; and a **web UI** for doing the same
+by hand. A CLI and REPL sit underneath for when you want neither.
 
 **Python 3.10-3.14 | CUDA (NVIDIA) | MPS (Apple Silicon) | CPU**
 
@@ -18,51 +17,71 @@ days you don't write it by hand.
   <img alt="The workflow browser: every workflow as a card with its description, output kinds, and variables" src="docs/img/ui-workflows.png">
 </picture>
 
-A workflow file is portable and easy to hand off — but that same flexibility
-means loading one can execute arbitrary Python (dynamic imports are how it
-reaches any diffusers pipeline or quantization backend without a bespoke
-adapter for each). Treat a workflow file from someone else the way you'd treat
-a `.py` script: see [Trust model](docs/SECURITY.md#trust-model) before running
-one you didn't write.
+## Getting started
 
-## Drive it from Claude Code
-
-Two processes: the engine, and the agent that talks to it.
+**1. Install.** The script picks the right torch build for your platform,
+creates a virtual environment and installs everything, MCP server included.
 
 ```bash
-# 1. the engine, holding your workspace. Leave it running.
-python -m dw.serve --workspace ~/studio --examples-dir ~/src/diffusers-workflow/workflows
+# Linux / macOS
+bash ./install.sh
+source ./activate
 
-# 2. register the MCP server with Claude Code (absolute path - see docs/MCP.md)
-claude mcp add dw -- "$(pwd)/venv/bin/dw-mcp"
+# Windows
+.\install.ps1
+.\venv\scripts\activate
 ```
 
-If the GPU is a different machine, start it with `--mcp` and skip the local
-install entirely — Claude Code connects over HTTP:
+`python -m dw.test` confirms torch and diffusers import and shows which
+accelerator was found.
+
+**2. Start the engine.** Leave it running; everything else talks to it.
 
 ```bash
-# on the GPU box
-python -m dw.serve --host 0.0.0.0 --token "$DW_API_TOKEN" --mcp --workspace ~/studio
+dw-serve
+# diffusers-workflow server on http://127.0.0.1:8765
+```
+
+That address is the web UI. Open it and run `templates/text-to-image` — a
+small, ungated model, so the first generation needs no Hugging Face login and
+downloads only a few GB.
 
-# on your laptop
-claude mcp add --transport http dw http://gpu-box:8765/mcp \
-  --header "Authorization: Bearer $DW_API_TOKEN"
+**3. Connect Claude Code.** Register the MCP server with the absolute path to
+`dw-mcp` in the venv you just made (the relative path is the one setup detail
+that reliably goes wrong):
+
+```bash
+claude mcp add dw -- "$(pwd)/venv/bin/dw-mcp"
 ```
 
-The [dw plugin](plugins/dw/README.md) adds one skill per model family - what
-to run for a given shape, the rules that bite, what it costs - and points at
-the vendors' own prompt guides rather than restating them:
+Then, optionally, the [dw plugin](plugins/dw/README.md) — one skill per model
+family that knows which workflow fits a request and the rules that bite:
 
 ```
 /plugin marketplace add dkackman/diffusers-workflow
 /plugin install dw@diffusers-workflow
 ```
 
-You don't have to compose that command by hand — the server's own **Server**
-page builds it from the address you pick, alongside the directories it
-resolved and the workspaces it holds:
+Most of the shipped workflows (Flux, LTX-2, MiniMax...) use **gated** models.
+Request access on the model's Hugging Face page, then `huggingface-cli login`
+once; without it the run fails partway through with a 401/403 from the Hub.
+
+> **GPU on another machine?** Start the engine there with `--mcp` and connect
+> over HTTP — nothing to install on the laptop:
+>
+> ```bash
+> # on the GPU box
+> dw-serve --host 0.0.0.0 --token "$DW_API_TOKEN" --mcp --workspace ~/studio
+>
+> # on your laptop
+> claude mcp add --transport http dw http://gpu-box:8765/mcp \
+>   --header "Authorization: Bearer $DW_API_TOKEN"
+> ```
+>
+> The server's own **Server** page composes that line for the address you
+> pick. End to end: [Remote GPU server](docs/REMOTE.md).
 
-![The Server page: the address picker, the generated claude mcp add line, the resolved directories, and the workspace list](docs/img/ui-server-dark.png)
+## Drive it from an agent
 
 Then just ask. The agent has 50 tools covering the whole surface — the
 workflow catalog, the real diffusers pipeline signatures, the job queue, the
@@ -75,241 +94,105 @@ waiting it out, and reporting what came back:
 
 ![The same session hours later: shots rendering one at a time, roughly 30 minutes each, with the agent reporting progress between them](docs/img/claude-generating.png)
 
-> **What can this box actually run, and what workflows do I already have?**
->
-> Claude calls `get_server_info` (device, version, workspace), `list_workflows`
-> (each with its description, variables and output kinds), and `list_models`
-> (what's already in the hub cache). It tells you the accelerator before it
-> proposes anything CUDA-only.
-
-> **Take my Flux workflow, swap in the portrait LoRA, and render four at 1024
-> square.**
->
-> `get_workflow` to read it, `get_pipeline_signature` to check the arguments
-> actually exist, `validate_workflow` (free — schema *and* signature checking,
-> no model loads), `save_workflow` into your workspace, then `run_workflow`.
-> That last one refuses unless it passes `acknowledged_cost=true`, so the agent
-> has to tell you it's about to spend GPU minutes before it spends them.
-
-> **How's it going?**
->
-> `wait_for_job` blocks for a bounded interval instead of hand-polling;
-> `get_job_events` pages through per-step and per-denoise-step progress.
-> `get_output_image` brings the result back into the conversation, downscaled,
-> so the agent can look at what it made and say whether it matches what you
-> asked for.
-
-> **That third frame is the one. Keep it, and use it to seed the video pass.**
->
-> `keep_output` promotes the file into the asset library under a name you pick
-> — the agent then writes `asset:hero-frame.png` into the next workflow, rather
-> than a run id that pruning would break.
-
-Nothing above needs a shell on the GPU box or a checkout of this repository.
-Six tools that cost real money or real disk (`run_workflow`, `rerun_job`,
-`enhance_prompt`, `download_model`, `delete_model`, `update_diffusers`) plus
-`delete_workspace` refuse until they're explicitly acknowledged, so an agent
-cannot quietly burn an hour of GPU time or delete 40GB of weights.
-
-Full setup, the complete tool reference, and the troubleshooting table:
-[MCP Server](docs/MCP.md). Running it on another machine end to end:
-[Remote GPU server](docs/REMOTE.md).
-
-### Several agents, one GPU
-
-A server holds several **workspaces** — each with its own workflows, assets
-and outputs, sharing one prompt library. An agent calls `use_workspace` once
-and everything it reads and writes for the rest of the session lands there, so
-two agents (or an agent and you, in the browser) share the GPU without saving
-over each other. See [Workspaces](docs/WORKSPACES.md).
-
-## The Web UI
-
-```bash
-python -m dw.serve
-# diffusers-workflow server on http://127.0.0.1:8765
-```
-
-Everything the engine does, in a browser backed by the same persistent GPU
+What a session looks like:
+
+- **"What can this box run, and what do I already have?"** — `get_server_info`
+  for the accelerator and workspace, `list_workflows` for the catalog with each
+  entry's shape, cost and variables, `list_models` for what is already in the
+  hub cache. The agent knows the device before it proposes anything CUDA-only.
+- **"Take my Flux workflow, swap in the portrait LoRA, render four at 1024."**
+  — `get_workflow`, `get_pipeline_signature` to check the arguments exist,
+  `validate_workflow` (free: schema *and* signature checking, no model loads),
+  `save_workflow`, `run_workflow`. That last one refuses until the agent passes
+  `acknowledged_cost=true`, so it has to tell you what it is about to spend.
+- **"How's it going?"** — `wait_for_job` blocks for a bounded interval instead
+  of polling; `get_output_image` brings the result back into the conversation
+  so the agent can look at what it made.
+- **"That third frame is the one — keep it and seed the video pass from it."**
+  — `keep_output` promotes the file into the asset library under a name you
+  pick, and the next workflow references `asset:hero-frame.png`.
+
+Everything that costs real GPU time or real disk (`run_workflow`, `rerun_job`,
+`enhance_prompt`, `download_model`, `delete_model`, `update_diffusers`,
+`delete_workspace`) refuses until it is explicitly acknowledged, so an agent
+cannot quietly burn an hour of GPU or delete 40GB of weights.
+
+One server holds several **workspaces** — each with its own workflows, assets
+and outputs — so two agents, or an agent and you in the browser, share the GPU
+without saving over each other. An agent calls `use_workspace` once and the
+rest of the session lands there.
+
+The complete tool reference, client configuration for other MCP hosts, and the
+troubleshooting table: [MCP Server](docs/MCP.md). Workspaces in depth:
+[Workspaces](docs/WORKSPACES.md).
+
+## The web UI
+
+Everything the engine does, in a browser, backed by the same persistent GPU
 worker — models stay loaded between runs.
 
-**A form-based editor with the real pipeline signatures.** Forms and argument
+**An editor built from the real pipeline signatures.** Forms and argument
 autocomplete are generated by introspecting diffusers itself, so every knob a
-pipeline exposes is available — with its documentation — without leaving the
-browser. A split view puts the JSON beside the form, both editable; validation
-catches schema errors *and* argument typos (by checking the pipeline's actual
-call signature) before any model loads. A flow view draws the workflow's
-data-flow graph.
+pipeline exposes is there with its documentation. Validation catches schema
+errors *and* argument typos before any model loads.
 
 ![The editor: introspection-driven forms beside live JSON in Monaco](docs/img/ui-editor.png)
 
-**A gallery where every image is a recipe.** Each run gets its own directory
-with a `manifest.json` beside its files, and images carry their full workflow
-definition and seed; *open as workflow* drops the definition into the editor
-with the seed pinned, ready to reproduce or riff on. *Keep as asset* promotes a
-generated file into the asset library so later workflows can rely on it.
+**A gallery where every image is a recipe.** Outputs carry their full workflow
+and seed; *open as workflow* drops any image back into the editor, ready to
+reproduce or riff on. *Keep as asset* promotes a generated file into the asset
+library for later workflows to build on.
 
 ![The gallery with generated images and videos](docs/img/ui-gallery.jpg)
 
-**A prompt library shared by every workflow.** Store a prompt once, reference
-it anywhere as `prompt:name` — the Prompts page browses, edits, and filters the
-library, and an *Enhance with AI* panel expands an idea into a full prompt with
-a local language model.
-
-**A model manager for the disk your models actually consume.** The Hugging Face
-hub cache, inventoried: sizes, revisions, last-used dates, free space — download
-new models by id with live progress, delete with one click.
+**A prompt library** stores a prompt once and lets any workflow reference it,
+with an *Enhance with AI* panel that expands an idea into a full prompt using
+a local language model. **A model manager** inventories the Hugging Face hub
+cache — sizes, last use, free space — and downloads or deletes models with
+live progress.
 
 ![The model manager listing cached models with sizes](docs/img/ui-models.png)
 
-Jobs queue, stream progress live (per denoising step), cancel cooperatively,
-and persist to a searchable history. See [Server & Web UI](docs/SERVER.md) for
-the pages and the HTTP API.
+Jobs queue, stream progress live per denoising step, cancel cooperatively and
+persist to a searchable history. See [Server & Web UI](docs/SERVER.md) for the
+pages and the HTTP API.
 
 ## The command line
 
-The engine runs standalone, with no server involved.
-`workflows/templates/text-to-image.json` is the smallest starting point — a small, ungated model
-and a literal prompt, so the first run needs no Hugging Face login and
-downloads only a few GB:
+The engine also runs standalone, with no server involved:
 
 ```bash
 python -m dw.run workflows/templates/text-to-image.json
 python -m dw.run workflows/templates/text-to-image.json prompt="a cat" num_images_per_prompt=4
-python -m dw.validate workflows/templates/text-to-image.json
-```
-
-Most of the workflows under `workflows/` (Flux, LTX-2, MiniMax...) use **gated**
-Hugging Face models — the repo owner has to approve your account first. Request
-access on the model's page (e.g. [black-forest-labs/FLUX.1-dev](https://huggingface.co/black-forest-labs/FLUX.1-dev)),
-then:
-
-```bash
-huggingface-cli login
-python -m dw.run workflows/models/flux-dev.json
-```
-
-Without this, the run fails partway through with an HTTP 401/403 from the Hub.
-
-An interactive REPL keeps models resident between runs for 2-4x faster
-iteration:
-
-```text
-dw> workflow load models/flux-dev
-dw> arg set prompt="a beautiful sunset"
-dw> workflow run
-[... models load once ...]
-
-dw> arg set prompt="a starry night"
-dw> workflow run
-Reusing loaded models from cache
-[... 2-4x faster ...]
-```
-
-See [REPL Commands](docs/REPL_COMMANDS.md) and [Worker Guide](docs/REPL_WORKER_GUIDE.md).
-
-## Installation
-
-### Linux / macOS
-
-```bash
-bash ./install.sh
-source ./activate
-python -m dw.test
-```
-
-### Windows
-
-```powershell
-.\install.ps1
-.\venv\scripts\activate
-python -m dw.test
-```
-
-The install scripts detect your Python version, create a virtual environment,
-and install all dependencies including platform-specific packages (bitsandbytes
-on CUDA, fp4-fp8-for-torch-mps on macOS).
-
-## What a workflow is
-
-Underneath every front end is one JSON document: named steps, each a diffusers
-pipeline or a utility task, with arguments that can reference variables,
-earlier steps' outputs, stored prompts, assets, and files an earlier run wrote.
-
-```json
-{
-    "id": "flux_example",
-    "variables": { "prompt": "an apple" },
-    "steps": [
-        {
-            "name": "main",
-            "pipeline": {
-                "configuration": { "component_type": "FluxPipeline", "offload": "sequential" },
-                "from_pretrained_arguments": {
-                    "model_name": "black-forest-labs/FLUX.1-dev",
-                    "torch_dtype": "torch.bfloat16"
-                },
-                "arguments": {
-                    "prompt": "variable:prompt",
-                    "num_inference_steps": 25,
-                    "guidance_scale": 3.5
-                }
-            },
-            "result": { "content_type": "image/jpeg" }
-        }
-    ]
-}
+python -m dw.validate workflows/models/flux-dev.json
 ```
 
-Arguments carry references rather than paths, which is what makes multi-stage
-work composable:
-
-| Reference | Resolves to |
-| --- | --- |
-| `variable:prompt` | A workflow variable, overridable from the CLI, the UI form, or a tool call |
-| `previous_result:step_name` | An earlier step's output — this is how text-to-image chains into image-to-video |
-| `prompt:folder/name` | The text of a stored prompt in the shared prompt library |
-| `asset:iris.png` | A file in the workspace's input-media library |
-| `output:ltx2/Gyre/latest/still.png` | A file an earlier run wrote, `latest` picking the newest run that holds it |
-| `constant:...` | A value declared in Python rather than copied into JSON |
-
-The full structure — steps, tasks, offloading, quantization, LoRAs,
-schedulers, chained video — is in the [Workflow Guide](docs/WORKFLOW_GUIDE.md).
-The schema the server validates against is browsable
-[here](https://json-schema.app/view/%23?url=https%3A%2F%2Fraw.githubusercontent.com%2Fdkackman%2Fdiffusers-workflow%2Frefs%2Fheads%2Fmaster%2Fdw%2Fworkflow_schema.json),
-and [workflows/](workflows/) is a corpus of runnable examples.
-
-## Features
-
-- **MCP server** — 50 tools letting an agent author, validate, save, run,
-  watch and inspect generations against a running server, locally or over the
-  network, with a cost gate on everything that spends GPU time or disk
-- **Web UI** — browse and run workflows, edit them in introspection-driven
-  forms, watch jobs stream live progress, manage output and models
-- **Workspaces** — your workflows, prompts, assets and outputs live outside the
-  checkout; one server can hold several, so several agents don't collide
-- **Reproducible by construction** — each run writes its own directory with a
-  manifest; outputs embed their full workflow definition and seed, and any
-  image in the gallery reopens as the exact workflow that made it
-- **Step-output caching** — a step whose resolved arguments and seed are
-  unchanged reuses its cached result instead of re-executing, so re-running a
-  fixed-seed workflow finishes instantly and writes no new files
-- **Multi-step pipelines** — chain text-to-image, image-to-video, inpainting,
-  ControlNet; compose workflows from other workflows with `builtin:`
-- **Long-video chaining** — run a video pipeline once per segment and stitch
-  the segments into one clip, with audio-driven length and frame-to-frame
-  continuity
-- **Quantization** — BitsAndBytes, TorchAO, GGUF, SDNQ, optimum-quanto
-- **Inference acceleration** — TeaCache, FirstBlockCache, FasterCache,
-  MagCache, TaylorSeerCache
-- **Prompt weighting** — A1111-style `(word:1.5)` syntax with long prompt support
-- **Prompt library** — store a prompt once, reference it from any workflow,
-  with a UI for browsing, editing and AI-enhancing
-- **LoRA and IP-Adapter** support
-- **Utility tasks** — upscaling, face restoration, segmentation, captioning,
-  frame interpolation, QR codes, and more
-- **Interactive REPL** with persistent GPU model caching
-- **Cross-platform** — CUDA, MPS (Apple Silicon), and CPU
+An interactive REPL (`python -m dw.repl`) keeps models resident between runs
+for 2-4x faster iteration. See [REPL Commands](docs/REPL_COMMANDS.md).
+
+## What's underneath
+
+Every front end reads and writes the same thing: a JSON document of named
+steps, each a diffusers pipeline or a utility task, whose arguments reference
+variables, earlier steps' outputs, stored prompts and assets rather than
+hard-coded values. That is what makes text-to-image chain into image-to-video,
+and what makes a generated image reopen as the exact recipe that produced it.
+[workflows/](workflows/) is a corpus of runnable examples across model
+families; the [Workflow Guide](docs/WORKFLOW_GUIDE.md) is the reference when
+you do want to write one.
+
+Because a workflow reaches any diffusers pipeline or quantization backend by
+dynamic import, loading one can execute arbitrary Python. Treat a workflow
+file from someone else the way you'd treat a `.py` script — see
+[Trust model](docs/SECURITY.md#trust-model).
+
+Under the hood the engine also handles: quantization (BitsAndBytes, TorchAO,
+GGUF, SDNQ, optimum-quanto); inference acceleration (TeaCache,
+FirstBlockCache, FasterCache, MagCache, TaylorSeerCache); LoRA and IP-Adapter;
+A1111-style prompt weighting; long-video chaining with audio-driven length;
+step-output caching, so re-running a fixed-seed workflow finishes instantly;
+and utility tasks for upscaling, face restoration, segmentation, captioning,
+frame interpolation and more.
 
 ## Documentation
 
diff --git a/docs/MCP.md b/docs/MCP.md
index fb9946b..8b7cc31 100644
--- a/docs/MCP.md
+++ b/docs/MCP.md
@@ -213,7 +213,7 @@ when no single workflow covers it.
 | `list_guides()` | — | List the documentation the engine serves: each guide's name, what it covers, and its section headings. The index is the routing table - match a request's shape against a heading rather than guessing |
 | `get_guide(name, section=None)` | `name`, `section` | Get one guide whole, or one section of it. Prefer a section: a guide runs to thousands of lines. Section names match loosely, so a heading copied approximately still resolves |
 | `list_workflows(shape=None, traits=None, configures=None, include_models=False)` | `shape`, `traits`, `configures`, `include_models` | List stored workflows. Always the server's compact view: each entry carries `summary`, `shape`, `traits`, `cost`, `kinds`, `variable_names`, and `configures` only when set - `get_workflow` has the full description and definition. `shape` keeps one of `image`, `image-set`, `image-edit`, `shot`, `sequence`, `audio`, `text`, `utility`; `traits` is comma-separated and every one listed must match (`has-audio`, `chained`, `image-conditioned`, `identity-referenced`, `needs-input-media`, `composes-workflows`); an unknown value in either is a 400 listing the vocabulary. Templates only by default - `configures=<template>` lists the checkpoint configs tuned for one, `include_models=true` lists them all. The first call to make for a request an existing workflow might cover |
-| `get_workflow(name)` | `name` | Get one stored workflow's full JSON definition |
+| `get_workflow(name, variables_only=False)` | `name` | Get one stored workflow's full JSON definition. `variables_only=true` answers with just its variables and their defaults (long strings cut to 200 characters, the cut ones named in `truncated`) — the cheap way to confirm what a variable defaults to |
 | `get_schema()` | — | Get the JSON schema every workflow definition must satisfy |
 | `list_pipelines()` | — | List every diffusers pipeline class this installation provides |
 | `get_pipeline_signature(name)` | `name` | Get a pipeline's real call arguments |
@@ -225,9 +225,9 @@ when no single workflow covers it.
 | `get_memory()` | — | Get the worker's VRAM and RAM statistics |
 | `get_health()` | — | Check that the server is alive, and which machine answered: `version`, `device`, whether the worker process is up, the job running now and the queue depth |
 | `get_server_info()` | — | What this installation can do and where it keeps things: `device` (the accelerator a run will use), `version`, the `workspace` this session is working in and the workflow/asset/output/prompt `directories` of *that* workspace, the bind address and port, whether a token is required, and whether MCP is mounted. Check the device before authoring - a CUDA-only choice (bitsandbytes, `torch.compile`, flash attention) is not available on an `mps` or `cpu` server |
-| `list_jobs()` | — | List queued, running and recent jobs. In a named workspace, that workspace's jobs; in the default one, every job the server holds |
+| `list_jobs(limit=20, status=None, workspace=None)` | optional `limit` (newest N), `status` (one state or a comma-separated set of `queued`, `running`, `succeeded`, `failed`, `cancelled`), `workspace` | List queued, running and recent jobs, **newest first**. Bounded by default: the unbounded listing was over a client's tool-result limit on a server with a few months of history, which made it a tool that could not be called at all. `total` says how many matched and `truncated`/`next` say so when the answer was cut - raise `limit` or narrow with `status`. Without `workspace`, a named workspace lists its own jobs and the default one lists every job the server holds |
 | `list_gallery(limit=50)` | `limit` | List generated output files, newest first. A name is `<workflow>/<run id>/<file>`; each entry also carries a ready-made `url`, already scoped to the workspace that made it - a hand-built `/outputs/<name>` URL 404s for anything but the default workspace |
-| `get_gallery_metadata(name)` | `name` | Get the metadata embedded in a generated file: the exact workflow and arguments that produced it, and, for audio/video, a `media` block (duration, rate, channels, fps, size, peak/mean dBFS) |
+| `get_gallery_metadata(name, envelope=False)` | `name` | Get the metadata embedded in a generated file: the exact workflow and arguments that produced it, and, for audio/video, a `media` block (duration, rate, channels, fps, size, peak/mean dBFS). `envelope=true` adds `media.envelope` — `rms_dbfs` and `peak_dbfs` one entry per second — which is what locates something in a track rather than measuring the whole of it |
 
 ### Media
 
@@ -249,14 +249,15 @@ The session starts in `default` and stays there unless it is told otherwise.
 
 | Tool | Arguments | Purpose |
 | --- | --- | --- |
-| `validate_workflow(workflow=None, name=None, workspace=None)` | exactly one of `workflow` (inline definition) or `name` (a stored workflow, as `list_workflows` reports it), optional `workspace` | Check a workflow against the schema and against real pipeline signatures. Free and instant. Validating by name uses the workflow file's own directory as the base directory, so it sees what a run would. Returns every schema violation in `errors`, each with the JSON path it sits at, so a draft is fixed in one pass. `workspace` names the workspace for this one call without switching the session to it - use it to pin a job whose `output:` or `asset:` references live in a workspace other than the session's |
+| `validate_workflow(workflow=None, name=None, workspace=None, arguments=None)` | exactly one of `workflow` (inline definition) or `name` (a stored workflow, as `list_workflows` reports it), optional `workspace`, optional `arguments` | Check a workflow against the schema and against real pipeline signatures. Free and instant. Validating by name uses the workflow file's own directory as the base directory, so it sees what a run would. Returns every schema violation in `errors`, each with the JSON path it sits at, so a draft is fixed in one pass, and a `previous_result:` that names no earlier step is one of them. `workspace` names the workspace for this one call without switching the session to it - use it to pin a job whose `output:` or `asset:` references live in a workspace other than the session's. Pass the same `arguments` you will pass to `run_workflow` and they are checked too - an undeclared or renamed variable name, a value that will not coerce to the declared type, and an `asset:`, `prompt:` or `output:` reference that names nothing this workspace can reach, each reported at `arguments.<name>`. `checked_arguments` lists what was covered, so a `valid: true` about the stored defaults cannot be mistaken for one about your values. `run_workflow` makes the same check and refuses a bad argument rather than queuing a job that fails on its first step |
 | `list_workspaces()` | — | The server's workspaces and which one this session is using. Each has its own workflows, assets and outputs; the prompt library is shared by all of them |
 | `use_workspace(name)` | `name` | Work in that workspace for the rest of the session - every later call reads and writes there. This is how to keep your work out of another agent's namespace rather than sharing the default one. Checked against the server, so a typo fails here rather than scoping every later call to nothing |
 | `create_workspace(name, use=False)` | `name`, `use` | Create a workspace. Pass use=true to switch this session to it as well; otherwise the session stays where it was and the result says so |
 | `delete_workspace(name, acknowledged_cost=False)` | `name`, `acknowledged_cost` | Permanently delete a workspace and everything in it. Refuses without the acknowledgement, reporting what it would remove |
 | `list_assets()` | — | 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 |
-| `keep_output(name, asset_name=None, overwrite=False)` | `name`, optional `asset_name`, `overwrite` | Keep a generated file as an input asset under a stable `asset:` name, so a later workflow can rely on it. The copy happens on the server: nothing is downloaded or re-uploaded |
-| `upload_asset(file_path)` | `file_path` | Push a local image, video or audio file into the server's asset library and get back its `asset:` reference. The file is read from the machine the MCP server runs on, so this is how an input reaches a dw.serve running somewhere else |
+| `keep_output(name, asset_name=None, overwrite=False, shared=False)` | `name`, optional `asset_name`, `overwrite`, `shared` | Keep a generated file as an input asset under a stable `asset:` name, so a later workflow can rely on it. The copy happens on the server: nothing is downloaded or re-uploaded. `asset_name` may name a folder and takes the kept file's extension when it has none; `shared=true` keeps it in the library every workspace shares, which is where a recurring cast belongs |
+| `upload_asset(file_path, asset_name=None, shared=False)` | `file_path` | Push a local image, video or audio file into the server's asset library and get back its `asset:` reference. The file is read from the machine the MCP server runs on, so this is how an input reaches a dw.serve running somewhere else. `asset_name` stores it under a readable name (`cast/priya-voice.wav`) instead of a random one; `shared=true` puts it in the library every workspace shares |
+| `delete_asset(name)` | `name` | Permanently remove one file from the asset library, by the name `list_assets` reports. Deletes from whichever library holds it - this workspace's own before the shared one; one from a read-only examples library is refused. Any workflow still carrying that `asset:` reference stops loading |
 | `save_workflow(name, workflow)` | `name`, `workflow` | Save a workflow into the server's writable workflow directory, overwriting any existing workflow of that name there. 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 |
 | `delete_workflow(name)` | `name` | Permanently delete a stored workflow |
 
@@ -286,7 +287,7 @@ references written in the same session.
 | `get_job_workflow(job_id)` | `job_id` | The workflow the job actually ran. `realized: true` means every mutable input is pinned (arguments, seed, prompts, `output:latest`); `false` means the job predates run tracking and this is the definition as submitted. Pass it to `save_workflow` to keep it under a name |
 | `export_job(job_id, overwrite=False)` | `job_id`, `overwrite` | Gather one finished job into `<workspace>/exports/<job id>/` on the server: the realized workflow, the run's manifest, the job row, a README, and copies of the assets, earlier-run inputs and outputs. Returns the directory, a zip URL, the file list with sizes and the total. The three JSON files are in the zip, not repeated here - get_job_workflow and get_job serve them individually. **The directory is on the machine running the server**, like `download_output`'s destination - fetch the zip URL and unpack it into `exports/` under the session's working directory (a deliverable, not a temp file); the archive already unpacks into one folder named after the job id |
 | `get_job_events(job_id, after=-1, limit=200)` | `job_id`, `after`, `limit` | Get a page of a job's progress events |
-| `wait_for_job(job_id, timeout_seconds=20)` | `job_id`, `timeout_seconds` | Block until a job reaches a terminal status, or `timeout_seconds` elapses (capped well under a generation's real runtime). Use instead of hand-polling `get_job`/`get_job_events` in a loop; if it returns `still_running: true`, call it again. Returns a slim job - status, warnings, error, and the manifest once finished - without the arguments; `get_job` has those |
+| `wait_for_job(job_id, timeout_seconds=20)` | `job_id`, `timeout_seconds` | Block until a job reaches a terminal status, or `timeout_seconds` elapses. **One call blocks for at most 55 seconds** — a larger `timeout_seconds` is clamped, not honoured, because no MCP client holds a tool call open for a generation's real runtime, so budget one call per ~55s of the job. Every reply carries `waited_seconds`, `timeout_requested_seconds`, `timeout_applied_seconds` and `timeout_capped`, so a capped return is distinguishable from an elapsed one. Use instead of hand-polling `get_job`/`get_job_events` in a loop; if it returns `still_running: true`, call it again. Returns a slim job - status, warnings, error, and the manifest once finished - without the arguments; `get_job` has those |
 | `cancel_job(job_id)` | `job_id` | Ask a queued or running job to stop |
 | `rerun_job(job_id, acknowledged_cost=False, new_seed=False)` | `job_id`, `acknowledged_cost`, `new_seed` | Queue a fresh job from a previous job's stored specification. Costs GPU time, so it passes the same gate as `run_workflow`. `new_seed=true` draws a fresh seed into the workflow's seed variable — without it a seeded workflow's rerun repeats its arguments exactly and the step cache serves the whole run from the earlier one's files (`reused: true`), generating nothing. `get_job_workflow`'s `seed_variable` says whether there is one |
 | `move_job(job_id, direction)` | `job_id`, `direction` (`up`\|`down`\|`front`\|`back`) | Reorder a queued job |
@@ -340,12 +341,16 @@ deletions rather than queued work and complete before they answer.
 The intended loop:
 
 1. `validate_workflow` — free, checks schema and pipeline signatures, no GPU
-   time spent
+   time spent. Pass the `arguments` you intend to run with: without them the
+   verdict covers the stored definition and its stock defaults, not the
+   values you wrote
 2. `run_workflow` with `acknowledged_cost=true` — pass a name straight from
    `list_workflows` as `workflow_path`; queues the job and returns
    immediately with a `job_id`
 3. `wait_for_job(job_id)` to block for a bounded interval instead of
-   hand-polling — call it again if it comes back `still_running: true` — or
+   hand-polling — one call covers at most 55 seconds however large
+   `timeout_seconds` is, so a minutes-long render takes several; call it
+   again if it comes back `still_running: true` — or
    `get_job_events(job_id)` repeatedly, passing back the previous call's
    `last_seq` as `after`, for incremental progress instead of just a
    terminal/not-terminal status
diff --git a/docs/SERVER.md b/docs/SERVER.md
index 633d91c..ea5bd17 100644
--- a/docs/SERVER.md
+++ b/docs/SERVER.md
@@ -137,7 +137,7 @@ from another machine:
 | Route | What it does |
 | --- | --- |
 | `POST /api/jobs` | Queue a run: `{"workflow_path": ...}` or an inline `{"workflow": {...}, "base_dir": ...}`, plus `arguments` for variable overrides. `workflow_path` accepts a stored workflow name as listed by `/api/workflows` (with or without `.json`, nested names included), or a relative/absolute path that still resolves under `--workflow-dir` - confined the same way the `/api/workflows` CRUD routes are; a path that names a real file outside that directory is rejected with 400, not opened. Answers with argument warnings from signature checking. |
-| `GET /api/jobs` | Queue + history summaries |
+| `GET /api/jobs?workspace=&status=&limit=` | Queue + history summaries, oldest first, with `total` beside them. `status` narrows to one state or a comma-separated set (`queued`, `running`, `succeeded`, `failed`, `cancelled`; anything else is a 400); `limit` keeps the newest N, and `total` still reports how many matched, so a bounded answer cannot be mistaken for a complete one. No parameters means every job, which is what the web UI polls |
 | `GET /api/jobs/{id}` | Full detail: spec, events, manifest, error. A manifest entry for a step served from the step cache carries `reused: true` |
 | `GET /api/jobs/{id}/workflow` | The workflow the job ran: `{id, definition, realized, seed_variable}`. `seed_variable` names the variable a `new_seed` rerun would draw into (null when the workflow has none), read from the workflow as written rather than the realized copy, whose seed is pinned. `realized: true` is the copy the run itself wrote (`workflow.json` in its run directory), with arguments, seed, prompts and `output:latest` pinned; `false` falls back to the submitted definition, which is what a job from before run tracking has. 404 means neither is readable - the job itself still is |
 | `POST /api/jobs/{id}/export?workspace=&overwrite=` | Gather one finished job into `<workspace>/exports/<job id>/`: `workflow.json`, `manifest.json`, `job.json`, `README.md`, `assets/`, `inputs/`, `outputs/`. 201 with the file list, total bytes, anything it could not find, a `zip_url`, and the three JSON files inline. 404 unknown job, 409 for a job still running or an existing export without `overwrite` |
@@ -203,7 +203,15 @@ The editor's forms come from these; they are just as usable from scripts:
   `/api/jobs`, above) as an alternative to inline `workflow` - exactly one
   of the two, or a 400. Every schema violation is returned in `errors`
   (`[{path, message}]`, sorted by path, capped at 25), and joined one per
-  line in `error`.
+  line in `error`. It also takes the `arguments` a caller is about to run
+  with, and checks them the way the run would: a name the workflow does not
+  declare, a value that will not coerce to the declared type, and an
+  `asset:`, `prompt:` or `output:` reference that names nothing this
+  workspace can reach - each reported at `arguments.<name>`. `POST /api/jobs`
+  makes the same check and answers 400 rather than queuing a job that would
+  fail on its first step; `checked_arguments` on a valid answer names what
+  was covered, since without arguments the verdict is about the stored
+  defaults only.
 
 ## Files and models
 
@@ -240,6 +248,9 @@ The editor's forms come from these; they are just as usable from scripts:
 - `GET/PUT/DELETE /api/workflows/{name}` — read, save, delete workflow files
   (confined to `--workflow-dir`)
 - `GET /api/workflows/{name:path}/download` — download a workflow file as JSON
+- `GET /api/workflows/{name:path}/variables` — a workflow's variables and what
+  they default to, without the definition around them. Long string defaults are
+  cut to 200 characters and named in `truncated`; `full=true` returns them whole
 - `GET /api/prompts`, `GET/PUT/DELETE /api/prompts/{name}` — the prompt
   library (confined to `--prompt-dir`, names held to what a `prompt:`
   reference can load); saves are validated against the prompt schema,
@@ -278,18 +289,33 @@ The editor's forms come from these; they are just as usable from scripts:
   `asset:` reference a workflow carries rather than a path, since a path
   only means something on the server's own machine. Empty rather than an
   error when no library is configured
-- `POST /api/assets/keep` (`{"name": ..., "asset_name": ..., "overwrite": false}`)
+- `POST /api/assets/keep` (`{"name": ..., "asset_name": ..., "overwrite": false, "shared": false}`)
   — keep a generated file as an input asset under a stable name, returning
   its `asset:` reference. A run's files are named by the run that made them,
   which is the wrong thing for a later workflow to depend on: `latest` moves
   and a pinned run id breaks when outputs are pruned. The copy happens inside
   the workspace and is a hard link where the filesystem allows one, so
   keeping one frame of a large render costs no second copy of it. Refuses an
-  existing name unless `overwrite`
+  existing name unless `overwrite`. `asset_name` may name a folder and takes
+  the kept file's extension when it carries none (a contradicting one is a
+  400) — the same rule the upload route follows, and what keeps a kept asset
+  from landing under an extensionless name the library listing never shows.
+  `"shared": true` keeps it in
+  `<root>/common/assets` instead — the library every workspace under the root
+  shares, which is where a recurring cast belongs
+- `DELETE /api/assets/{name}` — remove one file from the asset library,
+  deleting from whichever library on the search path 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, the same as a
+  read-only prompt or workflow; a name nothing holds answers 404
 - `POST /api/uploads?filename=...` — the raw bytes of one image, video or audio file
   (200MB ceiling, checked from `Content-Length` before a byte is read, and
   again on the body; extension held to the allowed image/video list), saved
-  into the asset library's `uploads/` subfolder under a generated name.
+  into the asset library's `uploads/` subfolder - the shared library at
+  `<root>/common/assets` when `shared=true`, this workspace's own otherwise -
+  under a generated name, or under `asset_name` when one is given (`cast/priya-voice.wav`, folders allowed,
+  the uploaded file's extension assumed, confined to the library the way
+  `keep_output`'s name is).
   Answers 201 with `path` - `asset:uploads/<name>`, the reference a saved
   workflow can carry and still resolve on a later run - and `url`, the same
   file under the `/inputs` mount, for the editor's preview. A server started
diff --git a/docs/TASKS.md b/docs/TASKS.md
index 688d513..d2d63ea 100644
--- a/docs/TASKS.md
+++ b/docs/TASKS.md
@@ -267,14 +267,17 @@ A bleed works because it copies ambience, which has no pitch and no attacks to
 give the copy away. It is the wrong tool for anything tonal - a copied musical
 phrase or half-spoken word reads as a stutter whichever direction it runs. When a
 shot ends on something tonal, either give the cut a continuous bed with
-`slice_audio` + `pair_audio`, which leaves no seam to treat at all, or fade the
+`slice_audio` + `loop_audio` + `mix_audio` + `pair_audio`, which leaves no seam
+to treat at all, or fade the
 seam gracefully with `seam_fade_ms` (a hundred or so milliseconds) and accept the
 cut. That advice inverts on a continuous bed - a laugh track, room tone - where a
 longer fade only digs the hole deeper (the same sitcom cut measured 54-59 dB
 holes with a 250-500 ms fade and no bleed). `audio_bleed_ms` wins where both are
 set and there is material to bleed. A bleed covers the gap but cannot fill it:
 the silence is inside the incoming shot's own head, and the only complete fix is
-a continuous bed under the whole cut with `slice_audio` + `pair_audio`.
+a continuous bed under the whole cut: `slice_audio` a few seconds of tone out of
+a shot, [`loop_audio`](#loop_audio) it to the length of the cut, `mix_audio` it
+under the episode and `pair_audio` it back onto the picture.
 
 ### dissolve_videos
 
@@ -552,6 +555,64 @@ rescaled - follow it with `normalize_audio` to bring the peak back down.
 **Example:** [dissolve-between-shots.json](../workflows/templates/dissolve-between-shots.json) — a
 generated score mixed under the shots' own audio.
 
+### loop_audio
+
+Make a bed of a given length out of a short recording — the room tone laid
+under a whole cut, which is the only complete fix for the hole at a seam. Each
+shot in a cut carries its own room and nothing runs underneath the join;
+a continuous bed does, the way a location's room tone is laid under a dialogue
+scene so the edits stop being audible:
+
+```json
+{
+    "task": {
+        "command": "loop_audio",
+        "arguments": {
+            "audio": "previous_result:room_tone",
+            "target_frames": 620,
+            "fps": 24,
+            "crossfade_ms": 250
+        }
+    }
+}
+```
+
+| Argument | Required | Description |
+| -------- | -------- | ----------- |
+| `audio` | Yes | Path or URL of an audio or video file, a video generated with a soundtrack (which brings its sample rate along), or a waveform |
+| `duration_seconds` | One of | How long the bed should be, in seconds |
+| `target_frames` / `fps` | One of | How long the bed should be, in video frames — how a bed is matched to a cut exactly |
+| `crossfade_ms` | No | Crossfade at each loop point, clamped to the material available (default 250) |
+| `sample_rate` | With a waveform | Sample rate of a waveform passed directly; given for a file or a video it overrides the rate they carry |
+
+Laps are joined with an equal-power crossfade rather than butted together, so
+the loop point is not a click and a tone with movement in it does not tick once
+a second. The source is used whole every lap and only the last one is trimmed,
+so the bed lands exactly on the requested length; a source longer than the
+request is trimmed to it.
+
+The bed is laid under the cut with `mix_audio` and attached to the picture with
+`pair_audio`:
+
+```json
+{ "name": "bed",   "task": { "command": "loop_audio",
+                             "arguments": { "audio": "previous_result:room_tone",
+                                            "target_frames": 620, "fps": 24 } } },
+{ "name": "mixed", "task": { "command": "mix_audio",
+                             "arguments": { "audios": ["previous_result:episode",
+                                                       "previous_result:bed"],
+                                            "gains": [1.0, 0.25] } } },
+{ "name": "cut",   "task": { "command": "pair_audio",
+                             "arguments": { "video": "previous_result:episode",
+                                            "audio": "previous_result:mixed" } },
+  "result": { "content_type": "video/mp4", "fps": 24 } }
+```
+
+Where the bed itself comes from is the open question: a few seconds of a
+generated shot's own ambience, cut out with `slice_audio` from a stretch with
+nothing tonal in it, is the material that matches — the room the shots were
+generated in.
+
 ### resample_audio
 
 Convert a track to a different sample rate. A pipeline that conditions on audio
@@ -579,6 +640,12 @@ supplied recording once, up front, feeds it what it already wants:
 A track already at the target rate is returned untouched. The conversion is
 PyAV's, which dw already needs for video - no torchaudio dependency.
 
+Every audio task returns the waveform *and* the rate it is at, so one chains
+into the next without the rate being restated: a `resample_audio` fed
+`previous_result:` from a `slice_audio` takes the source rate from the slice. A
+`sample_rate` given on the step still wins, and one declared on the step's
+`result` still decides what is written to disk.
+
 **Example:** [assemble-and-score.json](../workflows/templates/assemble-and-score.json)
 
 ## Data Gathering
@@ -858,6 +925,50 @@ For a detailed caption, hand the image to [`text_generation`](#text-generation)
 - [image-to-text.json](../workflows/templates/image-to-text.json) — Larger VLM answering a specific question
 - [describe-and-regenerate.json](../workflows/templates/describe-and-regenerate.json) — Describe an image, expand the caption, then regenerate it
 
+## Composing Text
+
+Assemble one block of text out of parts written once. A multi-shot workflow
+says the same things about its characters in every shot — who they are, what
+they are wearing, what their voice sounds like — and the engine deliberately
+has no string interpolation to splice them in with (see the no-interpolation
+rule in [the workflow guide](WORKFLOW_GUIDE.md)). Composition is the way
+round it: a part is a *whole* value, and `compose_text` joins parts in order.
+
+```json
+{
+    "name": "shot_1_prompt",
+    "task": {
+        "command": "compose_text",
+        "arguments": {
+            "parts": [
+                "variable:character_a_bible",
+                "variable:character_a_voice",
+                "variable:shot_1_action"
+            ],
+            "separator": "\n\n"
+        }
+    }
+},
+{
+    "name": "shot_1",
+    "pipeline": { "arguments": { "prompt": "previous_result:shot_1_prompt" } }
+}
+```
+
+| Argument | Required | Description |
+| -------- | -------- | ----------- |
+| `parts` | Yes | The parts to join, in order — each a whole value, usually a `variable:`, `prompt:` or `previous_result:` reference. Numbers are written out; `null` is dropped, so an optional part can be a variable left null |
+| `separator` | No | What goes between the parts (default: a blank line, the paragraph break the prompt formats use) |
+| `skip_empty` | No | Drop parts that are null or blank (default `true`). With it off, an empty part still contributes its separator |
+
+A part that is neither text nor a number is an error, not a coercion: it means
+the reference in that position resolved to something other than the text meant.
+
+The parts are positional. A named form (`"{bible} says {line}"`) would be the
+interpolation the engine does not have, one layer down — so a character bible
+is a variable named by every shot that needs it, and a voice string written
+once is checked by being the same value rather than by being compared.
+
 ## Extracting Sections
 
 Reduce generated text to a known set of labelled sections, dropping anything else:
diff --git a/docs/WORKFLOW_GUIDE.md b/docs/WORKFLOW_GUIDE.md
index 1613d43..460a6de 100644
--- a/docs/WORKFLOW_GUIDE.md
+++ b/docs/WORKFLOW_GUIDE.md
@@ -253,7 +253,9 @@ not validation.
   JSON type the field expects: `25`, not `"25"`.
 - `previous_result:` — `previous_result:step_name` is the outputs of an earlier
   step, named by that step's `name`. It iterates; see the cartesian rule
-  below. A `.field` suffix
+  below. Validation checks it: a literal reference naming no earlier step is
+  an error with the JSON path it sits at, rather than a run-time failure
+  reached after everything before it has generated. A `.field` suffix
   (`previous_result:invert.inverted_latents`) picks one field of a result that
   is a dict, or a data attribute of a result object.
 - `constant:` — `constant:module.path.NAME` is a value declared in Python,
@@ -287,6 +289,14 @@ each full prompt out, or put the shared text in a variable and let a step's
 argument override it whole. `validate_workflow` warns about a `variable:`
 reference that names nothing the workflow declares.
 
+When several steps share a block of text — a character's description and voice
+repeated in every shot of a dialogue short — the answer is composition rather
+than interpolation: write the shared text once as a variable and assemble each
+step's prompt with a [`compose_text`](TASKS.md#compose_text) task, whose parts
+are whole references joined in order. The shot then references the composed
+result (`"prompt": "previous_result:shot_1_prompt"`), so changing the voice
+changes it in every shot instead of in however many copies were made by hand.
+
 ### Types and escaping
 
 Any key ending in `_type` or `_dtype`, or named `dtype`, has its string value
@@ -323,7 +333,16 @@ signal to restructure the workflow, not to add another reference.
 
 1. `validate_workflow` — free and instant. It reports every schema error at
    once, each with the JSON path it sits at, plus warnings for argument names
-   that do not appear in the real pipeline signature.
+   that do not appear in the real pipeline signature. It also catches a
+   `previous_result:` (or `from_previous_result`) that names no earlier step,
+   which is what renaming a step half way through leaves behind. Pass the
+   `arguments` you are going to run with as well: a name the workflow no
+   longer declares, a value that will not coerce to the declared type, and an
+   `asset:`, `prompt:` or `output:` reference that names nothing in this
+   workspace each come back at `arguments.<name>`, for free, instead of after
+   the model has loaded. Without them the verdict is about the stored
+   definition and its stock defaults - `checked_arguments` in the answer says
+   which it was.
 2. Fix everything reported, including the warnings: a passing validation does
    not mean the pipeline accepts the arguments, and a typo against a real
    `__call__` shows up only as one of those warnings. The server only computes
@@ -340,7 +359,9 @@ signal to restructure the workflow, not to add another reference.
    images is the number to quote. Say "a few minutes" only when no entry with
    that pipeline has been measured.
 5. `wait_for_job` rather than a polling loop; call it again if it returns
-   `still_running: true`.
+   `still_running: true`. One call blocks for at most 55 seconds whatever
+   `timeout_seconds` says, so a minutes-long render takes several - the
+   reply's `timeout_capped` and `waited_seconds` say which happened.
 6. `get_output_image` to look at what was actually made, and say whether it
    answers the request. Nothing before this step establishes that it does.
 7. Getting the files to the user's machine. `download_output` and `export_job`
@@ -1254,6 +1275,14 @@ the workflow loads — use
 merely contains a `from_file` key without a `*_type` key is not an object description
 and is passed through untouched.
 
+An entry in a list whose source is `null` is **left out** of that list. That is what
+makes a reference optional: write it as an ordinary entry whose `from_file` (or
+`from_previous_result`) is a variable, declare the variable `null`, and a run that is
+given nothing for it generates exactly as it did before the reference existed — one
+workflow serving both, instead of two spellings of the same steps. It applies to
+`from_file`, `from_previous_result` and `from_arguments` alike. On its own rather than
+in a list there is nothing to leave it out of, so a null source there is an error.
+
 Any other key goes wherever the type can take it: to `from_file()` where its signature
 names it, and onto the object it returns where it does not. That is what corrects a
 decoded file, which is the only thing that knows what the container claimed:
diff --git a/docs/WORKSPACES.md b/docs/WORKSPACES.md
index b06f47f..5496cc8 100644
--- a/docs/WORKSPACES.md
+++ b/docs/WORKSPACES.md
@@ -220,6 +220,7 @@ several, and a client picks which one it is working in.
 <workspace root>/
   workflows/  assets/  outputs/    <- the 'default' workspace
   prompts/                         <- shared by all of them
+  common/assets/                   <- shared by all of them
   studio/
     workflows/  assets/  outputs/  <- the 'studio' workspace
   scratch/
@@ -234,9 +235,31 @@ reference, and a prompt duplicated per workspace would resolve to different
 text depending on where a workflow happened to be saved. `workflows`,
 `prompts`, `assets` and `outputs` are reserved names for that reason.
 
-A fifth name is reserved beside `workflows`, `prompts`, `assets` and `outputs`:
-`exports`. `POST /api/jobs/{id}/export` gathers one finished job into
-`<root>/exports/<job id>/`, and that folder is never mistaken for a workspace.
+Two more names are reserved beside `workflows`, `prompts`, `assets` and
+`outputs`: `exports` and `common`. `POST /api/jobs/{id}/export` gathers one
+finished job into `<root>/exports/<job id>/`, and that folder is never mistaken
+for a workspace.
+
+**The shared asset library.** `common/assets/` is the one place an asset can
+live that belongs to no single workspace. Assets are otherwise per workspace,
+which is right for the inputs of one piece of work and wrong for a recurring
+cast: a character's portrait and voice clip uploaded while making episode one
+were invisible from the workspace episode four was made in, and the only way
+through was to copy the files in. It sits on every workspace's asset search
+path behind that workspace's own library, so:
+
+- `asset:cast/priya.png` resolves in the workspace first, then in the shared
+  library, then in any read-only examples library — a workspace's own name
+  still shadows a shared one
+- `GET /api/assets` spans all of them and tags each entry's `origin`:
+  `workspace`, `common`, or `examples`
+- writes still land in the workspace unless they say otherwise:
+  `POST /api/uploads?shared=true`, `POST /api/assets/keep` with
+  `"shared": true`, and over MCP `upload_asset(..., shared=True)` /
+  `keep_output(..., shared=True)`
+
+It holds assets only. A prompt is already shared, and workflows and outputs
+belong to the work that made them.
 
 This is what lets two agents share one GPU without sharing a namespace: each
 takes a workspace, and neither can save over the other's workflows or delete
diff --git a/docs/proposals/list-driven-steps.md b/docs/proposals/list-driven-steps.md
new file mode 100644
index 0000000..4f9101b
--- /dev/null
+++ b/docs/proposals/list-driven-steps.md
@@ -0,0 +1,216 @@
+# Proposal: list-driven steps (`for_each`)
+
+Status: **needs approval**. Written for MCP feedback ticket T003; nothing here
+is implemented.
+
+## The ask, as filed
+
+> `music-video` and `dialogue-short`: each generates one step per shot. A
+> `shots: [...]` variable should fan out generation steps, one per list entry.
+> Step count is fixed in the template; adding a shot means editing the
+> template.
+
+Both templates are written the long way. `music-video` has `shot_1_wide_open`,
+`shot_2_closeup`, `shot_3_room`, `shot_4_finale`, each a near-copy of the one
+before, and `slice_1` … `slice_4` beside them cutting the audio bed into
+matching pieces. `dialogue-short` has five shot steps and two portrait steps.
+A five-shot episode is the template; a six-shot episode is a different file.
+
+The consumer side already moved this way: `assemble-and-score` takes a list,
+and `compose_text(parts=[...])` (T002) assembles text written once. What is
+missing is the generation side - a step that runs once per entry.
+
+## Why this is a proposal and not an edit
+
+Fanning a step out per list entry forces a question the ticket does not
+settle: **how does the downstream step name the group?**
+
+`previous_result:shot` today means "that step's result". A result holding N
+artifacts drives the cartesian iteration the engine already has -
+`dw/previous_results.py:get_iterations`, four images x three masks = twelve
+runs. So a fanned-out group read back through `previous_result:` would run
+the concat once *per shot* rather than once *over all of them*. Gathering and
+iterating are two different meanings and the reference syntax has one
+spelling. That, plus what the expanded steps are called, what the step cache
+keys on, and what the manifest and the realized workflow record, is more
+than a syntax addition.
+
+## The shape
+
+```json
+{
+  "name": "shot",
+  "for_each": "variable:shots",
+  "pipeline": {
+    "arguments": {
+      "prompt": "item:prompt",
+      "references": [
+        { "reference_type": "variable:image_reference_type",
+          "from_previous_result": "draw_singer" }
+      ]
+    }
+  }
+}
+```
+
+with
+
+```json
+"shots": [
+  { "name": "wide_open", "prompt": "the band walks on, wide" },
+  { "name": "closeup",   "prompt": "closeup on the singer" }
+]
+```
+
+and downstream
+
+```json
+{ "name": "edit",
+  "task": { "command": "concat_videos", "arguments": { "videos": "gather:shot" } } }
+```
+
+- `for_each` names a list - a `variable:` reference, or a literal list. One
+  step per entry, in list order.
+- `item:` inside the step is that entry: `item:prompt` is one field, bare
+  `item:` is the whole entry (a list of plain strings is the common case).
+- `gather:shot` is the list of every member's artifacts, in order, as one
+  value. It is a *list-valued* reference, which is the distinction
+  `previous_result:` cannot make.
+
+### Recommendation: expansion is a source transform, not a runtime concept
+
+Run the expansion as a pass over the definition immediately after
+`replace_variables` in `Workflow.run` (`dw/workflow.py`), before the run id is
+computed and before the step loop starts. The pass:
+
+1. replaces each `for_each` step with N ordinary steps, named `shot[wide_open]`
+   … (below);
+2. substitutes `item:` references inside each copy with that entry's values;
+3. rewrites every `gather:shot` into the explicit list of
+   `["previous_result:shot[wide_open]", "previous_result:shot[closeup]"]` -
+   exactly what a hand-written template contains today.
+
+After the pass the definition is an ordinary workflow. Nothing below it
+changes: no new reference kind at run time, no change to what
+`previous_result:` means, no change to the cartesian rule, and the step cache,
+the manifest, the event stream and `pipeline_reference` all keep working
+because they are looking at ordinary steps. **This is the argument for the
+whole design** - the alternative, teaching `get_previous_results` a second
+meaning, touches every consumer of a result and leaves two spellings that
+differ only by whether a group happens to be behind them.
+
+Consequences worth stating:
+
+- A `gather:` written *inside* a list splices into it
+  (`["previous_result:intro", "gather:shot"]` is one flat list), because
+  textual expansion is the natural reading. A `gather:` naming a step that is
+  not a `for_each` group is an error, not a one-element list - that is a typo
+  every time.
+- Pipeline loading is already shared: `pipeline_cache_key` hashes what a
+  pipeline *loads*, excluding arguments and seed, so N identical expanded
+  pipeline blocks hit one loaded model within the run. The expansion needs no
+  `pipeline_reference` rewriting to get the reuse the hand-written template
+  gets by hand. `release_pipeline` on a fanned step is the exception: it would
+  drop the model after the first member and reload it for the second. Refuse
+  it on a `for_each` step, or honour it only on the last member.
+
+### Expanded names: the entry's own name before its index
+
+`shot[wide_open]` when the entry is an object carrying a `name`, else
+`shot[0]`, `shot[1]`.
+
+The index alone is tempting and wrong for the cache. Entries are keyed
+`(workflow id, step name)` in `dw/step_cache.py`, so inserting a shot in the
+middle shifts every later index onto a different entry's content. The cache
+validates against the step's data as well, so the result is correct - it is a
+miss - but every shot after an insertion regenerates, which on a six-shot H3
+episode is most of an hour of GPU to add one shot in the middle. A name
+carried by the entry survives insertion, and it also makes the manifest, the
+event stream and the gallery read in shot names rather than in ordinals.
+
+Brackets rather than dots or underscores: `.` is already the property
+separator in a reference (`previous_result:segment.mask`) and `_` collides
+with a hand-written `shot_1`. A step name is otherwise an unrestricted string,
+so the bracket form has to be reserved - a hand-written step named `shot[0]`
+becomes an error.
+
+### Validation
+
+The static reference check shipped for T005
+(`previous_result_reference_errors`) runs on the unexpanded definition, where
+`shot[wide_open]` does not exist yet. `validate_workflow` should run the same
+expansion first, using the variables' declared defaults, and check the
+expanded steps - which also means an empty or absent default list validates
+as zero steps and a `gather:` naming nothing. Order becomes: schema ->
+substitute -> expand -> reference check. Schema validation stays where it is,
+against the template step, and the schema gains `for_each` on a step plus the
+`item:`/`gather:` prefixes wherever a reference is allowed.
+
+### The realized workflow and the manifest
+
+`dw/realize.py` folds the run's arguments into the variable defaults, so a
+realized list-driven workflow carries the actual `shots` list and reproduces
+the same expansion deterministically. **Keep `for_each` in the realized file**
+rather than writing the expanded steps: it reproduces the run exactly and stays
+legible. The manifest names the expanded steps (`shot[wide_open]`), because the
+manifest records what ran. That the two name steps differently is deliberate
+and should be documented where the manifest is.
+
+### Limits and cost
+
+Each entry is a full generation, so the expansion needs a ceiling of its own -
+something like 64 steps, refused outright above it, well below
+`MAX_ITERATIONS = 10000`, which guards a different thing. The larger
+consequence is that a list-driven template's cost is set by the caller:
+`list_workflows` quotes a per-workflow figure today, and a six-entry `shots`
+list is six times the shot cost. The catalog entry should carry the per-entry
+cost and the variable it multiplies by, and the MCP guidance
+(`docs/WORKFLOW_GUIDE.md`, "Authoring a workflow from an agent") should say to
+quote `cost x len(list)` before running.
+
+### What this does not do
+
+It does not give the engine a "zip". `for_each` runs over **one** list; a
+pairing - shot *i* with its audio slice *i* - is expressed by putting both in
+the same entry:
+
+```json
+{ "name": "wide_open", "prompt": "...", "start_frame": 0 }
+```
+
+That is the same answer the guide already gives for the cartesian rule
+("write it as one step per pair"), and it is why the entry should be an object
+rather than a string in any template that has more than a prompt to vary. Two
+`for_each` lists on one step, or a `for_each` over a cartesian product, is out
+of scope and probably always should be.
+
+## Phasing
+
+1. **Expansion pass + `item:` + `gather:`**, schema, validation ordering, the
+   64-step ceiling, and the reserved bracket name. No template changes. This is
+   self-contained and testable without a GPU: the pass is a pure function from
+   definition to definition, so its tests are ordinary unit tests.
+2. **`music-video` and `dialogue-short` rewritten** onto a `shots` list. Both
+   are breaking for scripted callers - the per-shot variables
+   (`shot_2_deflect`, `shot_3_react`, …) become entries in one list - and
+   T005 has already broken those names once this week, so the two should land
+   together or the second should wait for a deliberate version bump of the
+   templates.
+3. **Cost reporting** for a list-driven entry, in the catalog and in the
+   plugin skills that quote it.
+
+Stage 1 is the bulk of the work and carries the risk; stages 2 and 3 are
+mechanical once it exists.
+
+## Open questions for the approval
+
+- **Is the loop index needed inside an entry?** Nothing in the two templates
+  needs "shot 3 of 6" in a prompt, so v1 exposes no index. Adding `item:@index`
+  later is compatible; making it available now costs a second special name.
+- **Should `for_each` accept a number** (`"for_each": 4`) for the case where
+  only the count varies? It reads well and it is one line in the pass, but it
+  gives entries no names, which is exactly the cache problem above.
+- **`dialogue-short`'s two-speaker structure** (which character speaks in which
+  shot, T010's voice references) becomes a field on each entry
+  (`"speaker": "a"`). That is a template question, not an engine one, but it is
+  the thing stage 2 has to get right.
diff --git a/dw/arguments.py b/dw/arguments.py
index 92739c1..aedfbd6 100644
--- a/dw/arguments.py
+++ b/dw/arguments.py
@@ -62,6 +62,26 @@ def is_escaped(value):
 # Copying those into a workflow is how they go stale when the library moves on
 CONSTANT_PREFIX = "constant:"
 
+
+class _Omitted:
+    """An object description whose media is null - it is left out entirely.
+
+    An optional reference (a character's voice, a style image) is written as
+    a normal entry in a 'references' list with its source a variable, and the
+    variable declared null means "this run has none". Dropping the entry is
+    the only thing that can mean, since there is no object to build: a
+    pipeline handed a reference with no media in it fails, and a workflow
+    that had to carry two spellings of its references - one with the entry,
+    one without - is the copy a variable exists to avoid.
+    """
+
+    def __repr__(self):
+        return "<omitted>"
+
+
+OMITTED = _Omitted()
+
+
 # The media such an object may be built from - it opens the file itself, so the
 # extension is all that is checked here
 ALLOWED_FROM_FILE_EXTENSIONS = (
@@ -145,7 +165,15 @@ def realize_args(arg, base_dir=None):
             # describe - the type reference it names is realized by the recursion
             else:
                 realize_args(v, base_dir)
-                arg[k] = realize_object(v, base_dir)
+                realized = realize_object(v, base_dir)
+                if realized is OMITTED:
+                    raise ValueError(
+                        f"'{k}' names an object to build but the media it "
+                        f"would be built from is null. An optional one belongs "
+                        f"in a list, where it can be left out; on its own "
+                        f"there is nothing to leave it out of"
+                    )
+                arg[k] = realized
 
     # Recursively process lists
     elif isinstance(arg, list):
@@ -164,6 +192,11 @@ def realize_args(arg, base_dir=None):
                 continue
             realize_args(item, base_dir)
             arg[i] = realize_object(item, base_dir)
+        # An optional entry whose media is null leaves the list rather than
+        # reaching the pipeline as a reference with nothing in it
+        if any(item is OMITTED for item in arg):
+            kept = [item for item in arg if item is not OMITTED]
+            arg[:] = kept
 
 
 def is_path_reference(value):
@@ -333,6 +366,21 @@ def object_type_key(value, from_key):
     return type_keys[0]
 
 
+def _names_no_media(value):
+    """Whether a dict is an object description whose media came out null.
+
+    It has to name a type, the way every object description does, and the
+    key saying where its media comes from has to be there and be null -
+    which is what a "variable:" source resolves to when the variable is
+    declared null. A dict missing the source key altogether is not this: it
+    is whatever it always was, and is left alone.
+    """
+    for from_key in (FROM_FILE_KEY, FROM_PREVIOUS_RESULT_KEY, FROM_ARGUMENTS_KEY):
+        if value.get(from_key, False) is None:
+            return object_type_key(value, from_key) is not None
+    return False
+
+
 def realize_object(value, base_dir=None):
     """Construct an argument that names a type and the media to build it from.
 
@@ -377,6 +425,10 @@ def realize_object(value, base_dir=None):
             from a file, or a file location that cannot be resolved
         SecurityError: If the file it names fails validation
     """
+    if isinstance(value, dict) and _names_no_media(value):
+        # An optional reference this run was given nothing for
+        return OMITTED
+
     if isinstance(value, dict) and FROM_PREVIOUS_RESULT_KEY in value:
         # Validated now and built later - a type that cannot hold the step's output
         # is a workflow error worth raising before any of it runs
diff --git a/dw/media_info.py b/dw/media_info.py
index ebeeb67..b8b5b08 100644
--- a/dw/media_info.py
+++ b/dw/media_info.py
@@ -23,7 +23,7 @@ def _dbfs(value):
     return max(SILENCE_DBFS, 20.0 * math.log10(float(value)))
 
 
-def probe_media(path):
+def probe_media(path, envelope=False):
     """Duration, format and level of an audio or video file, or None.
 
     Video answers fps, frame_count, width and height, plus the soundtrack's
@@ -36,6 +36,22 @@ def probe_media(path):
     whichever streams are involved - `container.decode()` demuxes to EOF, so
     two separate passes (count video, then decode audio) would leave the
     second one nothing to read.
+
+    With `envelope=True` the same decode also reports the level second by
+    second, as `envelope: {"interval_seconds": 1.0, "rms_dbfs": [...],
+    "peak_dbfs": [...]}` - which is what tells an agent *where* in a track
+    something is, rather than only how loud the whole thing was: whether a
+    shot is still voiced at its last frame, where a score's quiet passage
+    sits, how deep the hole at a seam goes. Off by default, because a
+    ten-minute track is 600 numbers nobody asked for and the default
+    metadata call has to stay small.
+
+    Args:
+        path: The file to probe
+        envelope: Also report the per-second level of the soundtrack. The
+            list covers what decodes, which for a lossy codec can run a
+            fraction of a second past the reported duration - its own
+            priming and padding
     """
     try:
         container = av.open(path)
@@ -73,6 +89,11 @@ def probe_media(path):
             peak = 0.0
             total = 0.0
             count = 0
+            # One bin per second of the soundtrack, filled as frames decode:
+            # [sum of squares, sample count, peak] - the same numbers the
+            # whole-track level is made of, kept per second instead of once
+            bins = [] if envelope and audio is not None else None
+            elapsed = 0  # samples of the soundtrack seen so far
             streams = [
                 s
                 for s in ((video if need_frame_count else None), audio)
@@ -97,6 +118,10 @@ def probe_media(path):
                         peak = max(peak, float(numpy.abs(samples).max(initial=0.0)))
                         total += float(numpy.square(samples).sum())
                         count += samples.size
+                        if bins is not None:
+                            elapsed = _fill_envelope(
+                                bins, samples, elapsed, audio.rate, int(audio.channels)
+                            )
             except Exception as e:
                 # A track that opens fine can still fail mid-decode (damage
                 # past the header); the fields already gathered - duration,
@@ -111,4 +136,63 @@ def probe_media(path):
                 rms = math.sqrt(total / count) if count else 0.0
                 info["peak_dbfs"] = _dbfs(peak)
                 info["mean_dbfs"] = _dbfs(rms)
+                if bins is not None:
+                    info["envelope"] = _as_envelope(bins)
         return info
+
+
+def _as_frame_samples(samples, channels):
+    """One decoded audio frame as a (samples, channels) array.
+
+    A planar format decodes to (channels, samples); a packed one decodes to
+    (1, samples * channels) interleaved. Both have to become a run of
+    samples before they can be cut on a second boundary, or a stereo packed
+    frame would be counted as twice as much time as it holds.
+    """
+    if samples.ndim == 1:
+        return samples[:, numpy.newaxis]
+    if samples.shape[0] == channels and channels > 1:
+        return samples.T
+    if samples.shape[0] == 1 and channels > 1:
+        return samples.reshape(-1, channels)
+    return samples.T if samples.shape[0] < samples.shape[1] else samples
+
+
+def _fill_envelope(bins, samples, elapsed, rate, channels):
+    """Add a decoded audio frame's samples to the per-second bins.
+
+    A bin covers one second of the track regardless of how the decoder
+    happened to chop it, so a frame straddling a second boundary is split
+    across the two bins rather than counted in whichever one it started in.
+    `elapsed` is how many samples of the track came before this frame; the
+    new total is returned.
+    """
+    frame = _as_frame_samples(samples, channels)
+    length = frame.shape[0]
+    start = 0
+    while start < length:
+        second = (elapsed + start) // rate
+        while len(bins) <= second:
+            bins.append([0.0, 0, 0.0])
+        # How much of this frame still belongs to the second it is in
+        room = int((second + 1) * rate - (elapsed + start))
+        stop = min(length, start + max(room, 1))
+        piece = frame[start:stop]
+        entry = bins[second]
+        entry[0] += float(numpy.square(piece).sum())
+        entry[1] += int(piece.size)
+        entry[2] = max(entry[2], float(numpy.abs(piece).max(initial=0.0)))
+        start = stop
+    return elapsed + length
+
+
+def _as_envelope(bins):
+    """The per-second bins as the levels an agent reads."""
+    return {
+        "interval_seconds": 1.0,
+        "rms_dbfs": [
+            _dbfs(math.sqrt(total / count) if count else 0.0)
+            for total, count, _peak in bins
+        ],
+        "peak_dbfs": [_dbfs(peak) for _total, _count, peak in bins],
+    }
diff --git a/dw/previous_results.py b/dw/previous_results.py
index 1988f74..1461929 100644
--- a/dw/previous_results.py
+++ b/dw/previous_results.py
@@ -123,9 +123,7 @@ def get_previous_results(previous_results, previous_result_name):
         return previous_results[previous_result_name].get_artifacts()
 
     if "." not in previous_result_name:
-        raise KeyError(
-            f"Previous result '{previous_result_name}' not found. Available results: {list(previous_results.keys())}"
-        )
+        raise _not_found(previous_results, previous_result_name)
 
     # Find the longest known step name the reference resolves to, and treat
     # the remainder as the property name. The exact-match case returned
@@ -141,9 +139,7 @@ def get_previous_results(previous_results, previous_result_name):
     )
 
     if result_name is None:
-        raise KeyError(
-            f"Previous result '{previous_result_name}' not found. Available results: {list(previous_results.keys())}"
-        )
+        raise _not_found(previous_results, previous_result_name)
 
     property_name = previous_result_name[len(result_name) + 1 :]
     logger.debug(f"Getting property {property_name} from result {result_name}")
@@ -264,3 +260,126 @@ def substitute_at_path(container, path, value):
     copied = dict(container)
     copied[key] = replacement
     return copied
+
+
+class StepResults(dict):
+    """The run's results, which also remembers every step that produced one.
+
+    `release_unreferenced_results` deletes a result the moment no remaining
+    step references it, so by the time a misspelled reference fails, the
+    steps that ran are gone from the dict and the error printed
+    'Available results: []' on a run where several steps had completed
+    (T015). Keeping the names - not the results, which is the whole point of
+    releasing them - costs nothing and is the one thing that diagnostic
+    needed.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.completed_steps = list(self.keys())
+
+    def __setitem__(self, key, value):
+        if key not in self.completed_steps:
+            self.completed_steps.append(key)
+        super().__setitem__(key, value)
+
+
+def _not_found(previous_results, previous_result_name):
+    """The error a reference that names nothing raises.
+
+    Names what is there as well as what was asked for: the gap between them
+    is the fix, and on a long run it is the only thing standing between a
+    typo and another 40 minutes of GPU.
+    """
+    message = (
+        f"Previous result '{previous_result_name}' not found. "
+        f"Available results: {list(previous_results.keys())}"
+    )
+    released = [
+        name
+        for name in getattr(previous_results, "completed_steps", ())
+        if name not in previous_results
+    ]
+    if released:
+        message += (
+            f". Earlier steps that ran: {released} - their results were "
+            f"released because no remaining step references them"
+        )
+    return KeyError(message)
+
+
+def previous_result_reference_errors(workflow_definition):
+    """Every 'previous_result:' reference that names no earlier step.
+
+    References resolve lazily, one step at a time, so a reference naming a
+    step that does not exist is only discovered when execution reaches it -
+    after everything before it has run. On a workflow whose steps are
+    generation steps that is 40 minutes of GPU spent to learn about a typo
+    a read of the file would have caught (T005). The names are all in the
+    definition, so this is answerable before anything runs.
+
+    Only literal references are checked: one spelled by a 'variable:' the
+    caller supplies is not knowable here and is left alone.
+    """
+    steps = workflow_definition.get("steps")
+    if not isinstance(steps, list):
+        return []
+
+    errors = []
+    seen = []
+    for index, step in enumerate(steps):
+        if not isinstance(step, dict):
+            continue
+        found = {}
+        _collect_reference_paths(step, (), found)
+        for path, reference in sorted(found.items(), key=lambda item: str(item[0])):
+            if any(reference_resolves_to(reference, name) for name in seen):
+                continue
+            location = _render_path(("steps", index) + path)
+            errors.append(
+                {
+                    "path": location,
+                    "message": (
+                        f"previous_result '{reference}' names no earlier step. "
+                        f"Steps available here: {seen}"
+                    ),
+                }
+            )
+        name = step.get("name")
+        if isinstance(name, str):
+            seen.append(name)
+    return errors
+
+
+def _collect_reference_paths(value, path, found):
+    """Every literal previous-result reference under `value`, by JSON path.
+
+    Both spellings: the 'previous_result:' prefix on a string, and the
+    'from_previous_result' key of a constructed object, which names a step
+    without the prefix.
+    """
+    if isinstance(value, dict):
+        for key, item in value.items():
+            if key == FROM_PREVIOUS_RESULT_KEY and isinstance(item, str):
+                if not item.startswith("variable:"):
+                    found[path + (key,)] = item
+                continue
+            _collect_reference_paths(item, path + (key,), found)
+    elif isinstance(value, list):
+        for index, item in enumerate(value):
+            _collect_reference_paths(item, path + (index,), found)
+    elif isinstance(value, str) and value.startswith(PREVIOUS_RESULT_PREFIX):
+        found[path] = value[len(PREVIOUS_RESULT_PREFIX) :]
+
+
+def _render_path(path):
+    """'steps[3].task.arguments.videos[1]' - the same shape schema errors use."""
+    rendered = ""
+    for part in path:
+        if isinstance(part, int):
+            rendered += f"[{part}]"
+        elif rendered:
+            rendered += f".{part}"
+        else:
+            rendered = str(part)
+    return rendered
diff --git a/dw/serve.py b/dw/serve.py
index e3688d0..59c1d54 100644
--- a/dw/serve.py
+++ b/dw/serve.py
@@ -196,7 +196,18 @@ def main():
 
     example_dirs = example_libraries(args.examples_dirs)
     set_library_fallbacks(PROMPTS_SUBDIR, example_dirs[PROMPTS_SUBDIR])
-    set_library_fallbacks(ASSETS_SUBDIR, example_dirs[ASSETS_SUBDIR])
+    # The shared library goes ahead of the examples and behind the
+    # workspace's own, which is the order 'asset:' resolves in: a workspace
+    # name shadows a shared one, and a shared one shadows an example's.
+    # Created here rather than on first use so it is on the path the worker
+    # inherited at startup, whenever the first shared asset lands
+    common_assets = workspace.common_assets
+    if common_assets:
+        os.makedirs(common_assets, exist_ok=True)
+    set_library_fallbacks(
+        ASSETS_SUBDIR,
+        ([common_assets] if common_assets else []) + example_dirs[ASSETS_SUBDIR],
+    )
 
     try:
         import uvicorn
diff --git a/dw/server/app.py b/dw/server/app.py
index 195936d..d66a42a 100644
--- a/dw/server/app.py
+++ b/dw/server/app.py
@@ -50,14 +50,20 @@
     workflow_argument_warnings,
 )
 from ..schema import load_schema, validate_data, format_validation_errors
-from ..prompts import PROMPT_PREFIX, RESERVED_TEXT_PREFIXES
+from ..prompts import (
+    PROMPT_PREFIX,
+    RESERVED_TEXT_PREFIXES,
+    resolve_prompt_reference,
+)
+from ..assets import is_asset_reference, resolve_asset_reference
+from ..variables import argument_errors
 from ..workflow import Workflow, workflow_from_definition, workflow_from_file
 from .enhancers import build_enhance_workflow, preset_descriptions
 from .exports import export_directory, export_job
 from ..result import read_embedded_metadata
 from ..media_info import probe_media
 from ..hub_cache import scan_models, delete_model, DownloadManager
-from ..runs import strip_run_id
+from ..runs import is_output_reference, resolve_output_reference, strip_run_id
 from ..workspace import (
     ASSETS_SUBDIR,
     DEFAULT_WORKSPACE_NAME,
@@ -76,6 +82,7 @@
     workspace_usage,
 )
 from ..workflow_sources import (
+    COMMON_ORIGIN,
     EXAMPLES_ORIGIN,
     WORKSPACE_ORIGIN,
     find_workflow,
@@ -86,7 +93,13 @@
     workflow_sources,
     writable_source,
 )
-from .jobs import JobManager, MAX_PERSISTED_EVENTS, TERMINAL_STATES
+from .jobs import (
+    JobManager,
+    MAX_PERSISTED_EVENTS,
+    QUEUED,
+    RUNNING,
+    TERMINAL_STATES,
+)
 from .netinfo import local_addresses
 from .updater import DiffusersUpdater
 from .catalog_shape import derive_catalog_metadata, project_listing
@@ -831,11 +844,45 @@ def submit_job(request: JobRequest, ws: Workspace = Depends(selected_workspace))
         return manager.describe(job)
 
     @app.get("/api/jobs")
-    def list_jobs(workspace: Optional[str] = None):
+    def list_jobs(
+        workspace: Optional[str] = None,
+        status: Optional[str] = None,
+        limit: Optional[int] = None,
+    ):
         """All jobs by default - a plain filter, not `selected_workspace`,
         since the jobs list spans every workspace the server holds unless a
-        caller asks to narrow it."""
-        return {"jobs": manager.list(workspace=workspace)}
+        caller asks to narrow it.
+
+        `status` narrows to one state or a comma-separated set of them.
+        `limit` keeps the newest N, and `total` always reports how many
+        matched before the cut, so a caller can tell a bounded answer from a
+        complete one. The default is still every matching job, oldest first -
+        what the web UI polls."""
+        statuses = [part.strip() for part in status.split(",")] if status else None
+        statuses = [part for part in statuses if part] if statuses else None
+        if statuses:
+            unknown = [
+                state
+                for state in statuses
+                if state not in (QUEUED, RUNNING, *TERMINAL_STATES)
+            ]
+            if unknown:
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"Unknown job status {', '.join(unknown)} - one of "
+                    f"{', '.join((QUEUED, RUNNING, *TERMINAL_STATES))}",
+                )
+        jobs = manager.list(workspace=workspace, statuses=statuses)
+        total = len(jobs)
+        if limit is not None:
+            if limit < 0:
+                raise HTTPException(
+                    status_code=400, detail="limit must not be negative"
+                )
+            # the newest are the interesting ones, and the list is oldest
+            # first - so the cut comes off the front, not the back
+            jobs = jobs[len(jobs) - limit :] if limit else []
+        return {"jobs": jobs, "total": total}
 
     @app.get("/api/jobs/{job_id}")
     def get_job(job_id: str):
@@ -1110,6 +1157,62 @@ def get_guide(name: str, section: Optional[str] = None):
         except GuideError as e:
             raise HTTPException(status_code=404, detail=str(e))
 
+    def _argument_reference_errors(arguments, ws):
+        """The 'asset:', 'prompt:' and 'output:' references in a caller's
+        arguments that name nothing this workspace can reach.
+
+        Resolved through the engine's own resolvers over the roots this
+        workspace searches, so validation agrees with what the run would
+        find - an asset that exists in another workspace is a miss here for
+        the same reason it would be a miss there. Only the reference is
+        resolved, never loaded: the point is to answer before any bytes move.
+        """
+
+        def over_roots(roots, resolve):
+            """Resolve against each root in turn, and on a total miss raise
+            the *first* root's error rather than the last.
+
+            The resolvers name the path they searched in their message, and
+            the first root is the workspace's own library plus the read-only
+            fallbacks the environment pins - which is the path a run would
+            report. The last root's message would name an examples directory
+            and leave out the workspace, reading as though the library the
+            caller works in was never looked in."""
+            first = None
+            for root in roots:
+                try:
+                    return resolve(root)
+                except Exception as e:
+                    first = first or e
+            raise first
+
+        if not isinstance(arguments, dict):
+            return []
+        errors = []
+        for name, value in arguments.items():
+            if not isinstance(value, str):
+                continue
+            path = f"arguments.{name}"
+            try:
+                if is_asset_reference(value):
+                    over_roots(
+                        _asset_roots(ws) or [ws.assets],
+                        lambda root: resolve_asset_reference(value, asset_dir=root),
+                    )
+                elif value.startswith(PROMPT_PREFIX):
+                    over_roots(
+                        _prompt_roots(),
+                        lambda root: resolve_prompt_reference(value, prompt_dir=root),
+                    )
+                elif is_output_reference(value):
+                    resolve_output_reference(value, root=ws.outputs)
+            except Exception as e:
+                # Every resolver here raises with a message written for the
+                # person who wrote the reference - a traversal refusal from
+                # the security layer included
+                errors.append({"path": path, "message": str(e)})
+        return errors
+
     @app.post("/api/validate")
     def validate_workflow(
         request: JobRequest, ws: Workspace = Depends(selected_workspace)
@@ -1188,12 +1291,32 @@ def validate_workflow(
                 "errors": errors,
                 "warnings": [],
             }
-        return {
+        # The arguments a caller is about to run with, checked the way the
+        # run itself would check them: an undeclared name, a value that will
+        # not coerce, an 'asset:'/'prompt:'/'output:' reference that names
+        # nothing in this workspace. Without this the free pre-flight covers
+        # every part of a run except the part the caller actually wrote
+        argument_problems = argument_errors(definition, request.arguments)
+        argument_problems += _argument_reference_errors(request.arguments, workspace)
+        if argument_problems:
+            return {
+                "valid": False,
+                "error": format_validation_errors(argument_problems),
+                "errors": argument_problems,
+                "warnings": [],
+                "checked_arguments": sorted(request.arguments or {}),
+            }
+        answer = {
             "valid": True,
             "error": None,
             "errors": [],
             "warnings": workflow_argument_warnings(definition),
         }
+        if request.arguments:
+            # Naming what was checked is the difference between 'the stored
+            # definition is valid' and 'the values you are about to pass are'
+            answer["checked_arguments"] = sorted(request.arguments)
+        return answer
 
     # ------------------------------------------------------------ workspaces
 
@@ -1302,6 +1425,10 @@ def remove_workspace(name: str, acknowledged: bool = False):
 
     # ------------------------------------------------------------- workflows
 
+    # How much of a long variable default the variables route shows before
+    # cutting it: enough to recognize a prompt by, far short of carrying one
+    VARIABLE_VALUE_PREVIEW = 200
+
     @app.get("/api/workflows")
     def list_workflows(
         ws: Workspace = Depends(selected_workspace),
@@ -1421,6 +1548,52 @@ def download_workflow(name: str, ws: Workspace = Depends(selected_workspace)):
             path, filename=os.path.basename(path), media_type="application/json"
         )
 
+    # Declared before the catch-all below, which would otherwise swallow
+    # '<name>/variables' as a workflow called that
+    @app.get("/api/workflows/{name:path}/variables")
+    def get_workflow_variables(
+        name: str, full: bool = False, ws: Workspace = Depends(selected_workspace)
+    ):
+        """A workflow's variables and the values they default to.
+
+        The listing says which variables a workflow has; confirming what one
+        of them defaults to meant fetching the whole definition, quantization
+        blocks and all, to read a single integer. This answers that question
+        by itself.
+
+        Long defaults - a shot's prompt runs to kilobytes - are cut to their
+        first 200 characters and named in `truncated`, so the answer stays
+        small for the numbers and names it is usually asked about; `full=true`
+        returns them whole, and `GET /api/workflows/{name}` is still the
+        definition itself.
+        """
+        path, source = resolve_readable_workflow(_sources_for(ws), name)
+        try:
+            with open(path, "r") as file:
+                definition = json.load(file)
+        except (OSError, json.JSONDecodeError) as e:
+            raise HTTPException(status_code=500, detail=f"Could not read workflow: {e}")
+
+        variables = definition.get("variables") or {}
+        values, truncated = {}, []
+        for variable, value in variables.items():
+            if (
+                not full
+                and isinstance(value, str)
+                and len(value) > VARIABLE_VALUE_PREVIEW
+            ):
+                values[variable] = value[:VARIABLE_VALUE_PREVIEW]
+                truncated.append(variable)
+            else:
+                values[variable] = value
+        return {
+            "name": name,
+            "variables": values,
+            "truncated": truncated,
+            "seed": definition.get("seed"),
+            "origin": source.origin,
+        }
+
     @app.get("/api/workflows/{name:path}")
     def get_workflow(name: str, ws: Workspace = Depends(selected_workspace)):
         path, source = resolve_readable_workflow(_sources_for(ws), name)
@@ -1666,13 +1839,23 @@ def _static_files_for(root):
             cache[root] = files
         return files
 
+    def _common_assets(ws):
+        """The library every workspace under this root shares, or None.
+
+        A recurring cast is not the property of the workspace that first
+        uploaded it, and a fresh workspace could not see it at all - the
+        prompt library has been shared from the start for the same reason.
+        """
+        return getattr(ws, "common_assets", None)
+
     def _asset_roots(ws):
         """The asset search path of one workspace: its own library, then the
-        read-only ones an --examples-dir tree brought with it. The same order
-        'asset:' resolves in (dw/assets.asset_search_path), so what the
-        browser lists is what a job would load."""
+        one shared by every workspace under this root, then the read-only
+        ones an --examples-dir tree brought with it. The same order 'asset:'
+        resolves in (dw/assets.asset_search_path), so what the browser lists
+        is what a job would load."""
         roots = []
-        for root in [ws.assets, *app.state.example_asset_dirs]:
+        for root in [ws.assets, _common_assets(ws), *app.state.example_asset_dirs]:
             if not root:
                 continue
             root = os.path.abspath(root)
@@ -1701,7 +1884,7 @@ def _asset_roots_for_job(job_id, ws):
         if not asset_dir:
             return _asset_roots(ws)
         roots = []
-        for root in [asset_dir, *app.state.example_asset_dirs]:
+        for root in [asset_dir, _common_assets(ws), *app.state.example_asset_dirs]:
             if not root:
                 continue
             root = os.path.abspath(root)
@@ -1819,12 +2002,22 @@ def gallery(
         }
 
     @app.get("/api/gallery/{name:path}/metadata")
-    def gallery_metadata(name: str, ws: Workspace = Depends(selected_workspace)):
+    def gallery_metadata(
+        name: str,
+        envelope: bool = False,
+        ws: Workspace = Depends(selected_workspace),
+    ):
         """Generation metadata embedded in a saved image ('workflow' inside
         it is the full definition the editor can reopen), plus the job that
         produced the file when history remembers one, plus - for audio and
         video - what the file itself holds: duration, format and level,
-        which is how an agent that cannot listen checks a track."""
+        which is how an agent that cannot listen checks a track.
+
+        `envelope=true` adds the soundtrack's level second by second, which
+        is what says *where* in a track something is - whether a shot is
+        still voiced at its last frame, how deep the hole at a seam goes.
+        Opt-in: a ten-minute track is 600 numbers, and the default call has
+        to stay small."""
         path = _output_file(name, ws.outputs)
         metadata = read_embedded_metadata(path)
         try:
@@ -1836,7 +2029,7 @@ def gallery_metadata(name: str, ws: Workspace = Depends(selected_workspace)):
             job = None
         extension = os.path.splitext(path)[1].lower()
         media = (
-            probe_media(path)
+            probe_media(path, envelope=envelope)
             if MEDIA_KINDS.get(extension) in ("audio", "video")
             else None
         )
@@ -1957,7 +2150,11 @@ def delete_output(name: str, ws: Workspace = Depends(selected_workspace)):
 
     @app.post("/api/uploads", status_code=201)
     async def upload_media(
-        request: Request, filename: str, ws: Workspace = Depends(selected_workspace)
+        request: Request,
+        filename: str,
+        asset_name: Optional[str] = None,
+        shared: bool = False,
+        ws: Workspace = Depends(selected_workspace),
     ):
         """Save a browser-picked image, video or audio file into the asset library's
         uploads/ subfolder and hand back the reference a workflow argument
@@ -1970,6 +2167,19 @@ async def upload_media(
         keeps the old behavior, writing to the output directory's uploads/
         and returning an absolute path. The body is the raw file bytes: no
         multipart parser dependency needed for a single-file upload.
+
+        `asset_name` stores it under a name of the caller's choosing -
+        'cast/priya-voice.wav' rather than the random one a browser upload
+        gets - which is what makes a recurring cast's references readable
+        in every workflow that carries them. It may name a folder, is
+        confined to the library the way `keep_output`'s is, and takes the
+        uploaded file's extension when it has none of its own. Without it
+        the name stays random, so two uploads of the same file never
+        collide.
+
+        `shared` puts it in the library every workspace under this root
+        shares rather than in this workspace's own - a recurring cast that
+        episode four, in a workspace of its own, still has to reach.
         """
         extension = os.path.splitext(os.path.basename(filename))[1].lower()
         if extension not in ALLOWED_UPLOAD_EXTENSIONS:
@@ -1995,28 +2205,67 @@ async def upload_media(
             )
 
         library = ws.assets or ws.outputs
+        if shared:
+            library = _common_assets(ws)
+            if not library:
+                raise HTTPException(
+                    status_code=409,
+                    detail="This server has no shared asset library - it was "
+                    "configured from loose directories rather than a workspace "
+                    "root, so there is nothing for an asset to be common to",
+                )
         uploads_dir = os.path.join(library, UPLOADS_SUBDIR)
-        os.makedirs(uploads_dir, exist_ok=True)
         name = f"{uuid.uuid4().hex}{extension}"
+        if asset_name:
+            name = asset_name
+            if not os.path.splitext(name)[1]:
+                name = f"{name}{extension}"
+            try:
+                # The same check the keep route makes: a name, possibly with
+                # folders in it, that cannot climb out of the library
+                name = validate_asset_reference(name)
+            except SecurityError as e:
+                raise HTTPException(status_code=400, detail=str(e))
+            if os.path.splitext(name)[1].lower() != extension:
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"asset_name {asset_name!r} does not match the "
+                    f"uploaded file's kind ({extension})",
+                )
+        os.makedirs(uploads_dir, exist_ok=True)
         try:
             dest = validate_output_path(os.path.join(uploads_dir, name), uploads_dir)
         except SecurityError as e:
             raise HTTPException(status_code=400, detail=str(e))
+        os.makedirs(os.path.dirname(dest), exist_ok=True)
 
         # Off the event loop: a 200 MB write would otherwise stall every SSE
         # stream and poll for its duration
         await run_in_threadpool(_write_bytes, dest, body)
         logger.info(f"Saved upload {filename!r} -> {dest}")
-        if ws.assets:
+        if shared or ws.assets:
             return {
                 "path": f"asset:{UPLOADS_SUBDIR}/{name}",
                 "url": _served_url(f"/inputs/{UPLOADS_SUBDIR}/{quote(name)}", ws),
+                "shared": shared,
             }
         return {
             "path": dest,
             "url": _served_url(f"/outputs/{UPLOADS_SUBDIR}/{quote(name)}", ws),
         }
 
+    def _asset_origin(ws, index, root):
+        """Which library an asset came from: this workspace's own, the one
+        shared by every workspace under the root, or a read-only examples
+        tree. A client that cannot tell them apart cannot say why deleting
+        one answers 403."""
+        if index == 0:
+            return WORKSPACE_ORIGIN
+        common = _common_assets(ws)
+        if common and os.path.abspath(common) == root:
+            return COMMON_ORIGIN
+        return EXAMPLES_ORIGIN
+
     @app.get("/api/assets")
     def list_assets(ws: Workspace = Depends(selected_workspace)):
         """The asset library: the input media an 'asset:' reference names.
@@ -2058,7 +2307,7 @@ def list_assets(ws: Workspace = Depends(selected_workspace)):
                         "kind": kind,
                         "size": stat.st_size,
                         "mtime": stat.st_mtime,
-                        "origin": WORKSPACE_ORIGIN if index == 0 else EXAMPLES_ORIGIN,
+                        "origin": _asset_origin(ws, index, root),
                         # For the editor's own preview - fetchable the same
                         # way an upload's URL is
                         "url": _served_url(f"/inputs/{quote(relative)}", ws),
@@ -2080,11 +2329,17 @@ class KeepRequest(BaseModel):
         asset_name: Optional[str] = Field(
             default=None,
             description="Name to keep it under in the asset library; its own "
-            "file name when omitted",
+            "file name when omitted. May name a folder; the kept file's "
+            "extension is assumed when the name has none",
         )
         overwrite: bool = Field(
             default=False, description="Replace an asset already under that name"
         )
+        shared: bool = Field(
+            default=False,
+            description="Keep it in the library every workspace under this "
+            "root shares, rather than in this workspace's own",
+        )
 
     @app.post("/api/assets/keep", status_code=201)
     def keep_output_as_asset(
@@ -2104,14 +2359,34 @@ def keep_output_as_asset(
         multi-gigabyte video to reuse one frame would be paying for the
         round trip twice.
         """
-        library = ws.assets
+        library = _common_assets(ws) if request.shared else ws.assets
         if not library:
             raise HTTPException(
-                status_code=409, detail="This workspace has no asset library"
+                status_code=409,
+                detail=(
+                    "This server has no shared asset library"
+                    if request.shared
+                    else "This workspace has no asset library"
+                ),
             )
 
         source = _output_file(request.name, ws.outputs)
         asset_name = request.asset_name or os.path.basename(request.name)
+        # The kept file's own extension when the name carries none, and a
+        # refusal when it carries a contradicting one - exactly what the
+        # upload route does with its `asset_name`. Without this a kept asset
+        # could be written under an extensionless name, which the library
+        # listing (which reads by kind) never shows again: the call reported
+        # success and the asset was invisible (T014)
+        extension = os.path.splitext(os.path.basename(request.name))[1].lower()
+        if not os.path.splitext(asset_name)[1]:
+            asset_name = f"{asset_name}{extension}"
+        elif os.path.splitext(asset_name)[1].lower() != extension:
+            raise HTTPException(
+                status_code=400,
+                detail=f"asset_name {request.asset_name!r} does not match the "
+                f"kept file's kind ({extension or 'no extension'})",
+            )
         try:
             asset_name = validate_asset_reference(asset_name)
             destination = validate_path(os.path.join(library, asset_name), library)
@@ -2145,8 +2420,54 @@ def keep_output_as_asset(
             "name": asset_name,
             "path": destination,
             "linked": linked,
+            "shared": bool(request.shared),
         }
 
+    @app.delete("/api/assets/{name:path}")
+    def delete_asset(name: str, ws: Workspace = Depends(selected_workspace)):
+        """Permanently remove one file from the asset library.
+
+        Deletes from whichever library on the search path holds it, the
+        workspace's own first, so the name deleted is the name 'asset:'
+        would have resolved to. An asset a read-only examples tree brought
+        with it is not this server's to delete - the same 403 a read-only
+        prompt or workflow answers with.
+
+        Not recoverable, and any workflow still carrying that 'asset:'
+        reference stops loading. Without this, everything else that writes
+        the library (uploads, keep) had no counterpart and a mistake could
+        only be cleaned up on the box (T014).
+        """
+        roots = _asset_roots(ws)
+        if not roots:
+            raise HTTPException(
+                status_code=409, detail="This server has no asset library"
+            )
+        try:
+            relative = validate_asset_reference(name)
+        except SecurityError as e:
+            raise HTTPException(status_code=400, detail=str(e))
+
+        for index, root in enumerate(roots):
+            try:
+                path = validate_path(os.path.join(root, relative), root)
+            except SecurityError:
+                continue
+            if not os.path.isfile(path):
+                continue
+            origin = _asset_origin(ws, index, root)
+            if origin == EXAMPLES_ORIGIN:
+                raise HTTPException(
+                    status_code=403,
+                    detail=f"asset:{relative} is read-only: it comes from an "
+                    f"examples library, not a library this server writes",
+                )
+            os.remove(path)
+            logger.info(f"Deleted asset:{relative} ({path})")
+            return {"name": relative, "deleted": True, "origin": origin}
+
+        raise HTTPException(status_code=404, detail=f"No such asset: {relative}")
+
     # ----------------------------------------------------------------- models
 
     @app.get("/api/models")
diff --git a/dw/server/jobs.py b/dw/server/jobs.py
index 2299261..e58cd0b 100644
--- a/dw/server/jobs.py
+++ b/dw/server/jobs.py
@@ -20,6 +20,7 @@
 from ..repl_worker import WorkerManager
 from ..workflow import workflow_from_file, workflow_from_definition
 from ..introspection import workflow_argument_warnings
+from ..variables import argument_errors
 from ..security import (
     SecurityError,
     validate_json_size,
@@ -155,21 +156,32 @@ def record(self, job):
                 ),
             )
 
-    def recent_summaries(self, limit=200, workspace=None):
+    def recent_summaries(self, limit=200, workspace=None, statuses=None):
         """Summary rows only - the jobs list is polled, and parsing four JSON
         blobs per row just to show six scalars was pure waste.
 
         `workspace` filters to one workspace's rows; omitted, history spans
         all of them the way the list already did before workspaces existed.
+        `statuses` filters to a set of terminal states - in SQL rather than
+        over the returned rows, or the newest-first cap above would be
+        spent on rows the filter then drops.
         """
         query = (
             "SELECT id, workflow, status, created_at, started_at, finished_at,"
             " workspace, workflow_name, run_id FROM jobs"
         )
         params = []
+        clauses = []
         if workspace:
-            query += " WHERE workspace = ?"
+            clauses.append("workspace = ?")
             params.append(workspace)
+        if statuses:
+            statuses = list(statuses)
+            placeholders = ", ".join("?" for _ in statuses)
+            clauses.append(f"status IN ({placeholders})")
+            params.extend(statuses)
+        if clauses:
+            query += " WHERE " + " AND ".join(clauses)
         query += " ORDER BY created_at DESC LIMIT ?"
         params.append(limit)
         with self._lock, self._connect() as connection:
@@ -517,6 +529,19 @@ def submit(
         if asset_dir:
             spec["asset_dir"] = asset_dir
 
+        # The caller's own arguments, checked against the variables this
+        # workflow declares. set_variables makes the same check at the top of
+        # the run, so a bad name failed a job that had already been queued -
+        # and a workflow declaring no variables dropped every argument in
+        # silence. Refused here instead, while it is still a 400
+        problems = argument_errors(loaded.workflow_definition, arguments)
+        if problems:
+            raise ValueError(
+                "; ".join(
+                    f"{problem['path']}: {problem['message']}" for problem in problems
+                )
+            )
+
         # Signature-level check of pipeline arguments - the typo that would
         # otherwise be a TypeError after the model loads becomes a warning
         # the client sees at submission
@@ -706,10 +731,13 @@ def describe(self, job):
             detail["queue_position"] = position
         return detail
 
-    def list(self, workspace=None):
+    def list(self, workspace=None, statuses=None):
         """All jobs, live and historical, sorted by creation. `workspace` filters to one workspace; omitted, the list
         spans every workspace the server holds, unchanged from before
-        workspaces existed."""
+        workspaces existed. `statuses` filters to a set of job states
+        ('queued', 'running', 'succeeded', 'failed', 'cancelled'); omitted,
+        every state is listed."""
+        statuses = set(statuses) if statuses else None
         with self._lock:
             live = sorted(self.jobs.values(), key=lambda j: j.created_at)
             positions = {job_id: i for i, job_id in enumerate(self._pending)}
@@ -719,10 +747,14 @@ def list(self, workspace=None):
             summary = job.summary()
             if workspace and summary["workspace"] != workspace:
                 continue
+            if statuses and summary["status"] not in statuses:
+                continue
             if job.id in positions:
                 summary["queue_position"] = positions[job.id]
             summaries.append(summary)
-        for historical in self.history.recent_summaries(workspace=workspace):
+        for historical in self.history.recent_summaries(
+            workspace=workspace, statuses=statuses
+        ):
             if historical["id"] not in live_ids:
                 summaries.append(historical)
         summaries.sort(key=lambda summary: summary["created_at"] or 0)
@@ -856,6 +888,28 @@ def _run_job(self, job):
                 status, error, traceback_text = outcome
                 self._finish(job, status, error=error, traceback_text=traceback_text)
 
+    def _record_manifest(self, job, message):
+        """What the run wrote, named the way clients address outputs.
+
+        Recorded for a failed or cancelled run as well as a successful one -
+        the files the steps before the stop wrote are on disk either way,
+        and a manifest that omits them is the difference between "this run
+        produced nothing" and "this run produced four of five shots"
+        (T015)."""
+        job.manifest = [
+            (
+                {
+                    **entry,
+                    "files": self._relative_output_names(
+                        entry["files"], job.spec.get("output_dir")
+                    ),
+                }
+                if "files" in entry
+                else entry
+            )
+            for entry in message.get("manifest", [])
+        ]
+
     def _relative_output_names(self, paths, output_dir=None):
         """The worker reports absolute paths; clients build '/outputs/<name>'
         URLs, and a run writes under '<output_dir>/<identity>/<run id>/'
@@ -918,23 +972,16 @@ def _consume_results(self, job):
                 self.last_memory = message.get("info")
                 job.add_event({"event": "memory", "info": self.last_memory})
             elif message_type == "success":
-                job.manifest = [
-                    (
-                        {
-                            **entry,
-                            "files": self._relative_output_names(
-                                entry["files"], job.spec.get("output_dir")
-                            ),
-                        }
-                        if "files" in entry
-                        else entry
-                    )
-                    for entry in message.get("manifest", [])
-                ]
+                self._record_manifest(job, message)
                 return (SUCCEEDED, None, None)
             elif message_type == "cancelled":
+                self._record_manifest(job, message)
                 return (CANCELLED, None, None)
             elif message_type == "error":
+                # A failed run's steps too: the ones before the failure wrote
+                # real files, and a job that reports an empty manifest hides
+                # them behind the error that stopped the run
+                self._record_manifest(job, message)
                 return (
                     FAILED,
                     message.get("message"),
diff --git a/dw/tasks/audio_utils.py b/dw/tasks/audio_utils.py
index e82ccf3..946317e 100644
--- a/dw/tasks/audio_utils.py
+++ b/dw/tasks/audio_utils.py
@@ -235,6 +235,22 @@ def load_audio(location, base_dir=None):
     return as_channels_samples(data), sample_rate
 
 
+def _as_track(waveform, sample_rate):
+    """An audio task's return value: the waveform with the rate it is at.
+
+    Every one of these commands already knows the rate - it was given, or it
+    came off the file or the video the track was taken from - and dropping it
+    on the way out made the next command in the chain ask for it again. A
+    resample fed straight from a slice failed for want of a number the slice
+    had read and thrown away (2026-09-11). An AudioTrack carries it, and
+    everything downstream of audio reads '.audio'/'.sample_rate' already; a
+    'sample_rate' the workflow declares on the result still wins at save.
+    """
+    from ..result import AudioTrack
+
+    return AudioTrack(numpy.ascontiguousarray(waveform), int(sample_rate))
+
+
 def _as_number(value, kind, name):
     """Coerce a numeric slice argument given as a string, leaving None alone."""
     if not isinstance(value, str):
@@ -276,8 +292,8 @@ def slice_audio(
             file or a video it overrides the rate they carry
 
     Returns:
-        The slice as a (samples, channels) float32 array - the layout audio
-        results are saved in
+        An AudioTrack holding the slice and the rate it is at, so the next
+        audio command in the chain does not have to be told the rate again
     """
     # A variable a workflow declares null carries no type, so a value given for
     # it on the command line arrives as a string - the same coercion the upscale
@@ -313,7 +329,7 @@ def slice_audio(
             "'start_frame'/'num_frames'/'fps'"
         )
 
-    return slice_samples(waveform, start, length).T
+    return _as_track(slice_samples(waveform, start, length), sample_rate)
 
 
 def resample_audio(audio, target_sample_rate, sample_rate=None):
@@ -335,12 +351,12 @@ def resample_audio(audio, target_sample_rate, sample_rate=None):
             file or a video it overrides the rate they carry
 
     Returns:
-        The resampled track as a (samples, channels) float32 array
+        An AudioTrack holding the resampled waveform and its new rate
     """
     waveform, sample_rate = _waveform_and_rate(audio, sample_rate, "resample_audio")
 
     if sample_rate == target_sample_rate:
-        return waveform.T
+        return _as_track(waveform, sample_rate)
 
     import av
     from av.audio.resampler import AudioResampler
@@ -363,7 +379,9 @@ def resample_audio(audio, target_sample_rate, sample_rate=None):
         f"Resampled {waveform.shape[1]} samples at {sample_rate}Hz "
         f"to {target_sample_rate}Hz"
     )
-    return numpy.concatenate(converted, axis=1).astype(numpy.float32).T
+    return _as_track(
+        numpy.concatenate(converted, axis=1).astype(numpy.float32), target_sample_rate
+    )
 
 
 def crossfade_audio(audios, crossfade_ms=75, sample_rate=None):
@@ -380,7 +398,7 @@ def crossfade_audio(audios, crossfade_ms=75, sample_rate=None):
             brings its own; given here it wins
 
     Returns:
-        The joined track as a (samples, channels) float32 array
+        An AudioTrack holding the joined waveform and its rate
     """
     if not isinstance(audios, list) or not audios:
         raise ValueError("crossfade_audio needs a non-empty list of audio tracks")
@@ -400,7 +418,9 @@ def crossfade_audio(audios, crossfade_ms=75, sample_rate=None):
                 f"crossfade_audio needs one sample rate, got {sorted(rates)}"
             )
         sample_rate = rates.pop()
-    return crossfade_concat(waveforms, sample_rate, crossfade_ms).T
+    return _as_track(
+        crossfade_concat(waveforms, sample_rate, crossfade_ms), sample_rate
+    )
 
 
 def mix_audio(audios, gains=None, sample_rate=None):
@@ -427,7 +447,7 @@ def mix_audio(audios, gains=None, sample_rate=None):
             brings its own; given here it wins
 
     Returns:
-        The mixed track as a (samples, channels) float32 array
+        An AudioTrack holding the mixed waveform and its rate
     """
     if not isinstance(audios, list) or not audios:
         raise ValueError("mix_audio needs a non-empty list of audio tracks")
@@ -460,7 +480,86 @@ def mix_audio(audios, gains=None, sample_rate=None):
     for index, waveform in enumerate(waveforms):
         gain = 1.0 if gains is None else float(gains[index])
         mixed[:, : waveform.shape[1]] += waveform * gain
-    return mixed.T
+    return _as_track(mixed, sample_rate)
+
+
+def loop_audio(
+    audio,
+    duration_seconds=None,
+    target_frames=None,
+    fps=None,
+    crossfade_ms=250,
+    sample_rate=None,
+):
+    """Task command: make a bed of a given length out of a short recording.
+
+    A cut between two independently generated shots has a hole in it: each
+    shot carries its own room, and nothing runs underneath the seam. A
+    continuous bed laid under the whole cut is what fills it - the way a
+    location's room tone is laid under a dialogue scene so the edits stop
+    being audible - and a bed is made by looping a few seconds of tone to
+    the length of the picture.
+
+    Laps are joined with an equal-power crossfade rather than butted
+    together, so the loop point is not a click and a tone with any movement
+    in it does not tick once a second. The source is used whole every lap;
+    only the last one is trimmed, to land exactly on the requested length. A
+    source longer than the request is trimmed to it.
+
+    Args:
+        audio: Path or URL of an audio file (or of a video file, whose
+            soundtrack is taken), a video generated with a soundtrack, or a
+            waveform (which needs sample_rate alongside it)
+        duration_seconds: How long the bed should be, in seconds
+        target_frames: How long the bed should be, in video frames - needs
+            'fps', and is how a bed is matched to a cut exactly
+        fps: Frame rate 'target_frames' is counted at
+        crossfade_ms: Length of the crossfade at each loop point, clamped to
+            the material available
+        sample_rate: Sample rate of a waveform passed directly; given for a
+            file or a video it overrides the rate they carry
+
+    Returns:
+        An AudioTrack holding the bed and the rate it is at
+    """
+    duration_seconds = _as_number(duration_seconds, float, "duration_seconds")
+    target_frames = _as_number(target_frames, int, "target_frames")
+    fps = _as_number(fps, Fraction, "fps")
+    crossfade_ms = _as_number(crossfade_ms, float, "crossfade_ms")
+
+    waveform, sample_rate = _waveform_and_rate(audio, sample_rate, "loop_audio")
+    if waveform.size == 0:
+        raise ValueError("loop_audio needs a source with samples in it")
+
+    if duration_seconds is not None:
+        length = int(round(duration_seconds * sample_rate))
+    elif target_frames is not None:
+        if fps is None:
+            raise ValueError("loop_audio needs 'fps' to count a length in frames")
+        length = frames_to_samples(target_frames, fps, sample_rate)
+    else:
+        raise ValueError(
+            "loop_audio needs either 'duration_seconds' or 'target_frames'/'fps' "
+            "to know how long a bed to make"
+        )
+    if length <= 0:
+        raise ValueError(f"loop_audio needs a length above zero, got {length} samples")
+    if crossfade_ms < 0:
+        raise ValueError("loop_audio 'crossfade_ms' cannot be negative")
+
+    window = min(int(crossfade_ms / 1000.0 * sample_rate), waveform.shape[1] // 2)
+    bed = waveform
+    # Each lap after the first overlaps the one before it by the crossfade, so
+    # a lap adds (source - window) samples rather than a whole source
+    while bed.shape[1] < length:
+        bed = crossfade_concat(
+            [bed, waveform], sample_rate, window / sample_rate * 1000.0
+        )
+    logger.debug(
+        f"loop_audio: {waveform.shape[1]} samples at {sample_rate}Hz looped to "
+        f"{length} ({bed.shape[1]} before trimming)"
+    )
+    return _as_track(bed[:, :length], sample_rate)
 
 
 def _equal_power_ramps(window):
@@ -517,7 +616,7 @@ def fade_audio(audio, fade_in_ms=0, fade_out_ms=0, sample_rate=None):
         sample_rate: Sample rate of a waveform passed directly
 
     Returns:
-        The faded track as a (samples, channels) float32 array
+        An AudioTrack holding the faded waveform and its rate
     """
     waveform, sample_rate = _waveform_and_rate(audio, sample_rate, "fade_audio")
     if fade_in_ms < 0 or fade_out_ms < 0:
@@ -531,7 +630,7 @@ def fade_audio(audio, fade_in_ms=0, fade_out_ms=0, sample_rate=None):
     fade_out = min(int(round(fade_out_ms / 1000 * sample_rate)), length)
     if fade_out:
         faded[:, length - fade_out :] *= _fade_curve(fade_out)
-    return faded.T
+    return _as_track(faded, sample_rate)
 
 
 def normalize_audio(audio, peak_dbfs=-1.0, sample_rate=None):
@@ -551,21 +650,21 @@ def normalize_audio(audio, peak_dbfs=-1.0, sample_rate=None):
         sample_rate: Sample rate of a waveform passed directly
 
     Returns:
-        The scaled track as a (samples, channels) float32 array; a silent
+        An AudioTrack holding the scaled waveform and its rate; a silent
         track is returned unchanged
     """
-    waveform, _ = _waveform_and_rate(audio, sample_rate, "normalize_audio")
+    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)")
     peak = float(numpy.abs(waveform).max()) if waveform.size else 0.0
     if peak == 0.0:
         logger.warning("normalize_audio: the track is silent - left unchanged")
-        return waveform.T
+        return _as_track(waveform, sample_rate)
     gain = 10 ** (peak_dbfs / 20) / peak
     logger.debug(
         f"normalize_audio: peak {peak:.3f}, gain {20 * numpy.log10(gain):+.1f} dB"
     )
-    return (waveform * gain).astype(numpy.float32).T
+    return _as_track((waveform * gain).astype(numpy.float32), sample_rate)
 
 
 def _fade_curve(window):
diff --git a/dw/tasks/compose_text.py b/dw/tasks/compose_text.py
new file mode 100644
index 0000000..ab71b3a
--- /dev/null
+++ b/dw/tasks/compose_text.py
@@ -0,0 +1,74 @@
+"""Assemble one block of text out of parts written once.
+
+A multi-shot workflow says the same things about its characters in every
+shot: who they are, what they are wearing, what their voice sounds like. The
+engine has no interpolation - a reference is the whole value of an argument,
+never a fragment spliced into one - which is deliberate (docs/WORKFLOW_GUIDE.md,
+'no interpolation'): a `{{name}}` inside a prompt would make every prompt a
+template language nobody declared, and resolution order for a half-substituted
+string is a bottomless pit.
+
+The way out is not interpolation but composition. A part is a whole value -
+a variable, an earlier step's output, a stored prompt - and this task joins
+parts in the order they are given. A character bible is then written once,
+as a variable, and named by every shot that needs it; changing the voice
+changes it everywhere, and nothing has to be hand-copied to stay in step.
+
+Positional, not named: the parts are a list, joined in order. A named form
+('{bible} says {line}') would be the interpolation the engine does not have,
+one layer down.
+"""
+
+import logging
+
+logger = logging.getLogger("dw")
+
+
+def compose_text(parts, separator="\n\n", skip_empty=True):
+    """Task command: join parts into one block of text.
+
+    Args:
+        parts: The parts to join, in order. Each is a whole value - usually
+            a "variable:", "prompt:" or "previous_result:" reference the
+            engine has already resolved. Numbers are written out; None is
+            dropped, so an optional part can be a variable left null
+        separator: What goes between the parts. Defaults to a blank line,
+            the paragraph break the prompt formats are written in
+        skip_empty: Drop parts that are None or empty. With it off, an
+            empty part still contributes its separator
+
+    Returns:
+        The joined text
+
+    Raises:
+        ValueError: If parts is not a list, or holds something that is not
+            text or a number - a dict or an image is a sign a reference
+            resolved to something other than what was meant
+    """
+    if not isinstance(parts, list):
+        raise ValueError(
+            f"compose_text needs a list of parts to join, got {type(parts).__name__}"
+        )
+
+    pieces = []
+    for index, part in enumerate(parts):
+        if part is None:
+            if skip_empty:
+                continue
+            part = ""
+        if isinstance(part, bool) or not isinstance(part, (str, int, float)):
+            raise ValueError(
+                f"compose_text part {index} is a {type(part).__name__} - a part "
+                f"is text (or a number), and anything else means the reference "
+                f"in that position resolved to something other than text"
+            )
+        text = part if isinstance(part, str) else str(part)
+        if skip_empty and not text.strip():
+            continue
+        pieces.append(text)
+
+    if not pieces:
+        raise ValueError("compose_text was given nothing to join")
+
+    logger.debug(f"compose_text: joined {len(pieces)} of {len(parts)} parts")
+    return separator.join(pieces)
diff --git a/dw/tasks/task.py b/dw/tasks/task.py
index 6467c4e..eb32869 100644
--- a/dw/tasks/task.py
+++ b/dw/tasks/task.py
@@ -198,6 +198,15 @@ def _handle_crossfade_audio(task, arguments, previous_pipelines):
     return crossfade_audio(**arguments)
 
 
+@register_command("loop_audio", implementation="dw.tasks.audio_utils.loop_audio")
+def _handle_loop_audio(task, arguments, previous_pipelines):
+    """Loop a short recording into a bed of a given length"""
+    logger.debug("Looping audio")
+    from .audio_utils import loop_audio
+
+    return loop_audio(**arguments)
+
+
 @register_command(
     "stabilize_video", implementation="dw.tasks.stabilize.stabilize_video"
 )
@@ -218,6 +227,15 @@ def _handle_mix_audio(task, arguments, previous_pipelines):
     return mix_audio(**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"""
+    logger.debug("Composing text")
+    from .compose_text import compose_text
+
+    return compose_text(**arguments)
+
+
 @register_command(
     "format_chat_message", implementation="dw.tasks.format_messages.format_chat_message"
 )
diff --git a/dw/variables.py b/dw/variables.py
index f45bfcb..4ac42e1 100644
--- a/dw/variables.py
+++ b/dw/variables.py
@@ -237,3 +237,51 @@ def get_value(v, desired_type, name=None):
         )
         logger.error(message)
         raise ValueError(message) from e
+
+
+def argument_errors(definition, arguments):
+    """What is wrong with a caller's `arguments` for this workflow, before
+    anything is queued.
+
+    Exactly the check `set_variables` makes at the top of a run - an
+    undeclared name, a value that will not coerce to the type the default
+    declares - made against a copy, so nothing is mutated and the answer
+    costs no GPU time. A workflow that declares no variables at all takes no
+    arguments: today those are dropped in silence (`Workflow.run` only
+    substitutes when a `variables` block exists), which is the one case the
+    run itself does not report.
+
+    Args:
+        definition: A workflow definition
+        arguments: The caller's argument dict; empty or None means no errors
+
+    Returns:
+        [{"path": "arguments.<name>", "message": str}, ...], one per bad
+        argument, in the order they were given
+    """
+    if not arguments:
+        return []
+    if not isinstance(arguments, dict):
+        return [{"path": "arguments", "message": "arguments must be an object"}]
+
+    declared = definition.get("variables") if isinstance(definition, dict) else None
+    if not isinstance(declared, dict) or not declared:
+        return [
+            {
+                "path": f"arguments.{name}",
+                "message": f"This workflow declares no variables, so '{name}' "
+                "has nowhere to land - it would be ignored by the run",
+            }
+            for name in arguments
+        ]
+
+    errors = []
+    for name, value in arguments.items():
+        # One at a time against a fresh copy, so each bad argument is
+        # reported with its own name rather than the first one stopping the
+        # rest from being checked
+        try:
+            set_variables({name: value}, copy.deepcopy(declared))
+        except (ValueError, TypeError, SecurityError) as e:
+            errors.append({"path": f"arguments.{name}", "message": str(e)})
+    return errors
diff --git a/dw/worker.py b/dw/worker.py
index 1590abb..911aeb8 100644
--- a/dw/worker.py
+++ b/dw/worker.py
@@ -173,6 +173,10 @@ def _handle_execute(self, command: Dict[str, Any]):
         arguments = command["arguments"]
         output_dir = command["output_dir"]
         log_level = command.get("log_level", "INFO")
+        # Bound before the load, so a failure or a cancellation still reports
+        # whatever the run had written by then - the steps that did complete
+        # are the first thing a failed long run is asked about
+        workflow = None
 
         try:
             set_log_level(log_level)
@@ -256,7 +260,11 @@ def _handle_execute(self, command: Dict[str, Any]):
         except WorkflowCancelled:
             self._cleanup_between_runs()
             self.result_queue.put(
-                {"type": "cancelled", "message": "Workflow run cancelled"}
+                {
+                    "type": "cancelled",
+                    "message": "Workflow run cancelled",
+                    "manifest": getattr(workflow, "manifest", []),
+                }
             )
         except Exception as e:
             logger.error(f"Error executing workflow: {e}", exc_info=True)
@@ -265,6 +273,10 @@ def _handle_execute(self, command: Dict[str, Any]):
                     "type": "error",
                     "message": f"Workflow execution error: {str(e)}",
                     "traceback": traceback.format_exc(),
+                    # The files the steps before the failure wrote are on
+                    # disk; reporting them is what keeps a run that died at
+                    # step five from looking like one that produced nothing
+                    "manifest": getattr(workflow, "manifest", []),
                 }
             )
 
diff --git a/dw/workflow.py b/dw/workflow.py
index e367aff..cea1b08 100644
--- a/dw/workflow.py
+++ b/dw/workflow.py
@@ -17,6 +17,10 @@
     activate_context,
     deactivate_context,
 )
+from .previous_results import (
+    StepResults,
+    previous_result_reference_errors,
+)
 from .step import Step
 from .step_cache import (
     step_cache,
@@ -281,7 +285,13 @@ def effective_output_dir(self):
     def validation_errors(self):
         """Every schema violation in the definition, as [{path, message}];
         empty when it validates."""
-        return validate_data_all(self.workflow_definition, load_schema("workflow"))
+        errors = validate_data_all(self.workflow_definition, load_schema("workflow"))
+        # Only once the shape is known good: the reference pass walks the
+        # steps array and a definition that fails the schema may have no
+        # such array to walk
+        if errors:
+            return errors
+        return previous_result_reference_errors(self.workflow_definition)
 
     def validate(self):
         """Validates workflow definition against JSON schema.
@@ -463,7 +473,9 @@ def run(
                 )
 
             # Initialize collections for sharing state between steps
-            results = {}  # Stores results from each step
+            # Stores results from each step, and remembers the names of
+            # steps whose results have since been released
+            results = StepResults()
             shared_components = {}  # Shared resources between steps
 
             # Use provided pipelines cache or create new dict
diff --git a/dw/workflow_sources.py b/dw/workflow_sources.py
index 56134e8..94788c4 100644
--- a/dw/workflow_sources.py
+++ b/dw/workflow_sources.py
@@ -28,6 +28,10 @@
 WORKSPACE_ORIGIN = "workspace"
 EXAMPLES_ORIGIN = "examples"
 BUILTIN_ORIGIN = "builtin"
+# Not a workflow source - the asset library shared by every workspace under
+# one root reports itself this way, so a client can tell a shared asset from
+# one of its own
+COMMON_ORIGIN = "common"
 
 
 def builtin_root():
diff --git a/dw/workspace.py b/dw/workspace.py
index 3625b0f..756ddd6 100644
--- a/dw/workspace.py
+++ b/dw/workspace.py
@@ -61,6 +61,16 @@
 
 SUBDIRS = (WORKFLOWS_SUBDIR, PROMPTS_SUBDIR, ASSETS_SUBDIR, OUTPUTS_SUBDIR)
 
+# The library shared by every workspace under one root:
+# '<root>/common/assets'. The prompt library is shared because a 'prompt:'
+# reference is shared by reference; assets are per workspace because an
+# upload belongs to the work that made it - but a recurring cast is neither,
+# and reaching it from a fresh workspace meant copying the files in
+# (2026-09-11). A shared library sits on every workspace's asset search
+# path, behind its own, so a workspace name still shadows a shared one and
+# a write still lands in the workspace unless it says otherwise
+COMMON_SUBDIR = "common"
+
 # Where a job export lands: '<root>/exports/<job id>/'. Not a workspace
 # folder - it is beside them, holding gathered copies rather than working
 # content - but it is a name a workspace may not take, and workspace_names
@@ -82,7 +92,7 @@
 
 # Names a workspace cannot take, because the root's own folders already
 # use them - its four content folders, and the exports gathered beside them
-RESERVED_WORKSPACE_NAMES = SUBDIRS + (EXPORTS_SUBDIR,)
+RESERVED_WORKSPACE_NAMES = SUBDIRS + (EXPORTS_SUBDIR, COMMON_SUBDIR)
 
 # What a named workspace holds - prompts excluded, per above
 NAMED_SUBDIRS = (WORKFLOWS_SUBDIR, ASSETS_SUBDIR, OUTPUTS_SUBDIR)
@@ -108,7 +118,14 @@ class Workspace:
     the default has four.
     """
 
-    def __init__(self, root, source, name=DEFAULT_WORKSPACE_NAME, prompts_root=None):
+    def __init__(
+        self,
+        root,
+        source,
+        name=DEFAULT_WORKSPACE_NAME,
+        prompts_root=None,
+        common_root=None,
+    ):
         self.root = os.path.abspath(os.path.expanduser(str(root)))
         self.source = source
         self.name = name
@@ -117,6 +134,13 @@ def __init__(self, root, source, name=DEFAULT_WORKSPACE_NAME, prompts_root=None)
             if prompts_root
             else None
         )
+        # Like the prompt library, the shared one belongs to the root rather
+        # than to this workspace - a named workspace is handed the root's
+        self._common_root = (
+            os.path.abspath(os.path.expanduser(str(common_root)))
+            if common_root
+            else None
+        )
 
     @property
     def is_default(self):
@@ -152,6 +176,12 @@ def assets(self):
     def outputs(self):
         return os.path.join(self.root, OUTPUTS_SUBDIR)
 
+    @property
+    def common_assets(self):
+        """The asset library every workspace under this root shares."""
+        root = self._common_root or os.path.join(self.root, COMMON_SUBDIR)
+        return os.path.join(root, ASSETS_SUBDIR)
+
     def ensure(self):
         """Create the workspace and its subdirectories if they are missing.
 
@@ -174,6 +204,7 @@ def describe(self):
             "assets": self.assets,
             "outputs": self.outputs,
             "prompts": self.prompts,
+            "common_assets": self.common_assets,
         }
 
     def __repr__(self):
@@ -436,6 +467,7 @@ def named_workspace(workspace, name):
         workspace.source,
         name=name,
         prompts_root=os.path.join(workspace.root, PROMPTS_SUBDIR),
+        common_root=os.path.join(workspace.root, COMMON_SUBDIR),
     )
 
 
@@ -653,6 +685,15 @@ def outputs(self):
     def prompts(self):
         return self._prompts
 
+    @property
+    def common_assets(self):
+        """The shared library, when there is a root to hang it off. A server
+        configured from three loose directories has no root and so no shared
+        library - there is nothing for it to be common to."""
+        return (
+            os.path.join(self.root, COMMON_SUBDIR, ASSETS_SUBDIR) if self.root else None
+        )
+
     def ensure(self):
         """Not implemented here: a ConfiguredWorkspace's folders were each
         already resolved by the entry point that configured them, and each
diff --git a/dw_mcp/CLAUDE.md b/dw_mcp/CLAUDE.md
index 719fcc5..b186c6c 100644
--- a/dw_mcp/CLAUDE.md
+++ b/dw_mcp/CLAUDE.md
@@ -17,7 +17,13 @@ means something else to the engine), `use_workspace` to switch, and
 `DwClient._scoped` adds the selector to every request's query string so no
 handler carries a workspace parameter. The default sends nothing, so a
 session that never chooses looks exactly like one from before workspaces.
-`run_workflow` and `validate_workflow` are the two exceptions: each takes an
+`list_jobs` is bounded (newest 20) rather than complete: the unbounded
+listing spilled 176 entries past a client's tool-result limit and could not
+be called at all, so the tool asks the API for `limit`/`status`, reverses the
+oldest-first list the web UI polls, and reports `total` so a cut answer says
+it was cut, and it takes a `workspace` of its own to narrow by.
+`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.
diff --git a/dw_mcp/assets.py b/dw_mcp/assets.py
index 5d10e2a..f8581f8 100644
--- a/dw_mcp/assets.py
+++ b/dw_mcp/assets.py
@@ -11,7 +11,7 @@
 
 import os
 
-from dw_mcp.client import DwApiError
+from dw_mcp.client import DwApiError, api_path
 
 # Twin of the server's own limit (dw/server/app.py). Checked here as well so
 # a 200MB file fails before it is read and pushed, not after
@@ -43,11 +43,26 @@
 
 def list_assets(client):
     """The input media on the server, each with the 'asset:' reference a
-    workflow argument carries."""
+    workflow argument carries.
+
+    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.
+    """
     return client.get_json("/api/assets")
 
 
-def keep_output(client, name, asset_name=None, overwrite=False):
+def delete_asset(client, name):
+    """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.
+    """
+    return client.delete_json(api_path("api", "assets", name))
+
+
+def keep_output(client, name, asset_name=None, overwrite=False, shared=False):
     """Keep a generated file as an input asset, under a stable name.
 
     A run's files are named by the run that made them, which is the wrong
@@ -58,20 +73,41 @@ def keep_output(client, name, asset_name=None, overwrite=False):
     The copy happens on the server, inside the workspace - downloading a
     render here only to upload it back would move the bytes twice for
     nothing.
+
+    `shared` keeps it in the library every workspace under the server's
+    root shares instead, which is where something a later episode in its
+    own workspace has to reach belongs.
     """
     return client.post_json(
         "/api/assets/keep",
-        {"name": name, "asset_name": asset_name, "overwrite": overwrite},
+        {
+            "name": name,
+            "asset_name": asset_name,
+            "overwrite": overwrite,
+            "shared": shared,
+        },
     )
 
 
-def upload_asset(client, file_path):
+def upload_asset(client, file_path, asset_name=None, shared=False):
     """Put a local image, video or audio file into the server's asset
     library and get back the reference a workflow can use.
 
     The file is read from the machine this MCP server runs on, which is not
     necessarily the machine dw.serve runs on - that is the point of the
     tool.
+
+    `asset_name` is the name it is stored under - 'cast/priya-voice.wav'
+    rather than the random one an upload gets by default. A recurring cast
+    referenced as 'asset:uploads/084eaecc....wav' in every workflow cannot
+    be told apart without opening each file, which is the whole reason to
+    name one (2026-09-11). The extension comes from the uploaded file when
+    the name has none.
+
+    `shared` puts it in the library every workspace shares rather than in
+    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.
     """
     path = os.path.abspath(os.path.expanduser(str(file_path)))
     if not os.path.isfile(path):
@@ -97,9 +133,12 @@ def upload_asset(client, file_path):
     except OSError as e:
         raise DwApiError(f"Could not read {file_path}: {e}")
 
-    result = client.post_bytes(
-        "/api/uploads", body, params={"filename": os.path.basename(path)}
-    )
+    params = {"filename": os.path.basename(path)}
+    if asset_name:
+        params["asset_name"] = asset_name
+    if shared:
+        params["shared"] = "true"
+    result = client.post_bytes("/api/uploads", body, params=params)
     # '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
diff --git a/dw_mcp/authoring.py b/dw_mcp/authoring.py
index 9e72db2..1ceebe1 100644
--- a/dw_mcp/authoring.py
+++ b/dw_mcp/authoring.py
@@ -9,22 +9,29 @@
 from dw_mcp.client import DwApiError, api_path
 
 
-def validate_workflow(client, workflow=None, name=None, workspace=None):
+def validate_workflow(client, workflow=None, name=None, workspace=None, arguments=None):
     """Schema- and signature-check a workflow without queuing anything. This
     is free (no GPU work) and should be called before any run or save. Give
     either an inline definition or the name of a stored one, as
-    `list_workflows` reports it."""
+    `list_workflows` reports it.
+
+    `arguments` is the same dict `run_workflow` takes, checked against the
+    variables the workflow declares and against this workspace's libraries.
+    Without it the answer is about the stored definition and its stock
+    defaults - which is everything except the part the caller wrote
+    (2026-09-11)."""
     if (workflow is None) == (name is None):
         raise DwApiError(
             "Provide exactly one of `workflow` (an inline definition) or "
             "`name` (a stored workflow)."
         )
     params = {"workspace": workspace} if workspace else None
-    if workflow is None:
-        # The server resolves the name against its own workflow directory,
-        # so validation sees the same base directory a run would
-        return client.post_json("/api/validate", {"workflow_path": name}, params=params)
-    return client.post_json("/api/validate", {"workflow": workflow}, params=params)
+    payload = {"workflow_path": name} if workflow is None else {"workflow": workflow}
+    if arguments:
+        payload["arguments"] = arguments
+    # The server resolves a name against its own workflow directory, so
+    # validation sees the same base directory a run would
+    return client.post_json("/api/validate", payload, params=params)
 
 
 def save_workflow(client, name, workflow):
diff --git a/dw_mcp/catalog.py b/dw_mcp/catalog.py
index 2a48d1f..1f758a2 100644
--- a/dw_mcp/catalog.py
+++ b/dw_mcp/catalog.py
@@ -28,8 +28,17 @@ def list_workflows(
     return client.get_json("/api/workflows", params=params)
 
 
-def get_workflow(client, name):
-    """One workflow's full JSON definition."""
+def get_workflow(client, name, variables_only=False):
+    """One workflow's full JSON definition.
+
+    With variables_only=True, just its variables and what they default to -
+    confirming that a stored workflow's audio_bleed_ms is 1800 otherwise
+    means pulling the whole definition, quantization blocks and all, to
+    read one integer (2026-09-11). Long defaults come back cut to their
+    first 200 characters, with the names of the cut ones in `truncated`.
+    """
+    if variables_only:
+        return client.get_json(api_path("api", "workflows", name, "variables"))
     return client.get_json(api_path("api", "workflows", name))
 
 
@@ -91,9 +100,40 @@ def get_server_info(client):
     return client.get_json("/api/server")
 
 
-def list_jobs(client):
-    """The live queue plus recent history, oldest first."""
-    return client.get_json("/api/jobs")
+def list_jobs(client, limit=20, status=None, workspace=None):
+    """The live queue plus recent history, newest first and bounded.
+
+    Bounded because the unbounded answer was a dead tool: a server with a
+    few months of history spilled 176 entries past the client's tool-result
+    limit, and the call failed before a single id could be read
+    (2026-09-11). Newest first for the same reason the limit exists - the
+    job worth looking at is almost always the last one.
+
+    `total` is what matched before the cut, so a caller can tell a bounded
+    answer from a complete one; raise `limit` or narrow with `status` /
+    `workspace` to see the rest."""
+    params = {}
+    if limit is not None:
+        params["limit"] = limit
+    if status:
+        params["status"] = (
+            ",".join(status) if isinstance(status, (list, tuple)) else status
+        )
+    if workspace:
+        params["workspace"] = workspace
+    body = client.get_json("/api/jobs", params=params or None)
+    # The API answers oldest first - the order the web UI's list renders in.
+    # An agent reads the top of a tool result, so the newest job belongs there
+    jobs = list(reversed(body.get("jobs") or []))
+    total = body.get("total", len(jobs))
+    answer = {"jobs": jobs, "returned": len(jobs), "total": total}
+    if total > len(jobs):
+        answer["truncated"] = True
+        answer["next"] = (
+            f"{total - len(jobs)} older jobs were not listed - raise `limit`, "
+            "or narrow with `status` or `workspace`."
+        )
+    return answer
 
 
 def list_gallery(client, limit=50):
@@ -101,12 +141,20 @@ def list_gallery(client, limit=50):
     return client.get_json("/api/gallery", params={"limit": limit})
 
 
-def get_gallery_metadata(client, name):
+def get_gallery_metadata(client, name, envelope=False):
     """Metadata embedded in a saved file: the full workflow that made it,
     plus the job that produced it when history remembers one, plus for
     audio and video what the file holds - duration, sample rate, channels,
-    fps, size, peak and mean level in dBFS."""
-    body = client.get_json(api_path("api", "gallery", name, "metadata"))
+    fps, size, peak and mean level in dBFS.
+
+    With envelope=True the soundtrack's level is reported second by second
+    as well, which is what locates something in a track rather than only
+    measuring the whole of it. Opt-in: it is one number per second per
+    measure, and the default answer has to stay small."""
+    body = client.get_json(
+        api_path("api", "gallery", name, "metadata"),
+        params={"envelope": "true"} if envelope else None,
+    )
     media = body.get("media")
     if media and media.get("kind") in ("audio", "video"):
         body["next"] = (
diff --git a/dw_mcp/diagnose.py b/dw_mcp/diagnose.py
index 46f7f5d..4dcffaa 100644
--- a/dw_mcp/diagnose.py
+++ b/dw_mcp/diagnose.py
@@ -142,35 +142,63 @@ def wait_for_job(client, job_id, timeout_seconds=20):
 
     `timeout_seconds` is clamped to [0, MAX_WAIT_SECONDS]: a generation can
     run for minutes, far longer than an MCP client holds a tool call open,
-    so this never blocks past a budget kept well under that. Returns as
-    soon as the job's status is succeeded, failed or cancelled. If the
-    timeout elapses first, returns the job's last-seen status with
-    `still_running: true` instead of hanging - call again to keep waiting.
-    Returns a slim job - status, warnings, error, and the manifest once
-    finished - without the arguments; get_job has those."""
-    timeout_seconds = max(0.0, min(float(timeout_seconds), MAX_WAIT_SECONDS))
-    deadline = time.monotonic() + timeout_seconds
+    so this never blocks past a budget kept well under that. Every reply
+    says what was applied - `timeout_applied_seconds` is the budget the
+    call actually ran under, `timeout_requested_seconds` what was asked
+    for, and `waited_seconds` how long this call blocked - so a caller
+    asking for 600 can tell a capped return from an elapsed one rather
+    than inferring it from wall clock. Returns as soon as the job's status
+    is succeeded, failed or cancelled. If the timeout elapses first,
+    returns the job's last-seen status with `still_running: true` instead
+    of hanging - call again to keep waiting. Returns a slim job - status,
+    warnings, error, and the manifest once finished - without the
+    arguments; get_job has those."""
+    requested = max(0.0, float(timeout_seconds))
+    applied = min(requested, float(MAX_WAIT_SECONDS))
+    capped = applied < requested
+    started = time.monotonic()
+    deadline = started + applied
     while True:
         job = client.get_json(api_path("api", "jobs", job_id))
         status = job.get("status")
+        budget = {
+            "waited_seconds": round(time.monotonic() - started, 1),
+            "timeout_requested_seconds": round(requested, 1),
+            "timeout_applied_seconds": round(applied, 1),
+            "timeout_capped": capped,
+        }
         if status in TERMINAL_STATUSES:
             return {
                 "job_id": job_id,
                 "status": status,
                 "still_running": False,
+                **budget,
                 "job": slim_job(job),
                 "next": "get_job(job_id) for the arguments and traceback, "
                 "get_job_workflow(job_id) for the realized workflow.",
             }
         remaining = deadline - time.monotonic()
         if remaining <= 0:
+            next_step = (
+                "Call wait_for_job again, or get_job_events for incremental "
+                "progress."
+            )
+            if capped:
+                next_step = (
+                    f"You asked to wait {round(requested, 1)}s but one call "
+                    f"blocks for at most {MAX_WAIT_SECONDS}s, so this "
+                    "returned early rather than timing out. The job is still "
+                    "running: call wait_for_job again (each call covers "
+                    f"~{MAX_WAIT_SECONDS}s of it), or get_job_events for "
+                    "incremental progress."
+                )
             return {
                 "job_id": job_id,
                 "status": status,
                 "still_running": True,
+                **budget,
                 "job": slim_job(job),
-                "next": "Call wait_for_job again, or get_job_events for "
-                "incremental progress.",
+                "next": next_step,
             }
         time.sleep(min(WAIT_POLL_SECONDS, remaining))
 
diff --git a/dw_mcp/server.py b/dw_mcp/server.py
index 49ceb28..729b162 100644
--- a/dw_mcp/server.py
+++ b/dw_mcp/server.py
@@ -178,11 +178,16 @@ def list_workflows(
             include_models=include_models,
         )
 
-    def get_workflow(name: str) -> dict:
+    def get_workflow(name: str, variables_only: bool = False) -> dict:
         """Get one stored workflow's full JSON definition, by a name from
         `list_workflows`. Read one before editing it, and to learn the
-        idioms this installation actually uses."""
-        return catalog.get_workflow(client, name)
+        idioms this installation actually uses. Pass
+        `variables_only=true` when the question is only what a variable
+        defaults to - it answers with the variables and their values and
+        nothing else, which is a fraction of the definition; long defaults
+        (a shot's prompt) come back cut to 200 characters with the cut ones
+        named in `truncated`."""
+        return catalog.get_workflow(client, name, variables_only=variables_only)
 
     def get_schema() -> dict:
         """Get the JSON schema every workflow definition must satisfy - the
@@ -263,15 +268,25 @@ def get_server_info() -> dict:
         workspace."""
         return workspaces.server_info(client)
 
-    def list_jobs() -> dict:
-        """List queued, running and recent jobs, with their status and queue
-        position. The ids here are what `get_job`, `wait_for_job`,
-        `get_job_events`, `cancel_job`, `rerun_job` and `move_job` take -
-        including jobs from before this session, so a run someone started in
-        the browser can be picked up here. In a named workspace this lists
-        that workspace's jobs; in the default workspace it lists every job
-        the server holds, whichever workspace ran it."""
-        return catalog.list_jobs(client)
+    def list_jobs(
+        limit: int = 20, status: str | None = None, workspace: str | None = None
+    ) -> dict:
+        """List queued, running and recent jobs, newest first, with their
+        status and queue position. The ids here are what `get_job`,
+        `wait_for_job`, `get_job_events`, `cancel_job`, `rerun_job` and
+        `move_job` take - including jobs from before this session, so a run
+        someone started in the browser can be picked up here.
+
+        `limit` is the newest N (20 by default); `total` reports how many
+        matched, so a truncated answer says so rather than looking
+        complete. `status` narrows to one state or a comma-separated set of
+        them - queued, running, succeeded, failed, cancelled. `workspace`
+        lists one workspace's jobs; without it, a named workspace lists its
+        own and the default workspace lists every job the server holds,
+        whichever workspace ran it."""
+        return catalog.list_jobs(
+            client, limit=limit, status=status, workspace=workspace
+        )
 
     def list_gallery(limit: int = 50) -> dict:
         """List generated output files, newest first. A name is
@@ -284,15 +299,21 @@ def list_gallery(limit: int = 50) -> dict:
         name."""
         return catalog.list_gallery(client, limit=limit)
 
-    def get_gallery_metadata(name: str) -> dict:
+    def get_gallery_metadata(name: str, envelope: bool = False) -> dict:
         """Get the metadata embedded in a generated file: the exact
         workflow, arguments and seed that produced it. Use this to
         reproduce a result, or to see what a run that went wrong actually
         ran - it is the definition, not a summary, so it can be edited and
         re-run. For audio and video the `media` block carries duration,
         sample rate, channels, fps, size and level - the checks an agent
-        that cannot listen makes on a deliverable."""
-        return catalog.get_gallery_metadata(client, name)
+        that cannot listen makes on a deliverable. `envelope=true` adds
+        that level second by second (`media.envelope.rms_dbfs` /
+        `peak_dbfs`, one entry per second), which is what says *where* in a
+        track something is: whether a shot is still sounding at its last
+        frame, how deep the hole at a seam goes, where a score goes quiet.
+        Leave it off unless you are asking a question about a position in
+        the track - a long track is a long list."""
+        return catalog.get_gallery_metadata(client, name, envelope=envelope)
 
     def list_guides() -> dict:
         """List the documentation the engine serves: each guide's
@@ -417,18 +438,32 @@ def list_assets() -> dict:
         a file: what a workflow needs may already be there."""
         return assets.list_assets(client)
 
-    def upload_asset(file_path: str) -> dict:
+    def upload_asset(
+        file_path: str, asset_name: str | None = None, shared: bool = False
+    ) -> dict:
         """Put a local image, video or audio file into the server's asset
         library and get back the "asset:" reference to use in a workflow.
         The file 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. Accepts the usual image, video and audio
         extensions, up to 200MB. Reference the result rather than a path: a
-        path on this machine means nothing to the server."""
-        return assets.upload_asset(client, file_path)
+        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, the file's extension assumed) - without one 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."""
+        return assets.upload_asset(
+            client, file_path, asset_name=asset_name, shared=shared
+        )
 
     def keep_output(
-        name: str, asset_name: str | None = None, overwrite: bool = False
+        name: str,
+        asset_name: str | None = None,
+        overwrite: bool = False,
+        shared: bool = False,
     ) -> 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
@@ -436,21 +471,38 @@ def keep_output(
         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."""
+        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."""
         return assets.keep_output(
-            client, name, asset_name=asset_name, overwrite=overwrite
+            client, name, asset_name=asset_name, overwrite=overwrite, shared=shared
         )
 
+    def delete_asset(name: str) -> 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)
+
     tool(list_assets, READ_ONLY)
     tool(upload_asset, WRITES)
     tool(keep_output, WRITES)
+    tool(delete_asset, DELETES)
 
     # ------------------------------------------------------------ workspaces
 
     def list_workspaces() -> dict:
         """List the server's workspaces and say which one this session is
         working in. Each has its own workflows, assets and outputs; the
-        stored prompt library is shared by all of them."""
+        stored prompt library is shared by all of them, and so is the
+        shared asset library that `upload_asset(shared=true)` and
+        `keep_output(shared=true)` write into - which is how a recurring
+        cast stays reachable from the workspace the next piece is made
+        in."""
         return workspaces.list_workspaces(client)
 
     def use_workspace(name: str) -> dict:
@@ -487,6 +539,7 @@ def validate_workflow(
         workflow: dict | None = None,
         name: str | None = None,
         workspace: str | None = None,
+        arguments: dict | None = None,
     ) -> dict:
         """Check a workflow against the schema and against real pipeline
         signatures. Free and instant - always run this before run_workflow.
@@ -495,9 +548,21 @@ def validate_workflow(
         back at once, each with its JSON path. `workspace` names the
         workspace for this one call without switching the session to it -
         use it to pin a job whose `output:` or `asset:` references live in a
-        workspace other than the session's."""
+        workspace other than the session's.
+
+        Pass the same `arguments` you will pass to `run_workflow` and they
+        are checked too: a name the workflow no longer declares, a value
+        that will not coerce to the declared type, and an `asset:`,
+        `prompt:` or `output:` reference that names nothing this workspace
+        can reach - each with `arguments.<name>` as its path.
+        `checked_arguments` lists what was checked, so a valid answer says
+        whether it covered your values or only the stored defaults."""
         return authoring.validate_workflow(
-            client, workflow=workflow, name=name, workspace=workspace
+            client,
+            workflow=workflow,
+            name=name,
+            workspace=workspace,
+            arguments=arguments,
         )
 
     def save_workflow(name: str, workflow: dict) -> dict:
@@ -651,12 +716,26 @@ def wait_for_job(job_id: str, timeout_seconds: int = 20) -> dict:
         succeeded, failed or cancelled, or - if timeout_seconds elapses
         first - returns its current status with still_running: true so you
         can call again. Does not queue anything, so no acknowledged_cost.
-        timeout_seconds is capped well under a generation's real runtime;
-        call it repeatedly for a long job. Returns a slim job - status,
-        warnings, error, and the manifest once finished - without the
-        arguments; get_job has those."""
+
+        One call blocks for at most {cap} seconds, no matter what
+        timeout_seconds asks for - an MCP client will not hold a tool call
+        open for a generation's real runtime, which is minutes. A larger
+        value is not honoured, it is clamped, so budget roughly one call per
+        {cap}s of the job. Every reply says which happened: waited_seconds,
+        timeout_requested_seconds, timeout_applied_seconds and
+        timeout_capped.
+
+        Returns a slim job - status, warnings, error, and the manifest once
+        finished - without the arguments; get_job has those."""
         return diagnose.wait_for_job(client, job_id, timeout_seconds=timeout_seconds)
 
+    # The cap is a number a caller paces against, so the description states
+    # it rather than saying "well under a generation's runtime".
+    if wait_for_job.__doc__:  # absent under python -OO
+        wait_for_job.__doc__ = wait_for_job.__doc__.format(
+            cap=diagnose.MAX_WAIT_SECONDS
+        )
+
     def cancel_job(job_id: str) -> dict:
         """Ask a queued or running job to stop. Cooperative: a running job
         stops at the next step or denoise-step boundary, not instantly.
diff --git a/tests/test_arguments.py b/tests/test_arguments.py
index 66abd03..cbf6a89 100644
--- a/tests/test_arguments.py
+++ b/tests/test_arguments.py
@@ -485,6 +485,57 @@ def test_type_reference_is_resolved_before_construction(self):
 
             assert isinstance(args["reference"], Reference)
 
+    def test_an_optional_reference_with_no_media_leaves_the_list(self):
+        """A voice a workflow was given nothing for is a null variable. The
+        entry drops out rather than reaching the pipeline as a reference
+        with no media in it - which is what lets one workflow serve a run
+        with the voice and a run without, instead of two spellings of it."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            image_path = os.path.join(temp_dir, "subject.png")
+            Image.new("RGB", (10, 10)).save(image_path)
+
+            args = {
+                "references": [
+                    self.reference_argument(image_path),
+                    self.reference_argument(None),
+                ]
+            }
+            realize_args(args)
+
+            assert len(args["references"]) == 1
+            assert isinstance(args["references"][0], Reference)
+
+    def test_an_optional_reference_can_be_the_only_one(self):
+        args = {"references": [self.reference_argument(None)]}
+        realize_args(args)
+
+        assert args["references"] == []
+
+    def test_a_deferred_reference_with_no_step_leaves_the_list_too(self):
+        args = {
+            "references": [
+                {"reference_type": Reference, "from_previous_result": None},
+            ]
+        }
+        realize_args(args)
+
+        assert args["references"] == []
+
+    def test_an_object_argument_on_its_own_cannot_be_left_out(self):
+        """There is nothing to leave it out of - and silently passing None
+        where an object was named would fail later, somewhere less clear."""
+        args = {"reference": self.reference_argument(None)}
+
+        with pytest.raises(ValueError, match="null"):
+            realize_args(args)
+
+    def test_a_dict_with_no_source_key_is_not_an_omission(self):
+        # Only a source key that is present *and* null means omitted
+        args = {"reference": {"reference_type": Reference, "location": None}}
+        realize_args(args)
+
+        assert args["reference"] == {"reference_type": Reference, "location": None}
+
     def test_without_a_type_the_dict_is_left_untouched(self):
         # A dict that merely contains a 'from_file' key is not an object
         # description - it belongs to whatever consumes it
diff --git a/tests/test_audio_utils.py b/tests/test_audio_utils.py
index 15134d7..997c1b8 100644
--- a/tests/test_audio_utils.py
+++ b/tests/test_audio_utils.py
@@ -19,6 +19,15 @@
 )
 
 
+def samples(track):
+    """The (samples, channels) waveform an audio task's AudioTrack carries.
+
+    The tasks return an AudioTrack so the rate travels with the waveform;
+    these shape assertions are written in the save layout, so they unwrap it.
+    """
+    return numpy.asarray(track.audio).T
+
+
 class TestAsChannelsSamples:
     def test_a_mono_vector_gains_a_channel_axis(self):
         assert as_channels_samples(numpy.zeros(100)).shape == (1, 100)
@@ -244,12 +253,15 @@ def test_every_audio_task_takes_a_video_path(self, tmp_path):
 
         path = self._write_video(tmp_path / "cut.mp4")
 
-        assert resample_audio(path, 4000).shape[1] == 2
-        assert slice_audio(path, start_seconds=0, duration_seconds=1).shape[0] == 8000
-        assert fade_audio(path, fade_out_ms=100).shape[1] == 2
-        assert normalize_audio(path).shape[1] == 2
-        assert mix_audio([path, path]).shape[1] == 2
-        assert crossfade_audio([path, path], crossfade_ms=10).shape[1] == 2
+        assert samples(resample_audio(path, 4000)).shape[1] == 2
+        assert (
+            samples(slice_audio(path, start_seconds=0, duration_seconds=1)).shape[0]
+            == 8000
+        )
+        assert samples(fade_audio(path, fade_out_ms=100)).shape[1] == 2
+        assert samples(normalize_audio(path)).shape[1] == 2
+        assert samples(mix_audio([path, path])).shape[1] == 2
+        assert samples(crossfade_audio([path, path], crossfade_ms=10)).shape[1] == 2
 
 
 class TestBleedJoin:
@@ -319,27 +331,32 @@ def test_it_scales_the_length_to_the_new_rate(self):
 
         result = resample_audio(waveform, 32000, sample_rate=44100)
 
-        assert result.shape == (32000, 2)
+        assert samples(result).shape == (32000, 2)
+        assert result.sample_rate == 32000
 
     def test_it_returns_samples_by_channels(self):
         waveform = numpy.zeros((1, 44100), dtype=numpy.float32)
 
-        assert resample_audio(waveform, 22050, sample_rate=44100).shape == (22050, 1)
+        assert samples(resample_audio(waveform, 22050, sample_rate=44100)).shape == (
+            22050,
+            1,
+        )
 
     def test_matching_rates_pass_through_untouched(self):
         waveform = numpy.linspace(-1, 1, 1000, dtype=numpy.float32)[None, :]
 
         result = resample_audio(waveform, 8000, sample_rate=8000)
 
-        assert result.shape == (1000, 1)
-        assert numpy.allclose(result[:, 0], waveform[0])
+        assert samples(result).shape == (1000, 1)
+        assert result.sample_rate == 8000
+        assert numpy.allclose(samples(result)[:, 0], waveform[0])
 
     def test_a_tone_keeps_its_level_and_duration(self):
         rate, seconds = 44100, 0.5
         t = numpy.arange(int(rate * seconds)) / rate
         tone = numpy.sin(2 * numpy.pi * 440 * t).astype(numpy.float32)[None, :]
 
-        result = resample_audio(tone, 32000, sample_rate=44100)
+        result = samples(resample_audio(tone, 32000, sample_rate=44100))
 
         assert result.shape[0] == pytest.approx(32000 * seconds, rel=0.01)
         level = float(numpy.sqrt((result[:, 0] ** 2).mean()))
@@ -354,7 +371,10 @@ def test_a_raw_waveform_needs_its_rate(self):
     def test_it_accepts_a_torch_waveform(self):
         waveform = torch.zeros(2, 44100)
 
-        assert resample_audio(waveform, 32000, sample_rate=44100).shape == (32000, 2)
+        assert samples(resample_audio(waveform, 32000, sample_rate=44100)).shape == (
+            32000,
+            2,
+        )
 
 
 class TestFadeAudio:
@@ -363,7 +383,9 @@ def test_fades_end_on_silence_and_leave_the_middle_alone(self):
 
         track = numpy.ones((2, 1000), dtype=numpy.float32)
 
-        faded = fade_audio(track, fade_in_ms=100, fade_out_ms=200, sample_rate=1000)
+        faded = samples(
+            fade_audio(track, fade_in_ms=100, fade_out_ms=200, sample_rate=1000)
+        )
 
         assert faded.shape == (1000, 2)
         assert faded[0, 0] == pytest.approx(0.0, abs=1e-6)
@@ -385,7 +407,9 @@ def test_the_input_is_not_modified(self):
     def test_a_fade_longer_than_the_track_is_clamped(self):
         from dw.tasks.audio_utils import fade_audio
 
-        faded = fade_audio(numpy.ones((1, 10)), fade_in_ms=5000, sample_rate=100)
+        faded = samples(
+            fade_audio(numpy.ones((1, 10)), fade_in_ms=5000, sample_rate=100)
+        )
 
         assert faded.shape == (10, 1)
 
@@ -408,7 +432,7 @@ def test_the_peak_lands_on_the_target(self):
 
         track = numpy.array([[0.1, -0.25, 0.05]], dtype=numpy.float32)
 
-        scaled = normalize_audio(track, peak_dbfs=-6.0, sample_rate=100)
+        scaled = samples(normalize_audio(track, peak_dbfs=-6.0, sample_rate=100))
 
         assert scaled.shape == (3, 1)
         assert numpy.abs(scaled).max() == pytest.approx(10 ** (-6 / 20), abs=1e-6)
@@ -420,7 +444,9 @@ def test_the_peak_lands_on_the_target(self):
     def test_silence_is_left_alone(self):
         from dw.tasks.audio_utils import normalize_audio
 
-        assert numpy.all(normalize_audio(numpy.zeros((1, 10)), sample_rate=100) == 0)
+        assert numpy.all(
+            samples(normalize_audio(numpy.zeros((1, 10)), sample_rate=100)) == 0
+        )
 
     def test_a_target_above_full_scale_is_refused(self):
         from dw.tasks.audio_utils import normalize_audio
@@ -445,22 +471,34 @@ def test_slice_audio_takes_the_rate_from_the_video(self):
 
         sliced = slice_audio(self.video(), start_seconds=1.0, duration_seconds=2.0)
 
-        assert sliced.shape == (200, 2)
+        assert samples(sliced).shape == (200, 2)
+        # The rate it read travels with the slice, so a resample chained off it
+        # does not have to be told the rate again
+        assert sliced.sample_rate == 100
 
     def test_no_duration_slices_to_the_end_of_the_track(self):
         """A workflow that trims only when given a length still yields the
         track - the missing half of the pair means 'to the end', not an error."""
         from dw.tasks.audio_utils import slice_audio
 
-        assert slice_audio(self.video(), start_seconds=1.0).shape == (300, 2)
-        assert slice_audio(self.video(), start_seconds=0).shape == (400, 2)
+        assert samples(slice_audio(self.video(), start_seconds=1.0)).shape == (300, 2)
+        assert samples(slice_audio(self.video(), start_seconds=0)).shape == (400, 2)
 
     def test_no_start_slices_from_the_head_of_the_track(self):
         from dw.tasks.audio_utils import slice_audio
 
-        assert slice_audio(self.video(), duration_seconds=2.0).shape == (200, 2)
-        assert slice_audio(self.video(), start_frame=12, fps=24).shape == (350, 2)
-        assert slice_audio(self.video(), num_frames=24, fps=24).shape == (100, 2)
+        assert samples(slice_audio(self.video(), duration_seconds=2.0)).shape == (
+            200,
+            2,
+        )
+        assert samples(slice_audio(self.video(), start_frame=12, fps=24)).shape == (
+            350,
+            2,
+        )
+        assert samples(slice_audio(self.video(), num_frames=24, fps=24)).shape == (
+            100,
+            2,
+        )
 
     def test_a_slice_in_frames_still_needs_the_frame_rate(self):
         from dw.tasks.audio_utils import slice_audio
@@ -481,20 +519,24 @@ def test_a_given_rate_overrides_the_video_rate(self):
             self.video(), start_seconds=0.0, duration_seconds=1.0, sample_rate=50
         )
 
-        assert sliced.shape == (50, 2)
+        assert samples(sliced).shape == (50, 2)
+        assert sliced.sample_rate == 50
 
     def test_resample_audio_takes_the_rate_from_the_video(self):
         from dw.tasks.audio_utils import resample_audio
 
-        assert resample_audio(self.video(), target_sample_rate=100).shape == (400, 2)
+        assert samples(resample_audio(self.video(), target_sample_rate=100)).shape == (
+            400,
+            2,
+        )
 
     def test_fade_and_normalize_take_a_video(self):
         from dw.tasks.audio_utils import fade_audio, normalize_audio
 
-        faded = fade_audio(self.video(), fade_out_ms=1000)
+        faded = samples(fade_audio(self.video(), fade_out_ms=1000))
         assert faded.shape == (400, 2) and faded[-1, 0] == pytest.approx(0.0, abs=1e-6)
 
-        scaled = normalize_audio(self.video(level=0.5), peak_dbfs=0.0)
+        scaled = samples(normalize_audio(self.video(level=0.5), peak_dbfs=0.0))
         assert numpy.abs(scaled).max() == pytest.approx(1.0)
 
     def test_crossfade_audio_joins_videos_at_their_own_rate(self):
@@ -503,7 +545,8 @@ def test_crossfade_audio_joins_videos_at_their_own_rate(self):
         joined = crossfade_audio([self.video(), self.video()], crossfade_ms=1000)
 
         # 4 s + 4 s - 1 s overlap = 7 s at 100 Hz
-        assert joined.shape == (700, 2)
+        assert samples(joined).shape == (700, 2)
+        assert joined.sample_rate == 100
 
     def test_crossfade_audio_refuses_mixed_rates(self):
         from dw.tasks.audio_utils import crossfade_audio
@@ -523,3 +566,79 @@ def test_a_silent_video_is_refused(self):
 
         with pytest.raises(ValueError, match="carries none"):
             fade_audio(AudioVideo([], None, None), fade_in_ms=10)
+
+
+class TestLoopAudio:
+    """A bed made from a short recording - the room tone laid under a cut so
+    the seam between two independently generated shots is not a hole."""
+
+    def tone(self, samples=100, rate=100, level=0.5, channels=1):
+        return numpy.full((channels, samples), level, dtype=numpy.float32)
+
+    def test_it_makes_a_bed_of_the_requested_seconds(self):
+        from dw.tasks.audio_utils import loop_audio
+
+        bed = loop_audio(self.tone(), duration_seconds=3.5, sample_rate=100)
+
+        assert samples(bed).shape == (350, 1)
+        assert bed.sample_rate == 100
+
+    def test_a_length_in_frames_matches_a_cut_exactly(self):
+        from dw.tasks.audio_utils import loop_audio
+
+        bed = loop_audio(self.tone(), target_frames=48, fps=24, sample_rate=100)
+
+        assert samples(bed).shape == (200, 1)
+
+    def test_a_source_longer_than_the_bed_is_trimmed(self):
+        from dw.tasks.audio_utils import loop_audio
+
+        bed = loop_audio(self.tone(samples=400), duration_seconds=1.0, sample_rate=100)
+
+        assert samples(bed).shape == (100, 1)
+
+    def test_the_loop_point_is_crossfaded_rather_than_butted(self):
+        from dw.tasks.audio_utils import loop_audio
+
+        # A ramp ends far from where it starts, so a butt join would step;
+        # the crossfade has to leave the seam continuous
+        ramp = numpy.linspace(-1, 1, 200, dtype=numpy.float32)[None, :]
+        bed = samples(
+            loop_audio(ramp, duration_seconds=4.0, crossfade_ms=500, sample_rate=100)
+        )
+
+        steps = numpy.abs(numpy.diff(bed[:, 0]))
+        assert steps.max() < 0.1
+
+    def test_it_takes_the_rate_from_a_generated_video(self):
+        from dw.result import AudioVideo
+        from dw.tasks.audio_utils import loop_audio
+
+        video = AudioVideo([], numpy.zeros((2, 400), dtype=numpy.float32), 100)
+
+        bed = loop_audio(video, duration_seconds=10.0)
+
+        assert samples(bed).shape == (1000, 2)
+        assert bed.sample_rate == 100
+
+    def test_it_needs_to_be_told_how_long_a_bed_to_make(self):
+        from dw.tasks.audio_utils import loop_audio
+
+        with pytest.raises(ValueError, match="how long a bed"):
+            loop_audio(self.tone(), sample_rate=100)
+
+    def test_a_length_in_frames_still_needs_the_frame_rate(self):
+        from dw.tasks.audio_utils import loop_audio
+
+        with pytest.raises(ValueError, match="fps"):
+            loop_audio(self.tone(), target_frames=48, sample_rate=100)
+
+    def test_an_empty_source_is_refused(self):
+        from dw.tasks.audio_utils import loop_audio
+
+        with pytest.raises(ValueError, match="samples in it"):
+            loop_audio(
+                numpy.zeros((1, 0), dtype=numpy.float32),
+                duration_seconds=1.0,
+                sample_rate=100,
+            )
diff --git a/tests/test_compose_text.py b/tests/test_compose_text.py
new file mode 100644
index 0000000..3ac5678
--- /dev/null
+++ b/tests/test_compose_text.py
@@ -0,0 +1,50 @@
+"""compose_text assembles a block of text out of parts written once - the
+answer to hand-copying a character's description into every shot, without
+introducing the string interpolation the engine deliberately does not have."""
+
+import pytest
+
+from dw.tasks.compose_text import compose_text
+
+
+class TestComposeText:
+    def test_parts_are_joined_in_order(self):
+        assert compose_text(["first", "second"]) == "first\n\nsecond"
+
+    def test_the_separator_is_the_caller_s(self):
+        assert compose_text(["a", "b"], separator=" - ") == "a - b"
+
+    def test_an_absent_part_is_dropped(self):
+        """A character who does not speak in this shot is a null variable,
+        not a hole in the prompt."""
+        assert compose_text(["bible", None, "action"]) == "bible\n\naction"
+        assert compose_text(["bible", "   ", "action"]) == "bible\n\naction"
+
+    def test_an_absent_part_can_be_kept_instead(self):
+        assert compose_text(["a", None, "b"], skip_empty=False) == "a\n\n\n\nb"
+
+    def test_numbers_are_written_out(self):
+        assert compose_text(["shot", 3], separator=" ") == "shot 3"
+
+    def test_something_that_is_not_text_says_so(self):
+        """A part that came back as an image or a dict means the reference in
+        that position resolved to something other than the text meant."""
+        with pytest.raises(ValueError, match="part 1 is a dict"):
+            compose_text(["a", {"prompt": "b"}])
+
+    def test_a_list_is_required(self):
+        with pytest.raises(ValueError, match="list of parts"):
+            compose_text("just a string")
+
+    def test_nothing_to_join_says_so(self):
+        with pytest.raises(ValueError, match="nothing to join"):
+            compose_text([None, ""])
+
+
+class TestComposeTextAsATask:
+    def test_it_runs_through_the_task_dispatch(self):
+        from dw.tasks.task import Task
+
+        task = Task({"command": "compose_text", "arguments": {}}, "cpu")
+
+        assert task.run({"parts": ["a", "b"], "separator": ", "}) == "a, b"
diff --git a/tests/test_concat_videos.py b/tests/test_concat_videos.py
index 94623b3..9fdb49f 100644
--- a/tests/test_concat_videos.py
+++ b/tests/test_concat_videos.py
@@ -123,7 +123,8 @@ def test_slice_audio_runs_through_task(self):
             }
         )
 
-        assert result.shape == (200, 2)
+        assert result.audio.shape == (2, 200)
+        assert result.sample_rate == 100
 
     def test_crossfade_audio_runs_through_task(self):
         task = Task({"command": "crossfade_audio", "arguments": {}}, "cpu")
@@ -139,7 +140,7 @@ def test_crossfade_audio_runs_through_task(self):
             }
         )
 
-        assert result.shape == (390, 2)
+        assert result.audio.shape == (2, 390)
 
 
 class TestAudioBleed:
@@ -275,7 +276,8 @@ def test_resample_audio_runs_through_task(self):
             }
         )
 
-        assert result.shape == (32000, 2)
+        assert result.audio.shape == (2, 32000)
+        assert result.sample_rate == 32000
 
 
 class TestVideoFiles:
diff --git a/tests/test_dialogue_short_voices.py b/tests/test_dialogue_short_voices.py
new file mode 100644
index 0000000..7112c8d
--- /dev/null
+++ b/tests/test_dialogue_short_voices.py
@@ -0,0 +1,98 @@
+"""The dialogue-short template's optional voice references.
+
+A recurring cast's voice was carried only as a description repeated verbatim
+in every shot - about thirty hand-copied strings across three episodes, with
+nothing checking that they matched (2026-09-11). `character_a_voice` /
+`character_b_voice` name a clip instead, and each shot appends an audio
+reference for whoever speaks in it. Null is the default, and null means the
+reference is not there at all - so the template still generates exactly what
+it generated before the variables existed.
+"""
+
+import json
+import os
+
+import pytest
+
+from dw.arguments import realize_args
+from dw.variables import replace_variables
+
+TEMPLATE = os.path.join(
+    os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+    "workflows",
+    "templates",
+    "minimax",
+    "dialogue-short.json",
+)
+
+# Which character speaks in which shot - the template appends a voice
+# reference per speaker, and this is the mapping it is asserted against
+SPEAKERS = {
+    "shot_1_cold_open": ("a", "b"),
+    "shot_2_deflect": ("b",),
+    "shot_3_react": ("a",),
+    "shot_4_button": ("b",),
+    "shot_5_tag": ("a", "b"),
+}
+
+
+@pytest.fixture
+def definition():
+    with open(TEMPLATE, encoding="utf-8") as file:
+        return json.load(file)
+
+
+def shot_references(definition, variables):
+    """Every shot's references, as the engine realizes them for a run."""
+    resolved = replace_variables(definition, variables)
+    references = {}
+    for step in resolved["steps"]:
+        if step["name"] not in SPEAKERS:
+            continue
+        block = step.get("pipeline") or step.get("pipeline_reference")
+        arguments = block["arguments"]
+        realize_args(arguments)
+        references[step["name"]] = arguments["references"]
+    return references
+
+
+class TestOptionalVoices:
+    def test_the_voices_default_to_null(self, definition):
+        variables = definition["variables"]
+        assert variables["character_a_voice"] is None
+        assert variables["character_b_voice"] is None
+
+    def test_no_voice_named_leaves_only_the_portraits(self, definition):
+        for name, references in shot_references(
+            definition, dict(definition["variables"])
+        ).items():
+            assert len(references) == len(set(SPEAKERS[name])), name
+            assert all(
+                reference["from_previous_result"].startswith("draw_character")
+                for reference in references
+            ), name
+
+    def test_a_named_voice_is_referenced_in_the_shots_it_speaks_in(
+        self, definition, tmp_path
+    ):
+        from tests.test_media_info import write_wav
+
+        voice = tmp_path / "priya.wav"
+        write_wav(voice, seconds=1.0)
+        variables = dict(definition["variables"])
+        variables["character_a_voice"] = str(voice)
+
+        for name, references in shot_references(definition, variables).items():
+            built = [r for r in references if not isinstance(r, dict)]
+            assert len(built) == (1 if "a" in SPEAKERS[name] else 0), name
+
+    def test_the_variable_names_are_roles_rather_than_a_cast(self, definition):
+        """Every run carried howie_portrait_prompt and shot_3_howie_incredulous
+        through its arguments, manifest and export whatever the cast was."""
+        names = " ".join(definition["variables"]) + " ".join(
+            step["name"] for step in definition["steps"]
+        )
+        assert "howie" not in names.lower()
+        assert "pat_" not in names.lower()
+        assert "character_a_portrait_prompt" in definition["variables"]
+        assert "shot_3_react" in definition["variables"]
diff --git a/tests/test_jobs_listing.py b/tests/test_jobs_listing.py
new file mode 100644
index 0000000..021885b
--- /dev/null
+++ b/tests/test_jobs_listing.py
@@ -0,0 +1,162 @@
+"""Bounding the jobs list.
+
+An unbounded listing is a dead tool over MCP: a server holding a few months
+of history spilled 176 entries and the call failed before a single job id
+could be read. The API grew `limit` and `status` (and always reports
+`total`); the MCP tool bounds by default and answers newest first, since the
+job worth looking at is almost always the last one.
+"""
+
+import httpx
+import pytest
+
+from dw_mcp import catalog
+from dw_mcp.client import DwClient
+from dw.server.jobs import JobHistory
+
+from .test_server import (  # noqa: F401 - `server` is a fixture
+    server,
+    success_script,
+    valid_workflow,
+    wait_for_status,
+)
+
+
+def stored_job(history, job_id, status, created_at, workspace="default"):
+    """A finished job straight into history - the rows a long-lived server
+    accumulates, without running anything."""
+
+    class Row:
+        id = job_id
+        workflow_name = "w"
+        catalog_name = None
+        created_at = None
+        started_at = None
+        finished_at = None
+        manifest = []
+        warnings = []
+        error = None
+        events = []
+        run_id = None
+        run_dir = None
+
+    row = Row()
+    row.status = status
+    row.created_at = created_at
+    row.spec = {"workspace": workspace}
+    history.record(row)
+
+
+@pytest.fixture
+def history(tmp_path):
+    return JobHistory(str(tmp_path / "jobs.sqlite"))
+
+
+def test_history_filters_by_status_in_sql(history):
+    for index in range(5):
+        stored_job(history, f"j{index}", "succeeded", index)
+    stored_job(history, "bad", "failed", 99)
+
+    failed = history.recent_summaries(statuses=["failed"])
+
+    assert [row["id"] for row in failed] == ["bad"]
+    # and the cap is spent on matching rows, not on rows the filter drops
+    assert len(history.recent_summaries(limit=2, statuses=["succeeded"])) == 2
+
+
+def test_history_filters_by_status_and_workspace_together(history):
+    stored_job(history, "a", "failed", 1, workspace="qa")
+    stored_job(history, "b", "failed", 2, workspace="other")
+
+    rows = history.recent_summaries(statuses=["failed"], workspace="qa")
+
+    assert [row["id"] for row in rows] == ["a"]
+
+
+def test_listing_is_unchanged_without_the_new_parameters(server):
+    """The web UI polls this route: oldest first, every job, same shape."""
+    with server(success_script) as client:
+        client.post("/api/jobs", json={"workflow": valid_workflow()})
+
+        body = client.get("/api/jobs").json()
+
+        assert [job["id"] for job in body["jobs"]]
+        assert body["total"] == len(body["jobs"])
+
+
+def test_limit_keeps_the_newest_and_total_reports_the_rest(server):
+    with server(success_script) as client:
+        ids = []
+        for _ in range(3):
+            job = client.post("/api/jobs", json={"workflow": valid_workflow()}).json()
+            wait_for_status(client, job["id"], {"succeeded"})
+            ids.append(job["id"])
+
+        body = client.get("/api/jobs", params={"limit": 1}).json()
+
+        assert body["total"] == 3
+        # the cut comes off the front: the newest job is what is kept
+        assert [job["id"] for job in body["jobs"]] == [ids[-1]]
+        assert client.get("/api/jobs", params={"limit": 0}).json()["jobs"] == []
+
+
+def test_status_filter_narrows_the_listing(server):
+    with server(success_script) as client:
+        job = client.post("/api/jobs", json={"workflow": valid_workflow()}).json()
+        wait_for_status(client, job["id"], {"succeeded"})
+
+        succeeded = client.get("/api/jobs", params={"status": "succeeded"}).json()
+        queued = client.get("/api/jobs", params={"status": "queued,running"}).json()
+
+        assert [entry["id"] for entry in succeeded["jobs"]] == [job["id"]]
+        assert queued["jobs"] == [] and queued["total"] == 0
+
+
+def test_unknown_status_is_a_bad_request(server):
+    with server(success_script) as client:
+        response = client.get("/api/jobs", params={"status": "finished"})
+
+        assert response.status_code == 400
+        assert "finished" in response.json()["detail"]
+
+
+def mcp_client(body):
+    seen = {}
+
+    def handler(request):
+        seen["params"] = dict(request.url.params)
+        return httpx.Response(200, json=body)
+
+    return DwClient(transport=httpx.MockTransport(handler)), seen
+
+
+def test_mcp_list_jobs_bounds_and_reverses():
+    client, seen = mcp_client({"jobs": [{"id": "old"}, {"id": "new"}], "total": 176})
+
+    answer = catalog.list_jobs(client)
+
+    assert seen["params"]["limit"] == "20"
+    assert [job["id"] for job in answer["jobs"]] == ["new", "old"]
+    assert answer["returned"] == 2 and answer["total"] == 176
+    assert answer["truncated"] is True
+    assert "174 older jobs" in answer["next"]
+
+
+def test_mcp_list_jobs_says_nothing_about_truncation_when_complete():
+    client, _ = mcp_client({"jobs": [{"id": "a"}], "total": 1})
+
+    answer = catalog.list_jobs(client)
+
+    assert "truncated" not in answer and "next" not in answer
+
+
+def test_mcp_list_jobs_passes_its_filters():
+    client, seen = mcp_client({"jobs": [], "total": 0})
+
+    catalog.list_jobs(client, limit=5, status=["failed", "cancelled"], workspace="qa")
+
+    assert seen["params"] == {
+        "limit": "5",
+        "status": "failed,cancelled",
+        "workspace": "qa",
+    }
diff --git a/tests/test_library_sources.py b/tests/test_library_sources.py
index 10d318e..01f14b5 100644
--- a/tests/test_library_sources.py
+++ b/tests/test_library_sources.py
@@ -22,7 +22,7 @@
     set_library_fallbacks,
 )
 
-from .test_server import ScriptedWorkerManager, success_script
+from .test_server import ScriptedWorkerManager, success_script, valid_workflow
 
 
 def write_prompt(directory, name, text):
@@ -222,3 +222,28 @@ def test_an_example_asset_is_served(self, client):
         assert api.get("/inputs/iris.png").content == b"example-png"
         assert api.get("/inputs/mine.png").content == b"mine-png"
         assert api.get("/inputs/nothing.png").status_code == 404
+
+    def test_validated_arguments_reach_the_whole_asset_path(self, client, tmp_path):
+        """An argument may name an example asset or the workspace's own, and
+        a miss has to name the workspace's library rather than whichever root
+        happened to be searched last - a message that leaves out the library
+        the caller works in reads as though it was never looked in."""
+        api, workspace, checkout = client
+        definition = valid_workflow("refs")
+        definition["variables"] = {"image": "asset:mine.png"}
+
+        for name in ("asset:mine.png", "asset:iris.png"):
+            answer = api.post(
+                "/api/validate",
+                json={"workflow": definition, "arguments": {"image": name}},
+            ).json()
+            assert answer["valid"] is True, answer
+
+        missing = api.post(
+            "/api/validate",
+            json={"workflow": definition, "arguments": {"image": "asset:nope.png"}},
+        ).json()
+
+        assert missing["valid"] is False
+        assert missing["errors"][0]["path"] == "arguments.image"
+        assert os.path.abspath(workspace.assets) in missing["errors"][0]["message"]
diff --git a/tests/test_mcp_assets.py b/tests/test_mcp_assets.py
index 3ad70ab..7c9eedd 100644
--- a/tests/test_mcp_assets.py
+++ b/tests/test_mcp_assets.py
@@ -9,7 +9,13 @@
 import httpx
 import pytest
 
-from dw_mcp.assets import MAX_UPLOAD_BYTES, keep_output, list_assets, upload_asset
+from dw_mcp.assets import (
+    MAX_UPLOAD_BYTES,
+    delete_asset,
+    keep_output,
+    list_assets,
+    upload_asset,
+)
 from dw_mcp.client import DwApiError, DwClient
 
 
@@ -73,6 +79,24 @@ def test_a_file_is_pushed_and_the_reference_returned(self, tmp_path):
         assert result["uploaded"] == "iris.png"
         assert result["size"] == len(b"png-bytes")
 
+    def test_a_name_is_passed_through_when_one_is_given(self, tmp_path):
+        source = tmp_path / "clip-01.wav"
+        source.write_bytes(b"wav-bytes")
+        client, seen = recording()
+
+        upload_asset(client, str(source), asset_name="cast/priya-voice")
+
+        assert "asset_name=cast" in seen["url"].replace("%2F", "/")
+
+    def test_no_name_leaves_the_server_to_choose_one(self, tmp_path):
+        source = tmp_path / "clip-01.wav"
+        source.write_bytes(b"wav-bytes")
+        client, seen = recording()
+
+        upload_asset(client, str(source))
+
+        assert "asset_name" not in seen["url"]
+
     def test_only_the_base_name_is_sent(self, tmp_path):
         # The server generates the stored name; the directory this file sits
         # in is this machine's business and means nothing over there
@@ -167,3 +191,35 @@ def handler(request):
 
         with pytest.raises(DwApiError, match="already exists"):
             keep_output(client_over(handler), "Gyre/run/still.png")
+
+
+class TestDeleting:
+    """The counterpart to upload and keep: without it a mistaken name could
+    only be cleaned up on the box (T014)."""
+
+    def test_the_name_travels_as_a_path_segment(self):
+        seen = {}
+
+        def handler(request):
+            seen["url"] = str(request.url)
+            seen["method"] = request.method
+            return httpx.Response(
+                200,
+                json={
+                    "name": "qa-cast/priya-voice",
+                    "deleted": True,
+                    "origin": "common",
+                },
+            )
+
+        result = delete_asset(client_over(handler), "qa-cast/priya-voice")
+        assert result["deleted"] is True
+        assert seen["method"] == "DELETE"
+        assert "/api/assets/" in seen["url"]
+
+    def test_a_read_only_asset_refusal_reaches_the_caller(self):
+        def handler(request):
+            return httpx.Response(403, json={"detail": "asset:iris.png is read-only"})
+
+        with pytest.raises(DwApiError, match="read-only"):
+            delete_asset(client_over(handler), "iris.png")
diff --git a/tests/test_mcp_authoring.py b/tests/test_mcp_authoring.py
index e363b38..6721bba 100644
--- a/tests/test_mcp_authoring.py
+++ b/tests/test_mcp_authoring.py
@@ -182,3 +182,38 @@ def test_delete_surfaces_a_missing_workflow():
 
     with pytest.raises(DwApiError, match="No such workflow"):
         authoring.delete_workflow(client, "ghost")
+
+
+def body_recording_client():
+    """A client that keeps the request body, for the parts of a payload the
+    (method, path) recorders above cannot see."""
+    seen = {}
+
+    def handler(request):
+        seen["body"] = json.loads(request.content)
+        return httpx.Response(200, json={"valid": True, "errors": [], "warnings": []})
+
+    return DwClient(transport=httpx.MockTransport(handler)), seen
+
+
+def test_validate_sends_the_arguments_it_is_given():
+    """The pre-flight has to cover the values the caller wrote, or it only
+    ever checks the stored defaults."""
+    client, seen = body_recording_client()
+
+    authoring.validate_workflow(
+        client, name="templates/shot", arguments={"prompt": "a cat"}
+    )
+
+    assert seen["body"] == {
+        "workflow_path": "templates/shot",
+        "arguments": {"prompt": "a cat"},
+    }
+
+
+def test_validate_without_arguments_sends_no_arguments_key():
+    client, seen = body_recording_client()
+
+    authoring.validate_workflow(client, name="templates/shot")
+
+    assert seen["body"] == {"workflow_path": "templates/shot"}
diff --git a/tests/test_mcp_catalog.py b/tests/test_mcp_catalog.py
index 38a6ca0..568f689 100644
--- a/tests/test_mcp_catalog.py
+++ b/tests/test_mcp_catalog.py
@@ -40,6 +40,10 @@ def handler(request):
     [
         (lambda c: catalog.list_workflows(c), "/api/workflows"),
         (lambda c: catalog.get_workflow(c, "folder/w"), "/api/workflows/folder/w"),
+        (
+            lambda c: catalog.get_workflow(c, "folder/w", variables_only=True),
+            "/api/workflows/folder/w/variables",
+        ),
         (lambda c: catalog.get_schema(c), "/api/schema"),
         (lambda c: catalog.list_pipelines(c), "/api/pipelines"),
         (
diff --git a/tests/test_mcp_diagnose.py b/tests/test_mcp_diagnose.py
index 2c9926b..230fad9 100644
--- a/tests/test_mcp_diagnose.py
+++ b/tests/test_mcp_diagnose.py
@@ -322,6 +322,42 @@ def test_wait_for_job_caps_the_timeout_it_is_given():
     assert len(seen) == 1, "a terminal status on the first poll returns immediately"
 
 
+def test_wait_for_job_says_when_it_capped_the_timeout(monkeypatch):
+    """Asking for ten minutes gets a minute. The reply has to say so - a
+    caller cannot otherwise tell a capped return from an elapsed one, and
+    would read "still running after 600s" into a job that had 59s of wait."""
+    monkeypatch.setattr(diagnose, "WAIT_POLL_SECONDS", 0.01)
+    monkeypatch.setattr(diagnose, "MAX_WAIT_SECONDS", 0.03)
+    client, _seen = sequenced(
+        ("GET", "/api/jobs/job-1"), [{"id": "job-1", "status": "running"}]
+    )
+
+    result = diagnose.wait_for_job(client, "job-1", timeout_seconds=600)
+
+    assert result["still_running"] is True
+    assert result["timeout_capped"] is True
+    assert result["timeout_requested_seconds"] == 600
+    assert result["timeout_applied_seconds"] == 0.0
+    assert result["waited_seconds"] >= 0
+    assert "600" in result["next"], "the reply names what was asked for"
+
+
+def test_wait_for_job_reports_an_uncapped_budget_honestly(monkeypatch):
+    """Under the cap, nothing was capped - and the same fields are present
+    on a terminal return, so a caller reads them without branching."""
+    monkeypatch.setattr(diagnose, "WAIT_POLL_SECONDS", 0.01)
+    client, _seen = sequenced(
+        ("GET", "/api/jobs/job-1"), [{"id": "job-1", "status": "succeeded"}]
+    )
+
+    result = diagnose.wait_for_job(client, "job-1", timeout_seconds=5)
+
+    assert result["timeout_capped"] is False
+    assert result["timeout_applied_seconds"] == 5.0
+    assert result["timeout_requested_seconds"] == 5.0
+    assert "waited_seconds" in result
+
+
 def test_wait_for_job_does_not_require_acknowledged_cost():
     """It reads an already-queued job rather than starting anything, so the
     cost gate other job-queuing tools carry does not apply here."""
diff --git a/tests/test_mcp_server.py b/tests/test_mcp_server.py
index 9ffb10f..81366b3 100644
--- a/tests/test_mcp_server.py
+++ b/tests/test_mcp_server.py
@@ -65,6 +65,7 @@
     "list_assets",
     "upload_asset",
     "keep_output",
+    "delete_asset",
     "list_workspaces",
     "use_workspace",
     "create_workspace",
@@ -90,6 +91,7 @@
     "delete_output",
     "upload_asset",
     "keep_output",
+    "delete_asset",
     "use_workspace",
     "create_workspace",
     "delete_workspace",
@@ -103,6 +105,7 @@
     "delete_prompt",
     "download_output",
     "delete_output",
+    "delete_asset",
 }
 
 # Tools that refuse until the caller passes acknowledged_cost=true. The
@@ -429,6 +432,7 @@ def _a_file_to_upload():
         "POST",
         "/api/assets/keep",
     ),
+    ("delete_asset", {"name": "hero.png"}, "DELETE", "/api/assets/hero.png"),
     ("list_workspaces", {}, "GET", "/api/workspaces"),
     ("use_workspace", {"name": "default"}, "GET", "/api/workspaces"),
     ("create_workspace", {"name": "shots"}, "POST", "/api/workspaces"),
@@ -607,6 +611,18 @@ async def test_rerun_job_advertises_its_cost():
     assert "acknowledged_cost" in description
 
 
+@pytest.mark.asyncio
+async def test_wait_for_job_names_the_cap_it_applies():
+    """A caller paces its polling against a number, so the description
+    carries the real one rather than "well under a generation's runtime"."""
+    tools = await tools_of(server_over(ok({})))
+
+    description = tools["wait_for_job"].description
+    assert str(diagnose.MAX_WAIT_SECONDS) in description
+    assert "{cap}" not in description, "the placeholder must be formatted away"
+    assert "timeout_capped" in description
+
+
 @pytest.mark.asyncio
 async def test_export_job_warns_the_copy_costs_disk_and_names_total_bytes():
     tools = await tools_of(server_over(ok({})))
@@ -719,6 +735,7 @@ def refusing(request):
     "get_output_image": (media, "get_output_image"),
     "get_class": (catalog, "get_class"),
     "list_gallery": (catalog, "list_gallery"),
+    "list_jobs": (catalog, "list_jobs"),
     "download_model": (models, "download_model"),
     "delete_model": (models, "delete_model"),
     "update_diffusers": (models, "update_diffusers"),
@@ -728,6 +745,8 @@ def refusing(request):
     "get_output_text": (media, "get_output_text"),
     "enhance_prompt": (prompts, "enhance_prompt"),
     "download_output": (media, "download_output"),
+    "get_gallery_metadata": (catalog, "get_gallery_metadata"),
+    "get_workflow": (catalog, "get_workflow"),
 }
 
 
diff --git a/tests/test_media_info.py b/tests/test_media_info.py
index aef76bd..b45d925 100644
--- a/tests/test_media_info.py
+++ b/tests/test_media_info.py
@@ -179,3 +179,77 @@ def test_a_damaged_track_still_reports_header_fields(tmp_path):
     assert info["kind"] == "video"
     assert "peak_dbfs" not in info
     assert "frame_count" not in info
+
+
+class TestEnvelope:
+    """The per-second level: what says *where* in a track something is,
+    rather than only how loud the whole of it was."""
+
+    def write_gapped_wav(self, path, seconds=4.0, sample_rate=8000, silent_second=2):
+        """A tone with one second of silence punched out of the middle of it."""
+        import wave
+
+        t = numpy.arange(int(seconds * sample_rate)) / sample_rate
+        samples = (numpy.sin(2 * numpy.pi * 220 * t) * 0.5 * 32767).astype("<i2")
+        samples[silent_second * sample_rate : (silent_second + 1) * sample_rate] = 0
+        with wave.open(str(path), "w") as handle:
+            handle.setnchannels(2)
+            handle.setsampwidth(2)
+            handle.setframerate(sample_rate)
+            handle.writeframes(numpy.stack([samples, samples], 1).tobytes())
+
+    def test_it_is_off_unless_asked_for(self, tmp_path):
+        write_wav(tmp_path / "score.wav", seconds=2.0)
+
+        assert "envelope" not in probe_media(str(tmp_path / "score.wav"))
+
+    def test_one_entry_per_second_of_the_track(self, tmp_path):
+        self.write_gapped_wav(tmp_path / "score.wav", seconds=4.0)
+
+        envelope = probe_media(str(tmp_path / "score.wav"), envelope=True)["envelope"]
+
+        assert envelope["interval_seconds"] == 1.0
+        assert len(envelope["rms_dbfs"]) == 4
+        assert len(envelope["peak_dbfs"]) == 4
+
+    def test_it_finds_the_second_the_sound_stops_in(self, tmp_path):
+        self.write_gapped_wav(tmp_path / "score.wav", seconds=4.0, silent_second=2)
+
+        envelope = probe_media(str(tmp_path / "score.wav"), envelope=True)["envelope"]
+
+        assert envelope["rms_dbfs"][2] == pytest.approx(-120.0)
+        assert envelope["peak_dbfs"][2] == pytest.approx(-120.0)
+        for second in (0, 1, 3):
+            assert envelope["rms_dbfs"][second] > -20.0
+
+    def test_a_video_soundtrack_gets_one_too(self, tmp_path):
+        write_mp4(tmp_path / "shot.mp4", frames=12, fps=6)
+
+        info = probe_media(str(tmp_path / "shot.mp4"), envelope=True)
+
+        assert info["kind"] == "video"
+        assert info["frame_count"] == 12
+        # 2 s of soundtrack - and a third, near-silent bin is allowed: a
+        # lossy codec decodes its own priming and padding past the nominal
+        # duration, and the envelope reports what actually decoded
+        assert len(info["envelope"]["rms_dbfs"]) in (2, 3)
+        assert info["envelope"]["rms_dbfs"][0] > -30.0
+        assert info["peak_dbfs"] < 0.0
+
+    def test_a_silent_video_has_no_envelope_to_report(self, tmp_path):
+        write_mp4(tmp_path / "mute.mp4", frames=12, fps=6, with_audio=False)
+
+        assert "envelope" not in probe_media(str(tmp_path / "mute.mp4"), envelope=True)
+
+    def test_the_seconds_sum_back_to_the_whole_track(self, tmp_path):
+        """A bin holds the same sums the whole-track level is made of, so
+        recombining them has to land on the level the track reports."""
+        self.write_gapped_wav(tmp_path / "score.wav", seconds=4.0)
+
+        info = probe_media(str(tmp_path / "score.wav"), envelope=True)
+
+        assert max(info["envelope"]["peak_dbfs"]) == pytest.approx(
+            info["peak_dbfs"], abs=0.01
+        )
+        power = numpy.mean([10 ** (db / 10) for db in info["envelope"]["rms_dbfs"]])
+        assert 10 * math.log10(power) == pytest.approx(info["mean_dbfs"], abs=0.1)
diff --git a/tests/test_mix_audio.py b/tests/test_mix_audio.py
index 8747cca..e9c6979 100644
--- a/tests/test_mix_audio.py
+++ b/tests/test_mix_audio.py
@@ -10,34 +10,48 @@ def _tone(samples, level, channels=2):
     return numpy.full((channels, samples), level, dtype=numpy.float32)
 
 
+def _samples(track):
+    """The (samples, channels) waveform mix_audio's AudioTrack carries."""
+    return numpy.asarray(track.audio).T
+
+
 class TestMixAudio:
     def test_tracks_are_summed(self):
-        mixed = mix_audio([_tone(100, 0.2), _tone(100, 0.3)], sample_rate=44100)
+        mixed = _samples(
+            mix_audio([_tone(100, 0.2), _tone(100, 0.3)], sample_rate=44100)
+        )
         assert mixed.shape == (100, 2)
         assert mixed[0, 0] == pytest.approx(0.5)
 
     def test_gains_are_plain_multipliers(self):
-        mixed = mix_audio(
-            [_tone(100, 0.4), _tone(100, 0.4)], gains=[1.0, 0.5], sample_rate=44100
+        mixed = _samples(
+            mix_audio(
+                [_tone(100, 0.4), _tone(100, 0.4)], gains=[1.0, 0.5], sample_rate=44100
+            )
         )
         assert mixed[0, 0] == pytest.approx(0.6)
 
     def test_the_shorter_track_is_padded_with_silence(self):
-        mixed = mix_audio([_tone(100, 0.5), _tone(40, 0.25)], sample_rate=44100)
+        mixed = _samples(
+            mix_audio([_tone(100, 0.5), _tone(40, 0.25)], sample_rate=44100)
+        )
         assert mixed.shape == (100, 2)
         assert mixed[0, 0] == pytest.approx(0.75)
         assert mixed[-1, 0] == pytest.approx(0.5)
 
     def test_mono_is_tiled_up_to_the_widest_track(self):
-        mixed = mix_audio(
-            [_tone(50, 0.5, channels=1), _tone(50, 0.25, channels=2)], sample_rate=44100
+        mixed = _samples(
+            mix_audio(
+                [_tone(50, 0.5, channels=1), _tone(50, 0.25, channels=2)],
+                sample_rate=44100,
+            )
         )
         assert mixed.shape == (50, 2)
         assert mixed[0, 0] == pytest.approx(0.75)
         assert mixed[0, 1] == pytest.approx(0.75)
 
     def test_the_sum_is_not_rescaled(self):
-        mixed = mix_audio([_tone(10, 0.8), _tone(10, 0.8)], sample_rate=44100)
+        mixed = _samples(mix_audio([_tone(10, 0.8), _tone(10, 0.8)], sample_rate=44100))
         assert mixed.max() == pytest.approx(1.6)
 
     def test_an_empty_list_is_refused(self):
diff --git a/tests/test_previous_results.py b/tests/test_previous_results.py
index 5ca4011..1f6fe6f 100644
--- a/tests/test_previous_results.py
+++ b/tests/test_previous_results.py
@@ -5,10 +5,13 @@
 
 import pytest
 from dw.previous_results import (
+    StepResults,
     get_iterations,
     get_previous_results,
     find_previous_result_refs,
+    previous_result_reference_errors,
 )
+from dw.workflow import release_unreferenced_results
 from dw.result import Result
 from PIL import Image
 
@@ -435,3 +438,190 @@ def test_siblings_are_shared_rather_than_copied(self):
 
 if __name__ == "__main__":
     pytest.main([__file__, "-v"])
+
+
+class TestTheErrorNamesWhatRan:
+    """T015: release_unreferenced_results drops a result as soon as no
+    remaining step references it, so the error a misspelled reference raised
+    printed 'Available results: []' on a run where several steps had
+    completed - the one line that would have named the misspelling."""
+
+    def test_a_released_step_is_still_named(self):
+        results = StepResults()
+        results["first"] = Result({})
+        release_unreferenced_results(results, set())
+
+        with pytest.raises(KeyError) as exc_info:
+            get_previous_results(results, "first_renamed")
+
+        message = str(exc_info.value)
+        assert "first_renamed" in message
+        assert "Earlier steps that ran: ['first']" in message
+
+    def test_a_property_reference_says_the_same(self):
+        results = StepResults()
+        results["first"] = Result({})
+        release_unreferenced_results(results, set())
+
+        with pytest.raises(KeyError) as exc_info:
+            get_previous_results(results, "first_renamed.text")
+
+        assert "Earlier steps that ran: ['first']" in str(exc_info.value)
+
+    def test_nothing_extra_when_nothing_was_released(self):
+        results = StepResults()
+        results["first"] = Result({})
+
+        with pytest.raises(KeyError) as exc_info:
+            get_previous_results(results, "second")
+
+        message = str(exc_info.value)
+        assert "Available results: ['first']" in message
+        assert "Earlier steps" not in message
+
+    def test_a_plain_dict_still_works(self):
+        """Every other caller passes an ordinary dict."""
+        with pytest.raises(KeyError) as exc_info:
+            get_previous_results({"first": Result({})}, "second")
+        assert "Available results: ['first']" in str(exc_info.value)
+
+
+class TestStaticReferenceChecking:
+    """T005: references resolve lazily, so a step naming one that does not
+    exist is only found when execution reaches it - after 40 minutes of
+    generation, in the case that prompted this. The names are all in the
+    definition."""
+
+    def definition(self, *steps):
+        return {"id": "test", "steps": list(steps)}
+
+    def test_a_reference_to_a_missing_step_is_an_error(self):
+        errors = previous_result_reference_errors(
+            self.definition(
+                {"name": "first", "task": {"command": "compose_text"}},
+                {
+                    "name": "second",
+                    "task": {"arguments": {"parts": ["previous_result:first_renamed"]}},
+                },
+            )
+        )
+        assert len(errors) == 1
+        assert errors[0]["path"] == "steps[1].task.arguments.parts[0]"
+        assert "first_renamed" in errors[0]["message"]
+        assert "['first']" in errors[0]["message"]
+
+    def test_a_reference_to_an_earlier_step_is_fine(self):
+        assert (
+            previous_result_reference_errors(
+                self.definition(
+                    {"name": "first", "task": {}},
+                    {
+                        "name": "second",
+                        "task": {"arguments": {"parts": ["previous_result:first"]}},
+                    },
+                )
+            )
+            == []
+        )
+
+    def test_a_property_reference_resolves_to_its_step(self):
+        assert (
+            previous_result_reference_errors(
+                self.definition(
+                    {"name": "segment", "task": {}},
+                    {
+                        "name": "later",
+                        "task": {"arguments": {"m": "previous_result:segment.mask"}},
+                    },
+                )
+            )
+            == []
+        )
+
+    def test_a_step_cannot_reference_itself_or_a_later_one(self):
+        errors = previous_result_reference_errors(
+            self.definition(
+                {
+                    "name": "first",
+                    "task": {"arguments": {"x": "previous_result:second"}},
+                },
+                {"name": "second", "task": {}},
+            )
+        )
+        assert len(errors) == 1
+        assert "names no earlier step" in errors[0]["message"]
+
+    def test_a_constructed_objects_source_step_is_checked_too(self):
+        errors = previous_result_reference_errors(
+            self.definition(
+                {"name": "draw", "pipeline": {}},
+                {
+                    "name": "shot",
+                    "pipeline": {
+                        "arguments": {
+                            "references": [
+                                {
+                                    "reference_type": "pkg.ImageReference",
+                                    "from_previous_result": "draw_subject",
+                                }
+                            ]
+                        }
+                    },
+                },
+            )
+        )
+        assert len(errors) == 1
+        assert (
+            errors[0]["path"]
+            == "steps[1].pipeline.arguments.references[0].from_previous_result"
+        )
+
+    def test_a_null_source_is_not_a_reference(self):
+        """An optional reference the run was given nothing for - the list
+        entry is left out rather than built."""
+        assert (
+            previous_result_reference_errors(
+                self.definition(
+                    {
+                        "name": "shot",
+                        "pipeline": {
+                            "arguments": {
+                                "references": [
+                                    {
+                                        "reference_type": "pkg.AudioReference",
+                                        "from_previous_result": None,
+                                    }
+                                ]
+                            }
+                        },
+                    },
+                )
+            )
+            == []
+        )
+
+    def test_a_variable_spelled_reference_is_left_alone(self):
+        """What it names is not knowable before substitution."""
+        assert (
+            previous_result_reference_errors(
+                self.definition(
+                    {
+                        "name": "shot",
+                        "pipeline": {
+                            "arguments": {
+                                "references": [
+                                    {
+                                        "reference_type": "pkg.ImageReference",
+                                        "from_previous_result": "variable:source_step",
+                                    }
+                                ]
+                            }
+                        },
+                    },
+                )
+            )
+            == []
+        )
+
+    def test_a_definition_with_no_steps_is_not_an_error(self):
+        assert previous_result_reference_errors({"id": "test"}) == []
diff --git a/tests/test_server.py b/tests/test_server.py
index 32332b5..055d41f 100644
--- a/tests/test_server.py
+++ b/tests/test_server.py
@@ -1136,6 +1136,61 @@ def test_gallery_metadata_describes_audio_and_video(server, tmp_path):
         assert still["media"] is None
 
 
+def test_workflow_variables_answer_without_the_whole_definition(server, tmp_path):
+    """Confirming what a variable defaults to meant fetching the entire
+    workflow - quantization blocks and all - to read one integer."""
+    workflow = {
+        "id": "Variables",
+        "variables": {
+            "audio_bleed_ms": 1800,
+            "seam_fade_ms": None,
+            "prompt": "x" * 500,
+        },
+        "seed": 42,
+        "steps": [],
+    }
+    (tmp_path / "workflows" / "cut.json").write_text(json.dumps(workflow))
+
+    with server(success_script) as client:
+        body = client.get("/api/workflows/cut/variables").json()
+
+        assert body["variables"]["audio_bleed_ms"] == 1800
+        assert body["variables"]["seam_fade_ms"] is None
+        assert body["seed"] == 42
+        # a kilobyte of prompt is not what the question was about
+        assert body["truncated"] == ["prompt"]
+        assert len(body["variables"]["prompt"]) == 200
+
+        whole = client.get("/api/workflows/cut/variables?full=true").json()
+        assert whole["truncated"] == []
+        assert len(whole["variables"]["prompt"]) == 500
+
+        assert client.get("/api/workflows/ghost/variables").status_code == 404
+
+
+def test_gallery_metadata_reports_a_level_envelope_on_request(server, tmp_path):
+    """Per-second level is opt-in: the default answer stays small, and
+    `envelope=true` says where in the track the level sits."""
+    from tests.test_media_info import write_wav
+
+    with server(success_script) as client:
+        outputs = tmp_path / "outputs"
+        write_wav(outputs / "score-gen.0-0.0.wav", seconds=3.0)
+
+        plain = client.get("/api/gallery/score-gen.0-0.0.wav/metadata").json()
+        assert "envelope" not in plain["media"]
+
+        detailed = client.get(
+            "/api/gallery/score-gen.0-0.0.wav/metadata", params={"envelope": "true"}
+        ).json()
+        envelope = detailed["media"]["envelope"]
+        assert envelope["interval_seconds"] == 1.0
+        assert len(envelope["rms_dbfs"]) == 3
+        assert max(envelope["peak_dbfs"]) == pytest.approx(
+            detailed["media"]["peak_dbfs"], abs=0.01
+        )
+
+
 def test_gallery_metadata_survives_a_damaged_track(server, tmp_path):
     """A track that opens fine but fails partway through decode (damage
     past the header) must not 500 the metadata route - it should fall back
@@ -1437,6 +1492,48 @@ def test_upload_media_lands_in_the_asset_library(asset_server, tmp_path):
         assert fetched.content == b"not-really-png-bytes"
 
 
+def test_an_upload_can_be_given_a_readable_name(asset_server, tmp_path):
+    """A recurring cast stored as 'uploads/084eaecc....wav' cannot be told
+    apart in the workflows that carry it - asset_name is what makes the
+    reference say who it is."""
+    with asset_server(success_script) as client:
+        response = client.post(
+            "/api/uploads",
+            params={"filename": "clip-01.wav", "asset_name": "cast/priya-voice"},
+            content=b"not-really-wav-bytes",
+        )
+        assert response.status_code == 201
+        assert response.json()["path"] == "asset:uploads/cast/priya-voice.wav"
+        stored = tmp_path / "assets" / "uploads" / "cast" / "priya-voice.wav"
+        assert stored.read_bytes() == b"not-really-wav-bytes"
+
+        # the extension may be spelled out, and must match what was uploaded
+        named = client.post(
+            "/api/uploads",
+            params={"filename": "clip-02.wav", "asset_name": "cast/hal-voice.wav"},
+            content=b"more-bytes",
+        )
+        assert named.json()["path"] == "asset:uploads/cast/hal-voice.wav"
+
+        mismatched = client.post(
+            "/api/uploads",
+            params={"filename": "clip-03.wav", "asset_name": "cast/hal.png"},
+            content=b"more-bytes",
+        )
+        assert mismatched.status_code == 400
+
+
+def test_an_upload_name_cannot_climb_out_of_the_library(asset_server, tmp_path):
+    with asset_server(success_script) as client:
+        response = client.post(
+            "/api/uploads",
+            params={"filename": "clip.wav", "asset_name": "../../escaped.wav"},
+            content=b"bytes",
+        )
+        assert response.status_code == 400
+        assert not (tmp_path / "escaped.wav").exists()
+
+
 def test_the_asset_library_does_not_shadow_the_spa(tmp_path):
     """The SPA's own bundles live under /assets/ - Vite's default. An asset
     library mounted there would serve the library instead, and the page
diff --git a/tests/test_server_jobs.py b/tests/test_server_jobs.py
index c02ed4c..e24a265 100644
--- a/tests/test_server_jobs.py
+++ b/tests/test_server_jobs.py
@@ -119,3 +119,45 @@ def test_a_database_without_the_columns_is_migrated(tmp_path):
     history = JobHistory(path)
     row = history.get("old-1")
     assert row["run_id"] is None and row["run_dir"] is None
+
+
+def failing_script(command):
+    """A run that writes a file, then dies on the next step - the shape of a
+    dialogue-short whose last step names a renamed one (T015)."""
+    output_dir = command["output_dir"]
+    yield {
+        "type": "progress",
+        "event": "step_end",
+        "step": "first",
+        "files": [f"{output_dir}/QaDanglingRef/run/first.txt"],
+    }
+    yield {
+        "type": "error",
+        "message": "Workflow execution error: Previous result 'x' not found",
+        "traceback": "...",
+        "manifest": [
+            {"step": "first", "files": [f"{output_dir}/QaDanglingRef/run/first.txt"]}
+        ],
+    }
+
+
+def test_a_failed_job_reports_the_steps_that_completed(tmp_path):
+    manager = JobManager(
+        str(tmp_path / "outputs"),
+        worker_manager=ScriptedWorkerManager(failing_script),
+        history_path=str(tmp_path / "jobs.sqlite"),
+        workflow_dir=str(tmp_path),
+    )
+    try:
+        job = manager.submit(workflow=valid_workflow(), base_dir=None)
+        deadline = time.time() + 5
+        while job.status not in TERMINAL_STATES and time.time() < deadline:
+            time.sleep(0.01)
+        assert job.status == "failed"
+        # named the way clients address outputs, exactly as a success is
+        assert job.manifest == [
+            {"step": "first", "files": ["QaDanglingRef/run/first.txt"]}
+        ]
+        assert manager.history.get(job.id)["manifest"] == job.manifest
+    finally:
+        manager.shutdown()
diff --git a/tests/test_server_workspaces.py b/tests/test_server_workspaces.py
index 07892bd..2038d96 100644
--- a/tests/test_server_workspaces.py
+++ b/tests/test_server_workspaces.py
@@ -532,6 +532,116 @@ def test_a_kept_asset_is_listed_and_referable(self, server, workspace_root):
         assert [entry["reference"] for entry in listed] == ["asset:gyre/hero.png"]
 
 
+class TestKeepingUnderAnExtensionlessName:
+    """T014: a kept asset written without an extension is invisible to the
+    library listing, which reads by kind - so the call reported success and
+    the asset could never be found again."""
+
+    def written(self, root, name, content=b"wav-bytes"):
+        path = os.path.join(root, name)
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, "wb") as handle:
+            handle.write(content)
+        return path
+
+    def test_the_kept_files_extension_is_assumed(self, server, workspace_root):
+        self.written(workspace_root.outputs, "Ep/run/speak_a.wav")
+        with server() as client:
+            body = client.post(
+                "/api/assets/keep",
+                json={"name": "Ep/run/speak_a.wav", "asset_name": "cast/priya-voice"},
+            ).json()
+            listed = client.get("/api/assets").json()["assets"]
+        assert body["reference"] == "asset:cast/priya-voice.wav"
+        assert os.path.exists(
+            os.path.join(workspace_root.assets, "cast", "priya-voice.wav")
+        )
+        # the whole point: what the call handed back is what the library shows
+        assert [entry["reference"] for entry in listed] == [
+            "asset:cast/priya-voice.wav"
+        ]
+
+    def test_a_contradicting_extension_is_refused(self, server, workspace_root):
+        self.written(workspace_root.outputs, "Ep/run/speak_a.wav")
+        with server() as client:
+            response = client.post(
+                "/api/assets/keep",
+                json={"name": "Ep/run/speak_a.wav", "asset_name": "cast/priya.png"},
+            )
+        assert response.status_code == 400
+        assert "does not match" in response.json()["detail"]
+
+
+class TestDeletingAssets:
+    """Uploads and keeps had no counterpart: a mistaken name could only be
+    cleaned up on the box (T014)."""
+
+    def written(self, root, name, content=b"png-bytes"):
+        path = os.path.join(root, name)
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, "wb") as handle:
+            handle.write(content)
+        return path
+
+    def test_an_asset_is_deleted_and_gone_from_the_listing(
+        self, server, workspace_root
+    ):
+        self.written(workspace_root.assets, "cast/hero.png")
+        with server() as client:
+            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",
+        }
+        assert listed == []
+        assert not os.path.exists(
+            os.path.join(workspace_root.assets, "cast", "hero.png")
+        )
+
+    def test_a_shared_asset_is_deleted_from_the_shared_library(
+        self, server, workspace_root
+    ):
+        common = os.path.join(workspace_root.root, "common", "assets")
+        self.written(common, "cast/priya-voice.wav")
+        with server() as client:
+            response = client.delete("/api/assets/cast/priya-voice.wav")
+        assert response.status_code == 200
+        assert response.json()["origin"] == "common"
+        assert not os.path.exists(os.path.join(common, "cast", "priya-voice.wav"))
+
+    def test_a_workspace_asset_shadows_the_shared_one_it_deletes(
+        self, server, workspace_root
+    ):
+        """Deletion follows the search path, so the name deleted is the name
+        'asset:' would have resolved to."""
+        common = os.path.join(workspace_root.root, "common", "assets")
+        self.written(common, "hero.png", b"shared")
+        self.written(workspace_root.assets, "hero.png", b"mine")
+        with server() as client:
+            body = client.delete("/api/assets/hero.png").json()
+        assert body["origin"] == "workspace"
+        assert open(os.path.join(common, "hero.png"), "rb").read() == b"shared"
+
+    def test_an_unknown_name_is_a_404(self, server, workspace_root):
+        with server() as client:
+            assert client.delete("/api/assets/nothing.png").status_code == 404
+
+    @pytest.mark.parametrize("name", ["../escape.png", "%2e%2e/escape.png"])
+    def test_a_name_cannot_leave_the_library(self, server, workspace_root, name):
+        """405 is in the list because the client normalizes a literal '..'
+        out of the URL before it is sent - the server never sees that one.
+        The encoded form is the one that reaches the validator."""
+        self.written(os.path.dirname(workspace_root.assets), "escape.png")
+        with server() as client:
+            assert client.delete(f"/api/assets/{name}").status_code in (400, 404, 405)
+        assert os.path.exists(
+            os.path.join(os.path.dirname(workspace_root.assets), "escape.png")
+        )
+
+
 class TestRunning:
     def test_a_job_runs_in_the_workspace_it_named(self, server, workspace_root):
         with server() as client:
@@ -768,3 +878,129 @@ def test_the_listing_reports_each_workspace_s_disk_usage(server, workspace_root)
     assert spaces["shots"] == {"files": 1, "bytes": 4096}
     assert spaces["default"]["files"] == 1
     assert spaces["default"]["bytes"] == 500
+
+
+class TestSharedAssets:
+    """Assets are per workspace, which is right for the work that made them
+    and wrong for a recurring cast: episode four, started in a fresh
+    workspace, could not see the character portraits episode one uploaded
+    (2026-09-11). The shared library is the prompt library's treatment
+    applied to assets - one copy, reachable from every workspace."""
+
+    def test_a_shared_upload_is_visible_from_every_workspace(
+        self, server, workspace_root
+    ):
+        with server() as client:
+            client.post("/api/workspaces", json={"name": "episode-four"})
+            uploaded = client.post(
+                "/api/uploads",
+                params={
+                    "filename": "priya.png",
+                    "asset_name": "cast/priya",
+                    "shared": "true",
+                },
+                content=b"png",
+            )
+            assert uploaded.status_code == 201
+            body = uploaded.json()
+            assert body["path"] == "asset:uploads/cast/priya.png"
+            assert body["shared"] is True
+
+            for workspace in ("", "?workspace=episode-four"):
+                listed = client.get(f"/api/assets{workspace}").json()
+                names = {asset["name"]: asset for asset in listed["assets"]}
+                assert "uploads/cast/priya.png" in names, workspace
+                assert names["uploads/cast/priya.png"]["origin"] == "common"
+
+    def test_it_is_stored_once_at_the_root(self, server, workspace_root):
+        with server() as client:
+            client.post(
+                "/api/uploads",
+                params={"filename": "hal.png", "shared": "true"},
+                content=b"png",
+            )
+
+        shared = os.path.join(workspace_root.root, "common", "assets", "uploads")
+        assert len(os.listdir(shared)) == 1
+        assert not os.path.exists(os.path.join(workspace_root.assets, "uploads"))
+
+    def test_a_workspace_asset_shadows_a_shared_one_of_the_same_name(
+        self, server, workspace_root
+    ):
+        """The same order 'asset:' resolves in - the workspace's own first."""
+        with server() as client:
+            client.post(
+                "/api/uploads",
+                params={
+                    "filename": "hal.png",
+                    "asset_name": "cast/hal",
+                    "shared": "true",
+                },
+                content=b"shared-bytes",
+            )
+            client.post(
+                "/api/uploads",
+                params={"filename": "hal.png", "asset_name": "cast/hal"},
+                content=b"workspace-bytes",
+            )
+
+            listed = client.get("/api/assets").json()["assets"]
+            entries = [a for a in listed if a["name"] == "uploads/cast/hal.png"]
+            assert len(entries) == 1
+            assert entries[0]["origin"] == "workspace"
+
+            served = client.get("/inputs/uploads/cast/hal.png")
+            assert served.content == b"workspace-bytes"
+
+    def test_a_shared_asset_previews_like_any_other(self, server, workspace_root):
+        with server() as client:
+            client.post("/api/workspaces", json={"name": "episode-four"})
+            client.post(
+                "/api/uploads",
+                params={
+                    "filename": "priya.png",
+                    "asset_name": "cast/priya",
+                    "shared": "true",
+                },
+                content=b"png-bytes",
+            )
+            listed = client.get("/api/assets?workspace=episode-four").json()
+            url = listed["assets"][0]["url"]
+
+            assert client.get(url).content == b"png-bytes"
+
+    def test_an_output_can_be_kept_as_a_shared_asset(self, server, workspace_root):
+        generated = os.path.join(workspace_root.outputs, "still-gen.0-0.0.png")
+        with open(generated, "wb") as file:
+            file.write(b"generated")
+
+        with server() as client:
+            client.post("/api/workspaces", json={"name": "episode-four"})
+            kept = client.post(
+                "/api/assets/keep",
+                json={
+                    "name": "still-gen.0-0.0.png",
+                    "asset_name": "cast/priya.png",
+                    "shared": True,
+                },
+            )
+            assert kept.status_code == 201
+            assert kept.json()["shared"] is True
+            assert kept.json()["reference"] == "asset:cast/priya.png"
+
+            listed = client.get("/api/assets?workspace=episode-four").json()
+            assert [a["origin"] for a in listed["assets"]] == ["common"]
+
+        assert os.path.isfile(
+            os.path.join(workspace_root.root, "common", "assets", "cast", "priya.png")
+        )
+
+    def test_the_shared_library_is_not_a_workspace(self, server):
+        """'common' holds one library, not workflows and outputs - naming it
+        as a workspace has to be refused rather than making a folder."""
+        with server() as client:
+            refused = client.post("/api/workspaces", json={"name": "common"})
+            assert refused.status_code == 400
+            assert [
+                w["name"] for w in client.get("/api/workspaces").json()["workspaces"]
+            ] == ["default"]
diff --git a/tests/test_validate_arguments.py b/tests/test_validate_arguments.py
new file mode 100644
index 0000000..5b4cefd
--- /dev/null
+++ b/tests/test_validate_arguments.py
@@ -0,0 +1,185 @@
+"""Validating the arguments a caller is about to run with.
+
+`POST /api/validate` used to answer about the stored definition and its
+stock defaults - everything about a run except the part the caller actually
+wrote. A bad `asset:` reference or a variable renamed out of the template
+only surfaced once the run had been paid for (36 minutes, in the report that
+prompted this). The same fold-the-arguments-in check now runs at submission
+too, so a bad argument is a 400 rather than a job that fails after queuing.
+"""
+
+import json
+import os
+
+import pytest
+from fastapi.testclient import TestClient
+
+from dw.server.app import create_app
+from dw.server.jobs import JobManager
+from dw.variables import argument_errors
+from dw.workspace import Workspace
+
+from .test_server import ScriptedWorkerManager, success_script, valid_workflow
+
+
+def typed_workflow():
+    """Variables of three shapes: text, a number, and a reference-carrying
+    string - the three an argument can get wrong."""
+    workflow = valid_workflow("typed")
+    workflow["variables"] = {"prompt": "d", "steps": 25, "image": "asset:iris.png"}
+    return workflow
+
+
+@pytest.fixture
+def server(tmp_path):
+    root = Workspace(tmp_path / "studio", "flag").ensure()
+    with open(os.path.join(root.workflows, "Typed.json"), "w") as file:
+        json.dump(typed_workflow(), file)
+    with open(os.path.join(root.assets, "iris.png"), "wb") as file:
+        file.write(b"not really a png, but it is a file under that name")
+    with open(os.path.join(root.prompts, "hero.json"), "w") as file:
+        json.dump({"text": "a hero, centred"}, file)
+
+    def make(script=success_script):
+        manager = JobManager(
+            root.outputs,
+            worker_manager=ScriptedWorkerManager(script),
+            history_path=str(tmp_path / "jobs.sqlite"),
+            workflow_dir=root.workflows,
+        )
+        app = create_app(
+            workflow_dir=root.workflows,
+            output_dir=root.outputs,
+            job_manager=manager,
+            prompt_dir=root.prompts,
+            asset_dir=root.assets,
+            workspace=root.root,
+        )
+        return TestClient(app, base_url="http://localhost")
+
+    return make
+
+
+def validate(client, **body):
+    return client.post("/api/validate", json={"workflow_path": "Typed", **body}).json()
+
+
+class TestArgumentErrors:
+    """The engine-level check, with no server around it."""
+
+    def test_nothing_to_say_without_arguments(self):
+        assert argument_errors(typed_workflow(), {}) == []
+        assert argument_errors(typed_workflow(), None) == []
+
+    def test_an_undeclared_name_is_reported_with_the_declared_ones(self):
+        errors = argument_errors(typed_workflow(), {"prmopt": "x"})
+
+        assert [error["path"] for error in errors] == ["arguments.prmopt"]
+        assert "image, prompt, steps" in errors[0]["message"]
+
+    def test_every_bad_argument_is_reported_not_just_the_first(self):
+        errors = argument_errors(typed_workflow(), {"a": 1, "b": 2})
+
+        assert [error["path"] for error in errors] == ["arguments.a", "arguments.b"]
+
+    def test_a_value_that_will_not_coerce_is_reported(self):
+        errors = argument_errors(typed_workflow(), {"steps": "twenty"})
+
+        assert [error["path"] for error in errors] == ["arguments.steps"]
+
+    def test_a_workflow_with_no_variables_takes_no_arguments(self):
+        """The one case the run itself never reported: Workflow.run only
+        substitutes when a variables block exists, so these were dropped."""
+        bare = {"id": "bare", "steps": []}
+
+        errors = argument_errors(bare, {"prompt": "x"})
+
+        assert [error["path"] for error in errors] == ["arguments.prompt"]
+        assert "declares no variables" in errors[0]["message"]
+
+
+class TestValidateRoute:
+    def test_good_arguments_validate_and_are_named(self, server):
+        with server() as client:
+            result = validate(
+                client,
+                arguments={"prompt": "a cat", "steps": 30, "image": "asset:iris.png"},
+            )
+
+        assert result["valid"] is True
+        assert result["checked_arguments"] == ["image", "prompt", "steps"]
+
+    def test_the_stored_definition_alone_says_so(self, server):
+        """No arguments, no claim about any: the old answer, unchanged."""
+        with server() as client:
+            result = validate(client)
+
+        assert result["valid"] is True and "checked_arguments" not in result
+
+    def test_an_undeclared_argument_fails_validation(self, server):
+        with server() as client:
+            result = validate(client, arguments={"prmopt": "a cat"})
+
+        assert result["valid"] is False
+        assert result["errors"][0]["path"] == "arguments.prmopt"
+        assert result["checked_arguments"] == ["prmopt"]
+
+    def test_a_missing_asset_reference_fails_validation(self, server):
+        with server() as client:
+            result = validate(client, arguments={"image": "asset:iirs.png"})
+
+        assert result["valid"] is False
+        assert result["errors"][0]["path"] == "arguments.image"
+        assert "iirs.png" in result["errors"][0]["message"]
+
+    def test_an_asset_that_is_there_passes(self, server):
+        with server() as client:
+            assert validate(client, arguments={"image": "asset:iris.png"})["valid"]
+
+    def test_a_missing_prompt_reference_fails_validation(self, server):
+        with server() as client:
+            missing = validate(client, arguments={"prompt": "prompt:villain"})
+            found = validate(client, arguments={"prompt": "prompt:hero"})
+
+        assert missing["valid"] is False
+        assert missing["errors"][0]["path"] == "arguments.prompt"
+        assert found["valid"] is True
+
+    def test_a_traversal_in_a_reference_is_refused_not_resolved(self, server):
+        with server() as client:
+            result = validate(client, arguments={"image": "asset:../../etc/passwd"})
+
+        assert result["valid"] is False
+        assert result["errors"][0]["path"] == "arguments.image"
+
+    def test_arguments_are_checked_on_an_inline_definition_too(self, server):
+        with server() as client:
+            result = client.post(
+                "/api/validate",
+                json={"workflow": typed_workflow(), "arguments": {"nope": 1}},
+            ).json()
+
+        assert result["valid"] is False
+        assert result["errors"][0]["path"] == "arguments.nope"
+
+
+class TestSubmission:
+    def test_a_bad_argument_is_refused_before_the_job_is_queued(self, server):
+        with server() as client:
+            response = client.post(
+                "/api/jobs",
+                json={"workflow_path": "Typed", "arguments": {"prmopt": "a cat"}},
+            )
+
+            assert response.status_code == 400
+            assert "prmopt" in response.json()["detail"]
+            assert client.get("/api/jobs").json()["jobs"] == []
+
+    def test_good_arguments_still_queue(self, server):
+        with server() as client:
+            response = client.post(
+                "/api/jobs",
+                json={"workflow_path": "Typed", "arguments": {"prompt": "a cat"}},
+            )
+
+        assert response.status_code == 201
diff --git a/tests/test_worker_execute.py b/tests/test_worker_execute.py
index d9b12a9..f73ee9e 100644
--- a/tests/test_worker_execute.py
+++ b/tests/test_worker_execute.py
@@ -163,3 +163,35 @@ def test_full_cleanup_clears_step_cache():
         )
         is None
     )
+
+
+def test_failure_carries_the_manifest_of_the_steps_that_ran():
+    """T015: the steps before the failure wrote real files, and a report
+    that omits them reads as 'this run produced nothing'."""
+
+    class FailingWorkflow(StubWorkflow):
+        def run(self, arguments, previous_pipelines=None, context=None):
+            raise KeyError("Previous result 'first_renamed' not found")
+
+    worker = _make_worker()
+    messages = _execute(worker, FailingWorkflow())
+    error = next(m for m in messages if m["type"] == "error")
+    assert error["manifest"] == [{"step": "s", "files": ["/out/a.png"]}]
+
+
+def test_cancellation_carries_the_manifest_too():
+    worker = _make_worker()
+    worker.command_queue.put({"type": "cancel"})
+    messages = _execute(worker, StubWorkflow("wait_for_cancel"))
+    cancelled = next(m for m in messages if m["type"] == "cancelled")
+    assert cancelled["manifest"] == [{"step": "s", "files": ["/out/a.png"]}]
+
+
+def test_a_failure_before_the_workflow_loads_reports_no_manifest():
+    worker = _make_worker()
+    with patch("dw.worker.workflow_from_file", side_effect=OSError("no such file")):
+        worker._handle_execute(
+            {"workflow_path": "x.json", "arguments": {}, "output_dir": "/tmp"}
+        )
+    error = next(m for m in _drain(worker.result_queue) if m["type"] == "error")
+    assert error["manifest"] == []
diff --git a/tests/test_workflow.py b/tests/test_workflow.py
index b7bd02e..bc973e9 100644
--- a/tests/test_workflow.py
+++ b/tests/test_workflow.py
@@ -578,3 +578,38 @@ def test_validate_reports_every_schema_error_at_once(tmp_path):
     assert "  at steps[0].seed:" in message
     assert "  at variables:" in message
     assert message.count("Validation error") == 1
+
+
+def test_validate_catches_a_reference_to_a_step_that_does_not_exist(tmp_path):
+    """T005: a dangling 'previous_result:' used to validate clean and fail
+    at run time, after every step before it had run - 42 minutes of
+    generation, in the case that prompted this."""
+    from dw.workflow import Workflow
+
+    definition = {
+        "id": "renamed",
+        "steps": [
+            {
+                "name": "shot_1",
+                "task": {"command": "compose_text", "arguments": {"parts": ["a"]}},
+            },
+            {
+                "name": "episode",
+                "task": {
+                    "command": "concat_videos",
+                    "arguments": {
+                        "videos": [
+                            "previous_result:shot_1",
+                            "previous_result:shot_2_pat_deflects",
+                        ]
+                    },
+                },
+            },
+        ],
+    }
+    with pytest.raises(Exception) as exc_info:
+        Workflow(definition, str(tmp_path), "").validate()
+    message = str(exc_info.value)
+    assert "steps[1].task.arguments.videos[1]" in message
+    assert "shot_2_pat_deflects" in message
+    assert message.count("Validation error") == 1
diff --git a/tests/test_workspace.py b/tests/test_workspace.py
index d27ebfa..2e79e9b 100644
--- a/tests/test_workspace.py
+++ b/tests/test_workspace.py
@@ -184,6 +184,42 @@ def test_a_clean_workspace_is_deleted(self, tmp_path):
         assert not os.path.exists(created.root)
 
 
+class TestSharedAssetLibrary:
+    """One asset library under the root, reachable from every workspace -
+    the prompt library's treatment applied to a recurring cast, which
+    belongs to no one workspace."""
+
+    def test_it_hangs_off_the_root(self, tmp_path):
+        root = Workspace(tmp_path / "studio", FLAG)
+
+        assert root.common_assets == os.path.join(root.root, "common", "assets")
+
+    def test_a_named_workspace_points_back_at_the_root_s(self, tmp_path):
+        from dw.workspace import named_workspace
+
+        root = Workspace(tmp_path / "studio", FLAG)
+        named = named_workspace(root, "episode-four")
+
+        assert named.assets == os.path.join(named.root, "assets")
+        assert named.common_assets == root.common_assets
+
+    def test_it_is_not_a_name_a_workspace_can_take(self, tmp_path):
+        from dw.workspace import create_workspace, workspace_names
+        from dw.security import InvalidInputError
+
+        root = Workspace(tmp_path / "studio", FLAG).ensure()
+        os.makedirs(root.common_assets)
+
+        with pytest.raises(InvalidInputError):
+            create_workspace(root, "common")
+        assert workspace_names(root) == ["default"]
+
+    def test_it_is_named_in_the_description_a_client_reads(self, tmp_path):
+        root = Workspace(tmp_path / "studio", FLAG)
+
+        assert root.describe()["common_assets"] == root.common_assets
+
+
 class TestPromptLibraryPrecedence:
     """get_prompt_dir's older rules stay ahead of an inferred workspace and
     behind a named one."""
diff --git a/workflows/templates/minimax/dialogue-short.json b/workflows/templates/minimax/dialogue-short.json
index b375b72..fafcc0e 100644
--- a/workflows/templates/minimax/dialogue-short.json
+++ b/workflows/templates/minimax/dialogue-short.json
@@ -1,18 +1,26 @@
 {
     "id": "MiniMaxH3SitcomShort",
-    "description": "A digital short built the way television is built: from cuts, not from one long take. Chained generation degrades with length - every segment conditions on the previous segment's output, so artifacts compound and identity drifts. A scene cut resets that completely: each shot here is generated fresh from the same two character portraits, so shot five is exactly as clean as shot one and the scene can run as long as the script does. Two Z-Image steps draw the cast (the second reuses the first's loaded pipeline - identical configurations share one model - and 'release_pipeline' frees it before the video model loads). The first shot loads MiniMax-H3 once; the remaining shots are 'pipeline_reference' steps that rerun it with a new prompt, references and length - the tag shot runs 141 frames where the others run 124, since length is per-run. Character consistency across cuts comes from referencing the same portraits in every shot; voice consistency comes from repeating each character's voice description verbatim in every prompt. The soundscape writes the laugh track. A final 'concat_videos' task is the editor, splicing the shots into one episode - hard cuts, no trims, no seams to hide, because nothing was carried between them. Only the picture cuts hard: 'audio_bleed_ms' rings each shot's laugh track on over the silent opening of the next, the way a live audience carries across a cut. It and 'seam_fade_ms' are variables, so a seam is re-tuned with an argument rather than a copy of the workflow; 1800 ms is where a five-shot cut measured best, since a generated shot opens on more silence than it looks.",
+    "description": "A digital short built the way television is built: from cuts, not from one long take. Chained generation degrades with length - every segment conditions on the previous segment's output, so artifacts compound and identity drifts. A scene cut resets that completely: each shot here is generated fresh from the same two character portraits, so shot five is exactly as clean as shot one and the scene can run as long as the script does. Two Z-Image steps draw the cast (the second reuses the first's loaded pipeline - identical configurations share one model - and 'release_pipeline' frees it before the video model loads). The first shot loads MiniMax-H3 once; the remaining shots are 'pipeline_reference' steps that rerun it with a new prompt, references and length - the tag shot runs 141 frames where the others run 124, since length is per-run. Character consistency across cuts comes from referencing the same portraits in every shot; voice consistency comes from repeating each character's voice description verbatim in every prompt, and, when 'character_a_voice' / 'character_b_voice' name a clip ('asset:cast/priya.wav'), from an audio reference appended to every shot that character speaks in - a repeated description alone drifts. Both default to null, and a reference whose file is null is left out of the list, so a run that names no voice generates exactly what it generated before the variables existed. A shot where both speak gets both references; if that reads worse than one, name one voice and leave the other null. The variables are named for roles rather than for the cast of this example - 'character_a', 'shot_3_react' - because the beats are the reusable part and the sketch is not. The soundscape writes the laugh track. A final 'concat_videos' task is the editor, splicing the shots into one episode - hard cuts, no trims, no seams to hide, because nothing was carried between them. Only the picture cuts hard: 'audio_bleed_ms' rings each shot's laugh track on over the silent opening of the next, the way a live audience carries across a cut. It and 'seam_fade_ms' are variables, so a seam is re-tuned with an argument rather than a copy of the workflow; 1800 ms is where a five-shot cut measured best, since a generated shot opens on more silence than it looks.",
     "summary": "A multi-shot dialogue short: Z-Image draws the cast, each shot is generated fresh from the same portraits, then cut.",
     "cost": [
-        {"device": "cuda", "name": "RTX 3090", "vram_gb": 24, "minutes": 42}
+        {
+            "device": "cuda",
+            "name": "RTX 3090",
+            "vram_gb": 24,
+            "minutes": 42
+        }
     ],
     "variables": {
-        "howie_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",
-        "pat_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",
+        "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",
         "shot_1_cold_open": "subject_definitions:\n<Subject 1> is the wiry man in <Picture 1>, early 30s, short curly dark hair, mustard-yellow sweater vest over a white button-down shirt.\n<Subject 2> is the heavyset man in <Picture 2>, mid 40s, shaved head, open gray flannel shirt over a dark t-shirt.\n\nsummary:\n[reference generation] The target video is one shot of a 1990s multi-camera sitcom: <Subject 2> reads on the couch while <Subject 1> enters holding an empty ice cream carton and confronts him, in front of a live studio audience.\n\nretention_analysis:\n<Subject 1> (appears in [Shot 1]): fully_preserved - the face, hair, sweater vest and proportions of <Picture 1> are kept exactly, with the body newly animated to walk and speak.\n<Subject 2> (appears in [Shot 1]): fully_preserved - the face, head, flannel shirt and proportions of <Picture 2> are kept exactly, with the body newly posed seated and reading.\n\ndetailed_description:\nThe target video is in the style of a 1990s multi-camera sitcom, shot on studio video with warm, even, shadowless lighting. [Shot 1] A wide shot frames a living room set: a sagging olive-green couch centre frame in front of a brick wall with a window onto a painted city backdrop. <Subject 2> sits at the right end of the couch, ankles crossed, reading a magazine and not looking up. <Subject 1> strides in from frame left holding an empty pint-sized ice cream carton at chest height, stops beside the couch, holds the carton out toward <Subject 2> and turns it upside down to show it is empty. <Subject 1> (S1), a fast, nasal, high-pitched male tenor voice, tight with disbelief, says <d>[English] Okay. Who finished the pistachio?</d> <Subject 2> keeps reading and does not react. A live studio audience laughs warmly as the carton turns over. The camera holds a static wide shot throughout, level with the set, the way a sitcom master camera holds a scene.\n\noverall_soundscape:\nA bright, close television-studio room tone. Quick footsteps on a hollow stage floor as <Subject 1> enters, the papery rattle of the empty carton as it turns over, a soft page turn from the couch, and a warm burst of live studio-audience laughter that begins as the carton flips and settles under the end of the shot.\n\nnon_diegetic_music:\nN/A",
-        "shot_2_pat_deflects": "subject_definitions:\n<Subject 1> is the heavyset man in <Picture 1>, mid 40s, shaved head, calm and heavy-lidded, open gray flannel shirt over a dark t-shirt.\n\nsummary:\n[reference generation] The target video is one close-up shot of a 1990s multi-camera sitcom: <Subject 1> answers an accusation without looking up from his magazine, in front of a live studio audience.\n\nretention_analysis:\n<Subject 1> (appears in [Shot 1]): fully_preserved - the face, head, flannel shirt and proportions of <Picture 1> are kept exactly, with the head and jaw newly animated to speak.\n\ndetailed_description:\nThe target video is in the style of a 1990s multi-camera sitcom, shot on studio video with warm, even, shadowless lighting. [Shot 1] A medium close-up frames <Subject 1> from the chest up, seated at the end of an olive-green couch in front of a brick wall, holding an open magazine just below the frame line and reading it. He does not look up. <Subject 1> (S1), a flat, low, unhurried male baritone voice, completely unbothered, says <d>[English] Technically? The freezer has a defrost cycle.</d> On the last word he turns a page. A live studio audience laughs as the line lands. The camera holds a static close-up throughout, the way a sitcom cross-shot camera holds a speaker.\n\noverall_soundscape:\nA bright, close television-studio room tone. A soft page turn, the faint creak of couch springs as <Subject 1> settles, and a rolling wave of live studio-audience laughter that starts on the last word of the line and carries under the end of the shot.\n\nnon_diegetic_music:\nN/A",
-        "shot_3_howie_incredulous": "subject_definitions:\n<Subject 1> is the wiry man in <Picture 1>, early 30s, short curly dark hair, expressive eyebrows, mustard-yellow sweater vest over a white button-down shirt.\n\nsummary:\n[reference generation] The target video is one close-up shot of a 1990s multi-camera sitcom: <Subject 1> repeats an absurd excuse back in disbelief, holding up an empty ice cream carton, in front of a live studio audience.\n\nretention_analysis:\n<Subject 1> (appears in [Shot 1]): fully_preserved - the face, hair, sweater vest and proportions of <Picture 1> are kept exactly, with the head, jaw and arm newly animated to speak and gesture.\n\ndetailed_description:\nThe target video is in the style of a 1990s multi-camera sitcom, shot on studio video with warm, even, shadowless lighting. [Shot 1] A medium close-up frames <Subject 1> from the chest up, standing beside a couch in front of a brick wall, an empty pint-sized ice cream carton raised in one hand at head height. His eyebrows are high and his mouth is half open before he speaks. <Subject 1> (S1), a fast, nasal, high-pitched male tenor voice, tight with disbelief, cracking upward on the last word, says <d>[English] The defrost cycle used a spoon?</d> He shakes the empty carton once on the word spoon. A live studio audience erupts in a big laugh as the line lands. The camera holds a static close-up throughout, the way a sitcom cross-shot camera holds a speaker.\n\noverall_soundscape:\nA bright, close television-studio room tone. The hollow papery rattle of the empty carton as it shakes, and a big rising wave of live studio-audience laughter that breaks on the word spoon and rolls under the end of the shot.\n\nnon_diegetic_music:\nN/A",
-        "shot_4_pat_button": "subject_definitions:\n<Subject 1> is the heavyset man in <Picture 1>, mid 40s, shaved head, calm and heavy-lidded, open gray flannel shirt over a dark t-shirt.\n\nsummary:\n[reference generation] The target video is one close-up shot of a 1990s multi-camera sitcom: <Subject 1> shrugs off the accusation with a deadpan line, in front of a live studio audience.\n\nretention_analysis:\n<Subject 1> (appears in [Shot 1]): fully_preserved - the face, head, flannel shirt and proportions of <Picture 1> are kept exactly, with the head, jaw and shoulders newly animated to speak and shrug.\n\ndetailed_description:\nThe target video is in the style of a 1990s multi-camera sitcom, shot on studio video with warm, even, shadowless lighting. [Shot 1] A medium close-up frames <Subject 1> from the chest up, seated at the end of an olive-green couch in front of a brick wall, the magazine now closed in his lap. He looks up for the first time, holds a beat of eye contact just past the lens, and gives one slow shrug. <Subject 1> (S1), a flat, low, unhurried male baritone voice, perfectly deadpan, says <d>[English] I don't know its life.</d> He goes back to the magazine. A live studio audience gives a big laugh with scattered applause as he looks back down. The camera holds a static close-up throughout, the way a sitcom cross-shot camera holds a speaker.\n\noverall_soundscape:\nA bright, close television-studio room tone. The soft slap of the magazine reopening, a couch-spring creak under the shrug, and a big wave of live studio-audience laughter with a few claps in it that breaks after the line and rolls under the end of the shot.\n\nnon_diegetic_music:\nN/A",
+        "shot_2_deflect": "subject_definitions:\n<Subject 1> is the heavyset man in <Picture 1>, mid 40s, shaved head, calm and heavy-lidded, open gray flannel shirt over a dark t-shirt.\n\nsummary:\n[reference generation] The target video is one close-up shot of a 1990s multi-camera sitcom: <Subject 1> answers an accusation without looking up from his magazine, in front of a live studio audience.\n\nretention_analysis:\n<Subject 1> (appears in [Shot 1]): fully_preserved - the face, head, flannel shirt and proportions of <Picture 1> are kept exactly, with the head and jaw newly animated to speak.\n\ndetailed_description:\nThe target video is in the style of a 1990s multi-camera sitcom, shot on studio video with warm, even, shadowless lighting. [Shot 1] A medium close-up frames <Subject 1> from the chest up, seated at the end of an olive-green couch in front of a brick wall, holding an open magazine just below the frame line and reading it. He does not look up. <Subject 1> (S1), a flat, low, unhurried male baritone voice, completely unbothered, says <d>[English] Technically? The freezer has a defrost cycle.</d> On the last word he turns a page. A live studio audience laughs as the line lands. The camera holds a static close-up throughout, the way a sitcom cross-shot camera holds a speaker.\n\noverall_soundscape:\nA bright, close television-studio room tone. A soft page turn, the faint creak of couch springs as <Subject 1> settles, and a rolling wave of live studio-audience laughter that starts on the last word of the line and carries under the end of the shot.\n\nnon_diegetic_music:\nN/A",
+        "shot_3_react": "subject_definitions:\n<Subject 1> is the wiry man in <Picture 1>, early 30s, short curly dark hair, expressive eyebrows, mustard-yellow sweater vest over a white button-down shirt.\n\nsummary:\n[reference generation] The target video is one close-up shot of a 1990s multi-camera sitcom: <Subject 1> repeats an absurd excuse back in disbelief, holding up an empty ice cream carton, in front of a live studio audience.\n\nretention_analysis:\n<Subject 1> (appears in [Shot 1]): fully_preserved - the face, hair, sweater vest and proportions of <Picture 1> are kept exactly, with the head, jaw and arm newly animated to speak and gesture.\n\ndetailed_description:\nThe target video is in the style of a 1990s multi-camera sitcom, shot on studio video with warm, even, shadowless lighting. [Shot 1] A medium close-up frames <Subject 1> from the chest up, standing beside a couch in front of a brick wall, an empty pint-sized ice cream carton raised in one hand at head height. His eyebrows are high and his mouth is half open before he speaks. <Subject 1> (S1), a fast, nasal, high-pitched male tenor voice, tight with disbelief, cracking upward on the last word, says <d>[English] The defrost cycle used a spoon?</d> He shakes the empty carton once on the word spoon. A live studio audience erupts in a big laugh as the line lands. The camera holds a static close-up throughout, the way a sitcom cross-shot camera holds a speaker.\n\noverall_soundscape:\nA bright, close television-studio room tone. The hollow papery rattle of the empty carton as it shakes, and a big rising wave of live studio-audience laughter that breaks on the word spoon and rolls under the end of the shot.\n\nnon_diegetic_music:\nN/A",
+        "shot_4_button": "subject_definitions:\n<Subject 1> is the heavyset man in <Picture 1>, mid 40s, shaved head, calm and heavy-lidded, open gray flannel shirt over a dark t-shirt.\n\nsummary:\n[reference generation] The target video is one close-up shot of a 1990s multi-camera sitcom: <Subject 1> shrugs off the accusation with a deadpan line, in front of a live studio audience.\n\nretention_analysis:\n<Subject 1> (appears in [Shot 1]): fully_preserved - the face, head, flannel shirt and proportions of <Picture 1> are kept exactly, with the head, jaw and shoulders newly animated to speak and shrug.\n\ndetailed_description:\nThe target video is in the style of a 1990s multi-camera sitcom, shot on studio video with warm, even, shadowless lighting. [Shot 1] A medium close-up frames <Subject 1> from the chest up, seated at the end of an olive-green couch in front of a brick wall, the magazine now closed in his lap. He looks up for the first time, holds a beat of eye contact just past the lens, and gives one slow shrug. <Subject 1> (S1), a flat, low, unhurried male baritone voice, perfectly deadpan, says <d>[English] I don't know its life.</d> He goes back to the magazine. A live studio audience gives a big laugh with scattered applause as he looks back down. The camera holds a static close-up throughout, the way a sitcom cross-shot camera holds a speaker.\n\noverall_soundscape:\nA bright, close television-studio room tone. The soft slap of the magazine reopening, a couch-spring creak under the shrug, and a big wave of live studio-audience laughter with a few claps in it that breaks after the line and rolls under the end of the shot.\n\nnon_diegetic_music:\nN/A",
         "shot_5_tag": "subject_definitions:\n<Subject 1> is the wiry man in <Picture 1>, early 30s, short curly dark hair, mustard-yellow sweater vest over a white button-down shirt.\n<Subject 2> is the heavyset man in <Picture 2>, mid 40s, shaved head, open gray flannel shirt over a dark t-shirt.\n\nsummary:\n[reference generation] The target video is one shot of a 1990s multi-camera sitcom: <Subject 1> gives up and sits down next to <Subject 2>, the two trade a final exchange, and the scene ends on applause.\n\nretention_analysis:\n<Subject 1> (appears in [Shot 1]): fully_preserved - the face, hair, sweater vest and proportions of <Picture 1> are kept exactly, with the body newly animated to sit and speak.\n<Subject 2> (appears in [Shot 1]): fully_preserved - the face, head, flannel shirt and proportions of <Picture 2> are kept exactly, with the head newly animated to reply.\n\ndetailed_description:\nThe target video is in the style of a 1990s multi-camera sitcom, shot on studio video with warm, even, shadowless lighting. [Shot 1] A wide shot frames the living room set: the sagging olive-green couch centre frame in front of a brick wall with a window onto a painted city backdrop. <Subject 2> sits at the right end of the couch reading his magazine. <Subject 1> exhales, drops the empty carton onto the coffee table, and sits down heavily at the left end of the couch, staring straight ahead. A beat of silence. <Subject 1> (S1), a fast, nasal, high-pitched male tenor voice, now flat with defeat, says <d>[English] We're getting a padlock.</d> Without looking up, <Subject 2> (S2), a flat, low, unhurried male baritone voice, says <d>[English] Sure.</d> The studio audience laughs and applauds as the shot holds on the two of them side by side, neither moving. The camera holds a static wide shot throughout.\n\noverall_soundscape:\nA bright, close television-studio room tone. The hollow knock of the carton landing on the coffee table, a heavy couch-spring compression as <Subject 1> sits, a page turn, then a full wave of live studio-audience laughter that turns into warm applause and carries to the end of the shot.\n\nnon_diegetic_music:\nA short, bright sitcom scene-change sting - a bass guitar walk-down with a light drum hit - enters under the applause in the final second of the shot.",
+        "character_a_voice": null,
+        "character_b_voice": null,
+        "voice_reference_type": "diffusers.modular_pipelines.minimax_h3.MiniMaxH3AudioReference",
         "subject_reference_type": "diffusers.modular_pipelines.minimax_h3.MiniMaxH3ImageReference",
         "num_frames": 124,
         "tag_num_frames": 141,
@@ -30,7 +38,7 @@
     "seed": 42,
     "steps": [
         {
-            "name": "draw_howie",
+            "name": "draw_character_a",
             "pipeline": {
                 "configuration": {
                     "component_type": "ZImagePipeline",
@@ -42,7 +50,7 @@
                     "low_cpu_mem_usage": true
                 },
                 "arguments": {
-                    "prompt": "variable:howie_portrait_prompt",
+                    "prompt": "variable:character_a_portrait_prompt",
                     "num_inference_steps": 9,
                     "guidance_scale": 0.0,
                     "width": 768,
@@ -55,7 +63,7 @@
             }
         },
         {
-            "name": "draw_pat",
+            "name": "draw_character_b",
             "release_pipeline": true,
             "pipeline": {
                 "configuration": {
@@ -68,7 +76,7 @@
                     "low_cpu_mem_usage": true
                 },
                 "arguments": {
-                    "prompt": "variable:pat_portrait_prompt",
+                    "prompt": "variable:character_b_portrait_prompt",
                     "num_inference_steps": 9,
                     "guidance_scale": 0.0,
                     "width": 768,
@@ -194,11 +202,19 @@
                     "references": [
                         {
                             "reference_type": "variable:subject_reference_type",
-                            "from_previous_result": "draw_howie"
+                            "from_previous_result": "draw_character_a"
                         },
                         {
                             "reference_type": "variable:subject_reference_type",
-                            "from_previous_result": "draw_pat"
+                            "from_previous_result": "draw_character_b"
+                        },
+                        {
+                            "reference_type": "variable:voice_reference_type",
+                            "from_file": "variable:character_a_voice"
+                        },
+                        {
+                            "reference_type": "variable:voice_reference_type",
+                            "from_file": "variable:character_b_voice"
                         }
                     ],
                     "num_frames": "variable:num_frames",
@@ -218,15 +234,19 @@
             }
         },
         {
-            "name": "shot_2_pat_deflects",
+            "name": "shot_2_deflect",
             "pipeline_reference": {
                 "reference_name": "shot_1_cold_open",
                 "arguments": {
-                    "prompt": "variable:shot_2_pat_deflects",
+                    "prompt": "variable:shot_2_deflect",
                     "references": [
                         {
                             "reference_type": "variable:subject_reference_type",
-                            "from_previous_result": "draw_pat"
+                            "from_previous_result": "draw_character_b"
+                        },
+                        {
+                            "reference_type": "variable:voice_reference_type",
+                            "from_file": "variable:character_b_voice"
                         }
                     ],
                     "num_frames": "variable:num_frames",
@@ -246,15 +266,19 @@
             }
         },
         {
-            "name": "shot_3_howie_incredulous",
+            "name": "shot_3_react",
             "pipeline_reference": {
                 "reference_name": "shot_1_cold_open",
                 "arguments": {
-                    "prompt": "variable:shot_3_howie_incredulous",
+                    "prompt": "variable:shot_3_react",
                     "references": [
                         {
                             "reference_type": "variable:subject_reference_type",
-                            "from_previous_result": "draw_howie"
+                            "from_previous_result": "draw_character_a"
+                        },
+                        {
+                            "reference_type": "variable:voice_reference_type",
+                            "from_file": "variable:character_a_voice"
                         }
                     ],
                     "num_frames": "variable:num_frames",
@@ -274,15 +298,19 @@
             }
         },
         {
-            "name": "shot_4_pat_button",
+            "name": "shot_4_button",
             "pipeline_reference": {
                 "reference_name": "shot_1_cold_open",
                 "arguments": {
-                    "prompt": "variable:shot_4_pat_button",
+                    "prompt": "variable:shot_4_button",
                     "references": [
                         {
                             "reference_type": "variable:subject_reference_type",
-                            "from_previous_result": "draw_pat"
+                            "from_previous_result": "draw_character_b"
+                        },
+                        {
+                            "reference_type": "variable:voice_reference_type",
+                            "from_file": "variable:character_b_voice"
                         }
                     ],
                     "num_frames": "variable:num_frames",
@@ -310,11 +338,19 @@
                     "references": [
                         {
                             "reference_type": "variable:subject_reference_type",
-                            "from_previous_result": "draw_howie"
+                            "from_previous_result": "draw_character_a"
                         },
                         {
                             "reference_type": "variable:subject_reference_type",
-                            "from_previous_result": "draw_pat"
+                            "from_previous_result": "draw_character_b"
+                        },
+                        {
+                            "reference_type": "variable:voice_reference_type",
+                            "from_file": "variable:character_a_voice"
+                        },
+                        {
+                            "reference_type": "variable:voice_reference_type",
+                            "from_file": "variable:character_b_voice"
                         }
                     ],
                     "num_frames": "variable:tag_num_frames",
@@ -340,9 +376,9 @@
                 "arguments": {
                     "videos": [
                         "previous_result:shot_1_cold_open",
-                        "previous_result:shot_2_pat_deflects",
-                        "previous_result:shot_3_howie_incredulous",
-                        "previous_result:shot_4_pat_button",
+                        "previous_result:shot_2_deflect",
+                        "previous_result:shot_3_react",
+                        "previous_result:shot_4_button",
                         "previous_result:shot_5_tag"
                     ],
                     "trim_frames": 0,